ptools 1.0.0

data/CHANGES

@@ -0,0 +1,40 @@
+== 1.0.0 - 2-Jun-2005
+* Modified the File.middle method to accept an optional block.
+* File.whereis is now limited to unique values so that redundant PATH entries
+  do not cause redundant entries in the returned array (or block).
+* File.nl_convert and File.touch now return self.
+* File.nl_convert now raises ArgumentError (instead of StandardError) if
+  an unknown platform is provided.
+* File.wc now raises ArgumentError (instead of RuntimeError) if a bad option
+  is provided.
+* Made documentation rdoc friendly.
+* Test suite updates, corrections and additions.
+* Removed the INSTALL file.  See the README instead.
+* Moved project to RubyForge.
+
+== 0.1.3 - 5-Dec-2003
+* Modified File#which and File#whereis for Win32 to handle extensions better,
+  i.e. you can send "ruby" or "ruby.exe" and get back the same result.
+* Minor test changes to tc_which.rb and tc_whereis.rb.
+
+== 0.1.2 - 14-May-2003
+* Modified nl_convert() to allow the destination filename to be the same as the
+  source file.  In that case, a tempfile is used and copied back over the
+  original file.
+* The target file name for nl_convert() now defaults to the source file name and
+  the default format is now "dos".
+* Added a tc_constants.rb test suite.
+* Test suite additions/fixes.
+* Updates to MANIFEST.
+
+== 0.1.1 - 21-Mar-2003
+* Modified File.tail to return data in the same order that 'tail' does.
+* Modified File.which to return nil if the program is not found.
+* Modified File.whereis now uses '\' instead of '/' on MS Windows.
+* Added File.middle class method.
+* Test suite modification & additions.
+* Thanks go to Shanko for both the spot and patch for tail, which, whereis
+  and middle.
+
+== 0.1.0 - 18-Mar-2003
+* Initial release

data/MANIFEST

@@ -0,0 +1,20 @@
+CHANGES
+README
+MANIFEST
+install.rb
+ptools.gemspec
+
+lib/ptools.rb
+
+test/ts_all.rb
+test/tc_constants.rb
+test/tc_head.rb
+test/tc_middle.rb
+test/tc_nlconvert.rb
+test/tc_tail.rb
+test/tc_touch.rb
+test/tc_wc.rb
+test/tc_which.rb
+test/tc_whereis.rb
+test/test_file.txt
+test/test_file2.txt

data/README

@@ -0,0 +1,62 @@
+== Description
+   The ptools (power tools) package is an additional set of commands for the
+   File class based on Unix command line tools.
+   
+== Prerequisites
+   Ruby 1.8.0 or later is recommended but not required.
+
+== Installation
+   ruby test/ts_all.rb (optional)
+   ruby install.rb
+
+== Synopsis
+   require "ptools"
+
+   File.which("ruby")         # '/usr/local/bin/ruby'
+   File.whereis("ruby")       # ['/usr/local/bin/ruby','/opt/bin/ruby']
+
+   File.head("myfile")        # Returns first 10 lines of 'myfile'
+   File.middle("myfile",8,12) # Returns lines 8-12 of 'myfile'
+   File.tail("myfile",3)      # Returns last 3 lines of 'myfile'
+   File.wc("myfile",'words')  # Returns the number of words in 'myfile'
+
+   File.touch("newfile")      # "newfile" now exists
+
+   # Creates a copy of 'myfile' called 'newfile', in DOS format
+   File.nl_convert("myfile", "newfile", "dos")
+   
+== Known Bugs
+   There is a bug in 1.6.x that can cause $\ characters to accumulate when
+   converting to DOS or MAC format if nl_convert is run multiple times on
+   the same file.  This appears to be fixed in 1.8.x.
+
+== Acknowledgements
+   The which() method was adopted from the FileWhich code posted by Michael
+   Granger on http://www.rubygarden.org.  The 'whereis' command is a minor
+   modification of that code as well.
+
+   The nl_convert() method was adopted (somewhat) from the nlcvt program
+   found at http://www.perl.com/language/ppt/src/nlcvt/nlcvt, written by
+   Tom Christiansen.
+    
+   The middle() method was provided by Shashank Date.
+
+== Future Plans
+   Add whatever other tools people think might be useful.
+   
+== License
+   Ruby's
+    
+== Copyright
+   (C) 2003-2005 Daniel J. Berger
+   All Rights Reserved.
+    
+== Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+
+== Author
+   Daniel J. Berger
+   djberg96 at gmail dot com
+   imperator on IRC (irc.freenode.net)

