pathname2 1.6.3 → 1.6.4

data/CHANGES

@@ -1,3 +1,12 @@
+== 1.6.4 - 20-Jan-2011
+* Explicitly remove the Pathname const if it is already defined in order
+  to avoid a superclass mismatch error. This library assumes that if you
+  require pathname2, you want my version of the Pathname class.
+* Updated URI handling for Ruby 1.9.x.
+* Added the Pathname() method, a synonym for Pathname.new.
+* Some Rakefile and gemspec tweaks.
+* Some updates to the test suite, including some specifically for Windows 7.
+
 == 1.6.3 - 2-Oct-2009
 * Updated Windows platform handling code to include mingw and cygwin.
 * Added the :gem rake task.

data/README

@@ -1,109 +1,99 @@
 == Description
-   A drop-in replacement for the current Pathname class.
+  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 and as a gem)
-   * windows-pr 0.5.1 or later (available on the RAA and as a gem)
+  * facade 1.0.4 or later
+  * windows-pr 1.1.2 or later (Windows only)
    
-   The windows-pr library is only required on MS Windows.
-   
-== Installation, pure Ruby
-=== Manual Installation
-   rake test (optional)
-   rake install
-   
-=== Gem Installation
-   rake test (optional)
-   gem install pathname2-<version>.gem
-   
-== Installation, C extension
-   rake test_c (optional)
-   rake install_c
+== Installation
+
+  gem install pathname2
 
 == Synopsis
-   require "pathname2"
+  require 'pathname2'
 
-   # Unix
-   path1 = "/foo/bar/baz"
-   path2 = "../zap"
+  # Unix
+  path1 = "/foo/bar/baz"
+  path2 = "../zap"
 
-   path1 + path2 # "/foo/bar/zap"
-   path1 / path2 # "/foo/bar/zap" (same as +)
-   path1.exists? # Does this path exist?
-   path1.dirname # "/foo/bar"
-   path1.to_a    # ['foo','bar','baz']
+  path1 + path2 # "/foo/bar/zap"
+  path1 / path2 # "/foo/bar/zap" (same as +)
+  path1.exists? # Does this path exist?
+  path1.dirname # "/foo/bar"
+  path1.to_a    # ['foo','bar','baz']
 
-   # Windows
-   path1 = "C:/foo/bar/baz"
-   path2 = "../zap"
+  # Windows
+  path1 = "C:/foo/bar/baz"
+  path2 = "../zap"
 
-   path1 + path2 # "C:\\foo\\bar\\zap"
-   path1.root    # "C:\\"
-   path1.to_a    # ['C:','foo','bar','baz']
+  path1 + path2 # "C:\\foo\\bar\\zap"
+  path1.root    # "C:\\"
+  path1.to_a    # ['C:','foo','bar','baz']
 
 == Windows Notes
-   All forward slashes are converted to backslashes for Pathname objects.
+  All forward slashes are converted to backslashes for Pathname objects.
 
 == 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
-   will not worry myself with it.
+  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 Pathname in the standard library 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), though I'm not sure it warrants it.
-   * The Pathname#+ method auto cleans.
-   * It uses a facade for all File and Dir methods, as well as most FileUtils
-     methods.
-   * Pathname#clean works slightly differently.  In the stdlib 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'.
-   * Adds a Kernel level +pn+ method as a shortcut.
-   * Allows you to add paths together with the '/' operator.
+  * 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), though I'm not sure it warrants it.
+  * The Pathname#+ method auto cleans.
+  * It uses a facade for all File and Dir methods, as well as most FileUtils
+    methods.
+  * Pathname#clean works slightly differently.  In the stdlib 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'.
+  * Adds a Kernel level +pn+ method as a shortcut.
+  * Allows you to add paths together with the '/' operator.
      
 == Method Priority
-   Because there is some overlap in method names between File, Dir, and
-   FileUtils, the priority is as follows:
+  Because there is some overlap in method names between File, Dir, and
+  FileUtils, the priority is as follows:
    
-   * File
-   * Dir
-   * FileUtils
+  * File
+  * Dir
+  * FileUtils
    
-   In other words, whichever of these defines a given method first is the
-   method that is used by the pathname2 library.
+  In other words, whichever of these defines a given method first is the
+  method that is used by the pathname2 library.
    
 == Known Issues
-   In Ruby 1.8.3 and 1.8.4 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.
+  In Ruby 1.8.3 and 1.8.4 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.
    
-   Any other issues should be reported on the project page at
-   http://www.rubyforge.org/projects/shards
+  Any other issues should be reported on the project page at
+  http://www.rubyforge.org/projects/shards
+
+  The git repo itself is located at https://github.com/djberg96/pathname2
 
 == Future Plans
-   Suggestions welcome.
+  Suggestions welcome.
    
 == License
-   Artistic 2.0
+  Artistic 2.0
    
 == Copyright
-   (C) 2003-2009 Daniel J. Berger
-   All rights reserved.
+  (C) 2003-2011 Daniel J. Berger
+  All rights reserved.
 
 == Warranty
-   This library 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.
+  This library 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
+  Daniel J. Berger

data/Rakefile

