Class: File

Inherits:
Object
  • Object
show all
Defined in:
lib/ptools.rb

Constant Summary collapse

PTOOLS_VERSION =

The version of the ptools library.

'1.5.2'.freeze
IMAGE_EXT = 
%w[.bmp .gif .jpg .jpeg .png .ico].freeze
BLOCK_SIZE =

Constants for file operations

512
TAIL_CHUNK_SIZE =

64k chunks

2**16

Class Method Summary collapse

Class Method Details

.binary?(file) ⇒ Boolean

Returns whether or not file is a binary non-image file, i.e. executable, shared object, etc.

Internally this method simply looks for a double null sequence. This will work for the vast majority of cases, but it is not guaranteed to be absolutely accurate.

Example:

File.binary?('somefile.exe') # => true
File.binary?('somefile.txt') # => false

Returns:

  • (Boolean) 


74
75
76
77
78
79
80
81
82
 
# File 'lib/ptools.rb', line 74

def self.binary?(file)
  return false if File.stat(file).zero?
  return false if image?(file)
  return false if check_bom?(file)

  bytes = File.stat(file).blksize
  bytes = 4096 if bytes > 4096
  (File.read(file, bytes) || '').include?("\u0000\u0000")
end

.bmp?(file) ⇒ Boolean

Is the file a bitmap file?

Returns:

  • (Boolean) 


425
426
427
428
 
# File 'lib/ptools.rb', line 425

def self.bmp?(file)
  data = File.read(file, 6, nil, :encoding => 'binary')
  data[0, 2] == 'BM' && File.size(file) == data[2, 4].unpack1('i')
end

.gif?(file) ⇒ Boolean

Is the file a gif?

Returns:

  • (Boolean) 


444
445
446
 
# File 'lib/ptools.rb', line 444

def self.gif?(file)
  %w[GIF89a GIF97a].include?(File.read(file, 6))
end

.head(filename, num_lines = 10) ⇒ Object

In block form, yields the first num_lines from filename. In non-block form, returns an Array of num_lines

Examples:

# Return an array
File.head('somefile.txt') # => ['This is line1', 'This is line2', ...]

# Use a block
File.head('somefile.txt'){ |line| puts line }



207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/ptools.rb', line 207

def self.head(filename, num_lines = 10)
  a = []

  File.foreach(filename) do |line|
    break if num_lines <= 0

    num_lines -= 1
    if block_given?
      yield line
    else
      a << line
    end
  end

  a.empty? ? nil : a # Return nil in block form
end

.ico?(file) ⇒ Boolean

Is the file an ico file?

Returns:

  • (Boolean) 


467
468
469
 
# File 'lib/ptools.rb', line 467

def self.ico?(file)
  ["\000\000\001\000", "\000\000\002\000"].include?(File.read(file, 4, nil, :encoding => 'binary'))
end

.image?(file, check_file_extension: true) ⇒ Boolean

Returns whether or not the file is an image. Only JPEG, PNG, BMP, GIF, and ICO are checked against.

This reads and checks the first few bytes of the file. For a version that is more robust, but which depends on a 3rd party C library (and is difficult to build on MS Windows), see the ‘filemagic’ library.

By default the filename extension is also checked. You can disable this by passing false as the second argument, in which case only the contents are checked.

Examples:

File.image?('somefile.jpg') # => true
File.image?('somefile.txt') # => false

– The approach I used here is based on information found at en.wikipedia.org/wiki/Magic_number_(programming)

Returns:

  • (Boolean) 


54
55
56
57
58
59
60
 
# File 'lib/ptools.rb', line 54

def self.image?(file, check_file_extension: true)
  bool = bmp?(file) || jpg?(file) || png?(file) || gif?(file) || tiff?(file) || ico?(file)

  bool &&= IMAGE_EXT.include?(File.extname(file).downcase) if check_file_extension

  bool
end

.jpg?(file) ⇒ Boolean

Is the file a jpeg file?

Returns:

  • (Boolean) 


432
433
434
 
# File 'lib/ptools.rb', line 432

def self.jpg?(file)
  File.read(file, 10, nil, :encoding => 'binary') == String.new("\377\330\377\340\000\020JFIF").force_encoding(Encoding::BINARY)
end

.nl_convert(old_file, new_file = old_file, platform = 'local') ⇒ Object

Converts a text file from one OS platform format to another, ala ‘dos2unix’. The possible values for platform include:

  • MS Windows -> dos, windows, win32, mswin

  • Unix/BSD -> unix, linux, bsd, osx, darwin, sunos, solaris

  • Mac -> mac, macintosh, apple

You may also specify ‘local’, in which case your CONFIG value will be used. This is the default.

Note that this method is only valid for an ftype of “file”. Otherwise a TypeError will be raised. If an invalid format value is received, an ArgumentError is raised.

Raises:

  • (ArgumentError) 


285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'lib/ptools.rb', line 285

