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.0'.freeze
IMAGE_EXT = 
%w[.bmp .gif .jpg .jpeg .png .ico].freeze

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) 


70
71
72
73
74
75
76
77
78
 
# File 'lib/ptools.rb', line 70

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) 


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

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

.gif?(file) ⇒ Boolean

Is the file a gif?

Returns:

  • (Boolean) 


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

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 }



203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/ptools.rb', line 203

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) 


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

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) 


50
51
52
53
54
55
56
 
# File 'lib/ptools.rb', line 50

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) 


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

def self.jpg?(file)
  File.read(file, 10, nil, :encoding => 'binary') == "\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) 


283
284
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
 
# File 'lib/ptools.rb', line 283

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')
    nf = Tempfile.new("ruby_temp_#{temp_name}")
  else
    nf = File.new(new_file, 'w')
  end

  begin
    nf.open if old_file == new_file
    File.foreach(old_file) do |line|
      line.chomp!
      nf.print("#{line}#{format}")
    end
  ensure
    nf.close if nf && !nf.closed?
    if old_file == new_file
      require 'fileutils'
      File.delete(old_file)
      FileUtils.mv(nf.path, old_file)
    end
  end

  self
end

.nl_for_platform(platform) ⇒ Object

Returns the newline characters for the given platform.



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

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) 


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

def self.png?(file)
  File.read(file, 4, nil, :encoding => 'binary') == "\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) 


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

def self.sparse?(file)
  stats = File.stat(file)
  stats.size > stats.blocks * 512
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.



234
235
236
237
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
 
# File 'lib/ptools.rb', line 234

def self.tail(filename, num_lines = 10, &block)
  tail_size = 2**16 # 64k chunks

  # 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_size
  read_bytes = tail_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_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) 


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

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.



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

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) 


333
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
 
# File 'lib/ptools.rb', line 333

def self.wc(filename, option = 'all')
  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.foreach(filename) do |line|
      lines += 1
      words += line.split.length
      chars += line.chars.length
    end
    File.open(filename) do |f|
      bytes += 1 while f.getc
    end
    [bytes, chars, words, lines]
  end
end

.whereis(program, path = ENV['PATH']) ⇒ 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) 


146
147
148
149
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
 
# File 'lib/ptools.rb', line 146

def self.whereis(program, path = ENV['PATH'])
  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['PATH']) ⇒ 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) 


93
94
95
96
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
 
# File 'lib/ptools.rb', line 93

def self.which(program, path = ENV['PATH'])
  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