@@ -1,41 +1,43 @@
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-
-desc 'Install pathname2 library (non-gem)'
-task :install do
-   cp 'lib/pathname2.rb', Config::CONFIG['sitelibdir']
-end
-
-desc 'Build the pathname2 gem'
-task :gem do
-  spec = eval(IO.read('pathname2.gemspec'))
-  Gem::Builder.new(spec).build
-end
-
-desc "Install the pathname2 libarary as a gem"
-task :install_gem => [:gem] do
-   file = Dir["*.gem"].first
-   sh "gem install #{file}"
-end
-
-desc 'Run the test suite for the pure Ruby version'
-Rake::TestTask.new('test') do |t|
-   t.warning = true
-   t.verbose = true
-   
-   if Config::CONFIG['host_os'] =~ /mswin|win32|dos|cygwin|mingw/i
-      t.test_files = FileList['test/test_pathname_windows.rb']
-   else
-      t.test_files = FileList['test/test_pathname.rb']
-   end
-end
-
-desc 'Run the Pathname benchmark suite'
-task :benchmark do
-   sh 'ruby -Ilib benchmarks/bench_pathname.rb'
-end
-
-desc 'Run the benchmark suite for Pathname#+ vs File.join'
-task :benchmark_plus do
-   sh 'ruby -Ilib benchmarks/bench_plus.rb'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+
+CLEAN.include("**/*.gem", "**/*.rbc")
+
+namespace :gem do
+  desc "Build the pathname2 gem"
+  task :create => [:clean] do
+    spec = eval(IO.read('pathname2.gemspec'))
+    Gem::Builder.new(spec).build
+  end
+
+  desc "Install the pathname2 gem"
+  task :install => [:create] do
+     file = Dir["*.gem"].first
+     sh "gem install #{file}"
+  end
+end
+
+desc 'Run the test suite for the pure Ruby version'
+Rake::TestTask.new('test') do |t|
+  t.warning = true
+  t.verbose = true
+   
+  if Config::CONFIG['host_os'] =~ /mswin|win32|dos|cygwin|mingw/i
+    t.test_files = FileList['test/test_pathname_windows.rb']
+  else
+    t.test_files = FileList['test/test_pathname.rb']
+  end
+end
+
+desc 'Run the Pathname benchmark suite'
+task :benchmark do
+  sh 'ruby -Ilib benchmarks/bench_pathname.rb'
+end
+
+desc 'Run the benchmark suite for Pathname#+ vs File.join'
+task :benchmark_plus do
+  sh 'ruby -Ilib benchmarks/bench_plus.rb'
+end
+
+task :default => :test

data/lib/pathname2.rb

@@ -12,7 +12,7 @@
 # == Usage
 #
 # require "pathname2"
-# 
+#
 # # Unix
 # path1 = Pathname.new("/foo/bar/baz")
 # path2 = Pathname.new("../zap")
@@ -34,1075 +34,1091 @@
 # imperator on IRC (irc.freenode.net)
 #
 # == Copyright
-# Copyright (c) 2005-2008 Daniel J. Berger.
+# Copyright (c) 2005-2011 Daniel J. Berger.
 # Licensed under the same terms as Ruby itself.
 #
 require 'facade'
 require 'fileutils'
-require 'rbconfig'
 
-if Config::CONFIG['host_os'] =~ /mswin|win32|dos|cygwin|mingw/i
-   require 'windows/path'
-   require 'windows/file'
-   require 'windows/error'
-   require 'windows/limits'
+if File::ALT_SEPARATOR
+  require 'windows/path'
+  require 'windows/file'
+  require 'windows/error'
+  require 'windows/limits'
 end
 
+# You're mine now.
+Object.send(:remove_const, :Pathname) if defined?(Pathname)
+
 class Pathname < String
-   class Error < StandardError; end
-   extend Facade
-
-   facade File, File.methods(false).map{ |m| m.to_sym } - [
-      :chmod, :lchmod, :chown, :lchown, :dirname, :fnmatch, :fnmatch?,
-      :link, :open, :rename, :symlink, :truncate, :utime, :basename,
-      :expand_path, :join
-   ]
-
-   facade Dir, Dir.methods(false).map{ |m| m.to_sym } - [
-      :chdir,
-      :glob,
-      :foreach,
-      :mkdir, 
-      :open
-   ]
-
-   private
-   
-   alias :_plus_ :+ # Used to prevent infinite loops in some cases
-   
-   if Config::CONFIG['host_os'] =~ /mswin|win32|dos|cygwin|mingw/i
-      include Windows::Path
-      include Windows::File
-      include Windows::Error
-      include Windows::Limits
-   end
-   
-   public
-
-   # The version of the pathname2 library
-   VERSION = '1.6.3'
-
-   # The maximum length of a path
-   MAXPATH = 1024 unless defined? MAXPATH # Yes, I willfully violate POSIX
-   
-   # Returns the expanded path of the current working directory.
-   #
-   # Synonym for Pathname.new(Dir.pwd).
-   #
-   def self.pwd
-      new(Dir.pwd)      
-   end
-   
-   class << self
-      alias getwd pwd      
-   end
-
-   # Creates and returns a new Pathname object.
-   #
-   # 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'.
-   #
-   # Examples:
-   #
-   #   Pathname.new("/foo/bar/baz"
-   #   Pathname.new("foo")
-   #   Pathname.new("file:///foo/bar/baz")
-   #   Pathname.new("C:\\Documents and Settings\\snoopy")
-   #
-   def initialize(path)
-      if path.length > MAXPATH
-         msg = "string too long.  maximum string length is " + MAXPATH.to_s
-         raise Error, msg
+  class Error < StandardError; end
+  extend Facade
+
+  facade File, File.methods(false).map{ |m| m.to_sym } - [
+    :chmod, :lchmod, :chown, :lchown, :dirname, :fnmatch, :fnmatch?,
+    :link, :open, :realpath, :rename, :symlink, :truncate, :utime,
+    :basename, :expand_path, :join
+  ]
+
+  facade Dir, Dir.methods(false).map{ |m| m.to_sym } - [
+    :chdir, :entries, :glob, :foreach, :mkdir, :open
+  ]
+
+  private
+
+  alias :_plus_ :+ # Used to prevent infinite loops in some cases
+
+  if File::ALT_SEPARATOR
+    include Windows::Path
+    include Windows::File
+    include Windows::Error
+    include Windows::Limits
+  end
+
+  public
+
+  # The version of the pathname2 library
+  VERSION = '1.6.4'
+
+  # The maximum length of a path
+  MAXPATH = 1024 unless defined? MAXPATH # Yes, I willfully violate POSIX
+
+  # Returns the expanded path of the current working directory.
+  #
+  # Synonym for Pathname.new(Dir.pwd).
+  #
+  def self.pwd
+    new(Dir.pwd)
+  end
+
+  class << self
+    alias getwd pwd
+  end
+
+  # Creates and returns a new Pathname object.
+  #
+  # 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'.
+  #
+  # Examples:
+  #
+  #   Pathname.new("/foo/bar/baz"
+  #   Pathname.new("foo")
+  #   Pathname.new("file:///foo/bar/baz")
+  #   Pathname.new("C:\\Documents and Settings\\snoopy")
+  #
+  def initialize(path)
+    if path.length > MAXPATH
+      msg = "string too long.  maximum string length is " + MAXPATH.to_s
+      raise Error, msg
+    end
+
+    @sep = File::ALT_SEPARATOR || File::SEPARATOR
+    @win = File::ALT_SEPARATOR
+
+    # Handle File URL's. The separate approach for Windows is 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(path)
+        buf = 0.chr * MAXPATH
+        len = [buf.length].pack("l")
+        if PathCreateFromUrl(path, buf, len, 0) == S_OK
+          path = buf.strip
+        else
+          raise Error, "invalid file url: #{path}"
+        end
       end