data/lib/ptools.rb

@@ -0,0 +1,230 @@
+class File
+
+   PTOOLS_VERSION = "1.0.0"
+   WIN32EXTS      = %w/.exe .com .bat/
+   
+   # Looks for the first occurrence of +program+ within +path+.
+   # 
+   # On Win32, it looks for executables ending with .exe, .bat and .com
+   # which you may optionally include in the program name.
+   #
+   # Returns nil if not found.  
+   def self.which(program, path=ENV['PATH'])
+      programs = program.to_a
+      
+      # If no file extension is provided on Windows, try .bat, .com
+      # and .exe in turn.
+      if File::ALT_SEPARATOR && File.extname(program).empty?
+         unless WIN32EXTS.include?(File.extname(program))
+            WIN32EXTS.each{ |ext|
+               programs.push(program + ext)
+            }
+         end
+      end
+      
+      # Catch the first path found, or nil
+      location = catch(:done){
+         path.split(File::PATH_SEPARATOR).each{ |dir|
+            programs.each{ |prog|
+               f = File.join(dir, prog)
+               if File.executable?(f) && !File.directory?(f)
+                  location = File.join(dir, prog)
+                  location.tr!('/',File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+                  throw(:done, location)
+               end
+            }
+         }
+         nil # Evaluate to nil if not found
+      }
+
+      location
+   end
+
+   # In block form, yields each +program+ within +path+.  In non-block
+   # form, returns an array of each +program+ within +path+.
+   #  
+   # On Win32, it looks for executables ending with .exe, .bat and .com
+   # which you may optionally include in the program name.
+   def self.whereis(program, path=ENV['PATH'])
+      dirs = []
+      programs = program.to_a
+      
+      # If no file extension is provided on Windows, try .bat, .com
+      # and .exe in turn.
+      if File::ALT_SEPARATOR && File.extname(program).empty?
+         unless WIN32EXTS.include?(File.extname(program))
+            WIN32EXTS.each{ |ext|
+               programs.push(program + ext)
+            }
+         end
+      end
+      
+      path.split(File::PATH_SEPARATOR).each{ |dir|
+         programs.each{ |prog|
+            file = File.join(dir,prog)
+            file.tr!('/',File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+            if File.executable?(file) && !File.directory?(file)
+               if block_given?
+                  yield file
+               else
+                  dirs << file
+               end
+            end
+         }
+      }
+      dirs.empty? ? nil : dirs.uniq
+   end
+
+   # In block form, yields the first +num_lines+ from +filename+.  In non-block
+   # form, returns an Array of +num_lines+
+   def self.head(filename, num_lines=10)
+      a = []
+      IO.foreach(filename){ |line|
+         break if num_lines <= 0
+         num_lines -= 1
+         if block_given?
+            yield line
+         else
+            a << line
+         end
+      }
+      return a.empty? ? nil : a # Return nil in block form
+   end
+
+   # In block form, yields line +from+ up to line +to+.  In non-block form
+   # returns an Array of lines from +from+ to +to+.
+   def self.middle(filename, from=10, to=20)
+      if block_given?
+         IO.readlines(filename)[from-1..to-1].each{ |line| yield line }
+      else
+         IO.readlines(filename)[from-1..to-1]
+      end
+   end
+
+   # In block form, yields the last +num_lines+ of file +filename+.
+   # In non-block form, it returns the lines as an array.
+   #
+   # Note that this method slurps the entire file, so I don't recommend it
+   # for very large files.  Also note that 'tail -f' functionality is not
+   # present.
+   def self.tail(filename, num_lines=10)
+      if block_given?
+         IO.readlines(filename).reverse[0..num_lines-1].reverse.each{ |line|
+            yield line
+         }
+      else
+         IO.readlines(filename).reverse[0..num_lines-1].reverse
+      end
+   end
+
+   # Converts a text file from one OS platform format to another, ala
+   # 'dos2unix'.  Valid values for 'format', which are case insensitve,
+   # include:
+
+   # * MS Windows -> dos, windows, win32
+   # * Unix/BSD   -> unix, linux, bsd
+   # * Mac        -> mac, macintosh, apple, osx
+
+   # 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.
+   def self.nl_convert(filename, newfilename=filename, platform="dos")
+
+      unless File.ftype(filename) == "file"
+         raise TypeError, "Only valid for plain text files"
+      end
+
+      if platform =~ /dos|windows|win32/i
+         format = "\cM\cJ"
+      elsif platform =~ /unix|linux|bsd/i
+         format = "\cJ"
+      elsif platform =~ /mac|apple|macintosh|osx/i
+         format = "\cM"
+      else
+         raise ArgumentError, "Invalid platform string"
+      end
+
+      orig = $\
+      $\ = format
+
+      if filename == newfilename
+         require "ftools"
+         require "tempfile"
+         tf = Tempfile.new("temp")
+         tf.open
+         IO.foreach(filename){ |line|
+            line.chomp!
+            tf.print line
+         }
+         tf.close
+         File.delete(filename)
+         File.copy(tf.path,filename)
+      else
+         nf = File.new(newfilename,"w+")  
+         IO.foreach(filename){ |line|
+            line.chomp!
+            nf.print line
+         }
+         nf.close
+      end
+
+      $\ = orig
+      self
+   end
+
+   # Creates the 0 byte file +filename+.
+   def self.touch(filename)
+      File.open(filename,"w+"){}
+      self
+   end
+
+   # 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'.
+   def self.wc(filename,option='all')
+      option.downcase!
+      valid = %w/all bytes characters chars lines words/
+
+      unless valid.include?(option)
+         raise ArgumentError, "Invalid option: '#{option}'"
+      end
+
+      n = 0
+      if option == 'lines'
+         IO.foreach(filename){ n += 1 }
+         return n
+      elsif option == 'bytes'
+         File.open(filename){ |f|
+            f.each_byte{ n += 1 }
+         }
+         return n
+      elsif option == 'characters' || option == 'chars'
+         File.open(filename){ |f|
+            while f.getc
+               n += 1
+            end
+         }
+         return n
+      elsif option == 'words'
+         IO.foreach(filename){ |line|
+            n += line.split.length
+         }
+         return n
+      else
+         bytes,chars,lines,words = 0,0,0,0
+         IO.foreach(filename){ |line|
+            lines += 1
+            words += line.split.length
+            chars += line.split('').length
+         }
+         File.open(filename){ |f|
+            while f.getc
+               bytes += 1
+            end
+         }
+         return [bytes,chars,words,lines]
+      end
+   end
+end

data/test/tc_constants.rb

@@ -0,0 +1,22 @@
+##################################################
+# tc_constants.rb
+#
+# Tests whatever constant that have been defined
+##################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_Constants < Test::Unit::TestCase
+   def test_version
+      assert_equal("1.0.0", File::PTOOLS_VERSION, "Bad VERSION")
+   end
+end

data/test/tc_head.rb

@@ -0,0 +1,49 @@
+##########################################
+# tc_head.rb
+# 
+# Test case for the File.head method.
+##########################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_FileHead < Test::Unit::TestCase
+   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
+end

data/test/tc_middle.rb

@@ -0,0 +1,58 @@
+##########################################
+# tc_middle.rb
+#
+# Test case for the File.middle method
+##########################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_FileMiddle < Test::Unit::TestCase
+   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
+   end
+end

data/test/tc_nlconvert.rb

@@ -0,0 +1,79 @@
+#############################################
+# tc_nlconvert.rb
+#
+# Test case for the File.nl_convert method.
+#############################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_FileNLConvert < Test::Unit::TestCase
+   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
+      if File::ALT_SEPARATOR
+         msg = "test may fail on Win32" 
+      else
+         msg = "mac file should be the same size (or larger), but isn't"
+      end
+
+      assert_nothing_raised{ File.nl_convert(@test_file1, @mac_file, "mac") }
+      assert_equal(true, File.size(@mac_file) == File.size(@test_file1), msg)
+      assert_equal("\cM", IO.readlines(@mac_file).first.split("").last)
+   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)
+      }
+   end
+end

