pathname2 1.3.1 → 1.4.0

data/CHANGES

@@ -1,3 +1,17 @@
+== 1.4.0 -
+* Added destructive and non-destructive methods for some methods - pstrip,
+  pstrip!, undecorate, undecorate!, clean and clean!.
+* Added a C extension version of this package.  You can use the C version
+  instead of the pure Ruby version instead.  See the README for more details.
+* Fixed bug in the root method where the result wasn't guaranteed to be a
+  Pathname class.
+* Fixed bugs in Windows version where the receiver was inadvertantly modified
+  in some cases, and added tests to check for this in the future.
+* Modified the Dir.glob facade so that it (temporarily) changes to the path
+  directory, globs on that path, then returns to the original directory.
+* Added the bench_pathname.rb script to let you benchmark all Pathname
+  methods.
+
 == 1.3.1 - 21-Nov-2005
 * Added the Pathname#children method.
 * Added tests for the Pathname#children method.

data/MANIFEST

@@ -4,9 +4,13 @@ README
 install.rb
 pathname2.gempsec
 
+examples/bench_all.rb
 examples/bench_plus.rb
 examples/example_pathname.rb
 
+ext/extconf.rb
+ext/pathname2.c
+
 lib/pathname2.rb
 
 test/tc_pathname.rb

data/README

@@ -5,7 +5,7 @@
    * Ruby 1.8.0 or later
    * facade 1.0.0 or later (available on the RAA)
    
-== Installation
+== Installation, pure Ruby
 === Manual Installation
    ruby test/tc_pathname.rb (Unix, optional)
    ruby test/tc_pathname_win.rb (Windows, optional)
@@ -15,6 +15,13 @@
    ruby test/tc_pathname.rb (Unix, optional)
    ruby test/tc_pathname_win.rb (Windows, optional)
    gem install pathname2-<version>.gem
+   
+== Installation, C extension
+   cd to the 'ext' directory.
+   ruby extconf.rb
+   make
+   run appropriate test (optional)
+   make install
 
 == Synopsis
    require "pathname2"
@@ -28,7 +35,7 @@
    path1.dirname # "/foo/bar"
    path1.to_a    # ['foo','bar','baz']
 
-   # Win32
+   # Windows
    path1 = "C:/foo/bar/baz"
    path2 = "../zap"
 
@@ -39,7 +46,7 @@
 == Win32 Notes
    All forward slashes are converted to backslashes for Pathname objects.
 
-== Differences between Unix and Win32
+== Differences between Unix and Windows
    If your pathname consists solely of ".", or "..", the return
    value for Pathname#clean will be different. On Win32, "\\" is returned,
    while on Unix "." is returned.  I consider this an extreme edge case and
@@ -73,8 +80,12 @@
    not the one defined in the FileUtils module.
    
 == Known Issues
-   You cannot pass a frozen string to the constructor on Win32 systems.
-   There is an unresolved issue with Win32API and frozen objects.
+   You cannot pass a frozen string to the constructor on Windows using the
+   pure Ruby version.  There is an unresolved issue with Win32API and frozen
+   objects.
+   
+   Pathname#glob is not yet implemented in the C version.
+   Pathname#find is not implemented properly in the C version.
    
 == License
    Ruby's

data/lib/pathname2.rb

@@ -45,6 +45,8 @@ class Pathname < String
    extend Facade
    facade File
    facade Dir
+
+   alias :_plus_ :+ # Used to prevent infinite loops in some cases
    
    if PLATFORM.match("mswin")
       require "Win32API"
@@ -75,7 +77,7 @@ class Pathname < String
          Win32API.new("shlwapi", "PathRemoveBackslash", "P", "P")
    end
 
-   VERSION  = "1.3.1"
+   VERSION  = "1.4.0"
    MAX_PATH = 260
    
    # Creates and returns a new Pathname object.
@@ -103,7 +105,7 @@ class Pathname < String
          end
       end
 
-      # Convert forward slashes to backslashes on Win32
+      # Convert forward slashes to backslashes on Windows
       path = path.tr("/", @sep) if @win
       super(path)
    end
@@ -133,7 +135,7 @@ class Pathname < String
    # Win32 only
    #
    # Removes the decoration from a path string.  For example,
-   # C:\Path\File[5].txt would become C:\Path\File.txt.
+   # C:\Path\File[5].txt would become C:\Path\File.txt.  Non-destructive.
    def undecorate
       unless @win
          raise NotImplementedError, "not supported on this platform"
@@ -144,6 +146,20 @@ class Pathname < String
       Pathname.new(buf.split(0.chr).first)
    end
    