-
-      @sep = File::ALT_SEPARATOR || File::SEPARATOR
-      @win = Config::CONFIG['host_os'] =~ /mswin|win32|dos|cygwin|mingw/i
-
-      # 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(path.dup) # Dup to avoid frozen string issues
-            buf = 0.chr * MAXPATH
-            len = [buf.length].pack("l")
-            if PathCreateFromUrl(path, buf, len, 0) == S_OK
-               path = buf.strip
-            else
-               raise Error, "invalid file url: #{path}"
-            end
-         end
-      else
-         if path.index('file:///', 0)
-            require 'uri'
-            path = URI.decode(URI.parse(path).path)
-         end
+    else
+      if path.index('file:///', 0)
+        require 'uri'
+        if RUBY_VERSION.to_f >= 1.9
+          path = URI::Parser.new.unescape(path)[7..-1] # Blech
+        else
+          path = URI.decode(URI.parse(path).path)
+        end
+      end
+    end
+
+    # Convert forward slashes to backslashes on Windows
+    path = path.tr("/", @sep) if @win
+    super(path)
+  end
+
+  # Returns a real (absolute) pathname of +self+ in the actual filesystem.
+  #
+  # Unlike most Pathname methods, this one assumes that the path actually
+  # exists on your filesystem. If it doesn't, an error is raised. If a
+  # circular symlink is encountered a system error will be raised.
+  #
+  # Example:
+  #
+  #    Dir.pwd                      # => /usr/local
+  #    File.exists?('foo')          # => true
+  #    Pathname.new('foo').realpath # => /usr/local/foo
+  #
+  def realpath
+    File.stat(self) # Check to ensure that the path exists
+
+    if File.symlink?(self)
+      file = self.dup
+
+      while true
+        file = File.join(File.dirname(file), File.readlink(file))
+        break unless File.symlink?(file)
       end
 
-      # Convert forward slashes to backslashes on Windows
-      path = path.tr("/", @sep) if @win
-      super(path)
-   end
-
-   # Returns a real (absolute) pathname of +self+ in the actual filesystem.
-   #
-   # Unlike most Pathname methods, this one assumes that the path actually
-   # exists on your filesystem. If it doesn't, an error is raised. If a
-   # circular symlink is encountered a system error will be raised.
-   #
-   # Example:
-   #
-   #    Dir.pwd                      # => /usr/local
-   #    File.exists?('foo')          # => true
-   #    Pathname.new('foo').realpath # => /usr/local/foo
-   #
-   def realpath
-      File.stat(self) # Check to ensure that the path exists
-
-      if File.symlink?(self)
-         file = self.dup
-
-         while true
-            file = File.join(File.dirname(file), File.readlink(file))
-            break unless File.symlink?(file)
-         end
-
-         self.class.new(file).clean
+      self.class.new(file).clean
+    else
+      self.class.new(Dir.pwd) + self
+    end
+  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.
+  #
+  # Note that the result never contain the entries '.' and '..' in the
+  # the directory because they are not children.  Also note that this method
+  # is *not* recursive.
+  #
+  # Example:
+  #
+  # path = Pathname.new('/usr/bin')
+  # path.children        # => ['/usr/bin/ruby', '/usr/bin/perl', ...]
+  # path.children(false) # => ['ruby', 'perl', ...]
+  #
+  def children(with_directory = true)
+    with_directory = false if self == '.'
+    result = []
+    Dir.foreach(self) { |file|
+      next if file == '.' || file == '..'
+      if with_directory
+        result << self.class.new(File.join(self, file))
       else
-         self.class.new(Dir.pwd) + self
-      end
-   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.
-   #
-   # Note that the result never contain the entries '.' and '..' in the
-   # the directory because they are not children.  Also note that this method
-   # is *not* recursive.
-   #
-   # Example:
-   #
-   # path = Pathname.new('/usr/bin')
-   # path.children        # => ['/usr/bin/ruby', '/usr/bin/perl', ...]
-   # path.children(false) # => ['ruby', 'perl', ...]
-   #
-   def children(with_directory = true)
-      with_directory = false if self == '.'
-      result = []
-      Dir.foreach(self) { |file|
-         next if file == '.' || file == '..'
-         if with_directory
-            result << self.class.new(File.join(self, file))
-         else
-            result << self.class.new(file)
-         end
-      }
-      result
-   end
-
-   # Windows only
-   #
-   # Removes the decoration from a path string. Non-destructive.
-   # 
-   # Example:
-   #
-   # path = Pathname.new('C:\Path\File[5].txt')
-   # path.undecorate # => C:\Path\File.txt.
-   #
-   def undecorate
-      unless @win
-         raise NotImplementedError, "not supported on this platform"
-      end
-      buf = 0.chr * MAXPATH
-      buf[0..self.length-1] = self
-      PathUndecorate(buf)
-      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"
-      end
-      buf = 0.chr * MAXPATH
-      buf[0..self.length-1] = self
-      PathUndecorate(buf)
-      replace(buf.split(0.chr).first)
-      self
-   end
-   
-   # Windows only
-   #
-   # Returns the short path for a long path name.
-   #
-   # Example:
-   # 
-   #    path = Pathname.new('C:\Program Files\Java')
-   #    path.short_path # => C:\Progra~1\Java.
-   #
-   def short_path
-      unless @win
-         raise NotImplementedError, "not supported on this platform"
+        result << self.class.new(file)
       end
-      buf = 0.chr * MAXPATH
-      buf[0..self.length-1] = self
-      GetShortPathName(self, buf, buf.length)
-      self.class.new(buf.split(0.chr).first)
-   end
-   
-   # Windows only
-   #
-   # Returns the long path for a long path name.
-   #
-   # Example:
-   #
-   #    path = Pathname.new('C:\Progra~1\Java')
-   #    path.long_path # => C:\Program Files\Java.
-   #
-   def long_path
-      unless @win
-         raise NotImplementedError, "not supported on this platform"
+    }
+    result
+  end
+
+  # Windows only
+  #
+  # Removes the decoration from a path string. Non-destructive.
+  #
+  # Example:
+  #
+  # path = Pathname.new('C:\Path\File[5].txt')
+  # path.undecorate # => C:\Path\File.txt.
+  #
+  def undecorate
+    unless @win
+      raise NotImplementedError, "not supported on this platform"
+    end
+    buf = 0.chr * MAXPATH
+    buf[0..self.length-1] = self
+    PathUndecorate(buf)
+    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"
+    end
+    buf = 0.chr * MAXPATH
+    buf[0..self.length-1] = self
+    PathUndecorate(buf)
+    replace(buf.split(0.chr).first)
+    self
+  end
+
+  # Windows only
+  #
+  # Returns the short path for a long path name.
+  #
+  # Example:
+  #
+  #    path = Pathname.new('C:\Program Files\Java')
+  #    path.short_path # => C:\Progra~1\Java.
+  #
+  def short_path
+    unless @win
+      raise NotImplementedError, "not supported on this platform"
+    end
+    buf = 0.chr * MAXPATH
+    buf[0..self.length-1] = self
+    GetShortPathName(self, buf, buf.length)
+    self.class.new(buf.split(0.chr).first)
+  end
+
+  # Windows only
+  #
+  # Returns the long path for a long path name.
+  #
+  # Example:
+  #
+  #    path = Pathname.new('C:\Progra~1\Java')
+  #    path.long_path # => C:\Program Files\Java.
+  #
+  def long_path
+    unless @win
+      raise NotImplementedError, "not supported on this platform"
+    end
+    buf = 0.chr * MAXPATH
+    buf[0..self.length-1] = self
+    GetLongPathName(self, buf, buf.length)
+    self.class.new(buf.split(0.chr).first)
+  end
+
+  # Removes trailing slash, if present.  Non-destructive.
+  #
+  # Example:
+  #
+  #    path = Pathname.new('/usr/local/')
+  #    path.pstrip # => '/usr/local'
+  #
+  def pstrip
+    str = self.dup
+    if @win
+      PathRemoveBackslash(str)
+      str.strip!
+    else
+      if str.to_s[-1].chr == @sep
+        str.strip!
+        str.chop!
       end