data/test/tc_tail.rb

@@ -0,0 +1,50 @@
+########################################
+# tc_tail.rb
+#
+# Test case for the File.tail method.
+########################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_FileTail < Test::Unit::TestCase
+   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
+   end
+end

data/test/tc_touch.rb

@@ -0,0 +1,41 @@
+###########################################
+# tc_touch.rb
+#
+# Test case for the File.touch method.
+###########################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_FileTouch < Test::Unit::TestCase
+   def setup
+      @test_file = "delete.this"
+   end
+
+   def test_touch_basic
+      assert_respond_to(File, :touch)
+      assert_nothing_raised{ File.touch(@test_file) }
+   end
+
+   def test_touch_expected_results
+      assert_equal(File, File.touch(@test_file))
+      assert_equal(true, File.exists?(@test_file))
+      assert_equal(0, File.size(@test_file))
+   end
+
+   def test_touch_expected_errors
+      assert_raises(ArgumentError){ File.touch }
+   end
+
+   def teardown
+      File.delete(@test_file) if File.exists?(@test_file)
+   end
+end

data/test/tc_wc.rb

@@ -0,0 +1,49 @@
+####################################
+# tc_wc.rb
+#
+# Test case for the File.wc method.
+####################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_FileWC < Test::Unit::TestCase
+   def setup
+      @test_file = 'test_file1.txt'
+   end
+
+   def test_wc_basic
+      assert_respond_to(File, :wc)
+      assert_nothing_raised{ File.wc(@test_file) }
+      assert_nothing_raised{ File.wc(@test_file, 'bytes') }
+      assert_nothing_raised{ File.wc(@test_file, 'chars') }
+      assert_nothing_raised{ File.wc(@test_file, 'words') }
+      assert_nothing_raised{ File.wc(@test_file, 'LINES') }
+   end
+
+   def test_wc_results
+      assert_kind_of(Array, File.wc(@test_file))
+      assert_equal([166,166,25,25], File.wc(@test_file))
+      assert_equal(166, File.wc(@test_file,'bytes'), "Wrong number of bytes")
+      assert_equal(166, File.wc(@test_file,'chars'), "Wrong number of chars")
+      assert_equal(25,  File.wc(@test_file,'words'), "Wrong number of words")
+      assert_equal(25,  File.wc(@test_file,'lines'), "Wrong number of lines")
+   end
+
+   def test_wc_expected_errors
+      assert_raises(ArgumentError){ File.wc }
+      assert_raises(ArgumentError){ File.wc(@test_file, "bogus") }
+   end
+
+   def teardown
+      @test_file = nil
+   end
+end

