ptools 1.1.9-x86-mingw32

data/ptools.gemspec

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rbconfig'
+
+Gem::Specification.new do |gem|
+  gem.name       = 'ptools'
+  gem.version    = '1.1.9'
+  gem.license    = 'Artistic 2.0'
+  gem.author     = 'Daniel J. Berger'
+  gem.email      = 'djberg96@gmail.com'
+  gem.homepage   = 'http://www.rubyforge.org/projects/shards'
+  gem.summary    = 'Extra methods for the File class'
+  gem.test_files = Dir['test/test*']
+  gem.has_rdoc   = true
+  gem.files      = Dir['**/*'].reject{ |f| f.include?('CVS') || f.include?('git') }
+
+  gem.rubyforge_project = 'shards'
+  gem.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
+
+  gem.description = <<-EOF
+    The ptools (power tools) library provides several handy methods to
+    Ruby's core File class, such as File.which for finding executables,
+    File.null to return the null device on your platform, and so on.
+  EOF
+
+  gem.add_development_dependency('test-unit', '>= 2.0.7')
+
+  if Config::CONFIG['host_os'] =~ /mswin|win32|msdos|cygwin|mingw/i
+    gem.platform = Gem::Platform::CURRENT
+    gem.add_dependency('win32-file', '>= 0.5.4')
+  end
+end

data/test/test_binary.rb

@@ -0,0 +1,43 @@
+#####################################################################
+# tc_binary.rb
+# 
+# Test case for the File.binary? method. You should run this test
+# via the 'rake test_binary' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_Binary < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+   end
+   
+   def setup
+      @text_file = 'test_file1.txt'
+   end
+
+   def test_binary_basic
+      assert_respond_to(File, :binary?)
+      assert_nothing_raised{ File.binary?(@text_file) }
+   end
+
+   def test_binary_expected_results
+      assert_equal(false, File.binary?(@text_file))
+   end
+
+   def test_binary_expected_errors
+      assert_raise_kind_of(SystemCallError){ File.binary?('bogus') }
+   end
+
+   def teardown
+      @text_file = nil
+   end
+
+   def self.shutdown
+      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
+   end
+end

data/test/test_constants.rb

@@ -0,0 +1,32 @@
+#####################################################################
+# test_constants.rb
+#
+# Tests the constants that have been defined for our package. This
+# test case should be run via the 'rake test_constants' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'rbconfig'
+require 'ptools'
+
+class TC_Constants < Test::Unit::TestCase
+   def test_version
+      assert_equal('1.1.9', File::PTOOLS_VERSION)
+   end
+
+   def test_image_ext
+      assert_equal(%w/.bmp .gif .jpeg .jpg .png/, File::IMAGE_EXT.sort)
+   end
+
+   def test_windows
+      omit_unless(Config::CONFIG['host_os'].match('mswin'), "Skipping on Unix systems")
+      assert_not_nil(File::IS_WINDOWS)
+   end
+
+   def test_win32exts
+      omit_unless(Config::CONFIG['host_os'].match('mswin'), "Skipping on Unix systems")
+      assert_not_nil(File::WIN32EXTS)
+   end
+end

data/test/test_head.rb

@@ -0,0 +1,51 @@
+######################################################################
+# test_head.rb
+# 
+# Test case for the File.head method. This test should be run via
+# the 'rake test_head' task.
+######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileHead < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+   end
+   
+   def setup
+      @test_file = 'test_file1.txt'
+      @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
+
+   def test_head_basic
+      assert_respond_to(File, :head)
+      assert_nothing_raised{ File.head(@test_file) }
+      assert_nothing_raised{ File.head(@test_file, 5) }
+      assert_nothing_raised{ File.head(@test_file){} }
+   end
+
+   def test_head_expected_results
+      assert_kind_of(Array, File.head(@test_file))
+      assert_equal(@expected_head1, File.head(@test_file))
+      assert_equal(@expected_head2, File.head(@test_file, 5))
+   end
+
+   def test_head_expected_errors
+      assert_raises(ArgumentError){ File.head(@test_file, 5, "foo") }
+      assert_raises(Errno::ENOENT){ File.head("bogus") }
+   end
+
+   def teardown
+      @test_file = nil
+   end
+
+   def self.shutdown
+      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
+   end
+end

data/test/test_image.rb