-      buf = 0.chr * MAXPATH
-      buf[0..self.length-1] = self
-      GetLongPathName(self, buf, buf.length)
-      self.class.new(buf.split(0.chr).first)
-   end
-   
-   # Removes trailing slash, if present.  Non-destructive.
-   #
-   # Example:
-   #
-   #    path = Pathname.new('/usr/local/')
-   #    path.pstrip # => '/usr/local'
-   #
-   def pstrip
-      str = self.dup
-      if @win
-         PathRemoveBackslash(str)
-         str.strip!
-      else
-         if str.to_s[-1].chr == @sep
-            str.strip!
-            str.chop!
-         end
+    end
+    self.class.new(str)
+  end
+
+  # Performs the substitution of Pathname#pstrip in place.
+  #
+  def pstrip!
+    if @win
+      PathRemoveBackslash(self)
+      strip!
+    else
+      if self.to_s[-1].chr == @sep
+        strip!
+        chop!
       end
-      self.class.new(str)
-   end
-   
-   # Performs the substitution of Pathname#pstrip in place.
-   #
-   def pstrip!
-      if @win
-         PathRemoveBackslash(self)
-         strip!
+    end
+    self
+  end
+
+  # Splits a pathname into strings based on the path separator.
+  #
+  # Examples:
+  #
+  #    Pathname.new('/usr/local/bin').to_a # => ['usr', 'local', 'bin']
+  #    Pathname.new('C:\WINNT\Fonts').to_a # => ['C:', 'WINNT', 'Fonts']
+  #
+  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.
+  #
+  # Example:
+  #
+  #    Pathname.new('/usr/local/bin').each{ |element|
+  #       puts "Element: #{element}"
+  #    }
+  #
+  #    Yields 'usr', 'local', and 'bin', in turn
+  #
+  def each
+    to_a.each{ |element| yield element }
+  end
+
+  # Returns the path component at +index+, up to +length+ components, joined
+  # by the path separator. If the +index+ is a Range, then that is used
+  # instead and the +length+ is ignored.
+  #
+  # Keep in mind that on MS Windows the drive letter is the first element.
+  #
+  # Examples:
+  #
+  #    path = Pathname.new('/home/john/source/ruby')
+  #    path[0]    # => 'home'
+  #    path[1]    # => 'john'
+  #    path[0, 3] # => '/home/john/source'
+  #    path[0..1] # => '/home/john'
+  #
+  #    path = Pathname.new('C:/Documents and Settings/John/Source/Ruby')
+  #    path[0]    # => 'C:\'
+  #    path[1]    # => 'Documents and Settings'
+  #    path[0, 3] # => 'C:\Documents and Settings\John'
+  #    path[0..1] # => 'C:\Documents and Settings'
+  #
+  def [](index, length=nil)
+    if index.is_a?(Fixnum)
+      if length
+        path = File.join(to_a[index, length])
       else
-         if self.to_s[-1].chr == @sep
-            strip!
-            chop!
-         end
+        path = to_a[index]
       end
-      self
-   end
-
-   # Splits a pathname into strings based on the path separator.
-   #
-   # Examples:
-   #
-   #    Pathname.new('/usr/local/bin').to_a # => ['usr', 'local', 'bin']
-   #    Pathname.new('C:\WINNT\Fonts').to_a # => ['C:', 'WINNT', 'Fonts']
-   #
-   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.
-   #
-   # Example:
-   #
-   #    Pathname.new('/usr/local/bin').each{ |element|
-   #       puts "Element: #{element}"
-   #    }
-   #
-   #    Yields 'usr', 'local', and 'bin', in turn
-   #
-   def each
-      to_a.each{ |element| yield element }
-   end
-   
-   # Returns the path component at +index+, up to +length+ components, joined
-   # by the path separator. If the +index+ is a Range, then that is used
-   # instead and the +length+ is ignored.
-   #
-   # Keep in mind that on MS Windows the drive letter is the first element.
-   #
-   # Examples:
-   #
-   #    path = Pathname.new('/home/john/source/ruby')
-   #    path[0]    # => 'home'
-   #    path[1]    # => 'john'
-   #    path[0, 3] # => '/home/john/source'
-   #    path[0..1] # => '/home/john'
-   #
-   #    path = Pathname.new('C:/Documents and Settings/John/Source/Ruby')
-   #    path[0]    # => 'C:\'
-   #    path[1]    # => 'Documents and Settings'
-   #    path[0, 3] # => 'C:\Documents and Settings\John'
-   #    path[0..1] # => 'C:\Documents and Settings'
-   #
-   def [](index, length=nil)     
-      if index.is_a?(Fixnum)
-         if length
-            path = File.join(to_a[index, length])
-         else
-            path = to_a[index]
-         end
-      elsif index.is_a?(Range)
-         if length
-            warn 'Length argument ignored'
-         end
-         path = File.join(to_a[index])
-      else
-         raise TypeError, "Only Fixnums and Ranges allowed as first argument"
-      end
-      
-      if path && @win
-         path = path.tr("/", "\\")
+    elsif index.is_a?(Range)
+      if length
+        warn 'Length argument ignored'
       end
