epath 0.0.0 → 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 Benoit Daloze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+# Path - Enhanced Pathname
+
+Path is a library to manage paths.  
+It is similar to Pathname, but has some extra goodness.  
+The method names are intended to be short and explicit, and avoid too much duplication like having 'name' or 'path' in the method name.
+
+I believe the object-oriented approach to manipulate paths is very elegant and useful.  
+Paths are naturally the subject of their methods and even if they are simple Strings behind, they carry way much more information and deserve a first-class status.
+
+Also, using a path library like this avoid to remember in which class the functionality is implemented, everything is in one place (if not, please open an issue!).
+
+## API
+
+All the useful methods of `File` (and so `IO`) and `Dir` should be included.  
+Most methods of `FileUtils` should be there too.
+
+### creation
+
+``` ruby
+Path.new('/usr/bin')
+Path['/usr/bin']
+Path('/usr/bin') # unless NO_EPATH_GLOBAL_FUNCTION is defined
+
+Path.new('/usr', 'bin')
+%w[foo bar].map(&Path) # => [Path('foo'), Path('bar')]
+```
+
+``` ruby
+Path.here # == Path(__FILE__).expand
+Path.dir # == Path(File.dirname(__FILE__)).expand
+Path.relative(path) # == Path(File.expand_path("../#{path}", __FILE__))
+Path.home # == Path(File.expand_path('~'))
+```
+
+### temporary
+
+``` ruby
+Path.tmpfile
+Path.tmpdir
+```
+
+### aliases
+
+* expand => expand_path
+* relative_to => relative_path_from
+
+### parts
+
+* base: basename(extname)
+* dir: alias of dirname
+* ext: extname without the leading dot
+* /: join paths
+
+```ruby
+Path('/usr')/'bin'
+```
+
+These method names are too long, any idea to make them shorter and clear?
+
+* without_extension
+* replace_extension(new_ext)
+
+### glob
+
+* entries: files under self, without . and ..
+* glob: relative glob to self, yield absolute paths
+
+### structure
+
+* ancestors: self and all the parent directories
+* backfind: ascends the parents until it finds the given path
+
+``` ruby
+# Path.backfind is Path.here.backfind
+Path.backfind('lib') # => Path's lib folder
+# it accepts XPath-like context
+Path.backfind('.[.git]') # => the root of this repository
+```
+
+### IO
+
+* read
+* write(contents)
+* append(contents)
+
+### management
+
+* mkdir
+* mkdir_p
+* rm_rf
+
+### Incompatibilities with Pathname
+
+* #entries never returns . and ..
+
+## Status
+
+This is still in the early development stage, you should expect many additions and some changes.
+
+## Author
+
+Benoit Daloze - eregon
+
+### Contributors
+
+Bernard Lambeau - blambeau

data/epath.gemspec

@@ -1,7 +1,9 @@
 Gem::Specification.new do |s|
   s.name = 'epath'
-  s.summary = 'summary'
+  s.summary = 'a Path manipulation library'
   s.author = 'eregon'
-  s.files = %w[epath.gemspec]
-  s.version = '0.0.0'
+  s.email = 'eregontp@gmail.com'
+  s.homepage = 'https://github.com/eregon/epath'
+  s.files = Dir['lib/**/*.rb'] + %w[README.md LICENSE epath.gemspec]
+  s.version = '0.0.1'
 end

data/lib/epath.rb

