pathname2 1.4.4 → 1.5.0

data/CHANGES

@@ -1,3 +1,10 @@
+== 1.5.0 - 17-Apr-2006
+* Better subclass handling, in that some methods that previously returned
+  hardcoded Pathname.new now return self.class.new.
+* File URL's are now handled on Unix as well (using the 'uri' package).
+* Some comment changes/clarifications.
+* Added the PathnameError class to the pure Ruby version.
+
 == 1.4.4 - 23-Mar-2006
 * If the path is a symbolic link the Pathname#realpath method
   now returns the absolute path of that link, i.e. the result

data/README

@@ -67,6 +67,8 @@
    * Pathname#clean works slightly differently.  In the old version,
      Pathname#clean("../a") returns "../a".  In this version, it returns "a".
      This affects other methods, such as Pathname#relative_path_from.
+   * Accepts file urls and converts them to paths automatically, e.g.
+     file:///foo%20bar/baz becomes '/foo bar/baz'.
      
 == Method Priority
    Because there is some overlap in method names between File, Dir, ftools

data/lib/pathname2.rb

@@ -41,6 +41,8 @@ require "facade"
 require "ftools"
 require "fileutils"
 
+class PathnameError < StandardError; end
+
 class Pathname < String
    extend Facade
    facade File
@@ -77,12 +79,19 @@ class Pathname < String
          Win32API.new('shlwapi', 'PathRemoveBackslash', 'P', 'P')
    end
 
-   VERSION  = '1.4.4'
+   VERSION  = '1.5.0'
    MAX_PATH = 260
    
    # Creates and returns a new Pathname object.
    #
-   # On Windows systems, all forward slashes are replaced with backslashes.
+   # On platforms that define File::ALT_SEPARATOR, all forward slashes are
+   # replaced with the value of File::ALT_SEPARATOR.  On MS Windows, for
+   # example, all forward slashes are replaced with backslashes.
+   #
+   # File URL's will be converted to Pathname objects, e.g. the file URL
+   # "file:///C:/Documents%20and%20Settings" will become
+   # 'C:\Documents and Settings'.
+   #
    def initialize(path)
       if path.length > MAX_PATH
          msg = "string too long.  maximum string length is " + MAX_PATH.to_s
@@ -92,7 +101,9 @@ class Pathname < String
       @sep = File::ALT_SEPARATOR || File::SEPARATOR
       @win = RUBY_PLATFORM.match('mswin')
 
-      # Handle File URL's for Windows
+      # Handle File URL's.  The separate methods for Windows are necessary
+      # because Ruby's URI class does not (currently) parse absolute file URL's
+      # properly when they include a drive letter. 
       if @win
          if @@PathIsURL.call(path) > 0
             buf = 0.chr * MAX_PATH
@@ -103,6 +114,11 @@ class Pathname < String
                raise PathnameError, "invalid file url: #{path}"
             end
          end
+      else
+         if path.index('file:///', 0)
+            require 'uri'
+            path = URI.decode(URI.parse(path).path)
+         end
       end
 
       # Convert forward slashes to backslashes on Windows
@@ -114,11 +130,12 @@ class Pathname < String
    #
    # Unlike most Pathname methods, this one assumes that the path actually
    # exists on your filesystem.  If it doesn't, an error is raised.
+   #
    def realpath
-      pwd = Pathname.new(Dir.pwd)
+      pwd = self.class.new(Dir.pwd)
       File.stat(self)               # Check to ensure that the path exists
       if File.symlink?(self)
-         Pathname.new(File.readlink(self))
+         self.class.new(File.readlink(self))
       else 
          pwd + self
       end
@@ -138,9 +155,9 @@ class Pathname < String
       Dir.foreach(self) { |file|
          next if file == '.' || file == '..'
          if with_directory
-            result << Pathname.new(File.join(self, file))
+            result << self.class.new(File.join(self, file))
          else
-            result << Pathname.new(file)
+            result << self.class.new(file)
          end
       }
       result
@@ -150,6 +167,7 @@ class Pathname < String
    #
    # Removes the decoration from a path string.  For example,
    # C:\Path\File[5].txt would become C:\Path\File.txt.  Non-destructive.
+   #
    def undecorate
       unless @win
          raise NotImplementedError, "not supported on this platform"
@@ -157,12 +175,13 @@ class Pathname < String
       buf = 0.chr * MAX_PATH
       buf[0..self.length-1] = self
       @@PathUndecorate.call(buf)
-      Pathname.new(buf.split(0.chr).first)
+      self.class.new(buf.split(0.chr).first)
    end
    
    # Windows only
    #
    # Performs the substitution of Pathname#undecorate in place.