-      
-      path
-   end
-
-   # Yields each component of the path, concatenating the next component on
-   # each iteration as a new Pathname object, starting with the root path.
-   #
-   # Example:
-   #
-   #    path = Pathname.new('/usr/local/bin')
-   #
-   #    path.descend{ |name|
-   #       puts name
-   #    }
-   #
-   #    First iteration  => '/'
-   #    Second iteration => '/usr'
-   #    Third iteration  => '/usr/local'
-   #    Fourth iteration => '/usr/local/bin'
-   #
-   def descend
-      if root?
-         yield root
-         return
+      path = File.join(to_a[index])
+    else
+      raise TypeError, "Only Fixnums and Ranges allowed as first argument"
+    end
+
+    if path && @win
+      path = path.tr("/", "\\")
+    end
+
+    path
+  end
+
+  # Yields each component of the path, concatenating the next component on
+  # each iteration as a new Pathname object, starting with the root path.
+  #
+  # Example:
+  #
+  #    path = Pathname.new('/usr/local/bin')
+  #
+  #    path.descend{ |name|
+  #       puts name
+  #    }
+  #
+  #    First iteration  => '/'
+  #    Second iteration => '/usr'
+  #    Third iteration  => '/usr/local'
+  #    Fourth iteration => '/usr/local/bin'
+  #
+  def descend
+    if root?
+      yield root
+      return
+    end
+
+    if @win
+      path = unc? ? "#{root}\\" : ""
+    else
+      path = absolute? ? root : ""
+    end
+
+    # Yield the root directory if an absolute path (and not Windows)
+    unless @win && !unc?
+      yield root if absolute?
+    end
+
+    each{ |element|
+      if @win && unc?
+        next if root.to_a.include?(element)
       end
-   
-      if @win
-         path = unc? ? "#{root}\\" : ""
-      else
-         path = absolute? ? root : ""
+      path << element << @sep
+      yield self.class.new(path.chop)
+    }
+  end
+
+  # Yields the path, minus one component on each iteration, as a new
+  # Pathname object, ending with the root path.
+  #
+  # Example:
+  #
+  #    path = Pathname.new('/usr/local/bin')
+  #
+  #    path.ascend{ |name|
+  #       puts name
+  #    }
+  #
+  #    First iteration  => '/usr/local/bin'
+  #    Second iteration => '/usr/local'
+  #    Third iteration  => '/usr'
+  #    Fourth iteration => '/'
+  #
+  def ascend
+    if root?
+      yield root
+      return
+    end
+
+    n = to_a.length
+
+    while n > 0
+      path = to_a[0..n-1].join(@sep)
+      if absolute?
+        if @win && unc?
+          path = "\\\\" << path
+        end
+        unless @win
+          path = root << path
+        end
       end
 
-      # Yield the root directory if an absolute path (and not Windows)
-      unless @win && !unc?
-         yield root if absolute?
-      end
+      path = self.class.new(path)
+      yield path
 
-      each{ |element|
-         if @win && unc?
-            next if root.to_a.include?(element)
-         end
-         path << element << @sep
-         yield self.class.new(path.chop)
-      }
-   end
-
-   # Yields the path, minus one component on each iteration, as a new
-   # Pathname object, ending with the root path.
-   #
-   # Example:
-   #
-   #    path = Pathname.new('/usr/local/bin')
-   #
-   #    path.ascend{ |name|
-   #       puts name
-   #    }
-   #
-   #    First iteration  => '/usr/local/bin'
-   #    Second iteration => '/usr/local'
-   #    Third iteration  => '/usr'
-   #    Fourth iteration => '/'
-   #
-   def ascend
-      if root?
-         yield root
-         return
-      end
-      
-      n = to_a.length
-
-      while n > 0
-         path = to_a[0..n-1].join(@sep)
-         if absolute?
-            if @win && unc?
-               path = "\\\\" << path
-            end     
-            unless @win
-               path = root << path
-            end
-         end
-
-         path = self.class.new(path)
-         yield path
-         
-         if @win && unc?
-            break if path.root?
-         end
-         
-         n -= 1
+      if @win && unc?
+        break if path.root?
       end
 
-      # Yield the root directory if an absolute path (and not Windows)
-      unless @win
-         yield root if absolute?
-      end
-   end
-
-   # Returns the root directory of the path, or '.' if there is no root
-   # directory.
-   #
-   # 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.
-   #
-   # Examples:
-   #
-   #    Pathname.new('/usr/local').root       # => '/'
-   #    Pathname.new('lib').root              # => '.'
-   #
-   #    On MS Windows:
-   #
-   #    Pathname.new('C:\WINNT').root         # => 'C:'
-   #    Pathname.new('\\some\share\foo').root # => '\\some\share'
-   #
-   def root
-      dir = "." 
-        
-      if @win
-         buf = 0.chr * MAXPATH
-         buf[0..self.length-1] = self
-      
-         if PathStripToRoot(buf)
-            dir = buf.split(0.chr).first
-         end
-      else
-         dir = "/" if self =~ /^\//
+      n -= 1
+    end
+
+    # Yield the root directory if an absolute path (and not Windows)
+    unless @win
+      yield root if absolute?
+    end
+  end
+
+  # Returns the root directory of the path, or '.' if there is no root
+  # directory.
+  #
+  # 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.
+  #
+  # Examples:
+  #
+  #    Pathname.new('/usr/local').root       # => '/'
+  #    Pathname.new('lib').root              # => '.'
+  #
+  #    On MS Windows:
+  #
+  #    Pathname.new('C:\WINNT').root         # => 'C:'
+  #    Pathname.new('\\some\share\foo').root # => '\\some\share'
+  #
+  def root
+    dir = "."
+
+    if @win
+      buf = 0.chr * MAXPATH
+      buf[0..self.length-1] = self
+
+      if PathStripToRoot(buf)
+        dir = buf.split(0.chr).first
       end