+   # Win32 only
+   #
+   # Performs the substitution of Pathname#undecorate in place.
+   def undecorate!
+      unless @win
+         raise NotImplementedError, "not supported on this platform"
+      end
+      buf = 0.chr * MAX_PATH
+      buf[0..self.length-1] = self
+      @@PathUndecorate.call(buf)
+      replace(buf.split(0.chr).first)
+      self
+   end
+   
    # Win32 only
    #
    # Returns the short path for a long path name.  For example,
@@ -172,8 +188,23 @@ class Pathname < String
       Pathname.new(buf.split(0.chr).first)
    end
    
-   # Removes trailing slash, if present.
+   # Removes trailing slash, if present.  Non-destructive.
    def pstrip
+      str = self.dup
+      if @win
+         @@PathRemoveBackslash.call(str)
+         str.strip!
+      else
+         if str[-1] == @sep
+            str.strip!
+            str.chop!
+         end
+      end
+      Pathname.new(str)
+   end
+   
+   # Removes trailing slash, if present.  Destructive.
+   def pstrip!
       if @win
          @@PathRemoveBackslash.call(self)
          strip!
@@ -275,9 +306,9 @@ class Pathname < String
    # Returns the root directory of the path, or '.' if there is no root
    # directory.
    #
-   # On Unix, this means the '/' character.  On Win32 systems, this can
-   # refer to the drive letter, or the server and share path if the path
-   # is a UNC path.
+   # On Unix, this means the '/' character.  On Windows, this can refer
+   # to the drive letter, or the server and share path if the path is a
+   # UNC path.
    def root
       dir = "."   
       if @win
@@ -285,12 +316,12 @@ class Pathname < String
          buf[0..self.length-1] = self
       
          if @@PathStripToRoot.call(buf) > 0
-            dir = Pathname.new(buf.split(0.chr).first)
+            dir = buf.split(0.chr).first
          end
       else
          dir = "/" if self =~ /^\//
       end
-      dir
+      Pathname.new(dir)
    end
 
    # Returns whether or not the path consists only of a root directory.
@@ -352,12 +383,13 @@ class Pathname < String
 
       # Any path plus "." is the same directory
       return self if string == "."
+      return string if self == "."
       
       # Use the builtin PathAppend method if on Windows - much easier
       if @win
          buf = 0.chr * MAX_PATH
          buf[0..self.length-1] = self
-         @@PathAppend.call(buf, string << 0.chr)
+         @@PathAppend.call(buf, string)
          buf.strip!
          return Pathname.new(buf) # PathAppend cleans automatically
       end
@@ -369,7 +401,8 @@ class Pathname < String
       new_string = array.join(@sep)
       
       unless relative? || @win
-         new_string = @sep + new_string # Add root path back if needed
+         temp = @sep + new_string # Add root path back if needed
+         new_string.replace(temp)
       end
       
       Pathname.new(new_string).clean
@@ -411,11 +444,39 @@ class Pathname < String
          end
       }
       final = final.join(@sep)
-      final = root + final if root != "."
+      final = root._plus_(final) if root != "."
       final = "." if final.empty?
       Pathname.new(final)
    end
    alias :cleanpath :clean
+   
+   # Removes unnecessary '.' paths and ellides '..' paths appropriately.
+   # Modifies the receiver in place.
+   def clean!
+      return self if self.empty?
+
+      if @win
+         path = 0.chr * MAX_PATH
+         if @@PathCanonicalize.call(path, self) > 0
+            replace(path.split(0.chr).first)
+         end
+         return self
+      end
+
+      final = []
+      to_a.each{ |element|
+         next if element == "."
+         final.push(element)
+         if element == ".." && self != ".."
+            2.times{ final.pop }
+         end
+      }
+      final = final.join(@sep)
+      final = root + final if root != "."
+      final = "." if final.empty?
+      replace(Pathname.new(final))
+      self
+   end
 
    #-- Find facade
 
@@ -434,7 +495,7 @@ class Pathname < String
       if self == "."
          Find.find(self){ |f| yield Pathname.new(f.sub(%r{\A\./}, '')) }
       else
-         Find.find(self) {|f| yield Pathname.new(f) }
+         Find.find(self){ |f| yield Pathname.new(f) }
       end
    end
 
@@ -464,11 +525,13 @@ class Pathname < String
 
    # Dir.glob
    def glob(*args)