+   #
    def undecorate!
       unless @win
          raise NotImplementedError, "not supported on this platform"
@@ -178,6 +197,7 @@ class Pathname < String
    #
    # Returns the short path for a long path name.  For example,
    # C:\Program Files\Java would return C:\Progra~1\Java.
+   #
    def short_path
       unless @win
          raise NotImplementedError, "not supported on this platform"
@@ -185,13 +205,14 @@ class Pathname < String
       buf = 0.chr * MAX_PATH
       buf[0..self.length-1] = self
       @@GetShortPathName.call(self, buf, buf.length)
-      Pathname.new(buf.split(0.chr).first)
+      self.class.new(buf.split(0.chr).first)
    end
    
    # Windows only
    #
    # Returns the long path for a long path name.  For example,
    # C:\Progra~1\Java would return C:\Program Files\Java.
+   #
    def long_path
       unless @win
          raise NotImplementedError, "not supported on this platform"
@@ -199,10 +220,11 @@ class Pathname < String
       buf = 0.chr * MAX_PATH
       buf[0..self.length-1] = self
       @@GetLongPathName.call(self, buf, buf.length)
-      Pathname.new(buf.split(0.chr).first)
+      self.class.new(buf.split(0.chr).first)
    end
    
    # Removes trailing slash, if present.  Non-destructive.
+   #
    def pstrip
       str = self.dup
       if @win
@@ -214,10 +236,11 @@ class Pathname < String
             str.chop!
          end
       end
-      Pathname.new(str)
+      self.class.new(str)
    end
    
    # Removes trailing slash, if present.  Destructive.
+   #
    def pstrip!
       if @win
          @@PathRemoveBackslash.call(self)
@@ -231,8 +254,9 @@ class Pathname < String
       self
    end
 
-   # Splits a pathname into pieces based on the path separator.  For example,
+   # Splits a pathname into strings based on the path separator.  For example,
    # "/foo/bar/baz" would return a three element array of ['foo','bar','baz'].
+   #
    def to_a
       array = split(@sep) # Split string by path separator
       array.delete("")    # Remove empty elements
@@ -240,6 +264,7 @@ class Pathname < String
    end
    
    # Yields each component of the path name to a block.
+   #
    def each
       to_a.each{ |element| yield element }
    end
@@ -250,6 +275,7 @@ class Pathname < String
    # For example, if the path is "/foo/bar/baz", then "/" would be yielded
    # on the first iteration, "/foo" on the second, "/foo/bar on the third and
    # finally "/foo/bar/baz".
+   #
    def descend
       if root?
          yield root
@@ -272,7 +298,7 @@ class Pathname < String
             next if root.to_a.include?(element)
          end
          path << element << @sep
-         yield Pathname.new(path.chop)
+         yield self.class.new(path.chop)
       }
    end
 
@@ -282,6 +308,7 @@ class Pathname < String
    # For example, if the path is "/foo/bar/baz", then "/foo/bar/baz" would
    # be yielded on the first iteration, "/foo/bar" on the second, "/foo" on
    # the third, and finally "/".
+   #
    def ascend
       if root?
          yield root
@@ -301,7 +328,7 @@ class Pathname < String
             end
          end
 
-         path = Pathname.new(path)
+         path = self.class.new(path)
          yield path
          
          if @win && unc?
@@ -323,6 +350,7 @@ class Pathname < String
    # 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
@@ -335,10 +363,11 @@ class Pathname < String
       else
          dir = "/" if self =~ /^\//
       end
-      Pathname.new(dir)
+      self.class.new(dir)
    end
 
    # Returns whether or not the path consists only of a root directory.
+   #
    def root?
       if @win
          @@PathIsRoot.call(self) > 0
@@ -351,6 +380,7 @@ class Pathname < String
    #
    # Determines if the string is a valid Universal Naming Convention (UNC)
    # for a server and share path.
+   #
    def unc?
       unless @win
          raise NotImplementedError, "not supported on this platform"
@@ -365,6 +395,7 @@ class Pathname < String
    # applicable.
    #
    # For example, Pathname.new("C:\\foo").drive_number would return 2.
+   #
    def drive_number
       unless @win
          raise NotImplementedError, "not supported on this platform"
@@ -374,13 +405,16 @@ class Pathname < String
       num >= 0 ? num : nil
    end
 
-   # Pathnames may only be compared against other Pathnames, not strings.
+   # Compares two Pathname objects.  Note that Pathnames may only be compared
+   # against other Pathnames, not strings.  Otherwise nil is returned.
+   #
    def <=>(string)
       return nil unless string.kind_of?(Pathname)
       super
    end
 
    # Returns the parent directory of the given path.
