epath 0.0.1 → 0.1.0

data/lib/epath/file.rb

@@ -0,0 +1,109 @@
+class Path
+  # Returns last access time. See +File.atime+.
+  def atime
+    File.atime(@path)
+  end
+
+  # Returns last (directory entry, not file) change time. See +File.ctime+.
+  def ctime
+    File.ctime(@path)
+  end
+
+  # Returns last modification time. See +File.mtime+.
+  def mtime
+    File.mtime(@path)
+  end
+
+  # Changes permissions. See +File.chmod+.
+  def chmod(mode) File.chmod(mode, @path) end
+
+  # See +File.lchmod+.
+  def lchmod(mode) File.lchmod(mode, @path) end
+
+  # Change owner and group of file. See +File.chown+.
+  def chown(owner, group)
+    File.chown(owner, group, @path)
+  end
+
+  # See +File.lchown+.
+  def lchown(owner, group)
+    File.lchown(owner, group, @path)
+  end
+
+  # Returns "type" of file ("file", "directory", etc). See +File.ftype+.
+  def ftype
+    File.ftype(@path)
+  end
+
+  # Creates a hard link to +target+ and returns self.
+  #
+  # Raises Errno::EEXIST if self already exist.
+  # See +File.link+ (arguments are swapped).
+  def make_link(target)
+    File.link(target, @path)
+    self
+  end
+
+  # Read symbolic link. See +File.readlink+.
+  def readlink
+    Path.new(File.readlink(@path))
+  end
+
+  # Rename the file and returns the new Path. See +File.rename+.
+  def rename(to)
+    File.rename(@path, to)
+    Path(to)
+  end
+
+  # Returns a +File::Stat+ object. See +File.stat+.
+  def stat
+    File.stat(@path)
+  end
+
+  # See +File.lstat+.
+  def lstat
+    File.lstat(@path)
+  end
+
+  # See +File.size+.
+  def size
+    File.size(@path)
+  end
+
+  # Creates a symbolic link to +target+ and returns self.
+  #
+  # Raises Errno::EEXIST if self already exist.
+  # See +File.symlink+ (arguments are swapped).
+  def make_symlink(target)
+    File.symlink(target, @path)
+    self
+  end
+
+  # Truncate the file to +length+ bytes. See +File.truncate+.
+  def truncate(length) File.truncate(@path, length) end
+
+  # Update the access and modification times. See +File.utime+.
+  def utime(atime, mtime) File.utime(atime, mtime, @path) end
+
+  # See +File.expand_path+.
+  def expand_path(*args)
+    Path.new(File.expand_path(@path, *args))
+  end
+  alias :expand :expand_path
+
+  # Returns the real (absolute) path of +self+ in the actual
+  # filesystem not containing symlinks or useless dots.
+  #
+  # All components of the path must exist when this method is called.
+  def realpath(basedir=nil)
+    Path.new(real_path_internal(true, basedir))
+  end
+
+  # Returns the real (absolute) path of +self+ in the actual filesystem.
+  # The real path doesn't contain symlinks or useless dots.
+  #
+  # The last component of the real path can be nonexistent.
+  def realdirpath(basedir=nil)
+    Path.new(real_path_internal(false, basedir))
+  end
+end

data/lib/epath/file_dir.rb

@@ -0,0 +1,12 @@
+class Path
+  # Removes a file or directory, using +File.unlink+ or
+  # +Dir.unlink+ as necessary.
+  def unlink
+    if directory?
+      Dir.unlink @path
+    else
+      File.unlink @path
+    end
+  end
+  alias :delete :unlink
+end

data/lib/epath/file_predicates.rb

@@ -0,0 +1,149 @@
+# All methods from FileTest and all predicates from File are included
+
+class Path
+  # See +File.blockdev?+.
+  def blockdev?
+    File.blockdev?(@path)
+  end
+
+  # See +File.chardev?+.
+  def chardev?
+    File.chardev?(@path)
+  end
+
+  # See +File.executable?+.
+  def executable?
+    File.executable?(@path)
+  end
+
+  # See +File.executable_real?+.
+  def executable_real?
+    File.executable_real?(@path)
+  end
+
+  # See +File.exist?+.
+  def exist?
+    File.exist?(@path)
+  end
+  alias :exists? :exist?
+
+  # See +File.grpowned?+.
+  def grpowned?
+    File.grpowned?(@path)
+  end
+
+  # See +File.directory?+.
+  def directory?
+    File.directory?(@path)
+  end
+  alias :dir? :directory?
+
+  # See +File.file?+.
+  def file?
+    File.file?(@path)
+  end
+
+  # See +File.pipe?+.
+  def pipe?
+    File.pipe?(@path)
+  end
+
+  # See +File.socket?+.
+  def socket?
+    File.socket?(@path)
+  end
+
+  # See +File.owned?+.
+  def owned?
+    File.owned?(@path)
+  end
+
+  # See +File.readable?+.
+  def readable?
+    File.readable?(@path)
+  end
+
+  if File.respond_to? :world_readable?
+    # See +File.world_readable?+.
+    def world_readable?
+      File.world_readable?(@path)
+    end
+  else
+    def world_readable?
+      mode = File.stat(@path).mode & 0777
+      mode if (mode & 04).nonzero?
+    end
+  end
+
+  # See +File.readable_real?+.
+  def readable_real?
+    File.readable_real?(@path)
+  end
+
+  # See +File.setuid?+.
+  def setuid?
+    File.setuid?(@path)
+  end
+
+  # See +File.setgid?+.
+  def setgid?
+    File.setgid?(@path)
+  end
+
+  # See +File.size?+.
+  def size?
+    File.size?(@path)
+  end
+
+  # See +File.sticky?+.
+  def sticky?
+    File.sticky?(@path)
+  end
+
+  # See +File.symlink?+.
+  def symlink?
+    File.symlink?(@path)
+  end
+
+  # See +File.writable?+.
+  def writable?
+    File.writable?(@path)
+  end
+
+  if File.respond_to? :world_writable?
+    # See +File.world_writable?+.
+    def world_writable?
+      File.world_writable?(@path)
+    end
+  else
+    def world_writable?
+      mode = File.stat(@path).mode & 0777
+      mode if (mode & 02).nonzero?
+    end
+  end
+
+  # See +File.writable_real?+.
+  def writable_real?
+    File.writable_real?(@path)
+  end
+
+  # See +File.zero?+.
+  # empty? is not defined in File/FileTest, but is is clearer
+  def zero?
+    File.zero?(@path)
+  end
+  alias :empty? :zero?
+
+  # See +File.identical?+.
+  def identical?(path)
+    File.identical?(@path, path)
+  end
+
+  # Only in File, not FileTest
+
+  # Return +true+ if the receiver matches the given pattern.
+  # See +File.fnmatch?+.
+  def fnmatch?(pattern, *args)
+    File.fnmatch?(pattern, @path, *args)
+  end
+end

data/lib/epath/fileutils.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+
+class Path
+  # Creates a full path, including any intermediate directories that don't yet exist.
+  # See +FileUtils.mkpath+.
+  def mkpath
+    FileUtils.mkpath(@path)
+    self
+  end
+  alias :mkdir_p :mkpath
+
+  # Deletes a directory and all beneath it. See +FileUtils.rm_r+.
+  def rmtree
+    # The name "rmtree" is borrowed from File::Path of Perl.
+    # File::Path provides "mkpath" and "rmtree".
+    FileUtils.rm_r(@path)
+    self
+  end
+  alias :rm_r :rmtree
+
+  def rm
+    FileUtils.rm(@path)
+    self
+  end
+
+  def rm_f
+    FileUtils.rm_f(@path)
+    self
+  end
+
+  def rm_rf
+    FileUtils.rm_rf(@path)
+    self
+  end
+
+  def touch
+    FileUtils.touch(@path)
+    self
+  end
+
+  def touch!
+    dirname.mkpath
+    touch
+  end
+end

data/lib/epath/find.rb

@@ -0,0 +1,21 @@
+class Path
+  # Path#find is an iterator to traverse a directory tree in a depth first
+  # manner. It yields a Path for each file under "this" directory.
+  #
+  # Returns an enumerator if no block is given.
+  #
+  # Since it is implemented by +find.rb+, +Find.prune+ can be used
+  # to control the traversal.
+  #
+  # If +self+ is +.+, yielded paths begin with a filename in the
+  # current directory, not +./+.
+  def find # :yield: path
+    return to_enum(__method__) unless block_given?
+    require 'find'
+    if @path == '.'
+      Find.find(@path) { |f| yield Path.new(f.sub(%r{\A\./}, '')) }
+    else
+      Find.find(@path) { |f| yield Path.new(f) }
+    end
+  end
+end

data/lib/epath/identity.rb

@@ -0,0 +1,58 @@
+class Path
+  class << self
+    def new(*args)
+      if args.size == 1 and Path === args[0]
+        args[0]
+      else
+        super(*args)
+      end
+    end
+    alias :[] :new
+
+    def to_proc
+      lambda { |path| new(path) }
+    end
+  end
+
+  # Compare this path with +other+. The comparison is string-based.
+  # Be aware that two different paths (+foo.txt+ and +./foo.txt+)
+  # can refer to the same file.
+  def == other
+    Path === other and @path == other.to_path
+  end
+  alias :eql? :==
+
+  # Provides for comparing paths, case-sensitively.
+  def <=>(other)
+    return nil unless Path === other
+    @path.tr('/', "\0") <=> other.to_s.tr('/', "\0")
+  end
+
+  def hash
+    @path.hash
+  end
+
+  # Return the path as a String.
+  def to_s
+    @path
+  end
+
+  # to_path is implemented so Path objects are usable with File.open, etc.
+  alias :to_path :to_s
+
+  alias :to_str :to_s if RUBY_VERSION < '1.9'
+
+  def to_sym
+    @path.to_sym
+  end
+
+  def inspect
+    "#<Path #{@path}>"
+  end
+end
+
+unless defined? NO_EPATH_GLOBAL_FUNCTION
+  def Path(*args)
+    Path.new(*args)
+  end
+end

data/lib/epath/implementation.rb

@@ -1,82 +1,156 @@
 # Path's low-level implementation based on Pathname
 
-require 'fileutils'
-
 class Path
-  # :stopdoc:
+  # @private
   SAME_PATHS = if File::FNM_SYSCASE.nonzero?
-    proc {|a, b| a.casecmp(b).zero?}
+    lambda { |a,b| a.casecmp(b).zero? }
   else
-    proc {|a, b| a == b}
+    lambda { |a,b| a == b }
   end
 
-  # :startdoc:
+  def initialize(*parts)
+    path = parts.size > 1 ? File.join(parts) : parts.first
+    @path = case path
+    when Tempfile
+      @_tmpfile = path # We would not want it to be GC'd
+      path.path.dup
+    when String
+      path.dup
+    else
+      path.to_s.dup
+    end
+
+    validate(@path)
 
-  def freeze() super; @path.freeze; self end
-  def taint() super; @path.taint; self end
-  def untaint() super; @path.untaint; self end
+    taint if @path.tainted?
+    @path.freeze
+    freeze
+  end
 
+  # Returns clean path of +self+ with consecutive slashes and useless dots removed.
+  # The filesystem is not accessed.
   #
-  # Compare this pathname with +other+.  The comparison is string-based.
-  # Be aware that two different paths (<tt>foo.txt</tt> and <tt>./foo.txt</tt>)
-  # can refer to the same file.
+  # If +consider_symlink+ is +true+, then a more conservative algorithm is used
+  # to avoid breaking symbolic linkages. This may retain more +..+
+  # entries than absolutely necessary, but without accessing the filesystem,
+  # this can't be avoided. See #realpath.
+  def cleanpath(consider_symlink=false)
+    if consider_symlink
+      cleanpath_conservative
+    else
+      cleanpath_aggressive
+    end
+  end
+
+  # #parent returns the parent directory.
   #
-  def == other
-    Path === other and @path == other.to_s
+  # This is same as <tt>self + '..'</tt>.
+  def parent
+    self + '..'
   end
-  alias eql? ==
 
-  # Provides for comparing pathnames, case-sensitively.
-  def <=>(other)
-    return nil unless Path === other
-    @path.tr('/', "\0") <=> other.to_s.tr('/', "\0")
+  # Path#+ appends a path fragment to this one to produce a new Path.
+  #
+  #   p1 = Path.new("/usr")   # => #<Path /usr>
+  #   p2 = p1 + "bin/ruby"    # => #<Path /usr/bin/ruby>
+  #   p3 = p1 + "/etc/passwd" # => #<Path /etc/passwd>
+  #
+  # This method doesn't access the file system, it is pure string manipulation.
+  def +(other)
+    Path.new(plus(@path, other.to_s))
   end
 
-  def hash # :nodoc:
-    @path.hash
+  # Path#join joins paths.
+  #
+  # <tt>path0.join(path1, ..., pathN)</tt> is the same as
+  # <tt>path0 + path1 + ... + pathN</tt>.
+  def join(*args)
+    args.unshift self
+    result = Path.new(args.pop)
+    return result if result.absolute?
+    args.reverse_each { |arg|
+      arg = Path.new(arg)
+      result = arg + result
+      return result if result.absolute?
+    }
+    result
   end
 
-  # Return the path as a String.
-  def to_s
-    @path.dup
+  # #relative_path_from 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.
+  #
+  # #relative_path_from doesn't access the filesystem. It assumes no symlinks.
+  #
+  # ArgumentError is raised when it cannot find a relative path.
+  def relative_path_from(base_directory)
+    dest_directory = cleanpath.to_s
+    base_directory = Path.new(base_directory).cleanpath.to_s
+    dest_prefix = dest_directory
+    dest_names = []
+    while r = chop_basename(dest_prefix)
+      dest_prefix, basename = r
+      dest_names.unshift basename if basename != '.'
+    end
+    base_prefix = base_directory
+    base_names = []
+    while r = chop_basename(base_prefix)
+      base_prefix, basename = r
+      base_names.unshift basename if basename != '.'
+    end
+    unless SAME_PATHS[dest_prefix, base_prefix]
+      raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}"
+    end
+    until dest_names.empty? or base_names.empty? or !SAME_PATHS[dest_names.first, base_names.first]
+      dest_names.shift
+      base_names.shift
+    end
+    if base_names.include? '..'
+      raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
+    end
+    base_names.fill('..')
+    relpath_names = base_names + dest_names
+    if relpath_names.empty?
+      Path.new('.')
+    else
+      Path.new(*relpath_names)
+    end
   end
 
-  # to_path is implemented so Path objects are usable with File.open, etc.
-  alias to_path to_s
+  # @private
+  module Helpers
+    private
 
-  alias to_str to_s if RUBY_VERSION < '1.9'
+    # remove the leading . of +ext+ if present.
+    def pure_ext(ext)
+      ext.start_with?('.') ? ext[1..-1] : ext
+    end
 
-  def inspect
-    "#<Path #{@path}>"
+    # add a leading . to +ext+ if missing. Returns '' if +ext+ is empty.
+    def dotted_ext(ext)
+      (ext.empty? or ext.start_with?('.')) ? ext : ".#{ext}"
+    end
   end
 