-      if block_given?
-         Dir.glob(*args){ |file| yield Pathname.new(file) }
-      else
-         Dir.glob(*args).map{ |file| Pathname.new(file) }
-      end
+      Dir.chdir(self){
+         if block_given?
+            Dir.glob(*args){ |file| yield Pathname.new(file) }
+         else
+            Dir.glob(*args).map{ |file| Pathname.new(file) }
+         end
+      }
    end
 
    # Dir.chdir

data/test/tc_pathname.rb

@@ -1,11 +1,18 @@
-##############################################
+##############################################################################
 # tc_pathname.rb
 #
-# Test suite for the pathname package (Unix)
-##############################################
+# Test suite for the pathname package (Unix).  If you pass a 'c' as command
+# line option, it will test against the C extension.  Otherwise, it will run
+# the tests against the pure Ruby version.
+##############################################################################
 Dir.chdir ".." if File.basename(Dir.pwd) == "test"
-$LOAD_PATH.unshift Dir.pwd
-$LOAD_PATH.unshift Dir.pwd + "/lib"
+
+# Test against the C extension if a 'c' is provided as an argument.
+if ARGV[0] && ARGV[0].chomp.downcase == "c"
+   $LOAD_PATH.unshift Dir.pwd + "/ext"
+else
+   $LOAD_PATH.unshift Dir.pwd + "/lib"
+end
 
 if PLATFORM.match("mswin")
    STDERR.puts("Please run 'tc_pathname_win.rb' instead.")
@@ -19,10 +26,18 @@ class TC_Pathname < Test::Unit::TestCase
    def setup
       @abs_path = Pathname.new("/usr/local/bin")
       @rel_path = Pathname.new("usr/local/bin")
+      @cur_path = Pathname.new(Dir.pwd)
 
       @abs_array = []
       @rel_array = []
    end
+
+   # Convenience method to verify that the receiver was not modified
+   # except perhaps slashes
+   def assert_non_destructive
+      assert_equal("/usr/local/bin", @abs_path)
+      assert_equal("usr/local/bin", @rel_path)
+   end
    
    # Convenience method for test_plus
    def assert_pathname_plus(a, b, c)
@@ -41,7 +56,7 @@ class TC_Pathname < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal("1.3.1", Pathname::VERSION)
+      assert_equal("1.4.0", Pathname::VERSION)
    end
 
    def test_ascend
@@ -61,6 +76,8 @@ class TC_Pathname < Test::Unit::TestCase
       assert_equal("usr/local", @rel_array[1])
       assert_equal("usr", @rel_array[2])
       assert_equal(3, @rel_array.length)
+
+      assert_non_destructive
    end
 
    def test_descend
@@ -80,35 +97,48 @@ class TC_Pathname < Test::Unit::TestCase
       assert_equal("usr/local", @rel_array[1])
       assert_equal("usr/local/bin", @rel_array[2])
       assert_equal(3, @rel_array.length)
+
+      assert_non_destructive
    end
 
    def test_children
-      Dir.chdir("..") if File.basename(Dir.pwd) == "test"
-      @cur_path = Pathname.new(Dir.pwd)
-
       assert_respond_to(@cur_path, :children)
       assert_nothing_raised{ @cur_path.children }
       assert_kind_of(Array, @cur_path.children)
 
+      # Delete Eclipse related files
+      children = @cur_path.children
+      children.delete_if{ |e| File.basename(e) == "CVS" }
+      children.delete_if{ |e| File.basename(e) == ".cvsignore" }
+      children.delete_if{ |e| File.basename(e) == ".project" }
+
       assert_equal(
          [
             Dir.pwd + "/CHANGES",
             Dir.pwd + "/MANIFEST",
             Dir.pwd + "/README",
-            Dir.pwd + "/install.rb",
-            Dir.pwd + "/pathname2.gemspec",
             Dir.pwd + "/examples",
+            Dir.pwd + "/ext",
+            Dir.pwd + "/install.rb",
             Dir.pwd + "/lib",
+            Dir.pwd + "/pathname2.gemspec",
             Dir.pwd + "/test"
          ],
-         @cur_path.children
+         children.sort
       )
+
+      # Delete Eclipse related files
+      children = @cur_path.children(false)
+      children.delete("CVS")
+      children.delete(".cvsignore")
+      children.delete(".project")
+
       assert_equal(
          [
-            "CHANGES","MANIFEST","README","install.rb",
-            "pathname2.gemspec","examples", "lib", "test"
+            "CHANGES", "MANIFEST", "README", "examples", "ext",
+            "install.rb", "lib", "pathname2.gemspec", "test"
          ],
-         @cur_path.children(false)
+         children.sort
       )
    end
 