def self.nl_convert(old_file, new_file = old_file, platform = 'local')
  raise ArgumentError, 'Only valid for plain text files' unless File::Stat.new(old_file).file?

  format = nl_for_platform(platform)

  if old_file == new_file
    require 'tempfile'
    temp_name = Time.new.strftime('%Y%m%d%H%M%S')
    Tempfile.open("ruby_temp_#{temp_name}") do |nf|
      File.foreach(old_file) do |line|
        line.chomp!
        nf.print("#{line}#{format}")
      end
      nf.close
      require 'fileutils'
      File.delete(old_file)
      FileUtils.mv(nf.path, old_file)
    end
  else
    File.open(new_file, 'w') do |nf|
      File.foreach(old_file) do |line|
        line.chomp!
        nf.print("#{line}#{format}")
      end
    end
  end

  self
end

.nl_for_platform(platform) ⇒ Object

Returns the newline characters for the given platform.



408
409
410
411
412
413
414
415
416
417
418
419
420
421
 
# File 'lib/ptools.rb', line 408

def self.nl_for_platform(platform)
  platform = RbConfig::CONFIG['host_os'] if platform == 'local'

  case platform
    when /dos|windows|win32|mswin|mingw/i
      "\cM\cJ"
    when /unix|linux|bsd|cygwin|osx|darwin|solaris|sunos/i
      "\cJ"
    when /mac|apple|macintosh/i
      "\cM"
    else
      raise ArgumentError, 'Invalid platform string'
  end
end

.png?(file) ⇒ Boolean

Is the file a png file?

Returns:

  • (Boolean) 


438
439
440
 
# File 'lib/ptools.rb', line 438

def self.png?(file)
  File.read(file, 4, nil, :encoding => 'binary') == String.new("\211PNG").force_encoding(Encoding::BINARY)
end

.sparse?(file) ⇒ Boolean

Returns whether or not file is a sparse file.

A sparse file is a any file where its size is greater than the number of 512k blocks it consumes, i.e. its apparent and actual file size is not the same.

See en.wikipedia.org/wiki/Sparse_file for more information.

Returns:

  • (Boolean) 


384
385
386
387
 
# File 'lib/ptools.rb', line 384

def self.sparse?(file)
  stats = File.stat(file)
  stats.size > stats.blocks * BLOCK_SIZE
end

.tail(filename, num_lines = 10, &block) ⇒ Object

In block form, yields the last num_lines of file filename. In non-block form, it returns the lines as an array.

Example:

File.tail('somefile.txt') # => ['This is line7', 'This is line8', ...]

If you’re looking for tail -f functionality, please use the file-tail gem instead.

– Internally I’m using a 64 chunk of memory at a time. I may allow the size to be configured in the future as an optional 3rd argument.



238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/ptools.rb', line 238

def self.tail(filename, num_lines = 10, &block)
  # MS Windows gets unhappy if you try to seek backwards past the
  # end of the file, so we have some extra checks here and later.
  file_size  = File.size(filename)
  read_bytes = file_size % TAIL_CHUNK_SIZE
  read_bytes = TAIL_CHUNK_SIZE if read_bytes == 0

  line_sep = File::ALT_SEPARATOR ? "\r\n" : "\n"

  buf = ''

  # Open in binary mode to ensure line endings aren't converted.
  File.open(filename, 'rb') do |fh|
    position = file_size - read_bytes # Set the starting read position

    # Loop until we have the lines or run out of file
    while buf.scan(line_sep).size <= num_lines and position >= 0
      fh.seek(position, IO::SEEK_SET)
      buf = fh.read(read_bytes) + buf
      read_bytes = TAIL_CHUNK_SIZE
      position -= read_bytes
    end
  end

  lines = buf.split(line_sep).pop(num_lines)

  if block_given?
    lines.each(&block)
  else
    lines
  end
end

.tiff?(file) ⇒ Boolean

Is the file a tiff?

Returns:

  • (Boolean) 


450
451
452
453
454
455
456
457
458
459
460
461
462
463
 
# File 'lib/ptools.rb', line 450

def self.tiff?(file)
  return false if File.size(file) < 12

  bytes = File.read(file, 4)

  # II is Intel, MM is Motorola
  return false if bytes[0..1] != 'II' && bytes[0..1] != 'MM'

  return false if bytes[0..1] == 'II' && bytes[2..3].ord != 42

  return false if bytes[0..1] == 'MM' && bytes[2..3].reverse.ord != 42

  true
end

.touch(filename) ⇒ Object

Changes the access and modification time if present, or creates a 0 byte file filename if it doesn’t already exist.



318
319
320
321
322
323
324
325
326
 
# File 'lib/ptools.rb', line 318

def self.touch(filename)
  if File.exist?(filename)
    time = Time.now
    File.utime(time, time, filename)
  else
    File.open(filename, 'w'){}
  end
  self
end

.wc(filename, option = 'all') ⇒ Object

With no arguments, returns a four element array consisting of the number of bytes, characters, words and lines in filename, respectively.

