pathname2 1.4.0 → 1.4.1

data/CHANGES

@@ -1,4 +1,10 @@
-== 1.4.0 -
+== 1.4.1 - 18-Feb-2005
+* Added the Pathname#parent method.
+* Added the Pathname#relative_path_from method.
+* Bug fix for Pathname#pstrip on *nix.
+* Corresponding test suite additions.
+
+== 1.4.0 - 19-Dec-2005
 * 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

data/README

@@ -64,6 +64,9 @@
    * The Pathname#+ method auto cleans.
    * It uses a facade for all File and Dir methods, as well as all ftools
      methods and most FileUtils methods.
+   * 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.
      
 == Method Priority
    Because there is some overlap in method names between File, Dir, ftools
@@ -87,6 +90,10 @@
    Pathname#glob is not yet implemented in the C version.
    Pathname#find is not implemented properly in the C version.
    
+   In Ruby 1.8.3 and later you will see a failure in the test suite regarding
+   'fu_world_writable?' from FileUtils.  You can ignore this.  That method is
+   supposed to be private.  See ruby-core:7383.
+   
 == License
    Ruby's
 

data/lib/pathname2.rb

@@ -77,7 +77,7 @@ class Pathname < String
          Win32API.new("shlwapi", "PathRemoveBackslash", "P", "P")
    end
 
-   VERSION  = "1.4.0"
+   VERSION  = "1.4.1"
    MAX_PATH = 260
    
    # Creates and returns a new Pathname object.
@@ -109,7 +109,7 @@ class Pathname < String
       path = path.tr("/", @sep) if @win
       super(path)
    end
-
+   
    # Returns the children of the directory, files and subdirectories, as an
    # array of Pathname objects. If you set +with_directory+ to +false+, then
    # the returned pathnames will contain the filename only.
@@ -195,7 +195,7 @@ class Pathname < String
          @@PathRemoveBackslash.call(str)
          str.strip!
       else
-         if str[-1] == @sep
+         if str[-1].chr == @sep
             str.strip!
             str.chop!
          end
@@ -209,7 +209,7 @@ class Pathname < String
          @@PathRemoveBackslash.call(self)
          strip!
       else
-         if self[-1] == @sep
+         if self[-1].chr == @sep
             strip!
             chop!
          end
@@ -366,6 +366,54 @@ class Pathname < String
       super
    end
 
+   # Returns the parent directory of the given path.
+   def parent
+      self + ".."
+   end
+
+   # Returns a relative path from the argument to the receiver.  If +self+
+   # is absolute, the argument must be absolute too.  If +self+ is relative,
+   # the argument must be relative too.
+   #
+   # This method does not access the filesystem.  It assumes no symlinks.
+   #
+   # Raises an ArgumentError if it cannot find a relative path.
+   def relative_path_from(base)
+      base = Pathname.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 if base == "."
+
+      dest_arr = self.clean.to_a
+      base_arr = base.clean.to_a
+      dest_arr.delete('.')
+      base_arr.delete('.')
+
+      diff_arr = dest_arr - base_arr
+
+      while !base_arr.empty? && !dest_arr.empty? && base_arr[0] == dest_arr[0]
+         base_arr.shift
+         dest_arr.shift
+      end
+
+      if base_arr.include?("..")
+         raise ArgumentError, "base directory may not contain '..'"
+      end
+
+      base_arr.fill("..")
+      rel_path = base_arr + dest_arr
+
+      if rel_path.empty?
+         Pathname.new(".")
+      else
+         Pathname.new(rel_path.join(@sep))
+      end
+   end
+
    # Adds two Pathname objects together, or a Pathname and a String.  It
    # also automatically cleans the Pathname.
    #
@@ -390,7 +438,7 @@ class Pathname < String
          buf = 0.chr * MAX_PATH
          buf[0..self.length-1] = self
          @@PathAppend.call(buf, string)
-         buf.strip!
+         buf = buf.split("\0").first
          return Pathname.new(buf) # PathAppend cleans automatically
       end
       

data/test/tc_pathname.rb

@@ -26,6 +26,9 @@ class TC_Pathname < Test::Unit::TestCase
    def setup
       @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")
       @cur_path = Pathname.new(Dir.pwd)
 
       @abs_array = []
@@ -55,8 +58,88 @@ class TC_Pathname < Test::Unit::TestCase
       assert_equal(int, result)
    end
 
+   # Convenience method for test_relative_path_from
+   def assert_relpath(result, dest, base)
+      assert_equal(result, Pathname.new(dest).relative_path_from(base))
+   end
+
+   # Convenience method for test_relative_path_from_expected_errors
+   def assert_relpath_err(to, from)
+      assert_raise(ArgumentError) {
+         Pathname.new(to).relative_path_from(from)
+      }
+   end
+
    def test_version
-      assert_equal("1.4.0", Pathname::VERSION)
+      assert_equal("1.4.1", Pathname::VERSION)
+   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
+   # 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(".", "..")
+   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)
+   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)
+   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)
    end
 
    def test_ascend

data/test/tc_pathname_win.rb

@@ -25,6 +25,7 @@ require "pathname2"
 require "test/unit"
 
 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")
@@ -51,7 +52,7 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
    def test_version
       assert_equal("1.4.0", Pathname::VERSION)
    end
-   
+
    # Convenience method for test_plus
    def assert_pathname_plus(a, b, c)
       a = Pathname.new(a)
@@ -85,6 +86,13 @@ class TC_Pathname_MSWin < Test::Unit::TestCase
       assert_equal("C:\\foo\\bar\\", @ppath)
       assert_equal("C:\\foo\\..\\bar\\.\\baz", @cpath)
    end
+
+   def test_parent
+      assert_respond_to(@bpath, :parent)
+      assert_equal("C:\\Program Files\\Windows NT", @bpath.parent)
+      assert_equal("foo\\bar", @npath.parent)
+      assert_equal("Z:\\", @rpath.parent)
+   end
    
    def test_short_path
       assert_respond_to(@bpath, :short_path)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: pathname2
 version: !ruby/object:Gem::Version 
-  version: 1.4.0
-date: 2005-12-19
+  version: 1.4.1
+date: 2006-02-18
 summary: An alternate implementation of the Pathname class
 require_paths: 
   - lib