data/test/tc_whereis.rb

@@ -0,0 +1,52 @@
+##########################################
+# tc_whereis.rb
+#
+# Test case for the File.whereis method.
+##########################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require "test/unit"
+require "ptools"
+
+class TC_FileWhereis < Test::Unit::TestCase
+
+   def setup
+      # Change this to suit your system
+      @expected_locs = ['/usr/local/bin/ruby','/opt/sfw/bin/ruby']
+      @expected_locs.push('/opt/bin/ruby', '/usr/bin/ruby')
+
+      # MS Windows - change as needed
+      if File::ALT_SEPARATOR
+         @expected_locs = ["c:\\ruby\\bin\\ruby.exe"]
+      end
+   end
+
+   def test_whereis_basic
+      assert_respond_to(File, :whereis)
+      assert_nothing_raised{ File.whereis("ruby") }
+      assert_nothing_raised{ File.whereis("ruby","/usr/bin:/usr/local/bin") }
+      assert_nothing_raised{ File.whereis("ruby"){} }
+   end
+
+   def test_whereis_expected_return_values
+      assert_kind_of(Array, File.whereis("ruby"))
+      assert_equal(true, @expected_locs.include?(File.whereis("ruby").first))
+      assert_equal(nil, File.whereis("blahblah"))
+   end
+
+   def test_whereis_expected_errors
+      assert_raises(ArgumentError){ File.whereis }
+      assert_raises(ArgumentError){ File.whereis("ruby","foo","bar") }
+   end
+
+   def teardown
+      @expected_locs = nil
+   end
+end