+   #
    def parent
       self + ".."
    end
@@ -394,14 +428,15 @@ class Pathname < String
    # files, or you may not get expected results.
    #
    # Raises an ArgumentError if it cannot find a relative path.
+   #
    def relative_path_from(base)
-      base = Pathname.new(base) unless base.kind_of?(Pathname)
+      base = self.class.new(base) unless base.kind_of?(Pathname)
 
       if self.absolute? != base.absolute?
          raise ArgumentError, "relative path between absolute and relative path"
       end
 
-      return Pathname.new(".") if self == base
+      return self.class.new(".") if self == base
       return self if base == "."
       
       # Because of the way the Windows version handles Pathname#clean, we need
@@ -432,9 +467,9 @@ class Pathname < String
       rel_path = base_arr + dest_arr
 
       if rel_path.empty?
-         Pathname.new(".")
+         self.class.new(".")
       else
-         Pathname.new(rel_path.join(@sep))
+         self.class.new(rel_path.join(@sep))
       end
    end
 
@@ -448,22 +483,23 @@ class Pathname < String
    #
    # Adding a root path to an existing path merely replaces the current
    # path.  Adding '.' to an existing path does nothing.
+   #
    def +(string)
       unless string.kind_of?(Pathname)
-         string = Pathname.new(string)
+         string = self.class.new(string)
       end
 
       # 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
+      # Use the builtin PathAppend() function if on Windows - much easier
       if @win
          buf = 0.chr * MAX_PATH
          buf[0..self.length-1] = self
          @@PathAppend.call(buf, string)
          buf = buf.split("\0").first
-         return Pathname.new(buf) # PathAppend cleans automatically
+         return self.class.new(buf) # PathAppend cleans automatically
       end
       
       # If the string is an absolute directory, return it
@@ -477,15 +513,17 @@ class Pathname < String
          new_string.replace(temp)
       end
       
-      Pathname.new(new_string).clean
+      self.class.new(new_string).clean
    end
 
    # Returns whether or not the path is an absolute path.
+   #
    def absolute?
       !relative?
    end
    
    # Returns whether or not the path is a relative path.
+   #
    def relative?
       if @win
          @@PathIsRelative.call(self) > 0
@@ -495,13 +533,15 @@ class Pathname < String
    end
 
    # Removes unnecessary '.' paths and ellides '..' paths appropriately.
+   # Non-destructive.
+   #
    def clean
       return self if self.empty?
 
       if @win
          path = 0.chr * MAX_PATH
          if @@PathCanonicalize.call(path, self) > 0
-            return Pathname.new(path.split(0.chr).first)
+            return self.class.new(path.split(0.chr).first)
          else
             return self
          end
@@ -518,12 +558,13 @@ class Pathname < String
       final = final.join(@sep)
       final = root._plus_(final) if root != "."
       final = "." if final.empty?
-      Pathname.new(final)
+      self.class.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?
 
@@ -546,7 +587,7 @@ class Pathname < String
       final = final.join(@sep)
       final = root + final if root != "."
       final = "." if final.empty?
-      replace(Pathname.new(final))
+      replace(self.class.new(final))
       self
    end
 
@@ -565,9 +606,9 @@ class Pathname < String
    def find(&block)
       require "find"
       if self == "."
-         Find.find(self){ |f| yield Pathname.new(f.sub(%r{\A\./}, '')) }
+         Find.find(self){ |f| yield self.class.new(f.sub(%r{\A\./}, '')) }
       else
-         Find.find(self){ |f| yield Pathname.new(f) }
+         Find.find(self){ |f| yield self.class.new(f) }
       end
    end
 
@@ -596,12 +637,17 @@ class Pathname < String
    #-- Dir methods not handled by facade
 
    # Dir.glob
+   #
+   # :no-doc:
+   # This differs from Tanaka's implementation in that it does a temporary
+   # chdir to the path in question, then performs the glob.
+   #
    def glob(*args)
       Dir.chdir(self){
          if block_given?
-            Dir.glob(*args){ |file| yield Pathname.new(file) }
+            Dir.glob(*args){ |file| yield self.class.new(file) }
          else
-            Dir.glob(*args).map{ |file| Pathname.new(file) }
+            Dir.glob(*args).map{ |file| self.class.new(file) }
          end
       }
    end
@@ -613,7 +659,7 @@ class Pathname < String
 
    # Dir.entries
    def entries