@@ -0,0 +1,43 @@
+#####################################################################
+# test_image.rb
+# 
+# Test case for the File.image? method. You should run this test
+# via the 'rake test_image' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_Ptools_Image < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+   end
+   
+   def setup   
+      @text_file = 'test_file1.txt'
+   end
+
+   def test_image_basic
+      assert_respond_to(File, :image?)
+      assert_nothing_raised{ File.image?(@text_file) }
+   end
+
+   def test_image_expected_results
+      assert_equal(false, File.image?(@text_file))
+   end
+
+   def test_image_expected_errors
+      assert_raises(Errno::ENOENT, ArgumentError){ File.image?('bogus') }
+   end
+
+   def teardown
+      @text_file = nil
+   end
+
+   def self.shutdown
+      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
+   end
+end

data/test/test_middle.rb

@@ -0,0 +1,61 @@
+#####################################################################
+# test_middle.rb
+#
+# Test case for the File.middle method. You should run this test
+# via the 'rake test_middle' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileMiddle < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+   end
+   
+   def setup   
+      @test_file = 'test_file1.txt'
+
+      @expected_middle1 = ["line10\n", "line11\n", "line12\n", "line13\n", "line14\n"]
+      @expected_middle1.push("line15\n","line16\n", "line17\n", "line18\n")
+      @expected_middle1.push("line19\n","line20\n")
+
+      @expected_middle2 = ["line14\n","line15\n","line16\n","line17\n"]
+      @expected_middle2.push("line18\n","line19\n","line20\n")
+
+      @expected_middle3 = ["line5\n","line6\n","line7\n"]
+      @expected_middle3.push("line8\n","line9\n","line10\n")
+   end
+
+   def test_method_basic
+      assert_respond_to(File, :middle)
+      assert_nothing_raised{ File.middle(@test_file) }
+      assert_nothing_raised{ File.middle(@test_file, 14) }
+      assert_nothing_raised{ File.middle(@test_file, 5, 10) }
+      assert_nothing_raised{ File.middle(@test_file){} }
+   end
+
+   def test_middle_expected_results
+      assert_kind_of(Array, File.middle(@test_file))
+      assert_equal(@expected_middle1, File.middle(@test_file))
+      assert_equal(@expected_middle2, File.middle(@test_file, 14))
+      assert_equal(@expected_middle3, File.middle(@test_file, 5, 10))
+   end
+
+   def test_middle_expected_errors
+      assert_raises(ArgumentError){ File.middle }
+      assert_raises(ArgumentError){ File.middle(@test_file, 5, 10, 15) }
+      assert_raises(NoMethodError){ File.middle(@test_file, "foo") }
+      assert_raises(Errno::ENOENT){ File.middle("bogus") }
+   end
+
+   def teardown
+      @test_file = nil
+      @expected_middle1 = nil
+      @expected_middle2 = nil
+      @expected_middle3 = nil
+   end
+end

data/test/test_nlconvert.rb