@@ -123,47 +153,67 @@ class TC_Pathname < Test::Unit::TestCase
    def test_root
       assert_respond_to(@abs_path, :root)
       assert_nothing_raised{ @abs_path.root }
+      assert_nothing_raised{ @rel_path.root }
+
       assert_equal("/", @abs_path.root)
+      assert_equal(".", @rel_path.root)
 
-      path1 = Pathname.new("foo")
-      path2 = Pathname.new("foo/bar/baz")
-      assert_equal(".", path1.root)
-      assert_equal(".", path2.root)
+      assert_non_destructive
    end
 
    def test_root?
       assert_respond_to(@abs_path, :root?)
       assert_nothing_raised{ @abs_path.root? }
+      assert_nothing_raised{ @rel_path.root? }
 
       path1 = Pathname.new("/")
       path2 = Pathname.new("a")
       assert_equal(true, path1.root?)
       assert_equal(false, path2.root?)
+
+      assert_non_destructive
    end
 
    def test_absolute
       assert_respond_to(@abs_path, :absolute?)
       assert_nothing_raised{ @abs_path.absolute? }
+      assert_nothing_raised{ @rel_path.absolute? }
+
+      assert_equal(true, @abs_path.absolute?)
+      assert_equal(false, @rel_path.absolute?)
+
       assert_equal(true, Pathname.new("/usr/bin/ruby").absolute?)
       assert_equal(false, Pathname.new("foo").absolute?)
       assert_equal(false, Pathname.new("foo/bar").absolute?)
       assert_equal(false, Pathname.new("../foo/bar").absolute?)
+
+      assert_non_destructive
    end
 
    def test_relative
       assert_respond_to(@abs_path, :relative?)
       assert_nothing_raised{ @abs_path.relative? }
+      assert_nothing_raised{ @rel_path.relative? }
+
+      assert_equal(false, @abs_path.relative?)
+      assert_equal(true, @rel_path.relative?)
+
       assert_equal(false, Pathname.new("/usr/bin/ruby").relative?)
       assert_equal(true, Pathname.new("foo").relative?)
       assert_equal(true, Pathname.new("foo/bar").relative?)
       assert_equal(true, Pathname.new("../foo/bar").relative?)
+
+      assert_non_destructive
    end
    
    def test_to_a
       assert_respond_to(@abs_path, :to_a)
       assert_nothing_raised{ @abs_path.to_a }
+      assert_nothing_raised{ @rel_path.to_a }
       assert_kind_of(Array, @abs_path.to_a)
       assert_equal(%w/usr local bin/, @abs_path.to_a)
+
+      assert_non_destructive
    end
 
    def test_spaceship_operator
@@ -202,7 +252,7 @@ class TC_Pathname < Test::Unit::TestCase
    # Any tests marked with "***" mean that this behavior is different than
    # the current implementation.  It also means I disagree with the current
    # implementation.
-   def test_cleanpath
+   def test_clean
       # Standard stuff
       assert_equal("/a/b/c", Pathname.new("/a/b/c").cleanpath)
       assert_equal("b/c", Pathname.new("./b/c").cleanpath)
@@ -220,6 +270,8 @@ class TC_Pathname < Test::Unit::TestCase
       assert_equal("..", Pathname.new("..").cleanpath)
       assert_equal('/', Pathname.new('/').cleanpath)
       assert_equal('/', Pathname.new('//').cleanpath)
+
+      assert_non_destructive
    end
 
    def test_facade_io
@@ -253,6 +305,7 @@ class TC_Pathname < Test::Unit::TestCase
       }
    end
 
+   # Doesn't work properly in 1.4.0
    def test_facade_find
       assert_respond_to(@abs_path, :find)
       assert_nothing_raised{ @abs_path.find{} }
@@ -266,6 +319,7 @@ class TC_Pathname < Test::Unit::TestCase
    def teardown
       @abs_path = nil
       @rel_path = nil
+      @cur_path = nil
 
       @abs_array.clear
       @rel_array.clear

data/test/tc_pathname_win.rb

@@ -1,11 +1,20 @@
-######################################################
+##########################################################################
 # tc_pathname_win.rb
 #
-# MS Windows test suite for the Pathname class.
-######################################################
+# MS Windows test suite for the Pathname class.  To test explicitly
+# against the C extension pass the letter 'c' as an argument.
+###########################################################################
 Dir.chdir ".." if File.basename(Dir.pwd) == "test"
 $LOAD_PATH.unshift Dir.pwd