-      
-      self.class.new(dir)
-   end
-
-   # Returns whether or not the path consists only of a root directory.
-   #
-   # Examples:
-   #
-   #   Pathname.new('/').root?    # => true
-   #   Pathname.new('/foo').root? # => false
-   #
-   def root?
-      if @win
-         PathIsRoot(self)
-      else
-         self == root
+    else
+      dir = "/" if self =~ /^\//
+    end
+
+    self.class.new(dir)
+  end
+
+  # Returns whether or not the path consists only of a root directory.
+  #
+  # Examples:
+  #
+  #   Pathname.new('/').root?    # => true
+  #   Pathname.new('/foo').root? # => false
+  #
+  def root?
+    if @win
+      PathIsRoot(self)
+    else
+      self == root
+    end
+  end
+
+  # MS Windows only
+  #
+  # Determines if the string is a valid Universal Naming Convention (UNC)
+  # for a server and share path.
+  #
+  # Examples:
+  #
+  #    Pathname.new("\\\\foo\\bar").unc?     # => true
+  #    Pathname.new('C:\Program Files').unc? # => false
+  #
+  def unc?
+    unless @win
+      raise NotImplementedError, "not supported on this platform"
+    end
+
+    PathIsUNC(self)
+  end
+
+  # MS Windows only
+  #
+  # Returns the drive number that corresponds to the root, or nil if not
+  # applicable.
+  #
+  # Example:
+  #
+  #    Pathname.new("C:\\foo").drive_number # => 2
+  #
+  def drive_number
+    unless @win
+      raise NotImplementedError, "not supported on this platform"
+    end
+
+    num = PathGetDriveNumber(self)
+    num >= 0 ? num : nil
+  end
+
+  # Compares two Pathname objects.  Note that Pathnames may only be compared
+  # against other Pathnames, not strings.  Otherwise nil is returned.
+  #
+  # Example:
+  #
+  #    path1 = Pathname.new('/usr/local')
+  #    path2 = Pathname.new('/usr/local')
+  #    path3 = Pathname.new('/usr/local/bin')
+  #
+  #    path1 <=> path2 # => 0
+  #    path1 <=> path3 # => -1
+  #
+  def <=>(string)
+    return nil unless string.kind_of?(Pathname)
+    super
+  end
+
+  # Returns the parent directory of the given path.
+  #
+  # Example:
+  #
+  #    Pathname.new('/usr/local/bin').parent # => '/usr/local'
+  #
+  def parent
+   self + ".." # Use our custom '+' method
+  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. For relative paths, this method uses
+  # an imaginary, common parent path.
+  #
+  # This method does not access the filesystem. It assumes no symlinks.
+  # You should only compare directories against directories, or files against
+  # files, or you may get unexpected results.
+  #
+  # Raises an ArgumentError if it cannot find a relative path.
+  #
+  # Examples:
+  #
+  #    path = Pathname.new('/usr/local/bin')
+  #    path.relative_path_from('/usr/bin') # => "../local/bin"
+  #
+  #    path = Pathname.new("C:\\WINNT\\Fonts")
+  #    path.relative_path_from("C:\\Program Files") # => "..\\WINNT\\Fonts"
+  #
+  def relative_path_from(base)
+    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 self.class.new(".") if self == base
+    return self if base == "."
+
+    # Because of the way the Windows version handles Pathname#clean, we need
+    # a little extra help here.
+    if @win
+      if root != base.root
+        msg = 'cannot determine relative paths from different root paths'
+        raise ArgumentError, msg
       end
-   end
-   
-   # MS Windows only
-   #
-   # Determines if the string is a valid Universal Naming Convention (UNC)
-   # for a server and share path.
-   #
-   # Examples:
-   #
-   #    Pathname.new("\\\\foo\\bar").unc?     # => true
-   #    Pathname.new('C:\Program Files').unc? # => false
-   #
-   def unc?
-      unless @win
-         raise NotImplementedError, "not supported on this platform"
+      if base == '..' && (self != '..' || self != '.')
+        raise ArgumentError, "base directory may not contain '..'"
       end
-
-      PathIsUNC(self)
-   end
-   
-   # MS Windows only
-   #
-   # Returns the drive number that corresponds to the root, or nil if not
-   # applicable.
-   #
-   # Example:
-   #
-   #    Pathname.new("C:\\foo").drive_number # => 2
-   #
-   def drive_number
-      unless @win
-         raise NotImplementedError, "not supported on this platform"
+    end
+
+    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?
+      self.class.new(".")
+    else
+      self.class.new(rel_path.join(@sep))
+    end
+  end
+
+  # Adds two Pathname objects together, or a Pathname and a String.  It
+  # also automatically cleans the Pathname.
+  #
+  # Adding a root path to an existing path merely replaces the current
+  # path.  Adding '.' to an existing path does nothing.
+  #
+  # Example:
+  #
+  #    path1 = '/foo/bar'
+  #    path2 = '../baz'
+  #    path1 + path2 # '/foo/baz'
+  #
+  def +(string)
+    unless string.kind_of?(Pathname)
+      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() function if on Windows - much easier
+    if @win
+      buf = 0.chr * MAXPATH
+      buf[0..self.length-1] = self
+      PathAppend(buf, string)
+      buf = buf.split("\0").first
+      return self.class.new(buf) # PathAppend cleans automatically
+    end
+
+    # If the string is an absolute directory, return it
+    return string if string.absolute?
+
+    array = to_a + string.to_a
+    new_string = array.join(@sep)
+
+    unless relative? || @win
+      temp = @sep + new_string # Add root path back if needed
+      new_string.replace(temp)
+    end
+
+    self.class.new(new_string).clean
+  end
+
+  alias :/ :+
+
+  # Returns whether or not the path is an absolute path.
+  #
+  # Example:
+  #
+  #    Pathname.new('/usr/bin').absolute? # => true
+  #    Pathname.new('usr').absolute?      # => false
+  #
+  def absolute?
+    !relative?
+  end
+
+  # Returns whether or not the path is a relative path.
+  #
+  # Example:
+  #
+  #    Pathname.new('/usr/bin').relative? # => true
+  #    Pathname.new('usr').relative?      # => false
+  #
+  def relative?
+    if @win
+      PathIsRelative(self)
+    else
+      root == "."
+    end
+  end
+
+  # Removes unnecessary '.' paths and ellides '..' paths appropriately.
+  # This method is non-destructive.
+  #
+  # Example:
+  #
+  #    path = Pathname.new('/usr/./local/../bin')
+  #    path.clean # => '/usr/bin'
+  #
+  def clean
+    return self if self.empty?
+
+    if @win
+      path = 0.chr * MAXPATH
+      if PathCanonicalize(path, self)
+        return self.class.new(path.split(0.chr).first)
+      else
+        return self
       end