@@ -0,0 +1,89 @@
+#####################################################################
+# test_nlconvert.rb
+#
+# Test case for the File.nl_convert method. You should run this
+# test via the 'rake test_nlconvert' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileNLConvert < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+      File.open('test_file2.txt', 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+   end
+   
+   def setup   
+      @test_file1 = 'test_file1.txt'
+      @test_file2 = 'test_file2.txt'
+      @dos_file   = 'dos_test_file.txt'
+      @mac_file   = 'mac_test_file.txt'
+      @unix_file  = 'nix_test_file.txt'
+   end
+
+   def test_nl_convert_basic
+      assert_respond_to(File, :nl_convert)
+      assert_nothing_raised{ File.nl_convert(@test_file2) }
+      assert_nothing_raised{ File.nl_convert(@test_file2, @test_file2) }
+      assert_nothing_raised{ File.nl_convert(@test_file2, @test_file2, "unix") }
+   end
+
+   def test_nl_convert_to_dos
+      msg = "dos file should be larger, but isn't"
+
+      assert_nothing_raised{ File.nl_convert(@test_file1, @dos_file, "dos") }
+      assert_equal(true, File.size(@dos_file) > File.size(@test_file1), msg)
+      assert_equal(["\cM","\cJ"],
+         IO.readlines(@dos_file).first.split("")[-2..-1]
+      )
+   end
+
+   def test_nl_convert_to_mac
+      assert_nothing_raised{ File.nl_convert(@test_file1, @mac_file, 'mac') }
+      assert_equal("\cM", IO.readlines(@mac_file).first.split("").last)
+
+      omit_if(Config::CONFIG['host_os'] =~ /win32|mswin|dos|cygwin|mingw/i)
+      msg = "=> Mac file should be the same size (or larger), but isn't"
+      assert_true(File.size(@mac_file) == File.size(@test_file1), msg)
+   end
+   
+   def test_nl_convert_to_unix
+      msg = "unix file should be the same size (or smaller), but isn't"
+
+      assert_nothing_raised{ File.nl_convert(@test_file1, @unix_file, "unix") }
+      assert_equal("\n", IO.readlines(@unix_file).first.split("").last)
+
+      if File::ALT_SEPARATOR
+         assert_equal(true, File.size(@unix_file) >= File.size(@test_file1),msg)
+      else
+         assert_equal(true, File.size(@unix_file) <= File.size(@test_file1),msg)
+      end
+   end
+   
+   def test_nl_convert_expected_errors
+      assert_raises(ArgumentError){ File.nl_convert }
+      assert_raises(ArgumentError){
+         File.nl_convert(@test_file1, "bogus.txt", "blah")
+      }
+   end
+
+   def teardown
+      [@dos_file, @mac_file, @unix_file].each{ |file|
+         File.delete(file) if File.exists?(file)
+      }
+      @dos_file   = nil
+      @mac_file   = nil
+      @unix_file  = nil
+      @test_file1 = nil
+      @test_file2 = nil
+   end
+
+   def self.shutdown
+      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
+      File.delete('test_file2.txt') if File.exists?('test_file2.txt')
+   end
+end

data/test/test_null.rb

@@ -0,0 +1,37 @@
+#####################################################################
+# test_null.rb
+# 
+# Test case for the File.null method. You should run this test via
+# the 'rake test_null' task.
+#####################################################################
+require 'test/unit'
+require 'ptools'
+
+class TC_Null < Test::Unit::TestCase
+   def setup
+      @nulls = ['/dev/null', 'NUL', 'NIL:', 'NL:']
+   end
+
+   def test_null_basic
+      assert_respond_to(File, :null)
+      assert_nothing_raised{ File.null }
+   end
+
+   def test_null_expected_results
+      assert_kind_of(String, File.null)
+      assert(@nulls.include?(File.null))
+   end
+
+   def test_null_expected_errors
+      assert_raises(ArgumentError){ File.null(1) }
+   end
+
+   def test_null_device_alias
+      assert_respond_to(File, :null_device)
+      assert_equal(true, File.method(:null) == File.method(:null_device))
+   end
+
+   def teardown
+      @nulls = nil
+   end
+end

data/test/test_tail.rb

@@ -0,0 +1,56 @@
+#####################################################################
+# test_tail.rb
+#
+# Test case for the File.tail method. This test should be run via
+# the 'rake test_tail' task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'ptools'
+
+class TC_FileTail < Test::Unit::TestCase
+   def self.startup
+      Dir.chdir('test') if File.exists?('test')
+      File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+   end
+   
+   def setup     
+      @test_file = 'test_file1.txt'
+
+      @expected_tail1 = ["line16\n","line17\n","line18\n","line19\n"]
+      @expected_tail1.push("line20\n","line21\n","line22\n", "line23\n")
+      @expected_tail1.push("line24\n","line25\n")
+
+      @expected_tail2 = ["line21\n","line22\n","line23\n","line24\n","line25\n"]
+   end
+
+   def test_tail_basic
+      assert_respond_to(File, :tail)
+      assert_nothing_raised{ File.tail(@test_file) }
+      assert_nothing_raised{ File.tail(@test_file, 5) }
+      assert_nothing_raised{ File.tail(@test_file){} }
+   end
+
+   def test_tail_expected_return_values
+      assert_kind_of(Array, File.tail(@test_file))
+      assert_equal(@expected_tail1, File.tail(@test_file))
+      assert_equal(@expected_tail2, File.tail(@test_file, 5))
+   end
+
+   def test_tail_expected_errors
+      assert_raises(ArgumentError){ File.tail }
+      assert_raises(ArgumentError){ File.tail(@test_file, 5, 5) }
+   end
+
+   def teardown
+      @test_file = nil
+      @expected_tail1 = nil
+      @expected_tail2 = nil
+   end
+
+   def self.shutdown
+      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
+   end
+end