-$LOAD_PATH.unshift Dir.pwd + "/lib"
+$c_extension = false
+
+# If the user passes a 'c', test against the C extension
+if ARGV[0] && ARGV[0].downcase == "c"
+   $c_extension = true
+   $LOAD_PATH.unshift Dir.pwd + "/ext"
+else
+   $LOAD_PATH.unshift Dir.pwd + "/lib"
+end
 
 unless PLATFORM.match("mswin")
    STDERR.puts("Please run 'tc_pathname.rb' instead.")
@@ -19,6 +28,7 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
    def setup
       @fpath = Pathname.new("C:/Program Files/Windows NT/Accessories")
       @bpath = Pathname.new("C:\\Program Files\\Windows NT\\Accessories")
+      @dpath = Pathname.new("C:\\Program Files\\File[5].txt")
       @spath = Pathname.new("C:\\PROGRA~1\\WINDOW~1\\ACCESS~1")
       @upath = Pathname.new("\\\\foo\\bar\\baz")
       @npath = Pathname.new("foo\\bar\\baz")
@@ -27,6 +37,11 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       @ypath = Pathname.new("\\\\foo")
       @zpath = Pathname.new("\\\\")
       @epath = Pathname.new("")
+      @ppath = Pathname.new("C:\\foo\\bar\\")
+      @cpath = Pathname.new("C:\\foo\\..\\bar\\.\\baz")
+      @tpath = Pathname.new("C:\\foo\\bar")
+
+      @cur_path = Pathname.new(Dir.pwd)
       
       @abs_array = []
       @rel_array = []
@@ -34,7 +49,7 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
    end
    
    def test_version
-      assert_equal("1.3.1", Pathname::VERSION)
+      assert_equal("1.4.0", Pathname::VERSION)
    end
    
    # Convenience method for test_plus
@@ -53,11 +68,31 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_equal(int, result)
    end
    
+   # Convenience method to verify that the receiver was not modified
+   # except perhaps slashes
+   def assert_non_destructive      
+      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @fpath)
+      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @bpath)
+      assert_equal("C:\\Program Files\\File[5].txt", @dpath)
+      assert_equal("C:\\PROGRA~1\\WINDOW~1\\ACCESS~1", @spath)
+      assert_equal("\\\\foo\\bar\\baz", @upath)
+      assert_equal("foo\\bar\\baz", @npath)
+      assert_equal("Z:\\", @rpath)
+      assert_equal("\\\\foo\\bar", @xpath)
+      assert_equal("\\\\foo", @ypath)
+      assert_equal("\\\\", @zpath)
+      assert_equal("", @epath)
+      assert_equal("C:\\foo\\bar\\", @ppath)
+      assert_equal("C:\\foo\\..\\bar\\.\\baz", @cpath)
+   end
+   
    def test_short_path
       assert_respond_to(@bpath, :short_path)
       assert_nothing_raised{ @bpath.short_path }      
       assert_kind_of(Pathname, @bpath.short_path)
       assert_equal("C:\\PROGRA~1\\WINDOW~1\\ACCESS~1", @bpath.short_path)
+      
+      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @bpath)
    end
    
    def test_long_path
@@ -69,13 +104,108 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
          "C:\\Program Files\\Windows NT\\Accessories",
          @spath.long_path
       )