@@ -0,0 +1,196 @@
+# Enchanced Pathname
+# Use the composite pattern with a Pathname
+
+require File.expand_path('../epath/implementation', __FILE__)
+require 'tempfile'
+
+class Path
+  DOTS = %w[. ..]
+
+  class << self
+    def new(*args)
+      if args.size == 1 and Path === args[0]
+        args[0]
+      else
+        super(*args)
+      end
+    end
+    alias_method :[], :new
+
+    def to_proc
+      lambda { |path| new(path) }
+    end
+
+    def here(from = nil)
+      from ||= caller
+      new(from.first.split(/:\d+(?:$|:in)/).first).expand
+    end
+    alias_method :file, :here
+
+    def dir(from = nil)
+      from ||= caller
+      file(from).dir
+    end
+
+    def home
+      new(Dir.respond_to?(:home) ? Dir.home : new("~").expand)
+    end
+
+    def relative(path)
+      new(path).expand dir(caller)
+    end
+
+    def backfind(path)
+      here(caller).backfind(path)
+    end
+
+    def tmpfile(basename = '', tmpdir = nil, options = nil)
+      tempfile = Tempfile.new(basename, *[tmpdir, options].compact)
+      file = new tempfile
+      if block_given?
+        begin
+          yield file
+        ensure
+          tempfile.close
+          tempfile.unlink if file.exist?
+        end
+      end
+      file
+    end
+    alias_method :tempfile, :tmpfile
+
+    def tmpdir(prefix_suffix = nil, *rest)
+      require 'tmpdir'
+      dir = new Dir.mktmpdir(prefix_suffix, *rest)
+      if block_given?
+        begin
+          yield dir
+        ensure
+          FileUtils.remove_entry_secure(dir) rescue nil
+        end
+      end
+      dir
+    end
+  end
+
+  def initialize(*parts)
+    path = parts.size > 1 ? parts.join(File::SEPARATOR) : parts.first
+    if Tempfile === path
+      @_tmpfile = path # We would not want it to be GC'd
+      @path = path.path
+    elsif String === path
+      @path = path.dup
+    else
+      @path = path.to_s
+    end
+    taint if @path.tainted?
+  end
+
+  def / part
+    join part.to_s
+  end
+
+  def base # basename(extname)
+    basename(extname)
+  end
+
+  def ext # extname without leading .
+    ext = extname
+    ext.empty? ? ext : ext[1..-1]
+  end
+
+  def without_extension # rm_ext
+    dir / base
+  end
+
+  # NOTE: Pathname has a similar feature named sub_ext
+  # It might be a better method name
+  def replace_extension(ext)
+    ext = ".#{ext}" unless ext.start_with? '.'
+    Path.new(without_extension.to_s + ext)
+  end
+
+  def entries
+    (Dir.entries(@path) - DOTS).map { |entry| Path.new(@path, entry).cleanpath }
+  end
+
+  def glob(pattern, flags = 0)
+    Dir.glob(join(pattern), flags).map(&Path)
+  end
+
+  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 mkdir_p
+    FileUtils.mkdir_p(@path)
+    self
+  end
+
+  def write(contents, open_args = nil)
+    if IO.respond_to? :write
+      IO.write(@path, contents, *[open_args].compact)
+    else
+      open('w', *[open_args].compact) { |f| f.write(contents) }
+    end
+  end
+
+  def append(contents, open_args = nil)
+    if IO.respond_to? :write
+      open_args = (Array(open_args) << {:mode => 'a'})
+      IO.write(@path, contents, *open_args.compact)
+    else
+      open('a', *[open_args].compact) { |f| f.write(contents) }
+    end
+  end
+
+  def to_sym
+    to_s.to_sym
+  end
+
+  def relative_to other
+    relative_path_from Path.new other
+  end
+  alias_method :%, :relative_to
+
+  def ancestors
+    ancestors = lambda do |y|
+      y << path = expand
+      until (path = path.parent).root?
+        y << path
+      end
+      y << path
+    end
+    RUBY_VERSION > '1.9' ? Enumerator.new(&ancestors) : ancestors.call([])
+  end
+
+  def backfind(path)
+    condition = path[/\[(.*)\]$/, 1] || ''
+    path = $` unless condition.empty?
+
+    result = ancestors.find { |ancestor| (ancestor/path/condition).exist? }
+    result/path if result
+  end
+
+  alias_method :expand, :expand_path
+  alias_method :dir, :dirname
+end
+
+EPath = Path # to meet everyone's expectations
+
+unless defined? NO_EPATH_GLOBAL_FUNCTION
+  def Path(*args)
+    Path.new(*args)
+  end
+end

data/lib/epath/implementation.rb

@@ -0,0 +1,873 @@
+# Path's low-level implementation based on Pathname
+
+require 'fileutils'
+
+class Path
+  # :stopdoc:
+  SAME_PATHS = if File::FNM_SYSCASE.nonzero?
+    proc {|a, b| a.casecmp(b).zero?}
+  else
+    proc {|a, b| a == b}
+  end
+
+  # :startdoc:
+
+  def freeze() super; @path.freeze; self end
+  def taint() super; @path.taint; self end
+  def untaint() super; @path.untaint; self end
+
+  #
+  # 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.
+  #
+  def == other
+    Path === other and @path == other.to_s
+  end
+  alias eql? ==
+
+  # Provides for comparing pathnames, case-sensitively.
+  def <=>(other)
+    return nil unless Path === other
+    @path.tr('/', "\0") <=> other.to_s.tr('/', "\0")
+  end
+
+  def hash # :nodoc:
+    @path.hash
+  end
+
+  # Return the path as a String.
+  def to_s
+    @path.dup
+  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 inspect
+    "#<Path #{@path}>"
+  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
+
+  # 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)
+  end
+
+  # chop_basename(path) -> [pre-basename, basename] or nil
+  def chop_basename(path)
+    base = File.basename(path)
+    if /\A#{SEPARATOR_PAT}?\z/o =~ 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)
+    names = []
+    while r = chop_basename(path)
+      path, basename = r
+      names.unshift basename
+    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
+    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
+    else
+      cleanpath_aggressive
+    end
+  end
+
+  #
+  # Clean the path simply by resolving and removing excess "." and ".." entries.
+  # Nothing more, nothing less.
+  #
+  def cleanpath_aggressive
+    path = @path
+    names = []
+    pre = path
+    while r = chop_basename(pre)
+      pre, base = r
+      case base
+      when '.'
+      when '..'
+        names.unshift base
+      else
+        if names[0] == '..'
+          names.shift
+        else
+          names.unshift base
+        end
+      end
+    end
+    if /#{SEPARATOR_PAT}/o =~ File.basename(pre)
+      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
+    names = []
+    pre = path
+    while r = chop_basename(pre)
+      pre, base = r
+      names.unshift base if base != '.'
+    end
+    if /#{SEPARATOR_PAT}/o =~ File.basename(pre)
+      names.shift while names[0] == '..'
+    end
+    if names.empty?
+      Path.new(File.dirname(pre))
+    else
+      if names.last != '..' && File.basename(path) == '.'
+        names << '.'
+      end
+      result = prepend_prefix(pre, File.join(*names))
+      if /\A(?:\.|\.\.)\z/ !~ names.last && has_trailing_separator?(path)
+        Path.new(add_trailing_separator(result))
+      else
+        Path.new(result)
+      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 = []
+      until unresolved.empty?
+        n = unresolved.shift
+        if n == '.'
+          next
+        elsif n == '..'
+          resolved.pop
+        else
+          path = prepend_prefix(prefix, File.join(*(resolved + [n])))
+          if h.include? path
+            if h[path] == :resolving
+              raise Errno::ELOOP.new(path)
+            else
+              prefix, *resolved = h[path]
+            end
+          else
+            begin
+              s = File.lstat(path)
+            rescue Errno::ENOENT => e
+              raise e if strict || !last || !unresolved.empty?
+              resolved << n
+              break
+            end
+            if s.symlink?
+              h[path] = :resolving
+              link_prefix, link_names = split_names(File.readlink(path))
+              if link_prefix == ''
+                prefix, *resolved = h[path] = realpath_rec(prefix, resolved + link_names, h, strict, unresolved.empty?)
+              else
+                prefix, *resolved = h[path] = realpath_rec(link_prefix, link_names, h, strict, unresolved.empty?)
+              end
+            else
+              resolved << n
+              h[path] = [prefix, *resolved]
+            end
+          end
+        end
+      end
+      return prefix, *resolved
+    end
+    private :realpath_rec
+
+    def real_path_internal(strict = false, basedir = nil)
+      path = @path
+      path = File.join(basedir, path) if basedir and relative?
+      prefix, names = split_names(path)
+      if prefix == ''
+        prefix, names2 = split_names(Dir.pwd)
+        names = names2 + names
+      end
+      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
+    prefix2 = path2
+    index_list2 = []
+    basename_list2 = []
+    while r2 = chop_basename(prefix2)
+      prefix2, basename2 = r2
+      index_list2.unshift prefix2.length
+      basename_list2.unshift basename2
+    end
+    return path2 if prefix2 != ''
+    prefix1 = path1
+    while true
+      while !basename_list2.empty? && basename_list2.first == '.'
+        index_list2.shift
+        basename_list2.shift
+      end
+      break unless r1 = chop_basename(prefix1)
+      prefix1, basename1 = r1
+      next if basename1 == '.'
+      if basename1 == '..' || basename_list2.empty? || basename_list2.first != '..'
+        prefix1 = prefix1 + basename1
+        break
+      end
+      index_list2.shift
+      basename_list2.shift
+    end
+    r1 = chop_basename(prefix1)
+    if !r1 && /#{SEPARATOR_PAT}/o =~ File.basename(prefix1)
+      while !basename_list2.empty? && basename_list2.first == '..'
+        index_list2.shift
+        basename_list2.shift
+      end
+    end
+    if !basename_list2.empty?
+      suffix2 = path2[index_list2.first..-1]
+      r1 ? File.join(prefix1, suffix2) : prefix1 + suffix2
+    else
+      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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: epath
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-07 00:00:00.000000000 Z
+date: 2011-12-16 00:00:00.000000000 Z
 dependencies: []
 description: 
-email: 
+email: eregontp@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/epath/implementation.rb
+- lib/epath.rb
+- README.md
+- LICENSE
 - epath.gemspec
-homepage: 
+homepage: https://github.com/eregon/epath
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -38,8 +42,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: summary
+summary: a Path manipulation library
 test_files: []