pathname2 1.0.0

data/CHANGES

@@ -0,0 +1,2 @@
+== 1.0.0 - 11-Jun-2005
+* Initial release

data/MANIFEST

@@ -0,0 +1,10 @@
+CHANGES
+MANIFEST
+README
+install.rb
+pathname2.gempsec
+
+lib/pathname2.rb
+
+test/tc_pathname.rb
+test/tc_pathname_win.rb

data/README

@@ -0,0 +1,90 @@
+== Description
+   A drop in replacement for the current Pathname class.
+
+== Prerequisites
+   * Ruby 1.8.0 or later
+   * facade 1.0.0 or later (available on the RAA)
+   
+== Installation
+=== Manual Installation
+   ruby test/tc_pathname.rb (Unix, optional)
+   ruby test/tc_pathname_win.rb (Windows, optional)
+   ruby install.rb
+   
+=== Gem Installation
+   ruby test/tc_pathname.rb (Unix, optional)
+   ruby test/tc_pathname_win.rb (Windows, optional)
+   gem install pathname2-<version>.gem
+
+== Synopsis
+   require "pathname"
+
+   # Unix
+   path1 = "/foo/bar/baz"
+   path2 = "../zap"
+
+   path1 + path2 # "/foo/bar/zap"
+   path1.exists? # Does this path exist?
+   path1.dirname # "/foo/bar"
+   path1.to_a    # ['foo','bar','baz']
+
+   # Win32
+   path1 = "C:/foo/bar/baz"
+   path2 = "../zap"
+
+   path1 + path2 # "C:\\foo\\bar\\zap"
+   path1.root    # "C:\\"
+   path1.to_a    # ['C:','foo','bar','baz']
+
+== Win32 Notes
+   All forward slashes are converted to backslashes for Pathname objects.
+
+== Differences between Unix and Win32
+   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
+   will not worry myself with it.
+
+== Differences between the old version and this version
+   * It is a subclass of String (and thus, mixes in Enumerable).
+   * It has sensical to_a and root instance methods.
+   * It works on Windows and Unix.  The current implementation does not work
+     with Windows path names very well, and not at all when it comes to UNC
+     paths.
+   * The Pathname#cleanpath method works differently - it always returns
+     a canonical pathname.  In addition, there is no special consideration
+     for symlinks (yet).
+   * 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.
+     
+== Method Priority
+   Because there is some overlap in method names between File, Dir, ftools
+   and FileUtils, the priority is as follows:
+   
+   * File
+   * Dir
+   * ftools
+   * FileUtils
+   
+   In other words, whichever of these defines a given method first is the
+   method that is used by the pathname2 package.  For example, the
+   Pathname#safe_unlink method used is the one defined in ftools.rb,
+   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.
+   
+== License
+   Ruby's
+
+== 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/pathname2.rb