data/test/tc_which.rb

@@ -0,0 +1,54 @@
+########################################
+# tc_which.rb
+#
+# Test case for the File.which method.
+########################################
+base = File.basename(Dir.pwd)
+
+if base == "test" or base =~ /ptools/
+   Dir.chdir("..") if base == "test"
+   $LOAD_PATH.unshift(Dir.pwd)
+   $LOAD_PATH.unshift(Dir.pwd + "/lib")
+   Dir.chdir("test") if Dir.pwd != "test"
+end
+
+require 'rbconfig'
+require 'test/unit'
+require 'ptools'
+
+# I make the assumption that Ruby is in your PATH for these tests
+
+class TC_FileWhich < Test::Unit::TestCase
+   include Config
+
+   def setup
+      @exe = File.join(CONFIG["bindir"], CONFIG["ruby_install_name"]) 
+
+      if File::ALT_SEPARATOR
+         @exe.tr!('/','\\')
+         @exe << ".exe"
+      end
+   end
+
+   def test_which_basic
+      assert_respond_to(File, :which)
+      assert_nothing_raised{ File.which("ruby") }
+      assert_nothing_raised{ File.which("ruby", "/usr/bin:/usr/local/bin") }
+   end
+
+   def test_which_expected_return_values
+      assert_kind_of(String, File.which("ruby"))
+      assert_equal(@exe, File.which("ruby"))
+      assert_equal(nil, File.which("ruby", "/bogus/path"))
+      assert_equal(nil, File.which("blahblah"))
+   end
+
+   def test_which_expected_errors
+      assert_raises(ArgumentError){ File.which }
+      assert_raises(ArgumentError){ File.which("ruby", "foo", "bar") }
+   end
+
+   def teardown
+      @exe = nil
+   end
+end

data/test/test_file1.txt

@@ -0,0 +1,25 @@
+line1
+line2
+line3
+line4
+line5
+line6
+line7
+line8
+line9
+line10
+line11
+line12
+line13
+line14
+line15
+line16
+line17
+line18
+line19
+line20
+line21
+line22
+line23
+line24
+line25

data/test/test_file2.txt

@@ -0,0 +1,25 @@
+line1
+line2
+line3
+line4
+line5
+line6
+line7
+line8
+line9
+line10
+line11
+line12
+line13
+line14
+line15
+line16
+line17
+line18
+line19
+line20
+line21
+line22
+line23
+line24
+line25

data/test/ts_all.rb

@@ -0,0 +1,17 @@
+########################################
+# ts_all.rb
+#
+# All tests for the ptools package.
+########################################
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(Dir.pwd + "/test")
+
+require 'tc_constants'
+require 'tc_head'
+require 'tc_middle'
+require 'tc_nlconvert'
+require 'tc_tail'
+require 'tc_touch'
+require 'tc_wc'
+require 'tc_which'
+require 'tc_whereis'

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: ptools
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2005-06-02
+summary: Extra methods for the File class
+require_paths: 
+  - lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/shards
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Daniel J. Berger
+files: 
+  - lib/ptools.rb
+  - README
+  - CHANGES
+  - MANIFEST
+  - test/tc_head.rb
+  - test/ts_all.rb
+  - test/tc_whereis.rb
+  - test/tc_middle.rb
+  - test/tc_which.rb
+  - test/tc_constants.rb
+  - test/tc_tail.rb
+  - test/tc_wc.rb
+  - test/tc_nlconvert.rb
+  - test/test_file1.txt
+  - test/test_file2.txt
+  - test/tc_touch.rb
+test_files: 
+  - test/ts_all.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+  - CHANGES
+executables: []
+extensions: []
+requirements: []
+dependencies: []