-      Dir.entries(self).map{ |file| Pathname.new(file) }
+      Dir.entries(self).map{ |file| self.class.new(file) }
    end
 
    # Dir.mkdir
@@ -721,7 +767,7 @@ class Pathname < String
    def mkdir_p(*args)
       FileUtils.mkdir_p(self, *args)
    end
-   alias mkpath   mkdir_p
+   alias mkpath mkdir_p
 
    # FileUtils.ln
    def ln(*args)

data/test/tc_pathname.rb

@@ -5,42 +5,47 @@
 # 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"
+Dir.chdir '..' if File.basename(Dir.pwd) == 'test'
 
 # 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"
+if ARGV[0] && ARGV[0].chomp.downcase == 'c'
+   $LOAD_PATH.unshift Dir.pwd + '/ext'
 else
-   $LOAD_PATH.unshift Dir.pwd + "/lib"
+   $LOAD_PATH.unshift Dir.pwd + '/lib'
 end
 
-if PLATFORM.match("mswin")
+if PLATFORM.match('mswin')
    STDERR.puts("Please run 'tc_pathname_win.rb' instead.")
    exit
 end
 
-require "pathname2"
-require "test/unit"
+require 'pathname2'
+require 'test/unit'
+
+class MyPathname < Pathname; end
 
 class TC_Pathname < Test::Unit::TestCase
    def setup
       @pwd = Dir.pwd
-      @abs_path = Pathname.new("/usr/local/bin")
-      @rel_path = Pathname.new("usr/local/bin")
-      @trl_path = Pathname.new("/usr/local/bin/")
-      @mul_path = Pathname.new("/usr/local/lib/local/lib")
-      @rul_path = Pathname.new("usr/local/lib/local/lib")
+      @abs_path = Pathname.new('/usr/local/bin')
+      @rel_path = Pathname.new('usr/local/bin')
+      @trl_path = Pathname.new('/usr/local/bin/')
+      @mul_path = Pathname.new('/usr/local/lib/local/lib')
+      @rul_path = Pathname.new('usr/local/lib/local/lib')
+      @url_path = Pathname.new('file:///foo%20bar/baz')
       @cur_path = Pathname.new(Dir.pwd)
 
       @abs_array = []
       @rel_array = []
+
+      @mypath = MyPathname.new('/usr/local/bin')
    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)
+      assert_equal('/usr/local/bin', @abs_path)
+      assert_equal('usr/local/bin', @rel_path)
    end
    
    # Convenience method for test_plus
@@ -72,81 +77,86 @@ class TC_Pathname < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal("1.4.4", Pathname::VERSION)
+      assert_equal('1.5.0', Pathname::VERSION)
+   end
+
+   def test_file_url_path
+      assert_equal('/foo bar/baz', @url_path)
    end
 
    def test_realpath
       assert_respond_to(@abs_path, :realpath)
       assert_equal(@pwd, Pathname.new('.').realpath)
       assert_raises(Errno::ENOENT){ Pathname.new('../bogus').realpath }
+
    end
 
    # These tests taken directly from Tanaka's pathname.rb. The one failure
    # (commented out) is due to the fact that Tanaka's cleanpath method returns
-   # the cleanpath for "../a" as "../a" (i.e. it does nothing) whereas mine
-   # converts "../a" into just "a".  Which is correct? I vote mine, because
-   # I don't see how you can get "more relative" from a relative path not
+   # the cleanpath for '../a' as '../a' (i.e. it does nothing) whereas mine
+   # converts '../a' into just 'a'.  Which is correct? I vote mine, because
+   # I don't see how you can get 'more relative' from a relative path not
    # already in the pathname.
    #
    def test_relative_path_from