@@ -0,0 +1,536 @@
+# == Synopsis
+#
+# Pathname represents a path name on a filesystem.  A Pathname can be
+# relative or absolute.  It does not matter whether the path exists or not.
+#
+# All functionality from File, FileTest, and Dir is included, using a facade
+# pattern.
+#
+# This class works on both Unix and Win32, including UNC path names.  Note
+# that forward slashes are converted to backslashes on Win32 systems.
+#
+# == Usage
+#
+# require "pathname"
+# 
+# # Unix
+# path1 = Pathname.new("/foo/bar/baz")
+# path2 = Pathname.new("../zap")
+#
+# path1 + path2 # "/foo/bar/zap"
+# path1.dirname # "/foo/bar"
+#
+# # Win32
+# path1 = Pathname.new("C:\\foo\\bar\\baz")
+# path2 = Pathname.new("..\\zap")
+#
+# path1 + path2 # "C:\\foo\\bar\\zap"
+# path1.exists? # Does the path exist?
+#
+# == Author
+#
+# Daniel J. Berger
+# djberg96 at gmail dot com
+# imperator on IRC (irc.freenode.net)
+#
+# == Copyright
+# Copyright (c) 2005 Daniel J. Berger.
+# Licensed under the same terms as Ruby itself.
+#
+require "facade"
+require "ftools"
+require "fileutils"
+
+class Pathname < String
+   extend Facade
+   facade File
+   facade Dir
+   
+   if PLATFORM.match("mswin32")
+      require "Win32API"
+      @@PathStripToRoot  = Win32API.new("shlwapi","PathStripToRoot","P","L")
+      @@PathIsUNC        = Win32API.new("shlwapi","PathIsUNC","P","L")
+      @@PathIsURL        = Win32API.new("shlwapi","PathIsURL","P","L")
+      @@PathCanonicalize = Win32API.new("shlwapi","PathCanonicalize","PP","L")
+      @@PathAppend       = Win32API.new("shlwapi","PathAppend","PP","L")     
+      @@PathIsRoot       = Win32API.new("shlwapi","PathIsRoot","P","L")
+      @@PathIsDirectory  = Win32API.new("shlwapi","PathIsDirectory","P","L")
+      @@PathIsRelative   = Win32API.new("shlwapi","PathIsRelative","P","L")
+      @@PathFileExists   = Win32API.new("shlwapi","PathFileExists","P","L")
+      @@PathUndecorate   = Win32API.new("shlwapi","PathUndecorate","P","L")
+
+      @@PathGetDriveNumber =
+         Win32API.new("shlwapi","PathGetDriveNumber","P","L")
+   
+      @@PathCreateFromUrl  =
+         Win32API.new("shlwapi", "PathCreateFromUrl", "PPPL", "L")
+   
+      @@PathRemoveBackslash =
+         Win32API.new("shlwapi", "PathRemoveBackslash", "P", "P")
+   end
+
+   VERSION  = "1.0.0"
+   MAX_PATH = 260
+   
+   # Creates and returns a new Pathname object.
+   #
+   # On Win32 systems, all forward slashes are replaced with backslashes.
+   def initialize(path)
+      if path.length > MAX_PATH
+         msg = "string too long.  maximum string length is " + MAX_PATH.to_s
+         raise PathnameError, msg
+      end
+
+      @sep   = File::ALT_SEPARATOR || File::SEPARATOR
+      @win32 = PLATFORM.match("mswin32")
+
+      # Handle File URL's for Windows
+      if @win32
+         if @@PathIsURL.call(path) > 0
+            buf = 0.chr * MAX_PATH
+            len = [buf.length].pack("l")
+            if @@PathCreateFromUrl.call(path, buf, len, 0) >= 0
+               path = buf.strip
+            else
+               raise PathnameError, "invalid file url: #{path}"
+            end
+         end
+      end
+
+      # Convert forward slashes to backslashes on Win32
+      path = path.tr("/", @sep) if @win32
+      super(path)
+   end
+
+   # Win32 only
+   #
+   # Removes the decoration from a path string.  For example,
+   # C:\Path\File[5].txt would become C:\Path\File.txt.
+   def undecorate
+      unless @win32
+         raise NotImplementedError, "not supported on this platform"
+      end
+      buf = 0.chr * MAX_PATH
+      buf[0..self.length-1] = self
+      @@PathUndecorate.call(buf)
+      Pathname.new(buf.split(0.chr).first)
+   end
+
+   # Removes trailing slash, if present.
+   def pstrip
+      if @win32
+         @@PathRemoveBackslash.call(self)
+         self.strip!
+      else
+         if self[-1] == @sep
+            self.strip!
+            self.chop!
+         end
+      end
+      self
+   end
+
+   # Splits a pathname into pieces 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
+      array
+   end
+   
+   # Yields each component of the path name to a block.
+   def each
+      self.to_a.each{ |element| yield element }
+   end
+
+   # 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.
+   def root
+      dir = "."   
+      if @win32
+         buf = 0.chr * MAX_PATH
+         buf[0..self.length-1] = self
+      
+         if @@PathStripToRoot.call(buf) > 0
+            dir = Pathname.new(buf.split(0.chr).first)
+         end
+      else
+         dir = File.dirname(self)
+         while dir != "/" && dir != "."
+            dir = File.dirname(dir)
+         end
+      end
+      dir = "." if dir.empty?
+      dir
+   end
+
+   # Returns whether or not the path consists only of a root directory.
+   def root?
+      if @win32
+         @@PathIsRoot.call(self) > 0
+      else
+         self == root
+      end
+   end
+   
+   # Win32 only
+   #
+   # Determines if the string is a valid Universal Naming Convention (UNC)
+   # for a server and share path.
+   def unc?
+      unless @win32
+         raise NotImplementedError, "not supported on this platform"
+      end
+
+      @@PathIsUNC.call(self) > 0
+   end
+   
+   # Win32 only
+   #
+   # Returns the drive number that corresponds to the root, or nil if not
+   # applicable.
+   #
+   # For example, Pathname.new("C:\\foo").drive_number would return 2.
+   def drive_number
+      unless @win32
+         raise NotImplementedError, "not supported on this platform"
+      end
+
+      num = @@PathGetDriveNumber.call(self)
+      num >= 0 ? num : nil
+   end
+
+   # Pathnames may only be compared against other Pathnames, not strings.
+   def <=>(string)
+      return nil unless string.kind_of?(Pathname)
+      super
+   end
+
+   # Adds two Pathname objects together, or a Pathname and a String.  It
+   # also automatically cleans the Pathname.
+   #
+   # Example:
+   #    path1 = '/foo/bar'
+   #    path2 = '../baz'
+   #    path1 + path2 # '/foo/baz'
+   #
+   # 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)
+      end
+
+      # Any path plus "." is the same directory
+      return self if string == "."
+      
+      # Use the builtin PathAppend method if on Windows - much easier
+      if @win32
+         buf = 0.chr * MAX_PATH
+         buf[0..self.length-1] = self
+         @@PathAppend.call(buf, string << 0.chr)
+         buf.strip!
+         return Pathname.new(buf) # PathAppend cleans automatically
+      end
+      
+      # If the string is an absolute directory, return it
+      return string if string.absolute?
+
+      array = self.to_a + string.to_a
+      new_string = array.join(@sep)
+      
+      unless self.relative? || @win32
+         new_string = @sep + new_string   # Add root path back if needed
+      end
+      
+      Pathname.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 @win32
+         @@PathIsRelative.call(self) > 0
+      else
+         root == "."
+      end
+   end
+
+   # Removes unnecessary '.' paths and ellides '..' paths appropriately.
+   def clean
+      return self if self.empty?
+
+      if @win32
+         path = 0.chr * MAX_PATH
+         if @@PathCanonicalize.call(path, self) > 0
+            return Pathname.new(path.split(0.chr).first)
+         else
+            return self
+         end
+      end
+
+      final = []
+      self.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?
+      Pathname.new(final)
+   end
+   alias :cleanpath :clean
+
+   #-- IO methods not handled by facade
+   
+   # IO.foreach
+   def foreach(*args, &block)
+      IO.foreach(self, *args, &block)
+   end
+
+   # IO.read
+   def read(*args)
+      IO.read(self, *args)
+   end
+
+   # IO.readlines
+   def readlines(*args)
+      IO.readlines(self, *args)  
+   end
+
+   # IO.sysopen
+   def sysopen(*args)
+      IO.sysopen(self, *args)
+   end
+
+   #-- Dir methods not handled by facade
+
+   # 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
+   end
+
+   # Dir.chdir
+   def chdir(&block)
+      Dir.chdir(self, &block)
+   end
+
+   # Dir.entries
+   def entries
+      Dir.entries(self).map{ |file| Pathname.new(file) }
+   end
+
+   # Dir.mkdir
+   def mkdir(*args)
+      Dir.mkdir(self, *args)
+   end
+
+   # Dir.opendir
+   def opendir(&block)
+      Dir.open(self, &block)
+   end
+
+   #-- File methods not handled by facade
+
+   # File.chmod
+   def chmod(mode)
+      File.chmod(mode, self)
+   end
+
+   # File.lchmod
+   def lchmod(mode)
+      File.lchmod(mode, self)
+   end
+
+   # File.chown
+   def chown(owner, group)
+      File.chown(owner, group, self)
+   end
+
+   # File.lchown
+   def lchown(owner, group)
+      File.lchown(owner, group, self)
+   end
+
+   # File.fnmatch
+   def fnmatch(pattern, *args)
+      File.fnmatch(pattern, self, *args)
+   end
+
+   # File.fnmatch?
+   def fnmatch?(pattern, *args)
+      File.fnmatch?(pattern, self, *args)
+   end
+
+   # File.link
+   def link(old)
+      File.link(old, self)
+   end
+
+   # File.open
+   def open(*args, &block)
+      File.open(self, *args, &block)
+   end
+
+   # File.rename
+   def rename(name)
+      File.rename(self, name)
+   end
+
+   # File.symlink
+   def symlink(old)
+      File.symlink(old, self)
+   end
+
+   # File.truncate
+   def truncate(length)
+      File.truncate(self, length)
+   end
+
+   # File.utime
+   def utime(atime, mtime)
+      File.utime(atime, mtime, self)
+   end
+
+   # File.basename
+   def basename(*args)
+      File.basename(self, *args)
+   end
+
+   # File.expand_path
+   def expand_path(*args)
+      File.expand_path(self, *args)
+   end
+
+   #--
+   # ftools facade
+   #++
+
+   # ftools File.copy
+   def copy(*args)
+      File.copy(self, *args)
+   end
+
+   #--
+   # FileUtils facade.  Note that methods already covered by File and Dir
+   # are not defined here (pwd, mkdir, etc).
+   #++
+
+   # FileUtils.cd
+   def cd(*args, &block)
+      FileUtils.cd(self, *args, &block)
+   end
+
+   # FileUtils.mkdir_p
+   def mkdir_p(*args)
+      FileUtils.mkdir_p(self, *args)
+   end
+   alias mkpath   mkdir_p
+
+   # FileUtils.ln
+   def ln(*args)
+      FileUtils.ln(self, *args)
+   end
+
+   # FileUtils.ln_s
+   def ln_s(*args)
+      FileUtils.ln_s(self, *args)
+   end
+
+   # FileUtils.ln_sf
+   def ln_sf(*args)
+      FileUtils.ln_sf(self, *args)
+   end
+
+   # FileUtils.cp
+   def cp(*args)
+      FileUtils.cp(self, *args)
+   end
+
+   # FileUtils.cp_r
+   def cp_r(*args)
+      FileUtils.cp_r(self, *args)
+   end
+
+   # FileUtils.mv
+   def mv(*args)
+      FileUtils.mv(self, *args)
+   end
+
+   # FileUtils.rm
+   def rm(*args)
+      FileUtils.rm(self, *args)
+   end
+   alias remove rm
+
+   # FileUtils.rm_f
+   def rm_f(*args)
+      FileUtils.rm_f(self, *args)
+   end
+
+   # FileUtils.rm_r
+   def rm_r(*args)
+      FileUtils.rm_r(self, *args)
+   end
+
+   # FileUtils.rm_rf
+   def rm_rf(*args)
+      FileUtils.rm_rf(self, *args)
+   end
+   alias rmtree rm_rf
+
+   # FileUtils.install
+   def install(*args)
+      FileUtils.install(self, *args)
+   end
+
+   # FileUtils.touch
+   def touch(*args)
+      FileUtils.touch(*args)
+   end
+
+   # FileUtils.compare_file
+   def compare_file(file)
+      FileUtils.compare_file(self, file)
+   end
+
+   # FileUtils.uptodate?
+   def uptodate?(*args)
+      FileUtils.uptodate(self, *args)
+   end
+
+   # FileUtils.copy_file
+   def copy_file(*args)
+      FileUtils.copy_file(self, *args)
+   end
+
+   # FileUtils.remove_dir
+   def remove_dir(*args)
+      FileUtils.remove_dir(self, *args)
+   end
+
+   # FileUtils.remove_file
+   def remove_file(*args)
+      FileUtils.remove_dir(self, *args)
+   end
+   
+   # FileUtils.copy_entry
+   def copy_entry(*args)
+      FileUtils.copy_entry(self, *args)
+   end
+end