+      
+      assert_equal("C:\\PROGRA~1\\WINDOW~1\\ACCESS~1", @spath)
+   end
+   
+   def test_undecorate
+      assert_respond_to(@dpath, :undecorate)
+      assert_nothing_raised{ @dpath.undecorate }
+      assert_kind_of(Pathname, @dpath.undecorate)
+      
+      assert_equal('C:\Program Files\File.txt', @dpath.undecorate)    
+      assert_equal('C:\Path\File', Pathname.new('C:\Path\File').undecorate)
+      assert_equal('C:\Path\File', Pathname.new('C:\Path\File[12]').undecorate)
+      assert_equal('C:\Path\[3].txt',
+         Pathname.new('C:\Path\[3].txt').undecorate
+      )
+      assert_equal('\\foo\bar.txt',Pathname.new('\\foo\bar[5].txt').undecorate)
+      assert_equal('\\foo\bar', Pathname.new('\\foo\bar[5]').undecorate)
+      assert_equal('\\foo\bar', Pathname.new('\\foo\bar').undecorate)
+      
+      assert_equal("C:\\Program Files\\File[5].txt", @dpath)
+   end
+   
+   def test_undecorate_bang
+      assert_respond_to(@dpath, :undecorate!)
+      assert_nothing_raised{ @dpath.undecorate! }
+      assert_kind_of(Pathname, @dpath.undecorate!)
+      
+      assert_equal('C:\Program Files\File.txt', @dpath.undecorate!)    
+      assert_equal('C:\Path\File', Pathname.new('C:\Path\File').undecorate!)
+      assert_equal('C:\Path\File', Pathname.new('C:\Path\File[12]').undecorate!)
+      assert_equal('C:\Path\[3].txt',
+         Pathname.new('C:\Path\[3].txt').undecorate!
+      )
+      assert_equal('\\foo\bar.txt',Pathname.new('\\foo\bar[5].txt').undecorate!)
+      assert_equal('\\foo\bar', Pathname.new('\\foo\bar[5]').undecorate!)
+      assert_equal('\\foo\bar', Pathname.new('\\foo\bar').undecorate!)
+      
+      assert_equal('C:\Program Files\File.txt', @dpath)
+   end
+   
+   def test_unc
+      assert_respond_to(@upath, :unc?)
+      assert_nothing_raised{ @upath.unc? }
+      
+      assert_equal(true, @upath.unc?)
+      assert_equal(true, @xpath.unc?)
+      assert_equal(true, @ypath.unc?)
+      assert_equal(true, @zpath.unc?)
+      assert_equal(false, @fpath.unc?)
+      assert_equal(false, @bpath.unc?)
+      assert_equal(false, @dpath.unc?)
+      assert_equal(false, @spath.unc?)
+      assert_equal(false, @epath.unc?)
+
+      # Arguably a bug in the PathIsUNC() function since drive letters
+      # are, in fact, a legal part of a UNC path (for historical reasons).
+      assert_equal(false, Pathname.new("C:\\\\foo\\bar\\baz").unc?)
+      
+      assert_non_destructive
+   end
+   
+   def test_pstrip
+      assert_respond_to(@ppath, :pstrip)
+      assert_nothing_raised{ @ppath.pstrip }
+      assert_nothing_raised{ @fpath.pstrip }
+      assert_kind_of(Pathname, @ppath.pstrip)
+
+      assert_equal('C:\foo', Pathname.new("C:\\foo\\").pstrip)
+      assert_equal('C:\foo', Pathname.new("C:\\foo").pstrip)
+      assert_equal("", Pathname.new("").pstrip)
+      
+      assert_equal("C:\\foo\\bar\\", @ppath)
    end
    
+   def test_pstrip_bang
+      assert_respond_to(@ppath, :pstrip!)
+      assert_nothing_raised{ @ppath.pstrip! }
+      assert_nothing_raised{ @fpath.pstrip! }
+      assert_kind_of(Pathname, @ppath.pstrip!)
+
+      assert_equal('C:\foo', Pathname.new("C:\\foo\\").pstrip!)
+      assert_equal('C:\foo', Pathname.new("C:\\foo").pstrip!)
+      assert_equal("", Pathname.new("").pstrip!)
+      
+      assert_equal("C:\\foo\\bar", @ppath)
+   end
+   
+   def test_exists
+      assert_respond_to(@fpath, :exists?)
+      assert_nothing_raised{ @fpath.exists? }
+      assert_equal(true, Pathname.new("C:\\").exists?)
+      assert_equal(false, Pathname.new("X:\\foo\\bar\\baz").exists?)
+   end
+ 
    def test_each
+      array = []
+      
       assert_respond_to(@fpath, :each)
-      assert_nothing_raised{ @fpath.each{ |e| } }
+      assert_nothing_raised{ @fpath.each{ |e| array.push(e) } }
+      assert_equal(["C:", "Program Files", "Windows NT", "Accessories"], array)
    end
-   
+  
    def test_descend
       assert_respond_to(@bpath, :descend)
       assert_nothing_raised{ @bpath.descend{} }
@@ -95,8 +225,10 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       
       assert_equal("\\\\foo\\bar", @unc_array[0])
       assert_equal("\\\\foo\\bar\\baz", @unc_array[1])
+      
+      assert_non_destructive      
    end
-   
+    
    def test_ascend
       assert_respond_to(@bpath, :ascend)
       assert_nothing_raised{ @bpath.ascend{} }
@@ -118,16 +250,20 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       
       assert_equal("\\\\foo\\bar\\baz", @unc_array[0])
       assert_equal("\\\\foo\\bar", @unc_array[1])
-      assert_equal(2, @unc_array.length)     
+      assert_equal(2, @unc_array.length)
+      
+      assert_non_destructive     
+   end
+  
+   # Fails due to PathIsURL for some reason in pure Ruby
+   def test_immutability
+      if $c_extension
+         path = "C:\\Program Files\\foo\\bar".freeze
+         assert_equal(true, path.frozen?)
+         assert_nothing_raised{ Pathname.new(path) }
+         assert_nothing_raised{ Pathname.new(path).root }
+      end
    end
-   
-   # Fails due to PathIsURL for some reason
-   #def test_immutability
-   #   path = "C:\\Program Files\\foo\\bar".freeze
-   #   assert_equal(true, path.frozen?)
-   #   assert_nothing_raised{ Pathname.new(path) }
-   #   assert_nothing_raised{ Pathname.new(path).root }
-   #end
    
    def test_plus_operator
       # Standard stuff
@@ -144,9 +280,24 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_pathname_plus("\\\\", "\\\\", "")
       assert_pathname_plus("\\\\foo\\baz", "\\\\foo\\bar", "\\..\\baz")
       assert_pathname_plus("\\\\", "\\\\", "..\\..\\..\\..")
+
+      # Pathname + String
+      assert_nothing_raised{ @tpath + "bar" }
+      assert_equal('C:\foo\bar\baz', @tpath + 'baz')
+      assert_equal('C:\foo\bar', @tpath)
+
+      # Ensure neither left nor right operand are modified
+      assert_nothing_raised{ @tpath + @npath }
+      assert_equal('C:\foo\bar\foo\bar\baz', @tpath + @npath)
+      assert_equal('C:\foo\bar', @tpath)
+      assert_equal('foo\bar\baz', @npath)
    end
-   
+  
    def test_clean
+      assert_respond_to(@cpath, :clean)
+      assert_nothing_raised{ @cpath.clean }
+      assert_kind_of(Pathname, @cpath.clean)
+
       # Our preset stuff
       assert_equal("C:\\Program Files\\Windows NT\\Accessories", @fpath.clean)
       assert_equal("C:\\Program Files\\Windows NT\\Accessories", @bpath.clean)
@@ -157,6 +308,7 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_equal("\\\\foo", @ypath.clean)
       assert_equal("\\\\", @zpath.clean)
       assert_equal("", @epath.clean)
+      assert_equal("C:\\bar\\baz", @cpath.clean)
 
       # Standard stuff
       assert_equal("C:\\a\\c", Pathname.new("C:\\a\\.\\b\\..\\c").clean)
@@ -170,8 +322,43 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       # Edge cases
       assert_equal("\\", Pathname.new(".").clean)
       assert_equal("\\", Pathname.new("..").clean)
+
+      assert_non_destructive
    end
-  
+
+   def test_clean_bang
+      assert_respond_to(@cpath, :clean!)
+      assert_nothing_raised{ @cpath.clean! }
+      assert_kind_of(Pathname, @cpath.clean!)
+
+      # Our preset stuff
+      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @fpath.clean!)
+      assert_equal("C:\\Program Files\\Windows NT\\Accessories", @bpath.clean!)
+      assert_equal("\\\\foo\\bar\\baz", @upath.clean!)
+      assert_equal("foo\\bar\\baz", @npath.clean!)
+      assert_equal("Z:\\", @rpath.clean!)
+      assert_equal("\\\\foo\\bar", @xpath.clean!)
+      assert_equal("\\\\foo", @ypath.clean!)
+      assert_equal("\\\\", @zpath.clean!)
+      assert_equal("", @epath.clean!)
+      assert_equal("C:\\bar\\baz", @cpath.clean!)
+
+      # Standard stuff
+      assert_equal("C:\\a\\c", Pathname.new("C:\\a\\.\\b\\..\\c").clean!)
+      assert_equal("C:\\a", Pathname.new("C:\\.\\a").clean!)
+      assert_equal("C:\\a\\b", Pathname.new("C:\\a\\.\\b").clean!)
+      assert_equal("C:\\b", Pathname.new("C:\\a\\..\\b").clean!)
+      assert_equal("C:\\a", Pathname.new("C:\\a\\.").clean!)
+      assert_equal("C:\\d", Pathname.new("C:\\..\\..\\..\\d").clean!)
+      assert_equal("C:\\a\\", Pathname.new("C:\\a\\").clean!)
+      
+      # Edge cases
+      assert_equal("\\", Pathname.new(".").clean!)
+      assert_equal("\\", Pathname.new("..").clean!)
+
+      assert_equal("C:\\bar\\baz", @cpath)
+   end
+
    def test_absolute
       assert_equal(true, @fpath.absolute?)
       assert_equal(true, @bpath.absolute?)
@@ -182,6 +369,8 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_equal(true, @ypath.absolute?)
       assert_equal(true, @zpath.absolute?)
       assert_equal(false, @epath.absolute?)