+    end
 
-      num = PathGetDriveNumber(self)
-      num >= 0 ? num : nil
-   end
-
-   # Compares two Pathname objects.  Note that Pathnames may only be compared
-   # against other Pathnames, not strings.  Otherwise nil is returned.
-   #
-   # Example:
-   #
-   #    path1 = Pathname.new('/usr/local')
-   #    path2 = Pathname.new('/usr/local')
-   #    path3 = Pathname.new('/usr/local/bin')
-   #
-   #    path1 <=> path2 # => 0
-   #    path1 <=> path3 # => -1
-   #
-   def <=>(string)
-      return nil unless string.kind_of?(Pathname)
-      super
-   end
-
-   # Returns the parent directory of the given path.
-   #
-   # Example:
-   #
-   #    Pathname.new('/usr/local/bin').parent # => '/usr/local'
-   #
-   def parent
-      self + ".." # Use our custom '+' method
-   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. For relative paths, this method uses
-   # an imaginary, common parent path.
-   #
-   # This method does not access the filesystem. It assumes no symlinks.
-   # You should only compare directories against directories, or files against
-   # files, or you may get unexpected results.
-   #
-   # Raises an ArgumentError if it cannot find a relative path.
-   #
-   # Examples:
-   #
-   #    path = Pathname.new('/usr/local/bin')
-   #    path.relative_path_from('/usr/bin') # => "../local/bin"
-   #
-   #    path = Pathname.new("C:\\WINNT\\Fonts")
-   #    path.relative_path_from("C:\\Program Files") # => "..\\WINNT\\Fonts"
-   #
-   def relative_path_from(base)
-      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
+    final = []
 
-      return self.class.new(".") if self == base
-      return self if base == "."
-      
-      # Because of the way the Windows version handles Pathname#clean, we need
-      # a little extra help here.
-      if @win
-         if root != base.root
-            msg = 'cannot determine relative paths from different root paths'
-            raise ArgumentError, msg
-         end
-         if base == '..' && (self != '..' || self != '.')
-            raise ArgumentError, "base directory may not contain '..'"
-         end
+    to_a.each{ |element|
+      next if element == "."
+      final.push(element)
+      if element == ".." && self != ".."
+        2.times{ final.pop }
       end
+    }
 
-      dest_arr = self.clean.to_a
-      base_arr = base.clean.to_a
-      dest_arr.delete('.')
-      base_arr.delete('.')
+    final = final.join(@sep)
+    final = root._plus_(final) if root != "."
+    final = "." if final.empty?
 
-      diff_arr = dest_arr - base_arr
+    self.class.new(final)
+  end
 
-      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
+  alias :cleanpath :clean
 
-      base_arr.fill("..")
-      rel_path = base_arr + dest_arr
+  # Identical to Pathname#clean, except that it modifies the receiver
+  # in place.
+  #
+  def clean!
+    return self if self.empty?
 
-      if rel_path.empty?
-         self.class.new(".")
-      else
-         self.class.new(rel_path.join(@sep))
-      end
-   end
-
-   # Adds two Pathname objects together, or a Pathname and a String.  It
-   # also automatically cleans the Pathname.
-   #
-   # Adding a root path to an existing path merely replaces the current
-   # path.  Adding '.' to an existing path does nothing.
-   #
-   # Example:
-   #
-   #    path1 = '/foo/bar'
-   #    path2 = '../baz'
-   #    path1 + path2 # '/foo/baz'
-   #
-   def +(string)
-      unless string.kind_of?(Pathname)
-         string = self.class.new(string)
+    if @win
+      path = 0.chr * MAXPATH
+      if PathCanonicalize(path, self)
+        replace(path.split(0.chr).first)
       end
+      return self
+    end
 
-      # Any path plus "." is the same directory
-      return self if string == "."
-      return string if self == "."
-      
-      # Use the builtin PathAppend() function if on Windows - much easier
-      if @win
-         buf = 0.chr * MAXPATH
-         buf[0..self.length-1] = self
-         PathAppend(buf, string)
-         buf = buf.split("\0").first
-         return self.class.new(buf) # PathAppend cleans automatically
-      end
-      
-      # If the string is an absolute directory, return it
-      return string if string.absolute?
-
-      array = to_a + string.to_a
-      new_string = array.join(@sep)
-      
-      unless relative? || @win
-         temp = @sep + new_string # Add root path back if needed
-         new_string.replace(temp)
-      end
-      
-      self.class.new(new_string).clean
-   end
-
-   alias :/ :+
-
-   # Returns whether or not the path is an absolute path.
-   #
-   # Example:
-   #
-   #    Pathname.new('/usr/bin').absolute? # => true
-   #    Pathname.new('usr').absolute?      # => false
-   #
-   def absolute?
-      !relative?
-   end
-   
-   # Returns whether or not the path is a relative path.
-   #
-   # Example:
-   #
-   #    Pathname.new('/usr/bin').relative? # => true
-   #    Pathname.new('usr').relative?      # => false
-   #
-   def relative?
-      if @win
-         PathIsRelative(self)
-      else
-         root == "."
-      end
-   end
-
-   # Removes unnecessary '.' paths and ellides '..' paths appropriately.
-   # This method is non-destructive.
-   #
-   # Example:
-   #
-   #    path = Pathname.new('/usr/./local/../bin')
-   #    path.clean # => '/usr/bin'
-   #
-   def clean
-      return self if self.empty?
-
-      if @win
-         path = 0.chr * MAXPATH
-         if PathCanonicalize(path, self)
-            return self.class.new(path.split(0.chr).first)
-         else
-            return self
-         end
-      end
+    final = []
 