data/test/tc_pathname.rb

@@ -0,0 +1,182 @@
+##############################################
+# tc_pathname.rb
+#
+# Test suite for the pathname package (Unix)
+##############################################
+Dir.chdir ".." if File.basename(Dir.pwd) == "test"
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + "/lib"
+
+require "pathname2"
+require "test/unit"
+
+class TC_Pathname < Test::Unit::TestCase
+   def setup
+      @path = Pathname.new("/usr/local/bin")
+   end
+   
+   # Convenience method for test_plus
+   def assert_pathname_plus(a, b, c)
+      a = Pathname.new(a)
+      b = Pathname.new(b)
+      c = Pathname.new(c)
+      assert_equal(a, b + c)
+   end
+
+   # Convenience method for test_spaceship operator
+   def assert_pathname_cmp(int, s1, s2)
+      p1 = Pathname.new(s1)
+      p2 = Pathname.new(s2)
+      result = p1 <=> p2
+      assert_equal(int, result)
+   end
+
+   def test_version
+      assert_equal("1.0.0", Pathname::VERSION)
+   end
+
+   def test_unc
+      assert_raises(NotImplementedError){ @path.unc? }
+   end
+
+   def test_enumerable
+      assert_respond_to(@path, :each)
+   end
+   
+   def test_root
+      assert_respond_to(@path, :root)
+      assert_nothing_raised{ @path.root }
+      assert_equal("/", @path.root)
+
+      path1 = Pathname.new("foo")
+      path2 = Pathname.new("foo/bar/baz")
+      assert_equal(".", path1.root)
+      assert_equal(".", path2.root)
+   end
+
+   def test_root?
+      assert_respond_to(@path, :root?)
+      assert_nothing_raised{ @path.root? }
+
+      path1 = Pathname.new("/")
+      path2 = Pathname.new("a")
+      assert_equal(true, path1.root?)
+      assert_equal(false, path2.root?)
+   end
+
+   def test_absolute
+      assert_respond_to(@path, :absolute?)
+      assert_nothing_raised{ @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?)
+   end
+
+   def test_relative
+      assert_respond_to(@path, :relative?)
+      assert_nothing_raised{ @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?)
+   end
+   
+   def test_to_a
+      assert_respond_to(@path, :to_a)
+      assert_nothing_raised{ @path.to_a }
+      assert_kind_of(Array, @path.to_a)
+      assert_equal(%w/usr local bin/, @path.to_a)
+   end
+
+   def test_spaceship_operator
+      assert_respond_to(@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")
+   end
+
+   def test_plus_operator
+      assert_respond_to(@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
+
+      # Edge cases
+      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
+   # the current implementation.  It also means I disagree with the current
+   # implementation.
+   def test_cleanpath
+      # 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)   # ***
+
+      # 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)
+   end
+
+   def test_facade_io
+      assert_respond_to(@path, :foreach)
+      assert_respond_to(@path, :read)
+      assert_respond_to(@path, :readlines)
+      assert_respond_to(@path, :sysopen)
+   end
+
+   def test_facade_file
+      File.methods(false).each{ |method|
+         assert_respond_to(@path, method.to_sym)
+      }
+   end
+
+   def test_facade_dir
+      Dir.methods(false).each{ |method|
+         assert_respond_to(@path, method.to_sym)
+      }
+   end
+
+   def test_facade_fileutils
+      methods = FileUtils.public_instance_methods
+      methods -= File.methods(false)
+      methods -= Dir.methods(false)
+      methods.delete_if{ |m| m =~ /stream/ }
+      methods.delete("identical?")
+
+      methods.each{ |method|
+         assert_respond_to(@path, method.to_sym)
+      }
+   end
+   
+   def teardown
+      @path = nil
+   end
+end

data/test/tc_pathname_win.rb

@@ -0,0 +1,227 @@
+############################################
+# tc_pathname.rb
+#
+# Test suite for the pathname package.
+############################################
+Dir.chdir ".." if File.basename(Dir.pwd) == "test"
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + "/lib"
+
+require "pathname2"
+require "test/unit"
+
+class TC_Pathname < Test::Unit::TestCase
+   def setup
+      @fpath = Pathname.new("C:/Program Files/Windows NT/Accessories")
+      @bpath = Pathname.new("C:\\Program Files\\Windows NT\\Accessories")
+      @upath = Pathname.new("\\\\foo\\bar\\baz")
+      @npath = Pathname.new("foo\\bar\\baz")
+      @rpath = Pathname.new("Z:\\")
+      @xpath = Pathname.new("\\\\foo\\bar")
+      @ypath = Pathname.new("\\\\foo")
+      @zpath = Pathname.new("\\\\")
+      @epath = Pathname.new("")
+   end
+   
+   def test_version
+      assert_equal("1.0.0", Pathname::VERSION)
+   end
+   
+   # Convenience method for test_plus
+   def assert_pathname_plus(a, b, c)
+      a = Pathname.new(a)
+      b = Pathname.new(b)
+      c = Pathname.new(c)
+      assert_equal(a, b + c)
+   end
+
+   # Convenience method for test_spaceship operator
+   def assert_pathname_cmp(int, s1, s2)
+      p1 = Pathname.new(s1)
+      p2 = Pathname.new(s2)
+      result = p1 <=> p2
+      assert_equal(int, result)
+   end
+   
+   def test_each
+      assert_respond_to(@fpath, :each)
+      assert_nothing_raised{ @fpath.each{ |e| } }
+   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
+      assert_pathname_plus("C:\\a\\b", "C:\\a", "b")
+      assert_pathname_plus("C:\\b", "a", "C:\\b")
+      assert_pathname_plus("a\\b", "a", "b")
+      assert_pathname_plus("C:\\b", "C:\\a", "..\\b")
+      assert_pathname_plus("C:\\a\\b", "C:\\a\\.", "\\b")
+      assert_pathname_plus("C:\\a\\b.txt", "C:\\a", "b.txt")
+      
+      # UNC paths
+      assert_pathname_plus("\\\\foo\\bar", "\\\\foo", "bar")
+      assert_pathname_plus("\\\\foo", "\\\\", "foo")
+      assert_pathname_plus("\\\\", "\\\\", "")
+      assert_pathname_plus("\\\\foo\\baz", "\\\\foo\\bar", "\\..\\baz")
+      assert_pathname_plus("\\\\", "\\\\", "..\\..\\..\\..")
+   end
+   
+   def test_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)
+
+      # 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)
+   end
+  
+   def test_absolute
+      assert_equal(true, @fpath.absolute?)
+      assert_equal(true, @bpath.absolute?)
+      assert_equal(true, @upath.absolute?)
+      assert_equal(false, @npath.absolute?)
+      assert_equal(true, @rpath.absolute?)
+      assert_equal(true, @xpath.absolute?)
+      assert_equal(true, @ypath.absolute?)
+      assert_equal(true, @zpath.absolute?)
+      assert_equal(false, @epath.absolute?)
+   end
+   
+   def test_relative
+      assert_equal(false, @fpath.relative?)
+      assert_equal(false, @bpath.relative?)
+      assert_equal(false, @upath.relative?)
+      assert_equal(true, @npath.relative?)
+      assert_equal(false, @rpath.relative?)
+      assert_equal(false, @xpath.relative?)
+      assert_equal(false, @ypath.relative?)
+      assert_equal(false, @zpath.relative?)
+      assert_equal(true, @epath.relative?)
+   end
+   
+   def test_root
+      assert_equal("C:\\", @fpath.root)
+      assert_equal("C:\\", @bpath.root)
+      assert_equal("\\\\foo\\bar", @upath.root)
+      assert_equal(".", @npath.root)
+      assert_equal("Z:\\", @rpath.root)
+      assert_equal("\\\\foo\\bar", @xpath.root)
+      assert_equal("\\\\foo", @ypath.root)
+      assert_equal("\\\\", @zpath.root)
+      assert_equal(".", @epath.root)
+      
+      # Edge cases
+      assert_equal(".", Pathname.new("..").root)
+      assert_equal(".", Pathname.new(".").root)
+   end
+   
+   def test_drive_number
+      assert_equal(2, @fpath.drive_number)
+      assert_equal(2, @bpath.drive_number)
+      assert_equal(nil, @upath.drive_number)
+      assert_equal(nil, @npath.drive_number)
+      assert_equal(25, @rpath.drive_number)
+      assert_equal(nil, @xpath.drive_number)
+      assert_equal(nil, @ypath.drive_number)
+      assert_equal(nil, @zpath.drive_number)
+      assert_equal(nil, @epath.drive_number)
+      
+      # Edge cases
+      assert_equal(nil, Pathname.new("..").drive_number)
+      assert_equal(nil, Pathname.new(".").drive_number)
+   end
+        
+   def test_to_a
+      expected = ["C:", "Program Files", "Windows NT", "Accessories"]
+      assert_equal(expected, @fpath.to_a)
+      assert_equal(expected, @bpath.to_a)
+      assert_equal(["foo","bar","baz"], @upath.to_a)
+      assert_equal(["foo","bar","baz"], @npath.to_a)
+      assert_equal(["Z:"], @rpath.to_a)
+      assert_equal(["foo","bar"], @xpath.to_a)
+      assert_equal(["foo"], @ypath.to_a)
+      assert_equal([], @zpath.to_a)
+      assert_equal([], @epath.to_a)
+   end
+ 
+   def test_is_root
+      assert_equal(false, @fpath.root?)
+      assert_equal(false, @bpath.root?)
+      assert_equal(false, @upath.root?)
+      assert_equal(false, @npath.root?)
+      assert_equal(true, @rpath.root?)
+      assert_equal(true, @xpath.root?)
+      assert_equal(true, @ypath.root?)
+      assert_equal(true, @zpath.root?)
+      assert_equal(false, @epath.root?)
+   end
+   
+   def test_facade_io
+      assert_respond_to(@fpath, :foreach)
+      assert_respond_to(@fpath, :read)
+      assert_respond_to(@fpath, :readlines)
+      assert_respond_to(@fpath, :sysopen)
+   end
+
+   def test_facade_file
+      File.methods(false).each{ |method|
+         assert_respond_to(@fpath, method.to_sym)
+      }
+      assert_respond_to(@fpath, :catname) # ftools check
+   end
+
+   def test_facade_dir
+      Dir.methods(false).each{ |method|
+         assert_respond_to(@fpath, method.to_sym)
+      }
+   end
+   
+   def test_facade_fileutils
+      methods = FileUtils.public_instance_methods
+      methods -= File.methods(false)
+      methods -= Dir.methods(false)
+      methods.delete_if{ |m| m =~ /stream/ }
+      methods.delete_if{ |m| m =~ /^ln/ }
+      methods.delete("identical?")
+
+      methods.each{ |method|
+         assert_respond_to(@fpath, method.to_sym)
+      }
+   end
+   
+   def teardown
+      @fpath = nil
+      @bpath = nil
+      @upath = nil
+      @npath = nil
+      @rpath = nil
+      @xpath = nil
+      @ypath = nil
+      @zpath = nil
+      @epath = nil
+   end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: pathname2
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2005-06-11
+summary: An alternate implementation of the Pathname 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/pathname2.rb
+  - README
+  - CHANGES
+  - MANIFEST
+  - test/tc_pathname_win.rb
+  - test/tc_pathname.rb
+test_files: 
+  - test/tc_pathname.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - 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: