ptools 1.3.3 → 1.4.0

data/spec/binary_spec.rb

@@ -0,0 +1,59 @@
+#####################################################################
+# test_binary.rb
+#
+# Test case for the File.binary? method. You should run this test
+# via the 'rake test_binary' task.
+#####################################################################
+require 'rubygems'
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :binary do
+  let(:dirname)  { File.dirname(__FILE__) }
+  let(:bin_file) { File::ALT_SEPARATOR ? File.join(ENV['windir'], 'notepad.exe') : '/bin/ls' }
+
+  before do
+    @txt_file = File.join(dirname, 'txt', 'english.txt')
+    @emp_file = File.join(dirname, 'txt', 'empty.txt')
+    @uni_file = File.join(dirname, 'txt', 'korean.txt')
+    @utf_file = File.join(dirname, 'txt', 'english.utf16')
+    @png_file = File.join(dirname, 'img', 'test.png')
+    @jpg_file = File.join(dirname, 'img', 'test.jpg')
+    @gif_file = File.join(dirname, 'img', 'test.gif')
+  end
+
+  example "File.binary? basic functionality" do
+    expect(File).to respond_to(:binary?)
+    expect{ File.binary?(@txt_file) }.not_to raise_error
+  end
+
+  example "File.binary? returns true for binary files" do
+    expect(File.binary?(bin_file)).to be true
+  end
+
+  example "File.binary? returns false for text files" do
+    expect(File.binary?(@emp_file)).to be false
+    expect(File.binary?(@txt_file)).to be false
+    expect(File.binary?(@uni_file)).to be false
+    expect(File.binary?(@utf_file)).to be false
+  end
+
+  example "File.binary? returns false for image files" do
+    expect(File.binary?(@png_file)).to be false
+    expect(File.binary?(@jpg_file)).to be false
+    expect(File.binary?(@gif_file)).to be false
+  end
+
+  example "File.binary? accepts an optional percentage argument" do
+    expect(File.binary?(@txt_file, 0.50)).to be false
+    expect(File.binary?(@txt_file, 0.05)).to be true
+  end
+
+  example "File.binary? raises an error if the file cannot be found" do
+    expect{ File.binary?('bogus') }.to raise_error(SystemCallError)
+  end
+
+  example "File.binary? only accepts one argument" do
+    expect{ File.binary?(@txt_file, bin_file) }.to raise_error(ArgumentError)
+  end
+end

data/spec/constants_spec.rb

@@ -0,0 +1,33 @@
+##############################################################################
+# constants_spec.rb
+#
+# Specs for the constants that have been defined in the ptools library.
+# This test case should be run via the 'rake spec:constants' task.
+##############################################################################
+require 'rubygems'
+require 'rspec'
+require 'rbconfig'
+require 'ptools'
+
+RSpec.describe File, :constants do
+  let(:windows) { File::ALT_SEPARATOR }
+
+  example "PTOOLS_VERSION constant is set to expected value" do
+    expect(File::PTOOLS_VERSION).to eq('1.4.0')
+    expect(File::PTOOLS_VERSION.frozen?).to be true
+  end
+
+  example "IMAGE_EXT constant is set to array of values" do
+    expect(File::IMAGE_EXT.sort).to eq(%w[.bmp .gif .jpeg .jpg .png])
+  end
+
+  example "WINDOWS constant is defined on MS Windows" do
+    skip "skipped unless MS Windows" unless windows
+    expect(File::MSWINDOWS).not_to be_nil
+  end
+
+  example "WIN32EXTS constant is defined on MS Windows" do
+    skip "skipped unless MS Windows" unless windows
+    expect(File::WIN32EXTS).not_to be_nil
+  end
+end

data/spec/head_spec.rb