Valid options are ‘bytes’, ‘characters’ (or just ‘chars’), ‘words’ and ‘lines’.

Raises:

  • (ArgumentError) 


334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
 
# File 'lib/ptools.rb', line 334

def self.wc(filename, option = 'all')
  option = option.downcase
  valid = %w[all bytes characters chars lines words]

  raise ArgumentError, "Invalid option: '#{option}'" unless valid.include?(option)

  n = 0

  if option == 'lines'
    File.foreach(filename){ n += 1 }
    n
  elsif option == 'bytes'
    File.open(filename) do |f|
      f.each_byte{ n += 1 }
    end
    n
  elsif %w[characters chars].include?(option)
    File.open(filename) do |f|
      n += 1 while f.getc
    end
    n
  elsif option == 'words'
    File.foreach(filename) do |line|
      n += line.split.length
    end
    n
  else
    bytes, chars, lines, words = 0, 0, 0, 0
    File.open(filename) do |f|
      while (line = f.gets)
        lines += 1
        words += line.split.length
        chars += line.chars.length
        bytes += line.bytesize
      end
    end
    [bytes, chars, words, lines]
  end
end

.whereis(program, path = ENV.fetch('PATH', nil)) ⇒ Object

Returns an array of each program within path, or nil if it cannot be found.

On Windows, it looks for executables ending with the suffixes defined in your PATHEXT environment variable, or ‘.exe’, ‘.bat’ and ‘.com’ if that isn’t defined, which you may optionally include in program.

Examples:

File.whereis('ruby') # => ['/usr/bin/ruby', '/usr/local/bin/ruby']
File.whereis('foo')  # => nil

Raises:

  • (ArgumentError) 


150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/ptools.rb', line 150

def self.whereis(program, path = ENV.fetch('PATH', nil))
  raise ArgumentError, 'path cannot be empty' if path.nil? || path.empty?

  paths = []

  # Bail out early if an absolute path is provided.
  if program =~ /^\/|^[a-z]:[\\\/]/i
    program += WIN32EXTS if MSWINDOWS && File.extname(program).empty?
    program = program.tr(File::ALT_SEPARATOR, File::SEPARATOR) if MSWINDOWS
    found = Dir[program]
    if found[0] && File.executable?(found[0]) && !File.directory?(found[0])
      if File::ALT_SEPARATOR
        return found.map{ |f| f.tr(File::SEPARATOR, File::ALT_SEPARATOR) }
      else
        return found
      end
    else
      return nil
    end
  end

  # Iterate over each path glob the dir + program.
  path.split(File::PATH_SEPARATOR).each do |dir|
    next unless File.exist?(dir) # In case of bogus second argument

    file = File.join(dir, program)

    # Dir[] doesn't handle backslashes properly, so convert them. Also, if
    # the program name doesn't have an extension, try them all.
    if MSWINDOWS
      file = file.tr(File::ALT_SEPARATOR, File::SEPARATOR)
      file += WIN32EXTS if File.extname(program).empty?
    end

    found = Dir[file].first

    # Convert all forward slashes to backslashes if supported
    if found && File.executable?(found) && !File.directory?(found)
      found.tr!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
      paths << found
    end
  end

  paths.empty? ? nil : paths.uniq
end

.which(program, path = ENV.fetch('PATH', nil)) ⇒ Object

Looks for the first occurrence of program within path.

On Windows, it looks for executables ending with the suffixes defined in your PATHEXT environment variable, or ‘.exe’, ‘.bat’ and ‘.com’ if that isn’t defined, which you may optionally include in program.

Returns nil if not found.

Examples:

File.which('ruby') # => '/usr/local/bin/ruby'
File.which('foo')  # => nil

Raises:

  • (ArgumentError) 


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/ptools.rb', line 97

def self.which(program, path = ENV.fetch('PATH', nil))
  raise ArgumentError, 'path cannot be empty' if path.nil? || path.empty?

  # Bail out early if an absolute path is provided.
  if program =~ /^\/|^[a-z]:[\\\/]/i
    program += WIN32EXTS if MSWINDOWS && File.extname(program).empty?
    found = Dir[program].first
    if found && File.executable?(found) && !File.directory?(found)
      return found
    else
      return nil
    end
  end

  # Iterate over each path glob the dir + program.
  path.split(File::PATH_SEPARATOR).each do |dir|
    dir = File.expand_path(dir)

    next unless File.exist?(dir) # In case of bogus second argument

    file = File.join(dir, program)

    # Dir[] doesn't handle backslashes properly, so convert them. Also, if
    # the program name doesn't have an extension, try them all.
    if MSWINDOWS
      file = file.tr(File::ALT_SEPARATOR, File::SEPARATOR)
      file += WIN32EXTS if File.extname(program).empty?
    end

    found = Dir[file].first

    # Convert all forward slashes to backslashes if supported
    if found && File.executable?(found) && !File.directory?(found)
      found.tr!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
      return found
    end
  end

  nil
end