+      
+      assert_non_destructive
    end
    
    def test_relative
@@ -194,10 +383,12 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_equal(false, @ypath.relative?)
       assert_equal(false, @zpath.relative?)
       assert_equal(true, @epath.relative?)
+      
+      assert_non_destructive
    end
    
    def test_root
-      assert_equal("C:\\", @fpath.root)
+      assert_equal("C:\\", @fpath.root)     
       assert_equal("C:\\", @bpath.root)
       assert_equal("\\\\foo\\bar", @upath.root)
       assert_equal(".", @npath.root)
@@ -210,6 +401,8 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       # Edge cases
       assert_equal(".", Pathname.new("..").root)
       assert_equal(".", Pathname.new(".").root)
+      
+      assert_non_destructive
    end
    
    def test_drive_number
@@ -226,6 +419,8 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       # Edge cases
       assert_equal(nil, Pathname.new("..").drive_number)
       assert_equal(nil, Pathname.new(".").drive_number)
+      
+      assert_non_destructive
    end
         
    def test_to_a
@@ -239,6 +434,9 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_equal(["foo"], @ypath.to_a)
       assert_equal([], @zpath.to_a)
       assert_equal([], @epath.to_a)
+      assert_equal(["C:", "foo", "bar"], @ppath.to_a)
+      
+      assert_non_destructive
    end
  
    def test_is_root
@@ -251,8 +449,13 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_equal(true, @ypath.root?)
       assert_equal(true, @zpath.root?)
       assert_equal(false, @epath.root?)
+      assert_equal(false, @ppath.root?)
+      
+      assert_non_destructive
    end
-   
+  
+   # These are the methods from IO we have to explicitly define since
+   # they aren't handled by Facade.
    def test_facade_io
       assert_respond_to(@fpath, :foreach)
       assert_respond_to(@fpath, :read)
@@ -297,17 +500,21 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
    end
 
    def test_children
-      Dir.chdir("..") if File.basename(Dir.pwd) == "test"
-      @cur_path = Pathname.new(Dir.pwd)
-
       assert_respond_to(@cur_path, :children)
       assert_nothing_raised{ @cur_path.children }
       assert_kind_of(Array, @cur_path.children)
 
+      # Delete Eclipse related files
+      children = @cur_path.children
+      children.delete_if{ |e| File.basename(e) == "CVS" }
+      children.delete_if{ |e| File.basename(e) == ".cvsignore" }
+      children.delete_if{ |e| File.basename(e) == ".project" }
+
       assert_equal(
          [
             Dir.pwd + "/CHANGES",
             Dir.pwd + "/examples",
+            Dir.pwd + "/ext",
             Dir.pwd + "/install.rb",
             Dir.pwd + "/lib",
             Dir.pwd + "/MANIFEST",
@@ -315,20 +522,28 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
             Dir.pwd + "/README",
             Dir.pwd + "/test"
          ].map{ |e| e.tr("/","\\") },
-         @cur_path.children
+         children
       )
+      
+      # Delete Eclipse related files
+      children = @cur_path.children(false)
+      children.delete("CVS")
+      children.delete(".cvsignore")
+      children.delete(".project")
+      
       assert_equal(
          [
-            "CHANGES","examples","install.rb","lib",
+            "CHANGES","examples","ext","install.rb","lib",
             "MANIFEST", "pathname2.gemspec", "README", "test"
          ],
-         @cur_path.children(false)
+         children
       )
    end
-   
+  
    def teardown
       @fpath = nil
       @bpath = nil
+      @dpath = nil
       @spath = nil
       @upath = nil
       @npath = nil
@@ -337,6 +552,11 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       @ypath = nil
       @zpath = nil
       @epath = nil
+      @ppath = nil
+      @cpath = nil
+      @tpath = nil
+
+      @cur_path = nil
       
       @abs_array.clear
       @rel_array.clear

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.8.10
 specification_version: 1
 name: pathname2
 version: !ruby/object:Gem::Version 
-  version: 1.3.1
-date: 2005-11-21 00:00:00 -07:00
+  version: 1.4.0
+date: 2005-12-19
 summary: An alternate implementation of the Pathname class
 require_paths: 
   - lib
@@ -24,17 +24,15 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
-signing_key: 
-cert_chain: 
 authors: 
   - Daniel J. Berger
 files: 
   - lib/pathname2.rb
+  - README
   - CHANGES
   - MANIFEST
-  - README
-  - test/tc_pathname.rb
   - test/tc_pathname_win.rb
+  - test/tc_pathname.rb
 test_files: 
   - test/tc_pathname.rb
 rdoc_options: []