epath 0.3.0 → 0.4.0

data/README.md

@@ -164,10 +164,10 @@ String (not using a path library), Pathname, or another library.
 To this intend, [`Path + config`](http://rubydoc.info/github/eregon/epath/master/Path#%2B-class_method) allows to configure the behavior of `Path#+`.
 
 Coming from String, one should use `Path + :string`, and run ruby with the verbose option (`-w`),
-which will show were `+` is used as String concatenation.
+which will show where `+` is used as String concatenation.
 
 Coming from a path library using `+` as #join, one should just use the default (`Path + :warning`),
-which will show were `+` is used as #join.
+which will show where `+` is used.
 
 ## Status
 

data/lib/epath.rb

@@ -79,6 +79,7 @@ class Path
 
   # Whether +self+ is inside +ancestor+, such that +ancestor+ is an ancestor of +self+.
   # This is pure String manipulation. Paths should be absolute.
+  # +self+ is considered to be inside itself.
   def inside? ancestor
     @path == ancestor.to_s or @path.start_with?("#{ancestor}/")
   end

data/lib/epath/compatibility.rb

@@ -0,0 +1,60 @@
+class Path
+  private
+
+  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
+  else
+    def realpath_rec(prefix, unresolved, h, strict, last = true)
+      resolved = []
+      until unresolved.empty?
+        n = unresolved.shift
+        if n == '..'
+          resolved.pop
+        else
+          path = prepend_prefix(prefix, 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 == '' # if link is relative
+                link_prefix, link_names = prefix, resolved.concat(link_names)
+              end
+              prefix, *resolved = h[path] = realpath_rec(link_prefix, link_names, h, strict, unresolved.empty?)
+            else
+              resolved << n
+              h[path] = [prefix, *resolved]
+            end
+          end
+        end
+      end
+      return prefix, *resolved
+    end
+
+    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.concat(names)
+      end
+      prefix, *names = realpath_rec(prefix, names, {}, strict)
+      prepend_prefix(prefix, names)
+    end
+  end
+end

data/lib/epath/dir.rb

@@ -4,11 +4,11 @@ class Path
 
     # Returns or yields Path objects. See +Dir.glob+.
     # @yieldparam [Path] path
-    def glob(*args)
+    def glob(pattern, flags = 0)
       if block_given?
-        Dir.glob(*args) { |f| yield new(f) }
+        Dir.glob(pattern, flags) { |f| yield new(f) }
       else
-        Dir.glob(*args).map(&Path)
+        Dir.glob(pattern, flags).map(&Path)
       end
     end
 
@@ -58,7 +58,11 @@ class Path
   # Returns or yields Path objects. See +Dir.glob+.
   # @yieldparam [Path] path
   def glob(pattern, flags = 0)
-    Dir.glob(join(pattern), flags).map(&Path)
+    if block_given?
+      Dir.glob(join(pattern), flags) { |f| yield Path.new(f) }
+    else
+      Dir.glob(join(pattern), flags).map(&Path)
+    end
   end
 
   # Return the entries (files and subdirectories) in the directory.

data/lib/epath/file.rb

@@ -18,10 +18,14 @@ class Path
   end
 
   # Changes permissions of +path+. See +File.chmod+.
-  def chmod(mode) File.chmod(mode, @path) end
+  def chmod(mode)
+    File.chmod(mode, @path)
+  end
 
   # Changes permissions of +path+, not following symlink. See +File.lchmod+.
-  def lchmod(mode) File.lchmod(mode, @path) end
+  def lchmod(mode)
+    File.lchmod(mode, @path)
+  end
 
   # Changes the owner and group of the file. See +File.chown+.
   def chown(owner, group)
@@ -84,10 +88,23 @@ class Path
   end
 
   # Truncates the file to +length+ bytes. See +File.truncate+.
-  def truncate(length) File.truncate(@path, length) end
+  def truncate(length)
+    File.truncate(@path, length)
+  end
+
+  # Removes a file using +File.unlink+.
+  # This is incompatible with Pathname#unlink,
+  # which can also remove directories.
+  # Use {#rmdir} or {#rm_r} for directories.
+  def unlink
+    File.unlink @path
+  end
+  alias :delete :unlink
 
   # Updates the access and modification times. See +File.utime+.
-  def utime(atime, mtime) File.utime(atime, mtime, @path) end
+  def utime(atime, mtime)
+    File.utime(atime, mtime, @path)
+  end
 
   # Expands +path+, making it absolute.
   # If the path is relative, it is expanded with the current working directory,

data/lib/epath/identity.rb

@@ -4,8 +4,8 @@ class Path
 
     # Creates a new Path. See {#initialize}.
     def new(*args)
-      if args.size == 1 and Path === args[0]
-        args[0]
+      if args.size == 1 and Path === args.first
+        args.first
       else
         super(*args)
       end
@@ -18,10 +18,65 @@ class Path
     def to_proc
       lambda { |path| new(path) }
     end
+
+    # Whether +object+ looks like a path.
+    # The current test checks if the object responds to
+    # #to_path, #path or #to_str.
+    def like? object
+      [:to_path, :path, :to_str].any? { |meth| object.respond_to? meth }
+    end
+
+    # A matcher responding to #===. Useful for case clauses, grep, etc.
+    # See {Path.like?}.
+    #
+    #   case obj
+    #   when Path.like then Path(obj)
+    #   # ...
+    #   end
+    def like
+      @like ||= begin
+        matcher = Object.new
+        def matcher.===(object)
+          Path.like?(object)
+        end
+        matcher
+      end
+    end
   end
 
   # @!group Identity
 
+  # Creates a new Path.
+  # If multiple arguments are given, they are joined with File.join.
+  # The path will have File::ALT_SEPARATOR replaced with '/' and
+  # if it begins with a '~', it will be expanded (using File.expand_path).
+  # Accepts an Array of Strings, a Tempfile, anything that respond to #path,
+  # #to_path or #to_str with a String and defaults to calling #to_s.
+  #
+  # @param parts [Array<String>, Tempfile, #to_path, #path, #to_str, #to_s] the path-like object(s)
+  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
+      if path.respond_to? :to_path and String === path.to_path
+        path.to_path.dup
+      elsif path.respond_to? :path and String === path.path
+        path.path.dup
+      elsif path.respond_to? :to_str and String === path.to_str
+        path.to_str.dup
+      else
+        path.to_s.dup
+      end
+    end
+
+    init
+  end
+
   # Returns the +path+ as a String.
   # {#path} is implemented for better readability (+file.path+ instead of +file.to_s+) and as an accessor.
   # {#to_path} is implemented so Path objects are usable with +open+, etc.
@@ -59,11 +114,50 @@ class Path
   def inspect
     "#<Path #{@path}>"
   end
+
+  # YAML loading.
+  def yaml_initialize(tag, ivars)
+    @path = ivars['path']
+    init
+  end
+
+  # Psych loading.
+  def init_with(coder)
+    @path = coder['path']
+    init
+  end
+
+  # JSON dumping.
+  def to_json(*args)
+    {
+      'json_class' => 'Path',
+      'data'       => @path
+    }.to_json(*args)
+  end
+
+  # JSON loading.
+  def self.json_create json
+    new json['data']
+  end
+
+  # Marshal dumping.
+  def marshal_dump
+    @path
+  end
+
+  # Marshal loading.
+  def marshal_load path
+    @path = path
+    init
+  end
 end
 
 unless defined? NO_EPATH_GLOBAL_FUNCTION
-  # A shorthand method to create a {Path}. Same as {Path.new}.
-  def Path(*args)
-    Path.new(*args)
+  module Kernel
+    # A shorthand method to create a {Path}. Same as {Path.new}.
+    def Path(*args)
+      Path.new(*args)
+    end
+    private :Path
   end
 end

data/lib/epath/implementation.rb

@@ -8,61 +8,6 @@ class Path
     lambda { |a,b| a == b }
   end
 
-  # Creates a new Path.
-  # If multiple arguments are given, they are joined with File.join.
-  # The path will have File::ALT_SEPARATOR replaced with '/' and
-  # if it begins with a '~', it will be expanded (using File.expand_path).
-  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
-
-    init
-  end
-
-  # YAML loading.
-  def yaml_initialize(tag, ivars)
-    @path = ivars['path']
-    init
-  end
-
-  # Psych loading.
-  def init_with(coder)
-    @path = coder['path']
-    init
-  end
-
-  # JSON dumping.
-  def to_json(*args)
-    {
-      'json_class' => 'Path',
-      'data'       => @path
-    }.to_json(*args)
-  end
-
-  # JSON loading.
-  def self.json_create json
-    new json['data']
-  end
-
-  # Marshal dumping.
-  def marshal_dump
-    @path
-  end
-
-  # Marshal loading.
-  def marshal_load path
-    @path = path
-    init
-  end
-
   # Returns a cleaned version of +self+ with consecutive slashes and useless dots removed.
   # The filesystem is not accessed.
   #
@@ -143,16 +88,13 @@ class Path
   #   path0.join(path1, ..., pathN)
   #   # is the same as
   #   path0 / path1 / ... / pathN
-  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
+  def join(*paths)
+    result = nil
+    paths.reverse_each { |path|
+      result = Path.new(path) / result
       return result if result.absolute?
     }
-    result
+    self / result
   end
 
   # #relative_path_from returns a relative path from the argument to the
@@ -163,37 +105,23 @@ class Path
   #
   # ArgumentError is raised when it cannot find a relative path.
   def relative_path_from(base_directory)
-    dest_directory = clean.path
-    base_directory = Path.new(base_directory).clean.path
-    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
+    dest = clean.path
+    base = Path.new(base_directory).clean.path
+    dest_prefix, dest_names = split_names(dest)
+    base_prefix, base_names = split_names(base)
+
     unless SAME_PATHS[dest_prefix, base_prefix]
-      raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}"
+      raise ArgumentError, "different prefix: #{self.inspect} and #{base_directory.inspect}"
     end
-    until dest_names.empty? or base_names.empty? or !SAME_PATHS[dest_names.first, base_names.first]
+    while d = dest_names.first and b = base_names.first and SAME_PATHS[d, b]
       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
+    raise ArgumentError, "base_directory has ..: #{base_directory.inspect}" if base_names.include? '..'
+    # the number of names left in base is the ones we have to climb
+    names = base_names.fill('..').concat(dest_names)
+    return Path.new('.') if names.empty?
+    Path.new(*names)
   end
   alias :relative_to :relative_path_from
   alias :% :relative_path_from
@@ -243,41 +171,43 @@ class Path
     end
   end
 
+  def is_absolute?(path)
+    path.start_with?('/') or (path =~ /\A[a-zA-Z]:\// and is_root?($&))
+  end
+
+  def is_root?(path)
+    chop_basename(path) == nil and path.include?('/')
+  end
+
   # split_names(path) -> prefix, [name, ...]
   def split_names(path)
     names = []
     while r = chop_basename(path)
       path, basename = r
-      names.unshift basename
+      names.unshift basename if basename != '.'
     end
     return path, names
   end
 
-  def prepend_prefix(prefix, relpath)
+  def prepend_prefix(prefix, relnames)
+    relpath = File.join(*relnames)
     if relpath.empty?
       File.dirname(prefix)
     elsif prefix.include? '/'
-      add_trailing_separator(File.dirname(prefix)) + relpath
+      # safe because File.dirname returns a new String
+      add_trailing_separator(File.dirname(prefix)) << relpath
     else
       prefix + relpath
     end
   end
 
   def has_trailing_separator?(path)
-    if r = chop_basename(path)
-      pre, basename = r
-      pre.length + basename.length < path.length
-    else
-      false
-    end
+    !is_root?(path) and path.end_with?('/')
   end
 
-  def add_trailing_separator(path)
-    if File.basename(path + 'a') == 'a'
-      path
-    else
-      path + '/'
-    end
+  def add_trailing_separator(path) # mutates path
+    path << '/' unless path.end_with? '/'
+    path
   end
 
   def del_trailing_separator(path)
@@ -291,51 +221,41 @@ class Path
     end
   end
 
+  # remove '..' segments since root's parent is root
+  def remove_root_parents(prefix, names)
+    names.shift while names.first == '..' if is_root?(prefix)
+  end
+
   # Clean the path simply by resolving and removing excess "." and ".." entries.
   # Nothing more, nothing less.
   def cleanpath_aggressive
-    path = @path
+    pre = @path
     names = []
-    pre = path
     while r = chop_basename(pre)
       pre, base = r
-      case base
-      when '.'
-      when '..'
-        names.unshift base
+      if base == '.'
+        # do nothing, it can be ignored
+      elsif names.first == '..' and base != '..'
+        # base can be ignored as we go back to its parent
+        names.shift
       else
-        if names[0] == '..'
-          names.shift
-        else
-          names.unshift base
-        end
+        names.unshift base
       end
     end
-    if File.basename(pre).include? '/'
-      names.shift while names[0] == '..'
-    end
-    Path.new(prepend_prefix(pre, File.join(*names)))
+    remove_root_parents(pre, names)
+    Path.new(prepend_prefix(pre, names))
   end
 
   def cleanpath_conservative
     path = @path
-    names = []
-    pre = path
-    while r = chop_basename(pre)
-      pre, base = r
-      names.unshift base if base != '.'
-    end
-    if File.basename(pre).include? '/'
-      names.shift while names[0] == '..'
-    end
+    pre, names = split_names(path)
+    remove_root_parents(pre, names)
     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)
+      names << '.' if names.last != '..' and File.basename(path) == '.'
+      result = prepend_prefix(pre, names)
+      if names.last != '.' and names.last != '..' and has_trailing_separator?(path)
         Path.new(add_trailing_separator(result))
       else
         Path.new(result)
@@ -343,104 +263,31 @@ class Path
     end
   end
 
-  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
-  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
+  def plus(prefix, rel)
+    return rel if is_absolute?(rel)
+    _, names = split_names(rel)
 
-    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
-  end
+    loop do
+      # break if that was the last segment
+      break unless r = chop_basename(prefix)
+      prefix, name = r
+      next if name == '.'
 
-  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 if we can't resolve anymore
+      if name == '..' or names.first != '..'
+        prefix << name
         break
       end
-      index_list2.shift
-      basename_list2.shift
+      names.shift
     end
-    r1 = chop_basename(prefix1)
-    if !r1 && File.basename(prefix1).include?('/')
-      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
+
+    remove_root_parents(prefix, names)
+    has_prefix = chop_basename(prefix)
+    if names.empty?
+      has_prefix ? prefix : File.dirname(prefix)
     else
-      r1 ? prefix1 : File.dirname(prefix1)
+      suffix = File.join(*names)
+      has_prefix ? File.join(prefix, suffix) : prefix + suffix
     end
   end
 end

data/lib/epath/parts.rb

@@ -101,9 +101,7 @@ class Path
   # @yieldparam [Path] path
   def descend
     return to_enum(:descend) unless block_given?
-    vs = []
-    ascend { |v| vs << v }
-    vs.reverse_each { |v| yield v }
+    ascend.reverse_each { |v| yield v }
     nil
   end
 

data/lib/epath/predicates.rb

@@ -3,16 +3,12 @@ class Path
 
   # Whether a path is absolute.
   def absolute?
-    !relative?
+    is_absolute?(@path)
   end
 
   # Whether a path is relative.
   def relative?
-    path = @path
-    while r = chop_basename(path)
-      path, = r
-    end
-    path == ''
+    not absolute?
   end
 
   # #root? is a predicate for root directories. I.e. it returns +true+ if the
@@ -21,7 +17,7 @@ class Path
   # It doesn't access actual filesystem. So it may return +false+ for some
   # paths which points to roots such as +/usr/..+.
   def root?
-    !!(chop_basename(@path) == nil && @path.include?('/'))
+    is_root?(@path)
   end
 
   # #mountpoint? returns +true+ if +self+ points to a mountpoint.

data/lib/epath/require_tree.rb

@@ -1,22 +1,42 @@
 class Path
   # @!group Requiring
 
-  # Requires all .rb files recursively (in alphabetic order)
-  # under +directory+ (or this file's directory if not given).
-  def self.require_tree(directory = nil)
-    if directory
-      new(directory).require_tree
-    else
-      file = Path.file(caller)
-      file.dir.require_tree(file)
-    end
-  end
+  # Requires all .rb files recursively under +directory+
+  # (or the current file's directory if not given).
+  #
+  # The order of requires is alphabetical,
+  # but files having the same basename as a directory
+  # are required before files in this directory.
+  #
+  #   # in bar.rb
+  #   Path.require_tree
+  #   # require in this order:
+  #   # foo.rb
+  #   # foo/ext.rb
+  #   # foo/sub.rb
+  #
+  # @param directory [String] the directory to search,
+  #                           or the current file's directory.
+  # @option options [Array<String>] :except ([])
+  #   a list of prefixes to ignore, relative to +directory+.
+  def self.require_tree(directory = nil, options = {})
+    directory, options = nil, directory if Hash === directory
+    source = Path.file(caller)
+    directory = Path.relative(directory || source.dir, caller)
+    except = options[:except] || []
 
-  # @api private
-  # See {Path.require_tree}.
-  # It is not a real private method because {Path.require_tree}
-  # (so the {Path} class) needs to be able to call it.
-  def require_tree(source = nil)
-    glob('**/*.rb').sort.each { |file| require file.expand(dir).path unless file == source }
+    directory.glob('**/*.rb').reject { |path|
+      except.any? { |prefix| (path % directory).path.start_with?(prefix) }
+    }.sort! { |a,b|
+      if b.inside?(a.rm_ext)
+        -1
+      elsif a.inside?(b.rm_ext)
+        +1
+      else
+        a <=> b
+      end
+    }.each { |file|
+      require file.path unless source == file
+    }
   end
 end

data/lib/epath/version.rb

@@ -1,5 +1,5 @@
 class Path
   # The version of the gem.
   # Set here to avoid duplication and allow introspection.
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,41 +1,49 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: epath
-version: !ruby/object:Gem::Version
-  version: 0.3.0
+version: !ruby/object:Gem::Version 
+  hash: 15
   prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
-authors:
+authors: 
 - eregon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-12 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-07-04 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
 description: 
 email: eregontp@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
+- lib/epath/compatibility.rb
 - lib/epath/dir.rb
 - lib/epath/file.rb
-- lib/epath/file_dir.rb
 - lib/epath/file_predicates.rb
 - lib/epath/fileutils.rb
 - lib/epath/find.rb
@@ -51,29 +59,39 @@ files:
 - README.md
 - LICENSE
 - epath.gemspec
+has_rdoc: true
 homepage: https://github.com/eregon/epath
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: a Path manipulation library
 test_files: []
-has_rdoc: 
+

data/lib/epath/file_dir.rb

@@ -1,12 +0,0 @@
-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