-  if File::ALT_SEPARATOR
-    SEPARATOR_LIST = "#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}"
-    SEPARATOR_PAT = /[#{SEPARATOR_LIST}]/
-  else
-    SEPARATOR_LIST = "#{Regexp.quote File::SEPARATOR}"
-    SEPARATOR_PAT = /#{Regexp.quote File::SEPARATOR}/
-  end
+  include Helpers
+  extend Helpers
 
-  # Return a pathname which the extension of the basename is substituted by
-  # <i>repl</i>.
-  #
-  # If self has no extension part, <i>repl</i> is appended.
-  def sub_ext(repl)
-    ext = File.extname(@path)
-    Path.new(@path.chomp(ext) + repl)
+  private
+
+  def validate(path)
+    raise ArgumentError, "path contains a null byte: #{path.inspect}" if path.include? "\0"
+    path.gsub!(File::ALT_SEPARATOR, '/') if File::ALT_SEPARATOR
   end
 
   # chop_basename(path) -> [pre-basename, basename] or nil
   def chop_basename(path)
     base = File.basename(path)
-    if /\A#{SEPARATOR_PAT}?\z/o =~ base
+    if base.empty? or base == '/'
       return nil
     else
       return path[0, path.rindex(base)], base
     end
   end
-  private :chop_basename
 
   # split_names(path) -> prefix, [name, ...]
   def split_names(path)
@@ -87,41 +161,47 @@ class Path
     end
     return path, names
   end
-  private :split_names
 
   def prepend_prefix(prefix, relpath)
     if relpath.empty?
       File.dirname(prefix)
-    elsif /#{SEPARATOR_PAT}/o =~ prefix
-      prefix = File.dirname(prefix)
-      prefix = File.join(prefix, "") if File.basename(prefix + 'a') != 'a'
-      prefix + relpath
+    elsif prefix.include? '/'
+      add_trailing_separator(File.dirname(prefix)) + relpath
     else
       prefix + relpath
     end
   end
-  private :prepend_prefix
 
-  # Returns clean pathname of +self+ with consecutive slashes and useless dots
-  # removed.  The filesystem is not accessed.
-  #
-  # If +consider_symlink+ is +true+, then a more conservative algorithm is used
-  # to avoid breaking symbolic linkages.  This may retain more <tt>..</tt>
-  # entries than absolutely necessary, but without accessing the filesystem,
-  # this can't be avoided.  See #realpath.
-  #
-  def cleanpath(consider_symlink=false)
-    if consider_symlink
-      cleanpath_conservative
+  def has_trailing_separator?(path)
+    if r = chop_basename(path)
+      pre, basename = r
+      pre.length + basename.length < path.length
     else
-      cleanpath_aggressive
+      false
+    end
+  end
+
+  def add_trailing_separator(path)
+    if File.basename(path + 'a') == 'a'
+      path
+    else
+      path + '/'
+    end
+  end
+
+  def del_trailing_separator(path)
+    if r = chop_basename(path)
+      pre, basename = r
+      pre + basename
+    elsif /\/+\z/o =~ path
+      $` + File.dirname(path)[/\/*\z/o]
+    else
+      path
     end
   end
 
-  #
   # Clean the path simply by resolving and removing excess "." and ".." entries.
   # Nothing more, nothing less.
-  #
   def cleanpath_aggressive
     path = @path
     names = []
@@ -140,45 +220,11 @@ class Path
         end
       end
     end
-    if /#{SEPARATOR_PAT}/o =~ File.basename(pre)
+    if File.basename(pre).include? '/'
       names.shift while names[0] == '..'
     end
     Path.new(prepend_prefix(pre, File.join(*names)))
   end
-  private :cleanpath_aggressive
-
-  # has_trailing_separator?(path) -> bool
-  def has_trailing_separator?(path)
-    if r = chop_basename(path)
-      pre, basename = r
-      pre.length + basename.length < path.length
-    else
-      false
-    end
-  end
-  private :has_trailing_separator?
-
-  # add_trailing_separator(path) -> path
-  def add_trailing_separator(path)
-    if File.basename(path + 'a') == 'a'
-      path
-    else
-      File.join(path, "") # xxx: Is File.join is appropriate to add separator?
-    end
-  end
-  private :add_trailing_separator
-
-  def del_trailing_separator(path)
-    if r = chop_basename(path)
-      pre, basename = r
-      pre + basename
-    elsif /#{SEPARATOR_PAT}+\z/o =~ path
-      $` + File.dirname(path)[/#{SEPARATOR_PAT}*\z/o]
-    else
-      path
-    end
-  end
-  private :del_trailing_separator
 
   def cleanpath_conservative
     path = @path
@@ -188,7 +234,7 @@ class Path
       pre, base = r
       names.unshift base if base != '.'
     end
-    if /#{SEPARATOR_PAT}/o =~ File.basename(pre)
+    if File.basename(pre).include? '/'
       names.shift while names[0] == '..'
     end
     if names.empty?
@@ -205,13 +251,11 @@ class Path
       end
     end
   end
-  private :cleanpath_conservative
 
   if File.respond_to?(:realpath) and File.respond_to?(:realdirpath)
     def real_path_internal(strict = false, basedir = nil)
       strict ? File.realpath(@path, basedir) : File.realdirpath(@path, basedir)
     end
-    private :real_path_internal
   else
     def realpath_rec(prefix, unresolved, h, strict, last = true)
       resolved = []
@@ -254,7 +298,6 @@ class Path
       end
       return prefix, *resolved
     end
-    private :realpath_rec
 
     def real_path_internal(strict = false, basedir = nil)
       path = @path
@@ -267,151 +310,6 @@ class Path
       prefix, *names = realpath_rec(prefix, names, {}, strict)
       prepend_prefix(prefix, File.join(*names))
     end
-    private :real_path_internal
-  end
-
-  #
-  # Returns the real (absolute) pathname of +self+ in the actual
-  # filesystem not containing symlinks or useless dots.
-  #
-  # All components of the pathname must exist when this method is
-  # called.
-  #
-  def realpath(basedir=nil)
-    Path.new(real_path_internal(true, basedir))
-  end
-
-  #
-  # Returns the real (absolute) pathname of +self+ in the actual filesystem.
-  # The real pathname doesn't contain symlinks or useless dots.
-  #
-  # The last component of the real pathname can be nonexistent.
-  #
-  def realdirpath(basedir=nil)
-    Path.new(real_path_internal(false, basedir))
-  end
-
-  # #parent returns the parent directory.
-  #
-  # This is same as <tt>self + '..'</tt>.
-  def parent
-    self + '..'
-  end
-
-  # #mountpoint? returns +true+ if <tt>self</tt> points to a mountpoint.
-  def mountpoint?
-    begin
-      stat1 = lstat
-      stat2 = parent.lstat
-      stat1.dev != stat2.dev or stat1.ino == stat2.ino
-    rescue Errno::ENOENT
-      false
-    end
-  end
-
-  #
-  # #root? is a predicate for root directories.  I.e. it returns +true+ if the
-  # pathname consists of consecutive slashes.
-  #
-  # It doesn't access actual filesystem.  So it may return +false+ for some
-  # pathnames which points to roots such as <tt>/usr/..</tt>.
-  #
-  def root?
-    !!(chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o =~ @path)
-  end
-
-  # Predicate method for testing whether a path is absolute.
-  # It returns +true+ if the pathname begins with a slash.
-  def absolute?
-    !relative?
-  end
-
-  # The opposite of #absolute?
-  def relative?
-    path = @path
-    while r = chop_basename(path)
-      path, = r
-    end
-    path == ''
-  end
-
-  #
-  # Iterates over each component of the path.
-  #
-  #   Path.new("/usr/bin/ruby").each_filename {|filename| ... }
-  #     # yields "usr", "bin", and "ruby".
-  #
-  def each_filename # :yield: filename
-    return to_enum(__method__) unless block_given?
-    _, names = split_names(@path)
-    names.each {|filename| yield filename }
-    nil
-  end
-
-  # Iterates over and yields a new Path object
-  # for each element in the given path in descending order.
-  #
-  #  Path.new('/path/to/some/file.rb').descend {|v| p v}
-  #     #<Path:/>
-  #     #<Path:/path>
-  #     #<Path:/path/to>
-  #     #<Path:/path/to/some>
-  #     #<Path:/path/to/some/file.rb>
-  #
-  #  Path.new('path/to/some/file.rb').descend {|v| p v}
-  #     #<Path:path>
-  #     #<Path:path/to>
-  #     #<Path:path/to/some>
-  #     #<Path:path/to/some/file.rb>
-  #
-  # It doesn't access actual filesystem.
-  def descend
-    vs = []
-    ascend {|v| vs << v }
-    vs.reverse_each {|v| yield v }
-    nil
-  end
-
-  # Iterates over and yields a new Path object
-  # for each element in the given path in ascending order.
-  #
-  #  Path.new('/path/to/some/file.rb').ascend {|v| p v}
-  #     #<Path:/path/to/some/file.rb>
-  #     #<Path:/path/to/some>
-  #     #<Path:/path/to>
-  #     #<Path:/path>
-  #     #<Path:/>
-  #
-  #  Path.new('path/to/some/file.rb').ascend {|v| p v}
-  #     #<Path:path/to/some/file.rb>
-  #     #<Path:path/to/some>
-  #     #<Path:path/to>
-  #     #<Path:path>
-  #
-  # It doesn't access actual filesystem.
-  def ascend
-    path = @path
-    yield self
-    while r = chop_basename(path)
-      path, = r
-      break if path.empty?
-      yield Path.new(del_trailing_separator(path))
-    end
-  end
-
-  #
-  # Path#+ appends a pathname fragment to this one to produce a new Path
-  # object.
-  #
-  #   p1 = Path.new("/usr")      # Path:/usr
-  #   p2 = p1 + "bin/ruby"           # Path:/usr/bin/ruby
-  #   p3 = p1 + "/etc/passwd"        # Path:/etc/passwd
-  #
-  # This method doesn't access the file system; it is pure string manipulation.
-  #
-  def +(other)
-    other = Path.new(other) unless Path === other
-    Path.new(plus(@path, other.to_s))
   end
 
   def plus(path1, path2) # -> path
@@ -441,7 +339,7 @@ class Path
       basename_list2.shift
     end
     r1 = chop_basename(prefix1)
-    if !r1 && /#{SEPARATOR_PAT}/o =~ File.basename(prefix1)
+    if !r1 && File.basename(prefix1).include?('/')
       while !basename_list2.empty? && basename_list2.first == '..'
         index_list2.shift
         basename_list2.shift
@@ -454,420 +352,4 @@ class Path
       r1 ? prefix1 : File.dirname(prefix1)
     end
   end
-  private :plus
-
-  #
-  # Path#join joins pathnames.
-  #
-  # <tt>path0.join(path1, ..., pathN)</tt> is the same as
-  # <tt>path0 + path1 + ... + pathN</tt>.
-  #
-  def join(*args)
-    args.unshift self
-    result = args.pop
-    result = Path.new(result) unless Path === result
-    return result if result.absolute?
-    args.reverse_each {|arg|
-      arg = Path.new(arg) unless Path === arg
-      result = arg + result
-      return result if result.absolute?
-    }
-    result
-  end
-
-  #
-  # Returns the children of the directory (files and subdirectories, not
-  # recursive) as an array of Path objects.  By default, the returned
-  # pathnames will have enough information to access the files.  If you set
-  # +with_directory+ to +false+, then the returned pathnames will contain the
-  # filename only.
-  #
-  # For example:
-  #   pn = Path("/usr/lib/ruby/1.8")
-  #   pn.children
-  #       # -> [ Path:/usr/lib/ruby/1.8/English.rb,
-  #              Path:/usr/lib/ruby/1.8/Env.rb,
-  #              Path:/usr/lib/ruby/1.8/abbrev.rb, ... ]
-  #   pn.children(false)
-  #       # -> [ Path:English.rb, Path:Env.rb, Path:abbrev.rb, ... ]
-  #
-  # Note that the results never contain the entries <tt>.</tt> and <tt>..</tt> in
-  # the directory because they are not children.
-  #
-  def children(with_directory=true)
-    with_directory = false if @path == '.'
-    result = []
-    Dir.foreach(@path) {|e|
-      next if e == '.' || e == '..'
-      if with_directory
-        result << Path.new(File.join(@path, e))
-      else
-        result << Path.new(e)
-      end
-    }
-    result
-  end
-
-  # Iterates over the children of the directory
-  # (files and subdirectories, not recursive).
-  # It yields Path object for each child.
-  # By default, the yielded pathnames will have enough information to access the files.
-  # If you set +with_directory+ to +false+, then the returned pathnames will contain the filename only.
-  #
-  #   Path("/usr/local").each_child {|f| p f }
-  #   #=> #<Path:/usr/local/share>
-  #   #   #<Path:/usr/local/bin>
-  #   #   #<Path:/usr/local/games>
-  #   #   #<Path:/usr/local/lib>
-  #   #   #<Path:/usr/local/include>
-  #   #   #<Path:/usr/local/sbin>
-  #   #   #<Path:/usr/local/src>
-  #   #   #<Path:/usr/local/man>
-  #
-  #   Path("/usr/local").each_child(false) {|f| p f }
-  #   #=> #<Path:share>
-  #   #   #<Path:bin>
-  #   #   #<Path:games>
-  #   #   #<Path:lib>
-  #   #   #<Path:include>
-  #   #   #<Path:sbin>
-  #   #   #<Path:src>
-  #   #   #<Path:man>
-  #
-  def each_child(with_directory=true, &b)
-    children(with_directory).each(&b)
-  end
-
-  #
-  # #relative_path_from 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.
-  #
-  # #relative_path_from doesn't access the filesystem.  It assumes no symlinks.
-  #
-  # ArgumentError is raised when it cannot find a relative path.
-  #
-  def relative_path_from(base_directory)
-    dest_directory = cleanpath.to_s
-    base_directory = base_directory.cleanpath.to_s
-    dest_prefix = dest_directory
-    dest_names = []
-    while r = chop_basename(dest_prefix)
-      dest_prefix, basename = r
-      dest_names.unshift basename if basename != '.'
-    end
-    base_prefix = base_directory
-    base_names = []
-    while r = chop_basename(base_prefix)
-      base_prefix, basename = r
-      base_names.unshift basename if basename != '.'
-    end
-    unless SAME_PATHS[dest_prefix, base_prefix]
-      raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}"
-    end
-    while !dest_names.empty? &&
-          !base_names.empty? &&
-          SAME_PATHS[dest_names.first, base_names.first]
-      dest_names.shift
-      base_names.shift
-    end
-    if base_names.include? '..'
-      raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
-    end
-    base_names.fill('..')
-    relpath_names = base_names + dest_names
-    if relpath_names.empty?
-      Path.new('.')
-    else
-      Path.new(File.join(*relpath_names))
-    end
-  end
-end
-
-class Path    # * IO *
-  #
-  # #each_line iterates over the line in the file.  It yields a String object
-  # for each line.
-  #
-  def each_line(*args, &block) # :yield: line
-    IO.foreach(@path, *args, &block)
-  end
-
-  # See <tt>IO.read</tt>.  Returns all data from the file, or the first +N+ bytes
-  # if specified.
-  def read(*args) IO.read(@path, *args) end
-
-  # See <tt>IO.binread</tt>.  Returns all the bytes from the file, or the first +N+
-  # if specified.
-  def binread(*args) IO.binread(@path, *args) end
-
-  # See <tt>IO.readlines</tt>.  Returns all the lines from the file.
-  def readlines(*args) IO.readlines(@path, *args) end
-
-  # See <tt>IO.sysopen</tt>.
-  def sysopen(*args) IO.sysopen(@path, *args) end
-end
-
-
-class Path    # * File *
-
-  # See <tt>File.atime</tt>.  Returns last access time.
-  def atime() File.atime(@path) end
-
-  # See <tt>File.ctime</tt>.  Returns last (directory entry, not file) change time.
-  def ctime() File.ctime(@path) end
-
-  # See <tt>File.mtime</tt>.  Returns last modification time.
-  def mtime() File.mtime(@path) end
-
-  # See <tt>File.chmod</tt>.  Changes permissions.
-  def chmod(mode) File.chmod(mode, @path) end
-
-  # See <tt>File.lchmod</tt>.
-  def lchmod(mode) File.lchmod(mode, @path) end
-
-  # See <tt>File.chown</tt>.  Change owner and group of file.
-  def chown(owner, group) File.chown(owner, group, @path) end
-
-  # See <tt>File.lchown</tt>.
-  def lchown(owner, group) File.lchown(owner, group, @path) end
-
-  # See <tt>File.fnmatch</tt>.  Return +true+ if the receiver matches the given
-  # pattern.
-  def fnmatch(pattern, *args) File.fnmatch(pattern, @path, *args) end
-
-  # See <tt>File.fnmatch?</tt> (same as #fnmatch).
-  def fnmatch?(pattern, *args) File.fnmatch?(pattern, @path, *args) end
-
-  # See <tt>File.ftype</tt>.  Returns "type" of file ("file", "directory",
-  # etc).
-  def ftype() File.ftype(@path) end
-
-  # See <tt>File.link</tt>.  Creates a hard link.
-  def make_link(old) File.link(old, @path) end
-
-  # See <tt>File.open</tt>.  Opens the file for reading or writing.
-  def open(*args, &block) # :yield: file
-    File.open(@path, *args, &block)
-  end
-
-  # See <tt>File.readlink</tt>.  Read symbolic link.
-  def readlink() Path.new(File.readlink(@path)) end
-
-  # See <tt>File.rename</tt>.  Rename the file.
-  def rename(to) File.rename(@path, to) end
-
-  # See <tt>File.stat</tt>.  Returns a <tt>File::Stat</tt> object.
-  def stat() File.stat(@path) end
-
-  # See <tt>File.lstat</tt>.
-  def lstat() File.lstat(@path) end
-
-  # See <tt>File.symlink</tt>.  Creates a symbolic link.
-  def make_symlink(old) File.symlink(old, @path) end
-
-  # See <tt>File.truncate</tt>.  Truncate the file to +length+ bytes.
-  def truncate(length) File.truncate(@path, length) end
-
-  # See <tt>File.utime</tt>.  Update the access and modification times.
-  def utime(atime, mtime) File.utime(atime, mtime, @path) end
-
-  # See <tt>File.basename</tt>.  Returns the last component of the path.
-  def basename(*args) Path.new(File.basename(@path, *args)) end
-
-  # See <tt>File.dirname</tt>.  Returns all but the last component of the path.
-  def dirname() Path.new(File.dirname(@path)) end
-
-  # See <tt>File.extname</tt>.  Returns the file's extension.
-  def extname() File.extname(@path) end
-
-  # See <tt>File.expand_path</tt>.
-  def expand_path(*args) Path.new(File.expand_path(@path, *args)) end
-
-  # See <tt>File.split</tt>.  Returns the #dirname and the #basename in an
-  # Array.
-  def split() File.split(@path).map {|f| Path.new(f) } end
-end
-
-
-class Path    # * FileTest *
-
-  # See <tt>FileTest.blockdev?</tt>.
-  def blockdev?() FileTest.blockdev?(@path) end
-
-  # See <tt>FileTest.chardev?</tt>.
-  def chardev?() FileTest.chardev?(@path) end
-
-  # See <tt>FileTest.executable?</tt>.
-  def executable?() FileTest.executable?(@path) end
-
-  # See <tt>FileTest.executable_real?</tt>.
-  def executable_real?() FileTest.executable_real?(@path) end
-
-  # See <tt>FileTest.exist?</tt>.
-  def exist?() FileTest.exist?(@path) end
-
-  # See <tt>FileTest.grpowned?</tt>.
-  def grpowned?() FileTest.grpowned?(@path) end
-
-  # See <tt>FileTest.directory?</tt>.
-  def directory?() FileTest.directory?(@path) end
-
-  # See <tt>FileTest.file?</tt>.
-  def file?() FileTest.file?(@path) end
-
-  # See <tt>FileTest.pipe?</tt>.
-  def pipe?() FileTest.pipe?(@path) end
-
-  # See <tt>FileTest.socket?</tt>.
-  def socket?() FileTest.socket?(@path) end
-
-  # See <tt>FileTest.owned?</tt>.
-  def owned?() FileTest.owned?(@path) end
-
-  # See <tt>FileTest.readable?</tt>.
-  def readable?() FileTest.readable?(@path) end
-
-  if FileTest.respond_to? :world_readable?
-    # See <tt>FileTest.world_readable?</tt>.
-    def world_readable?() FileTest.world_readable?(@path) end
-  else
-    def world_readable?
-      mode = File.stat(@path).mode & 0777
-      mode if (mode & 04).nonzero?
-    end
-  end
-
-  # See <tt>FileTest.readable_real?</tt>.
-  def readable_real?() FileTest.readable_real?(@path) end
-
-  # See <tt>FileTest.setuid?</tt>.
-  def setuid?() FileTest.setuid?(@path) end
-
-  # See <tt>FileTest.setgid?</tt>.
-  def setgid?() FileTest.setgid?(@path) end
-
-  # See <tt>FileTest.size</tt>.
-  def size() FileTest.size(@path) end
-
-  # See <tt>FileTest.size?</tt>.
-  def size?() FileTest.size?(@path) end
-
-  # See <tt>FileTest.sticky?</tt>.
-  def sticky?() FileTest.sticky?(@path) end
-
-  # See <tt>FileTest.symlink?</tt>.
-  def symlink?() FileTest.symlink?(@path) end
-
-  # See <tt>FileTest.writable?</tt>.
-  def writable?() FileTest.writable?(@path) end
-
-  if FileTest.respond_to? :world_writable?
-    # See <tt>FileTest.world_writable?</tt>.
-    def world_writable?() FileTest.world_writable?(@path) end
-  else
-    def world_writable?
-      mode = File.stat(@path).mode & 0777
-      mode if (mode & 02).nonzero?
-    end
-  end
-
-  # See <tt>FileTest.writable_real?</tt>.
-  def writable_real?() FileTest.writable_real?(@path) end
-
-  # See <tt>FileTest.zero?</tt>.
-  def zero?() FileTest.zero?(@path) end
-end
-
-
-class Path    # * Dir *
-  class << self
-    # See <tt>Dir.glob</tt>.  Returns or yields Path objects.
-    def glob(*args) # :yield: pathname
-      if block_given?
-        Dir.glob(*args) {|f| yield new(f) }
-      else
-        Dir.glob(*args).map {|f| new(f) }
-      end
-    end
-
-    # See <tt>Dir.getwd</tt>.  Returns the current working directory as a Path.
-    def Path.getwd
-      new Dir.getwd
-    end
-
-    alias pwd getwd
-  end
-
-  # Iterates over the entries (files and subdirectories) in the directory.  It
-  # yields a Path object for each entry.
-  def each_entry(&block) # :yield: pathname
-    Dir.foreach(@path) {|f| yield Path.new(f) }
-  end
-
-  # See <tt>Dir.mkdir</tt>.  Create the referenced directory.
-  def mkdir(*args) Dir.mkdir(@path, *args) end
-
-  # See <tt>Dir.rmdir</tt>.  Remove the referenced directory.
-  def rmdir() Dir.rmdir(@path) end
-
-  # See <tt>Dir.open</tt>.
-  def opendir(&block) # :yield: dir
-    Dir.open(@path, &block)
-  end
-end
-
-
-class Path    # * Find *
-  #
-  # Path#find is an iterator to traverse a directory tree in a depth first
-  # manner.  It yields a Path for each file under "this" directory.
-  #
-  # Since it is implemented by <tt>find.rb</tt>, <tt>Find.prune</tt> can be used
-  # to control the traversal.
-  #
-  # If +self+ is <tt>.</tt>, yielded pathnames begin with a filename in the
-  # current directory, not <tt>./</tt>.
-  #
-  def find # :yield: pathname
-    return to_enum(__method__) unless block_given?
-    require 'find'
-    if @path == '.'
-      Find.find(@path) {|f| yield Path.new(f.sub(%r{\A\./}, '')) }
-    else
-      Find.find(@path) {|f| yield Path.new(f) }
-    end
-  end
-end
-
-
-class Path    # * FileUtils *
-  # See <tt>FileUtils.mkpath</tt>.  Creates a full path, including any
-  # intermediate directories that don't yet exist.
-  def mkpath
-    FileUtils.mkpath(@path)
-    nil
-  end
-
-  # See <tt>FileUtils.rm_r</tt>.  Deletes a directory and all beneath it.
-  def rmtree
-    # The name "rmtree" is borrowed from File::Path of Perl.
-    # File::Path provides "mkpath" and "rmtree".
-    FileUtils.rm_r(@path)
-    nil
-  end
-end
-
-
-class Path    # * mixed *
-  # Removes a file or directory, using <tt>File.unlink</tt> or
-  # <tt>Dir.unlink</tt> as necessary.
-  def unlink()
-    begin
-      Dir.unlink @path
-    rescue Errno::ENOTDIR
-      File.unlink @path
-    end
-  end
-  alias delete unlink
 end