-      assert_relpath("../a", "a", "b")
-      assert_relpath("../a", "a", "b/")
-      assert_relpath("../a", "a/", "b")
-      assert_relpath("../a", "a/", "b/")
-      assert_relpath("../a", "/a", "/b")
-      assert_relpath("../a", "/a", "/b/")
-      assert_relpath("../a", "/a/", "/b")
-      assert_relpath("../a", "/a/", "/b/")
-
-      assert_relpath("../b", "a/b", "a/c")
-      assert_relpath("../a", "../a", "../b")
-
-      assert_relpath("a", "a", ".")
-      assert_relpath("..", ".", "a")
-
-      assert_relpath(".", ".", ".")
-      assert_relpath(".", "..", "..")
-      assert_relpath("..", "..", ".")
-
-      assert_relpath("c/d", "/a/b/c/d", "/a/b")
-      assert_relpath("../..", "/a/b", "/a/b/c/d")
-      assert_relpath("../../../../e", "/e", "/a/b/c/d")
-      assert_relpath("../b/c", "a/b/c", "a/d")
-
-      assert_relpath("../a", "/../a", "/b")
-      #assert_relpath("../../a", "../a", "b") # fails
-      assert_relpath(".", "/a/../../b", "/b")
-      assert_relpath("..", "a/..", "a")
-      assert_relpath(".", "a/../b", "b")
-
-      assert_relpath("a", "a", "b/..")
-      assert_relpath("b/c", "b/c", "b/..")
-
-      assert_relpath_err("/", ".")
-      assert_relpath_err(".", "/")
-      assert_relpath_err("a", "..")
-      assert_relpath_err(".", "..")
+      assert_relpath('../a', 'a', 'b')
+      assert_relpath('../a', 'a', 'b/')
+      assert_relpath('../a', 'a/', 'b')
+      assert_relpath('../a', 'a/', 'b/')
+      assert_relpath('../a', '/a', '/b')
+      assert_relpath('../a', '/a', '/b/')
+      assert_relpath('../a', '/a/', '/b')
+      assert_relpath('../a', '/a/', '/b/')
+
+      assert_relpath('../b', 'a/b', 'a/c')
+      assert_relpath('../a', '../a', '../b')
+
+      assert_relpath('a', 'a', '.')
+      assert_relpath('..', '.', 'a')
+
+      assert_relpath('.', '.', '.')
+      assert_relpath('.', '..', '..')
+      assert_relpath('..', '..', '.')
+
+      assert_relpath('c/d', '/a/b/c/d', '/a/b')
+      assert_relpath('../..', '/a/b', '/a/b/c/d')
+      assert_relpath('../../../../e', '/e', '/a/b/c/d')
+      assert_relpath('../b/c', 'a/b/c', 'a/d')
+
+      assert_relpath('../a', '/../a', '/b')
+      #assert_relpath('../../a', '../a', 'b') # fails
+      assert_relpath('.', '/a/../../b', '/b')
+      assert_relpath('..', 'a/..', 'a')
+      assert_relpath('.', 'a/../b', 'b')
+
+      assert_relpath('a', 'a', 'b/..')
+      assert_relpath('b/c', 'b/c', 'b/..')
+
+      assert_relpath_err('/', '.')
+      assert_relpath_err('.', '/')
+      assert_relpath_err('a', '..')
+      assert_relpath_err('.', '..')
    end
 
    def test_parent
       assert_respond_to(@abs_path, :parent)
-      assert_equal("/usr/local", @abs_path.parent)
-      assert_equal("usr/local", @rel_path.parent)
-      assert_equal("/", Pathname.new("/").parent)
+      assert_equal('/usr/local', @abs_path.parent)
+      assert_equal('usr/local', @rel_path.parent)
+      assert_equal('/', Pathname.new('/').parent)
    end
 
    def test_pstrip
       assert_respond_to(@trl_path, :pstrip)
       assert_nothing_raised{ @trl_path.pstrip }
-      assert_equal("/usr/local/bin", @trl_path.pstrip)
-      assert_equal("/usr/local/bin/", @trl_path)
+      assert_equal('/usr/local/bin', @trl_path.pstrip)
+      assert_equal('/usr/local/bin/', @trl_path)
    end
 
    def test_pstrip_bang
       assert_respond_to(@trl_path, :pstrip!)
       assert_nothing_raised{ @trl_path.pstrip! }
-      assert_equal("/usr/local/bin", @trl_path.pstrip!)
-      assert_equal("/usr/local/bin", @trl_path)
+      assert_equal('/usr/local/bin', @trl_path.pstrip!)
+      assert_equal('/usr/local/bin', @trl_path)
    end
 
    def test_ascend
@@ -156,15 +166,15 @@ class TC_Pathname < Test::Unit::TestCase
       @abs_path.ascend{ |path| @abs_array.push(path) }
       @rel_path.ascend{ |path| @rel_array.push(path) }
 
-      assert_equal("/usr/local/bin", @abs_array[0])
-      assert_equal("/usr/local", @abs_array[1])
-      assert_equal("/usr", @abs_array[2])
-      assert_equal("/", @abs_array[3])
+      assert_equal('/usr/local/bin', @abs_array[0])
+      assert_equal('/usr/local', @abs_array[1])
+      assert_equal('/usr', @abs_array[2])
+      assert_equal('/', @abs_array[3])
       assert_equal(4, @abs_array.length)
 