@@ -0,0 +1,41 @@
+######################################################################
+# head_spec.rb
+#
+# Specs for the File.head method. These specs should be run via
+# the 'rake spec:head' task.
+######################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :head do
+  let(:test_file) { 'test_file_head.txt' }
+
+  before do
+    File.open(test_file, 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+    @expected_head1 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
+    @expected_head1.push("line6\n","line7\n","line8\n","line9\n","line10\n")
+    @expected_head2 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
+  end
+
+  example "head method basic functionality" do
+    expect(File).to respond_to(:head)
+    expect{ File.head(test_file) }.not_to raise_error
+    expect{ File.head(test_file, 5) }.not_to raise_error
+    expect{ File.head(test_file){} }.not_to raise_error
+  end
+
+  example "head method returns the expected results" do
+    expect(File.head(test_file)).to be_kind_of(Array)
+    expect(File.head(test_file)).to eq(@expected_head1)
+    expect(File.head(test_file, 5)).to eq(@expected_head2)
+  end
+
+  example "head method requires two arguments" do
+    expect{ File.head(test_file, 5, "foo") }.to raise_error(ArgumentError)
+    expect{ File.head("bogus") }.to raise_error(Errno::ENOENT)
+  end
+
+  after do
+    File.delete(test_file) if File.exists?(test_file)
+  end
+end

data/spec/image_spec.rb

@@ -0,0 +1,51 @@
+#####################################################################
+# image_spec.rb
+#
+# Specs for the File.image? method. You should run these specs via
+# the 'rake spec:image' task.
+#####################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :image do
+  before do
+    Dir.chdir('spec') if File.exist?('spec')
+    @txt_file  = File.join(Dir.pwd, 'txt', 'english.txt')
+    @uni_file  = File.join(Dir.pwd, 'txt', 'korean.txt')
+    @jpg_file  = File.join(Dir.pwd, 'img', 'test.jpg')
+    @png_file  = File.join(Dir.pwd, 'img', 'test.png')
+    @gif_file  = File.join(Dir.pwd, 'img', 'test.gif')
+    @ico_file  = File.join(Dir.pwd, 'img', 'test.ico')
+  end
+
+  example "image? method basic functionality" do
+    expect(File).to respond_to(:image?)
+    expect{ File.image?(@txt_file) }.not_to raise_error
+    expect(File.image?(@txt_file)).to be(true).or be(false)
+  end
+
+  example "image? method returns false for a text file" do
+    expect(File.image?(@txt_file)).to be false
+    expect(File.image?(@uni_file)).to be false
+  end
+
+  example "image? method returns true for a gif" do
+    expect(File.image?(@gif_file)).to be true
+  end
+
+  example "image? method returns true for a jpeg" do
+    expect(File.image?(@jpg_file)).to be true
+  end
+
+  example "image? method returns true for a png" do
+    expect(File.image?(@png_file)).to be true
+  end
+
+  example "image? method returns true for an ico" do
+    expect(File.image?(@ico_file)).to be true
+  end
+
+  example "image? method raises an error if the file does not exist" do
+    expect{ File.image?('bogus') }.to raise_error(Exception) # Errno::ENOENT or ArgumentError
+  end
+end

data/spec/nlconvert_spec.rb

@@ -0,0 +1,104 @@
+#####################################################################
+# test_nlconvert.rb
+#
+# Test case for the File.nl_convert method. You should run this
+# test via the 'rake test_nlconvert' task.
+#####################################################################
+require 'rubygems'
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :nlconvert do
+  let(:windows)    { File::ALT_SEPARATOR }
+  let(:dirname)    { File.dirname(__FILE__) }
+  let(:test_file1) { File.join(dirname, 'test_nl_convert1.txt') }
+  let(:test_file2) { File.join(dirname, 'test_nl_convert2.txt') }
+
+  before do
+    File.open(test_file1, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+    File.open(test_file2, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+    @test_file1 = File.join(dirname, 'test_nl_convert1.txt')
+    @test_file2 = File.join(dirname, 'test_nl_convert2.txt')
+    @dos_file   = File.join(dirname, 'dos_test_file.txt')
+    @mac_file   = File.join(dirname, 'mac_test_file.txt')
+    @unix_file  = 'unix_test_file.txt'
+  end
+
+  example "nl_for_platform basic functionality" do
+    expect(File).to respond_to(:nl_for_platform)
+  end
+
+  example "nl_for_platform returns expected results" do
+    expect(File.nl_for_platform('dos') ).to eq( "\cM\cJ")
+    expect(File.nl_for_platform('unix') ).to eq( "\cJ")
+    expect(File.nl_for_platform('mac') ).to eq( "\cM")
+
+  end
+
+  example "nl_for_platform with 'local' platform does not raise an error" do
+    expect{ File.nl_for_platform('local') }.not_to raise_error
+  end
+
+  example "nl_for_platform with unsupported platform raises an error" do
+    expect{ File.nl_for_platform('bogus') }.to raise_error(ArgumentError)
+  end
+
+  example "nl_convert basic functionality" do
+    expect(File).to respond_to(:nl_convert)
+  end
+
+  example "nl_convert accepts one, two or three arguments" do
+    expect{ File.nl_convert(@test_file2) }.not_to raise_error
+    expect{ File.nl_convert(@test_file2, @test_file2) }.not_to raise_error
+    expect{ File.nl_convert(@test_file2, @test_file2, "unix") }.not_to raise_error
+  end
+
+  example "nl_convert with dos platform argument works as expected" do
+    expect{ File.nl_convert(@test_file1, @dos_file, "dos") }.not_to raise_error
+    expect{ File.nl_convert(@test_file1, @dos_file, "dos") }.not_to raise_error
+    expect(File.size(@dos_file)).to be > File.size(@test_file1)
+    expect(IO.readlines(@dos_file).first.split("")[-2..-1]).to eq(["\cM","\cJ"])
+  end
+
+  example "nl_convert with mac platform argument works as expected" do
+    expect{ File.nl_convert(@test_file1, @mac_file, 'mac') }.not_to raise_error
+    expect(IO.readlines(@mac_file).first.split("").last).to eq("\cM")
+
+    skip if windows
+    expect(File.size(@mac_file)).to eq(File.size(@test_file1))
+  end
+
+  example "nl_convert with unix platform argument works as expected" do
+    expect{ File.nl_convert(@test_file1, @unix_file, "unix") }.not_to raise_error
+    expect(IO.readlines(@unix_file).first.split("").last).to eq("\n")
+
+    if windows
+      expect(File.size(@unix_file) >= File.size(@test_file1)).to be true
+    else
+      expect(File.size(@unix_file) <= File.size(@test_file1)).to be true
+    end
+  end
+
+  example "nl_convert requires at least one argument" do
+    expect{ File.nl_convert }.to raise_error(ArgumentError)
+  end
+
+  example "nl_convert requires a valid platform string" do
+    expect{ File.nl_convert(@test_file1, "bogus.txt", "blah") }.to raise_error(ArgumentError)
+  end
+
+  example "nl_convert accepts a maximum of three arguments" do
+    expect{ File.nl_convert(@example_file1, @test_file2, 'dos', 1) }.to raise_error(ArgumentError)
+    expect{ File.nl_convert(@test_file1, @test_file2, 'dos', 1) }.to raise_error(ArgumentError)
+  end
+
+  example "nl_convert will fail on anything but plain files" do
+    expect{ File.nl_convert(IO::NULL, @test_file1) }.to raise_error(ArgumentError)
+  end
+
+  after do
+    [@dos_file, @mac_file, @unix_file].each{ |file| File.delete(file) if File.exist?(file) }
+    File.delete(test_file1) if File.exist?(test_file1)
+    File.delete(test_file2) if File.exist?(test_file2)
+  end
+end

data/spec/sparse_spec.rb

@@ -0,0 +1,43 @@
+#####################################################################
+# test_is_sparse.rb
+#
+# Test case for the File.sparse? method. You should run this test
+# via the 'rake test:is_sparse' task.
+#####################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :sparse do
+  let(:windows) { File::ALT_SEPARATOR }
+  let(:osx) { RbConfig::CONFIG['host_os'] =~ /darwin|osx/i }
+  let(:non_sparse_file) { File.expand_path(File.basename(__FILE__)) }
+  let(:sparse_file) { 'test_sparse_file' }
+
+  before do
+    Dir.chdir("spec") if File.exist?("spec")
+    system("dd of=#{sparse_file} bs=1k seek=5120 count=0 2>/dev/null") unless windows
+  end
+
+  example "is_sparse basic functionality" do
+    skip "skipped on MS Windows or OSX" if windows || osx
+    expect(File).to respond_to(:sparse?)
+    expect{ File.sparse?(sparse_file) }.not_to raise_error
+    expect(File.sparse?(sparse_file)).to be(true).or be(false)
+  end
+
+  example "is_sparse returns the expected results" do
+    skip "skipped on MS Windows or OSX" if windows || osx
+    expect(File.sparse?(sparse_file)).to be true
+    expect(File.sparse?(non_sparse_file)).to be false
+  end
+
+  example "is_sparse only accepts one argument" do
+    skip if windows
+    expect{ File.sparse?(sparse_file, sparse_file) }.to raise_error(ArgumentError)
+  end
+
+  after do
+    Dir.chdir("spec") if File.exist?("spec")
+    File.delete(sparse_file) if File.exist?(sparse_file)
+  end
+end

data/spec/tail_spec.rb

@@ -0,0 +1,107 @@
+#####################################################################
+# tail_spec.rb
+#
+# Tests for the File.tail method. This test should be run via
+# the 'rake spec:tail' task.
+#####################################################################
+require 'rspec'
+require 'ptools'
+
+RSpec.describe File, :tail do
+  let(:dirname)            { File.dirname(__FILE__) }
+  let(:test_file1)         { File.join(dirname, 'test_file1.txt') }
+  let(:test_file64)        { File.join(dirname, 'test_file64.txt') }
+  let(:test_file128)       { File.join(dirname, 'test_file128.txt') }
+  let(:test_file_trail)    { File.join(dirname, 'test_file_trail.txt') }
+  let(:test_file_trail_nl) { File.join(dirname, 'test_file_trail_nl.txt') }
+
+  before do
+    File.open(test_file1, 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+
+    # Trailing newline test
+    File.open(test_file_trail, 'w'){ |fh|
+      2.times{ |n| fh.puts "trail#{n+1}" }
+      fh.write "trail3"
+    }
+
+    File.open(test_file_trail_nl, 'w'){ |fh|
+      3.times{ |n| fh.puts "trail#{n+1}" }
+    }
+
+    # Larger files
+    test_tail_fmt_str = "line data data data data data data data %5s"
+
+    File.open(test_file64, 'w'){ |fh|
+      2000.times{ |n|
+        fh.puts test_tail_fmt_str % (n+1).to_s
+      }
+    }
+
+    File.open(test_file128, 'w'){ |fh|
+      4500.times{ |n|
+        fh.puts test_tail_fmt_str % (n+1).to_s
+      }
+    }
+
+    @expected_tail1 = %w{
+      line16 line17 line18 line19 line20
+      line21 line22 line23 line24 line25
+    }
+
+    @expected_tail2 = ["line21","line22","line23","line24","line25"]
+
+    @expected_tail_more = []
+    25.times{ |n| @expected_tail_more.push "line#{n+1}" }
+
+    @expected_tail_trail = %w{ trail2 trail3 }
+
+    @test_tail_fmt_str = "line data data data data data data data %5s"
+  end
+
+  example "tail basic functionality" do
+    expect(File).to respond_to(:tail)
+    expect{ File.tail(test_file1) }.not_to raise_error
+    expect{ File.tail(test_file1, 5) }.not_to raise_error
+    expect{ File.tail(test_file1){}.not_to raise_error }
+  end
+
+  example "tail returns the expected values" do
+    expect(File.tail(test_file1)).to be_kind_of(Array)
+    expect(File.tail(test_file1)).to eq(@expected_tail1)
+    expect(File.tail(test_file1, 5)).to eq(@expected_tail2)
+  end
+
+  example "specifying a number greater than the actual number of lines works as expected" do
+    expect(File.tail(test_file1, 30)).to eq(@expected_tail_more)
+  end
+
+  example "tail requires two arguments" do
+    expect{ File.tail }.to raise_error(ArgumentError)
+    expect{ File.tail(test_file1, 5, 5) }.to raise_error(ArgumentError)
+  end
+
+  example "tail works as expected when there is no trailing newline" do
+    expect(File.tail(test_file_trail, 2)).to eq(@expected_tail_trail)
+    expect(File.tail(test_file_trail_nl, 2)).to eq(@expected_tail_trail)
+  end
+
+  example "tail works as expected on a file larger than 64k" do
+    expected_tail_64k = []
+    2000.times{ |n| expected_tail_64k.push(@test_tail_fmt_str % (n+1).to_s) }
+    expect(File.tail(test_file64, 2000)).to eq(expected_tail_64k)
+  end
+
+  example "tail works as expected on a file larger than 128k" do
+    expected_tail_128k = []
+    4500.times{ |n| expected_tail_128k.push(@test_tail_fmt_str % (n+1).to_s) }
+    expect(File.tail(test_file128, 4500)).to eq(expected_tail_128k)
+  end
+
+  after do
+    File.delete(test_file1) if File.exist?(test_file1)
+    File.delete(test_file64) if File.exist?(test_file64)
+    File.delete(test_file128) if File.exist?(test_file128)
+    File.delete(test_file_trail_nl) if File.exist?(test_file_trail_nl)
+    File.delete(test_file_trail) if File.exist?(test_file_trail)
+  end
+end