-      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._plus_(final) if root != "."
-      final = "." if final.empty?
-
-      self.class.new(final)
-   end
-
-   alias :cleanpath :clean
-   
-   # Identical to Pathname#clean, except that it modifies the receiver
-   # in place.
-   #
-   def clean!
-      return self if self.empty?
-
-      if @win
-         path = 0.chr * MAXPATH
-         if PathCanonicalize(path, self)
-            replace(path.split(0.chr).first)
-         end
-         return self
+    to_a.each{ |element|
+      next if element == "."
+      final.push(element)
+      if element == ".." && self != ".."
+        2.times{ final.pop }
       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(self.class.new(final))
-
-      self
-   end
-
-   alias cleanpath! clean!
-
-   # Similar to File.dirname, but this method allows you to specify the number
-   # of levels up you wish to refer to.
-   #
-   # The default level is 1, i.e. it works the same as File.dirname. A level of
-   # 0 will return the original path. A level equal to or greater than the
-   # number of path elements will return the root path.
-   #
-   # A number less than 0 will raise an ArgumentError.
-   #
-   # Example:
-   #
-   #    path = Pathname.new('/usr/local/bin/ruby')
-   #
-   #    puts path.dirname    # => /usr/local/bin
-   #    puts path.dirname(2) # => /usr/local
-   #    puts path.dirname(3) # => /usr
-   #    puts path.dirname(9) # => /
-   #
-   def dirname(level = 1)
-      raise ArgumentError if level < 0
-      local_path = self.dup
-
-      level.times{ |n| local_path = File.dirname(local_path) }
-      local_path
-   end
-
-   #-- Find facade
-
-   # Pathname#find is an iterator to traverse a directory tree in a depth first
-   # manner. It yields a Pathname for each file under the directory passed to
-   # Pathname.new.
-   #
-   # Since it is implemented by the Find module, Find.prune can be used to
-   # control the traverse.
-   #
-   # If +self+ is ".", yielded pathnames begin with a filename in the current
-   # current directory, not ".".
-   #
-   def find(&block)
-      require "find"
-      if self == "."
-         Find.find(self){ |f| yield self.class.new(f.sub(%r{\A\./}, '')) }
+    }
+
+    final = final.join(@sep)
+    final = root + final if root != "."
+    final = "." if final.empty?
+    replace(self.class.new(final))
+
+    self
+  end
+
+  alias cleanpath! clean!
+
+  # Similar to File.dirname, but this method allows you to specify the number
+  # of levels up you wish to refer to.
+  #
+  # The default level is 1, i.e. it works the same as File.dirname. A level of
+  # 0 will return the original path. A level equal to or greater than the
+  # number of path elements will return the root path.
+  #
+  # A number less than 0 will raise an ArgumentError.
+  #
+  # Example:
+  #
+  #    path = Pathname.new('/usr/local/bin/ruby')
+  #
+  #    puts path.dirname    # => /usr/local/bin
+  #    puts path.dirname(2) # => /usr/local
+  #    puts path.dirname(3) # => /usr
+  #    puts path.dirname(9) # => /
+  #
+  def dirname(level = 1)
+    raise ArgumentError if level < 0
+    local_path = self.dup
+
+    level.times{ |n| local_path = File.dirname(local_path) }
+    local_path
+  end
+
+  #-- Find facade
+
+  # Pathname#find is an iterator to traverse a directory tree in a depth first
+  # manner. It yields a Pathname for each file under the directory passed to
+  # Pathname.new.
+  #
+  # Since it is implemented by the Find module, Find.prune can be used to
+  # control the traverse.
+  #
+  # If +self+ is ".", yielded pathnames begin with a filename in the current
+  # current directory, not ".".
+  #
+  def find(&block)
+    require "find"
+    if self == "."
+      Find.find(self){ |f| yield self.class.new(f.sub(%r{\A\./}, '')) }
+    else
+      Find.find(self){ |f| yield self.class.new(f) }
+    end
+  end
+
+  #-- 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
+  #
+  # :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 self.class.new(file) }
       else
-         Find.find(self){ |f| yield self.class.new(f) }
+        Dir.glob(*args).map{ |file| self.class.new(file) }
       end
-   end
-
-   #-- 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
-   #
-   # :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 self.class.new(file) }
-         else
-            Dir.glob(*args).map{ |file| self.class.new(file) }
-         end
-      }
-   end
-
-   # Dir.chdir
-   def chdir(&block)
-      Dir.chdir(self, &block)
-   end
-
-   # Dir.entries
-   def entries
-      Dir.entries(self).map{ |file| self.class.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
-
-   # File.join
-   def join(*args)
-      File.join(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
+    }
+  end
+
+  # Dir.chdir
+  def chdir(&block)
+    Dir.chdir(self, &block)
+  end
+
+  # Dir.entries
+  def entries
+    Dir.entries(self).map{ |file| self.class.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
+
+  # File.join
+  def join(*args)
+    File.join(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
-   
-   # FileUtils.rmtree
-   def rmtree(*args)
-      FileUtils.rmtree(self, *args)
-   end
-
-   # 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
+  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
+
+  # FileUtils.rmtree
+  def rmtree(*args)
+    FileUtils.rmtree(self, *args)
+  end
+
+  # 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
 
 module Kernel
-   # Usage: pn{ path } 
-   #
-   # A shortcut for Pathname.new
-   #
-   def pn
-      instance_eval{ Pathname.new(yield) }
-   end
+  # Usage: pn{ path }
+  #
+  # A shortcut for Pathname.new
+  #
+  def pn
+    instance_eval{ Pathname.new(yield) }
+  end
+
+  begin
+    remove_method(:Pathname)
+  rescue NoMethodError, NameError
+    # Do nothing, not defined.
+  end
+
+  # Synonym for Pathname.new
+  #
+  def Pathname(path)
+    Pathname.new(path)
+  end
 end