-      assert_equal("usr/local/bin", @rel_array[0])
-      assert_equal("usr/local", @rel_array[1])
-      assert_equal("usr", @rel_array[2])
+      assert_equal('usr/local/bin', @rel_array[0])
+      assert_equal('usr/local', @rel_array[1])
+      assert_equal('usr', @rel_array[2])
       assert_equal(3, @rel_array.length)
 
       assert_non_destructive
@@ -177,15 +187,15 @@ class TC_Pathname < Test::Unit::TestCase
       @abs_path.descend{ |path| @abs_array.push(path) }
       @rel_path.descend{ |path| @rel_array.push(path) }
 
-      assert_equal("/", @abs_array[0])
-      assert_equal("/usr", @abs_array[1])
-      assert_equal("/usr/local", @abs_array[2])
-      assert_equal("/usr/local/bin", @abs_array[3])
+      assert_equal('/', @abs_array[0])
+      assert_equal('/usr', @abs_array[1])
+      assert_equal('/usr/local', @abs_array[2])
+      assert_equal('/usr/local/bin', @abs_array[3])
       assert_equal(4, @abs_array.length)
 
-      assert_equal("usr", @rel_array[0])
-      assert_equal("usr/local", @rel_array[1])
-      assert_equal("usr/local/bin", @rel_array[2])
+      assert_equal('usr', @rel_array[0])
+      assert_equal('usr/local', @rel_array[1])
+      assert_equal('usr/local/bin', @rel_array[2])
       assert_equal(3, @rel_array.length)
 
       assert_non_destructive
@@ -198,35 +208,35 @@ class TC_Pathname < Test::Unit::TestCase
 
       # 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" }
+      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 + "/examples",
-            Dir.pwd + "/ext",
-            Dir.pwd + "/install.rb",
-            Dir.pwd + "/lib",
-            Dir.pwd + "/pathname2.gemspec",
-            Dir.pwd + "/test"
+            Dir.pwd + '/CHANGES',
+            Dir.pwd + '/MANIFEST',
+            Dir.pwd + '/README',
+            Dir.pwd + '/examples',
+            Dir.pwd + '/ext',
+            Dir.pwd + '/install.rb',
+            Dir.pwd + '/lib',
+            Dir.pwd + '/pathname2.gemspec',
+            Dir.pwd + '/test'
          ],
          children.sort
       )
 
       # Delete Eclipse related files
       children = @cur_path.children(false)
-      children.delete("CVS")
-      children.delete(".cvsignore")
-      children.delete(".project")
+      children.delete('CVS')
+      children.delete('.cvsignore')
+      children.delete('.project')
 
       assert_equal(
          [
-            "CHANGES", "MANIFEST", "README", "examples", "ext",
-            "install.rb", "lib", "pathname2.gemspec", "test"
+            'CHANGES', 'MANIFEST', 'README', 'examples', 'ext',
+            'install.rb', 'lib', 'pathname2.gemspec', 'test'
          ],
          children.sort
       )
@@ -245,8 +255,8 @@ class TC_Pathname < Test::Unit::TestCase
       assert_nothing_raised{ @abs_path.root }
       assert_nothing_raised{ @rel_path.root }
 
-      assert_equal("/", @abs_path.root)
-      assert_equal(".", @rel_path.root)
+      assert_equal('/', @abs_path.root)
+      assert_equal('.', @rel_path.root)
 
       assert_non_destructive
    end
@@ -256,8 +266,8 @@ class TC_Pathname < Test::Unit::TestCase
       assert_nothing_raised{ @abs_path.root? }
       assert_nothing_raised{ @rel_path.root? }
 
-      path1 = Pathname.new("/")
-      path2 = Pathname.new("a")
+      path1 = Pathname.new('/')
+      path2 = Pathname.new('a')
       assert_equal(true, path1.root?)
       assert_equal(false, path2.root?)
 
@@ -272,10 +282,10 @@ class TC_Pathname < Test::Unit::TestCase
       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_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
@@ -288,10 +298,10 @@ class TC_Pathname < Test::Unit::TestCase
       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_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
@@ -309,55 +319,55 @@ class TC_Pathname < Test::Unit::TestCase
    def test_spaceship_operator
       assert_respond_to(@abs_path, :<=>)
 
-      assert_pathname_cmp( 0, "/foo/bar", "/foo/bar")
-      assert_pathname_cmp(-1, "/foo/bar", "/foo/zap")
-      assert_pathname_cmp( 1, "/foo/zap", "/foo/bar")
-      assert_pathname_cmp(-1, "foo", "foo/")
-      assert_pathname_cmp(-1, "foo/", "foo/bar")
+      assert_pathname_cmp( 0, '/foo/bar', '/foo/bar')
+      assert_pathname_cmp(-1, '/foo/bar', '/foo/zap')
+      assert_pathname_cmp( 1, '/foo/zap', '/foo/bar')
+      assert_pathname_cmp(-1, 'foo', 'foo/')
+      assert_pathname_cmp(-1, 'foo/', 'foo/bar')
    end
 
    def test_plus_operator
       assert_respond_to(@abs_path, :+)
 
       # Standard stuff
-      assert_pathname_plus("/foo/bar", "/foo", "bar")
-      assert_pathname_plus("foo/bar", "foo", "bar")
-      assert_pathname_plus("foo", "foo", ".")
-      assert_pathname_plus("foo", ".", "foo")
-      assert_pathname_plus("/foo", "bar", "/foo")
-      assert_pathname_plus("foo", "foo/bar", "..")
-      assert_pathname_plus("/foo", "/", "../foo")
-      assert_pathname_plus("foo/zap", "foo/bar", "../zap")
-      assert_pathname_plus(".", "foo", "..")
-      assert_pathname_plus("foo", "..", "foo")     # Auto clean
-      assert_pathname_plus("foo", "..", "../foo")  # Auto clean
+      assert_pathname_plus('/foo/bar', '/foo', 'bar')
+      assert_pathname_plus('foo/bar', 'foo', 'bar')
+      assert_pathname_plus('foo', 'foo', '.')
+      assert_pathname_plus('foo', '.', 'foo')
+      assert_pathname_plus('/foo', 'bar', '/foo')
+      assert_pathname_plus('foo', 'foo/bar', '..')
+      assert_pathname_plus('/foo', '/', '../foo')
+      assert_pathname_plus('foo/zap', 'foo/bar', '../zap')
+      assert_pathname_plus('.', 'foo', '..')
+      assert_pathname_plus('foo', '..', 'foo')     # Auto clean
+      assert_pathname_plus('foo', '..', '../foo')  # Auto clean
 
       # Edge cases
-      assert_pathname_plus(".", ".", ".")
-      assert_pathname_plus("/", "/", "..")
-      assert_pathname_plus(".", "..",  "..")
-      assert_pathname_plus(".", "foo", "..")
+      assert_pathname_plus('.', '.', '.')
+      assert_pathname_plus('/', '/', '..')
+      assert_pathname_plus('.', '..',  '..')
+      assert_pathname_plus('.', 'foo', '..')
    end
 
-   # Any tests marked with "***" mean that this behavior is different than
+   # 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_clean
       # Standard stuff
-      assert_equal("/a/b/c", Pathname.new("/a/b/c").cleanpath)
-      assert_equal("b/c", Pathname.new("./b/c").cleanpath)
-      assert_equal("a", Pathname.new("a/.").cleanpath)         # ***
-      assert_equal("a/c", Pathname.new("a/./c").cleanpath)
-      assert_equal("a/b", Pathname.new("a/b/.").cleanpath)     # ***
-      assert_equal(".", Pathname.new("a/../.").cleanpath)      # ***
-      assert_equal("/a", Pathname.new("/a/b/..").cleanpath)
-      assert_equal("/b", Pathname.new("/a/../b").cleanpath)
-      assert_equal("d", Pathname.new("a/../../d").cleanpath)   # ***
+      assert_equal('/a/b/c', Pathname.new('/a/b/c').cleanpath)
+      assert_equal('b/c', Pathname.new('./b/c').cleanpath)
+      assert_equal('a', Pathname.new('a/.').cleanpath)         # ***
+      assert_equal('a/c', Pathname.new('a/./c').cleanpath)
+      assert_equal('a/b', Pathname.new('a/b/.').cleanpath)     # ***
+      assert_equal('.', Pathname.new('a/../.').cleanpath)      # ***
+      assert_equal('/a', Pathname.new('/a/b/..').cleanpath)
+      assert_equal('/b', Pathname.new('/a/../b').cleanpath)
+      assert_equal('d', Pathname.new('a/../../d').cleanpath)   # ***
 
       # Edge cases
-      assert_equal("", Pathname.new("").cleanpath)
-      assert_equal(".", Pathname.new(".").cleanpath)
-      assert_equal("..", Pathname.new("..").cleanpath)
+      assert_equal('', Pathname.new('').cleanpath)
+      assert_equal('.', Pathname.new('.').cleanpath)
+      assert_equal('..', Pathname.new('..').cleanpath)
       assert_equal('/', Pathname.new('/').cleanpath)
       assert_equal('/', Pathname.new('//').cleanpath)
 
@@ -388,28 +398,45 @@ class TC_Pathname < Test::Unit::TestCase
       methods -= File.methods(false)
       methods -= Dir.methods(false)
       methods.delete_if{ |m| m =~ /stream/ }
-      methods.delete("identical?")
+      methods.delete('identical?')
 
       methods.each{ |method|
          assert_respond_to(@abs_path, method.to_sym)
       }
    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{} }
 
       Pathname.new(Dir.pwd).find{ |f|
-         Find.prune if f.match("CVS")
+         Find.prune if f.match('CVS')
          assert_kind_of(Pathname, f)
       }
    end
+
+   # Ensures that subclasses return the subclass as the class, not a hard
+   # coded Pathname.
+   def test_subclasses
+      assert_kind_of(MyPathname, @mypath)
+      assert_kind_of(MyPathname, @mypath + MyPathname.new('foo'))
+      assert_kind_of(MyPathname, @mypath.realpath)
+      assert_kind_of(MyPathname, @mypath.children.first)
+   end
    
    def teardown
+      @pwd      = nil
       @abs_path = nil
       @rel_path = nil
+      @trl_path = nil
+      @mul_path = nil
+      @rul_path = nil
       @cur_path = nil
+      @abs_path = nil
+      @rel_path = nil
+      @cur_path = nil
+
+      @mypath = nil
 
       @abs_array.clear
       @rel_array.clear

data/test/tc_pathname_win.rb

@@ -24,6 +24,8 @@ end
 require "pathname2"
 require "test/unit"
 
+class MyPathname < Pathname; end
+
 class TC_Pathname_MSWin < Test::Unit::TestCase
 
    def setup
@@ -42,15 +44,18 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       @cpath = Pathname.new("C:\\foo\\..\\bar\\.\\baz")
       @tpath = Pathname.new("C:\\foo\\bar")
 
+      @url_path = Pathname.new("file:///C:/Documents%20and%20Settings")
       @cur_path = Pathname.new(Dir.pwd)
       
+      @mypath = MyPathname.new("C:\\Program Files")
+      
       @abs_array = []
       @rel_array = []
       @unc_array = []
    end
    
    def test_version
-      assert_equal("1.4.4", Pathname::VERSION)
+      assert_equal("1.5.0", Pathname::VERSION)
    end
 
    # Convenience method for test_plus
@@ -80,6 +85,11 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
          Pathname.new(to).relative_path_from(from)
       }
    end
+   
+   def test_file_urls
+      assert_equal("C:\\Documents and Settings", @url_path)
+      assert_raises(PathnameError){ Pathname.new('http://rubyforge.org') }
+   end
 
    def test_realpath
       assert_respond_to(@fpath, :realpath)
@@ -605,6 +615,15 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
          children
       )
    end
+
+   # Ensures that subclasses return the subclass as the class, not a hard
+   # coded Pathname.
+   def test_subclasses
+      assert_kind_of(MyPathname, @mypath)
+      assert_kind_of(MyPathname, @mypath + MyPathname.new('foo'))
+      assert_kind_of(MyPathname, @mypath.realpath)
+      assert_kind_of(MyPathname, @mypath.children.first)
+   end
   
    def teardown
       @fpath = nil

metadata

@@ -3,11 +3,11 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: pathname2
 version: !ruby/object:Gem::Version 
-  version: 1.4.4
-date: 2006-03-23 00:00:00 -07:00
+  version: 1.5.0
+date: 2006-04-17 00:00:00 -06:00
 summary: An alternate implementation of the Pathname class
 require_paths: 
-- lib
+  - lib
 email: djberg96@gmail.com
 homepage: http://www.rubyforge.org/projects/shards
 rubyforge_project: 
@@ -18,42 +18,40 @@ bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
 authors: 
-- Daniel J. Berger
+  - Daniel J. Berger
 files: 
-- lib/pathname2.rb
-- CHANGES
-- MANIFEST
-- README
-- test/tc_pathname.rb
-- test/tc_pathname_win.rb
+  - lib/pathname2.rb
+  - CHANGES
+  - MANIFEST
+  - README
+  - test/tc_pathname.rb
+  - test/tc_pathname_win.rb
 test_files: 
-- test/tc_pathname.rb
+  - test/tc_pathname.rb
 rdoc_options: []
-
 extra_rdoc_files: 
-- README
-- CHANGES
+  - README
+  - CHANGES
 executables: []
-
 extensions: []
-
 requirements: []
-
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: facade
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.0.0
-    version: 
+  - !ruby/object:Gem::Dependency 
+    name: facade
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.0.0
+      version: