facets 1.4.0 → 1.4.1

data/forge/more/ostructable.rb

@@ -0,0 +1,212 @@
+#--
+# OpenStructable
+#
+# Copyright (c) 2005 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# ==========================================================================
+# Revision History ::
+# --------------------------------------------------------------------------
+# 05.04.28  Trans
+#   - Minor modifications to documentation.
+# ==========================================================================
+#
+# TODO
+# Keep this uptodate with ostruct.rb.
+#
+# TODO Ask Matz
+# See if Matz will accept it into core so we don't have to anymore.
+#
+# TODO Marshalling
+# As with OpenStruct, marshalling is problematic at the moment.
+#
+#++
+
+#:title: OpenStructable
+#
+# OpensStructable is a mixin module which can provide OpenStruct behavior to
+# any class or object. OpenStructable allows extention of data objects
+# with arbitrary attributes.
+#
+# == Usage
+#
+#   require 'mega/ostructable'
+#
+#   class Record
+#     include OpenStructable
+#   end
+#
+#   record = Record.new
+#   record.name    = "John Smith"
+#   record.age     = 70
+#   record.pension = 300
+#
+#   puts record.name     # -> "John Smith"
+#   puts record.address  # -> nil
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+# * Yukihiro Matsumoto
+# * Gavin Sinclair (Documentation)
+#
+
+module OpenStructable
+
+  def initialize(hash=nil)
+    @__table__ = {}
+    if hash
+      for k,v in hash
+        @__table__[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  # duplicate an OpenStruct object members.
+  def initialize_copy(orig)
+    super
+    @__table__ = @__table__.dup
+  end
+
+  def marshal_dump
+    @table
+  end
+  def marshal_load(x)
+    @table = x
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  def new_ostruct_member(name)
+    unless self.respond_to?(name)
+      self.instance_eval %{
+        def #{name}; @__table__[:#{name}]; end
+        def #{name}=(x); @__table__[:#{name}] = x; end
+      }
+    end
+  end
+
+  #
+  # Generate additional attributes and values.
+  #
+  def update(hash)
+    @__table__ ||= {}
+    if hash
+      for k,v in hash
+        @__table__[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  def method_missing(mid, *args) # :nodoc:
+    mname = mid.to_s
+    len = args.length
+    if mname =~ /=$/
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+      end
+      if self.frozen?
+        raise TypeError, "can't modify frozen #{self.class}", caller(1)
+      end
+      mname.chop!
+      @__table__ ||= {}
+      @__table__[mname.intern] = args[0]
+      self.new_ostruct_member(mname)
+    elsif len == 0
+      @__table__ ||= {}
+      @__table__[mid]
+    else
+      raise NoMethodError, "undefined method `#{mname}' for #{self}", caller(1)
+    end
+  end
+
+  #
+  # Remove the named field from the object.
+  #
+  def delete_field(name)
+    @__table__ ||= {}
+    @__table__.delete name.to_sym
+  end
+
+  #
+  # Returns a string containing a detailed summary of the keys and values.
+  #
+  def inspect
+    str = "<#{self.class}"
+    for k,v in (@__table__ ||= {})
+      str << " #{k}=#{v.inspect}"
+    end
+    str << ">"
+  end
+
+  def __table__ # :nodoc:
+    @__table__ ||= {}
+  end
+  protected :__table__
+
+  # Compare this object and +other+ for equality.
+  def ==(other)
+    return false unless(other.kind_of?(OpenStruct))
+    return @__table__ == other.table
+  end
+
+end
+
+=begin
+#
+# It is possibe to implement OpenStruct itself with
+# this OpenStructable module as follows:
+#
+class OpenStruct
+  include OpenStructable
+end
+=end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  # fixture
+
+  class Record
+    include OpenStructable
+  end
+
+  # test
+
+  class TC_OpenStructable < Test::Unit::TestCase
+
+    def test_record
+      record = nil
+      assert_nothing_raised {
+        record = Record.new
+        record.name    = "John Smith"
+        record.age     = 70
+        record.pension = 300
+      }
+      assert_equal( "John Smith", record.name )
+      assert_equal( 70, record.age )
+      assert_equal( nil, record.address )
+    end
+
+  end
+
+=end

data/forge/more/pairhash.rb

@@ -0,0 +1,55 @@
+
+class PairHash
+
+  def initialize( *args )
+    @outer = Hash.new([])
+  end
+
+  def add_entry( x, y, z )
+    a = [y,z]
+    @outer[x] << a
+    a
+  end
+
+  def del_entry( x, y=nil )
+    if y
+      @outer[x].reject! { |e| e[0] == y }
+    else
+      @outer.delete(x)
+    end
+  end
+
+  def inner_value?( v, x, y ) 
+    @outer[x].select { |e| e == [y,v] }
+  end
+
+end
+
+
+# test
+
+if $0 == __FILE__
+
+  require 'test/unit'
+
+  class TC < Test::Unit::TestCase
+
+    def setup
+      @ph = ::PairHash.new
+    end
+  
+    def test01
+      @ph.add_entry( "x", "aa", 2 )
+      @ph.add_entry( "x", "aa", 3 )
+      @ph.add_entry( "x", "bb", "boo" )
+    end
+   
+    def test02
+      assert( @ph.inner_value?( 3, "x", "aa" ) )
+    end
+   
+  end
+
+end
+
+

data/forge/more/pathname.rb

@@ -0,0 +1,1309 @@
+# = pathname.rb
+#
+# Object-Oriented Pathname Class
+#
+# Author:: Tanaka Akira <akr@m17n.org>
+# Documentation:: Author and Gavin Sinclair
+#
+# For documentation, see class Pathname.
+#
+# <tt>pathname.rb</tt> is distributed with Ruby since 1.8.0.
+#
+
+# THIS IS AN IMPROVED VERSION THAT USES AN ARRAY INSTEAD OF A STRING FOR PATH.
+
+#
+# == Pathname
+#
+# Pathname represents a pathname which locates a file in a filesystem.
+# It supports only Unix style pathnames.  It does not represent the file
+# itself.  A Pathname can be relative or absolute.  It's not until you try to
+# reference the file that it even matters whether the file exists or not.
+#
+# Pathname is immutable.  It has no method for destructive update.
+#
+# The value of this class is to manipulate file path information in a neater
+# way than standard Ruby provides.  The examples below demonstrate the
+# difference.  *All* functionality from File, FileTest, and some from Dir and
+# FileUtils is included, in an unsurprising way.  It is essentially a facade for
+# all of these, and more.
+#
+# == Examples
+#
+# === Example 1: Using Pathname
+#
+#   require 'pathname'
+#   p = Pathname.new("/usr/bin/ruby")
+#   size = p.size              # 27662
+#   isdir = p.directory?       # false
+#   dir  = p.dirname           # Pathname:/usr/bin
+#   base = p.basename          # Pathname:ruby
+#   dir, base = p.split        # [Pathname:/usr/bin, Pathname:ruby]
+#   data = p.read
+#   p.open { |f| _ } 
+#   p.each_line { |line| _ }
+#
+# === Example 2: Using standard Ruby
+#
+#   p = "/usr/bin/ruby"
+#   size = File.size(p)        # 27662
+#   isdir = File.directory?(p) # false
+#   dir  = File.dirname(p)     # "/usr/bin"
+#   base = File.basename(p)    # "ruby"
+#   dir, base = File.split(p)  # ["/usr/bin", "ruby"]
+#   data = File.read(p)
+#   File.open(p) { |f| _ } 
+#   File.foreach(p) { |line| _ }
+#
+# === Example 3: Special features
+#
+#   p1 = Pathname.new("/usr/lib")   # Pathname:/usr/lib
+#   p2 = p1 + "ruby/1.8"            # Pathname:/usr/lib/ruby/1.8
+#   p3 = p1.parent                  # Pathname:/usr
+#   p4 = p2.relative_path_from(p3)  # Pathname:lib/ruby/1.8
+#   pwd = Pathname.pwd              # Pathname:/home/gavin
+#   pwd.absolute?                   # true
+#   p5 = Pathname.new "."           # Pathname:.
+#   p5 = p5 + "music/../articles"   # Pathname:music/../articles
+#   p5.cleanpath                    # Pathname:articles
+#   p5.realpath                     # Pathname:/home/gavin/articles
+#   p5.children                     # [Pathname:/home/gavin/articles/linux, ...]
+# 
+# == Breakdown of functionality
+#
+# === Core methods
+#
+# These methods are effectively manipulating a String, because that's all a path
+# is.  Except for #mountpoint?, #children, and #realpath, they don't access the
+# filesystem.
+#
+# - +
+# - #join
+# - #parent
+# - #root?
+# - #absolute?
+# - #relative?
+# - #relative_path_from
+# - #each_filename
+# - #cleanpath
+# - #realpath
+# - #children
+# - #mountpoint?
+#
+# === File status predicate methods
+#
+# These methods are a facade for FileTest:
+# - #blockdev?
+# - #chardev?
+# - #directory?
+# - #executable?
+# - #executable_real?
+# - #exist?
+# - #file?
+# - #grpowned?
+# - #owned?
+# - #pipe?
+# - #readable?
+# - #readable_real?
+# - #setgid?
+# - #setuid?
+# - #size
+# - #size?
+# - #socket?
+# - #sticky?
+# - #symlink?
+# - #writable?
+# - #writable_real?
+# - #zero?
+#
+# === File property and manipulation methods
+#
+# These methods are a facade for File:
+# - #atime
+# - #ctime
+# - #mtime
+# - #chmod(mode)
+# - #lchmod(mode)
+# - #chown(owner, group)
+# - #lchown(owner, group)
+# - #fnmatch(pattern, *args)
+# - #fnmatch?(pattern, *args)
+# - #ftype
+# - #make_link(old)
+# - #open(*args, &block)
+# - #readlink
+# - #rename(to)
+# - #stat
+# - #lstat
+# - #make_symlink(old)
+# - #truncate(length)
+# - #utime(atime, mtime)
+# - #basename(*args)
+# - #dirname
+# - #extname
+# - #expand_path(*args)
+# - #split
+#
+# === Directory methods
+#
+# These methods are a facade for Dir:
+# - Pathname.glob(*args)
+# - Pathname.getwd / Pathname.pwd
+# - #rmdir
+# - #entries
+# - #each_entry(&block)
+# - #mkdir(*args)
+# - #opendir(*args)
+#
+# === IO
+#
+# These methods are a facade for IO:
+# - #each_line(*args, &block)
+# - #read(*args)
+# - #readlines(*args)
+# - #sysopen(*args)
+#
+# === Utilities
+#
+# These methods are a mixture of Find, FileUtils, and others:
+# - #find(&block)
+# - #mkpath
+# - #rmtree
+# - #unlink / #delete
+#
+#
+# == Method documentation
+#
+# As the above section shows, most of the methods in Pathname are facades.  The
+# documentation for these methods generally just says, for instance, "See
+# FileTest.writable?", as you should be familiar with the original method
+# anyway, and its documentation (e.g. through +ri+) will contain more
+# information.  In some cases, a brief description will follow.
+#
+class Pathname
+
+  class << self
+
+    def create( path=[], abs=false, trail=false )
+      o = self.allocate
+      o.instance_variable_set("@path", path.dup)
+      o.instance_variable_set("@absolute", abs ? true : false)
+      o.instance_variable_set("@trail", trail ? true : false)
+      o
+    end
+
+    def [](path)
+      new(path)
+    end
+  end
+
+  # Create a Pathname object from the given String (or String-like object).
+  # If +path+ contains a NUL character (<tt>\0</tt>), an ArgumentError is raised.
+  #
+  def initialize(*path)
+    path = path.join('/')
+    @absolute = path[0,1] == '/' ? true : false
+    @trail = (path.size > 1 and path[-1,1] == '/') ? true : false
+    @path = path.split(%r{/})
+    @path.delete('')
+
+    #case path
+    #when Pathname
+    #  @path = path.pathlist.dup
+    #  @absolute = path.absolute?
+    #when Array
+    #  @path = path.collect{|e| e.to_str}
+    #  @absolute = absolute
+    #else
+    #  path = path.to_str if path.respond_to?(:to_str)
+    #  raise ArgumentError, "pathname contains \\0: #{@path.inspect}" if /\0/ =~ @path
+    #  @path = path.split(%r{/})
+    #  @path.unshift('') if path[0,1] == '/'  # absolute path
+    #end
+
+    self.taint if path.tainted?
+  end
+
+  def freeze() super; @path.freeze; self end
+  def taint() super; @path.taint; self end
+  def untaint() super; @path.untaint; self end
+
+  # Stores the array of the componet parts of the pathname.
+  #
+  # protected
+  def pathlist
+    @path
+  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)
+    return false unless Pathname === other
+    if @absolute
+      return false unless other.absolute?
+    end
+    @path == other.pathlist
+  end
+  alias_method :===, :==
+  alias_method :eql?, :==
+
+  # Provides for comparing pathnames, case-sensitively.
+  def <=>(other)
+    return nil unless Pathname === other
+    return 1 if absolute? and not other.absolute?
+    return -1 if other.absolute? and not absolute?
+    r = @path <=> other.pathlist
+    return r unless r == 0
+    return 1 if trail? and not other.trail?
+    return -1 if other.trail? and not trail?
+    0
+  end
+
+  def hash # :nodoc:
+    to_s.hash
+  end
+
+  # Return the path as a String (same as to_s).
+  def path
+    s = ''
+    s << '/' if @absolute
+    s << @path.join('/')
+    s << '/' if @trail
+    s << '.' if s.empty?
+    s
+  end
+
+  # Return the path as a String (same as pathname).
+  def to_s
+    s = ''
+    s << '/' if @absolute
+    s << @path.join('/')
+    s << '/' if @trail
+    s << '.' if s.empty?
+    s
+  end
+
+  # to_str is implemented so Pathname objects are usable with File.open, etc.
+  alias_method :to_str, :to_s
+
+  def inspect # :nodoc:
+    "#<#{self.class}: #{to_s}>"
+  end
+
+  # append directory or file name to path
+  def <<(name)
+    name = name.to_str
+    @path << name unless name.strip.empty?
+    @path
+  end
+
+  #
+  # 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
+    # cleanpath_aggressive assumes:
+    # * no symlink
+    # * all pathname prefix contained in the pathname is existing directory
+    return Pathname.create([],@absolute,@trail) if path.empty?
+    absolute = absolute?
+    trail = trail?
+    names = []
+    @path.each {|name|
+      next if name == '.'
+      if name == '..'
+        if names.empty?
+          next if absolute
+        else
+          if names.last != '..'
+            names.pop
+            next
+          end
+        end
+      end
+      names << name
+    }
+    return Pathname.new(absolute ? '/' : '.') if names.empty?
+    #path = []
+    #path << '' if absolute
+    #path.concat(names)
+    Pathname.create(names, absolute) #, trail)
+  end
+  private :cleanpath_aggressive
+
+  def cleanpath_conservative
+    return Pathname.create([],@absolute) if @path.empty?
+    names = @path.dup #.scan(%r{[^/]+})
+    last_dot = (names.last == '.')
+    names.delete('.')
+    names.shift while names.first == '..' if absolute?
+    return Pathname.new(absolute? ? '/' : '.') if names.empty?
+    newpath = []
+    trail = false
+    #newpath << '' if absolute?
+    newpath.concat(names)
+    if names.last != '..'
+      if last_dot
+        newpath << '.'
+      elsif trail? #%r{/\z} =~ @path  #HOW TO DEAL WITH TRAILING '/' ?
+        trail = true
+      end
+    end
+    Pathname.create(newpath, absolute?, trail)
+  end
+  private :cleanpath_conservative
+
+  #
+  # Returns a real (absolute) pathname of +self+ in the actual filesystem.
+  # The real pathname doesn't contain symlinks or useless dots.
+  #
+  # No arguments should be given; the old behaviour is *obsoleted*. 
+  #
+  def realpath(*args)
+    unless args.empty?
+      warn "The argument for Pathname#realpath is obsoleted."
+    end
+    force_absolute = args.fetch(0, true)
+
+    if @path.first == ''
+      top = '/'
+      unresolved = @path.slice(1..-1) #.scan(%r{[^/]+})
+    elsif force_absolute
+      # Although POSIX getcwd returns a pathname which contains no symlink,
+      # 4.4BSD-Lite2 derived getcwd may return the environment variable $PWD
+      # which may contain a symlink.
+      # So the return value of Dir.pwd should be examined.
+      top = '/'
+      unresolved = Dir.pwd.split(%r{/}) + @path
+    else
+      top = ''
+      unresolved = @path.dup #.scan(%r{[^/]+})
+    end
+    resolved = []
+
+    until unresolved.empty?
+      case unresolved.last
+      when '.'
+        unresolved.pop
+      when '..'
+        resolved.unshift unresolved.pop
+      else
+        loop_check = {}
+        while (stat = File.lstat(path = top + unresolved.join('/'))).symlink?
+          symlink_id = "#{stat.dev}:#{stat.ino}"
+          raise Errno::ELOOP.new(path) if loop_check[symlink_id]
+          loop_check[symlink_id] = true
+          if %r{\A/} =~ (link = File.readlink(path))
+            top = '/'
+            unresolved = link.split(%r{/}) #scan(%r{[^/]+})
+          else
+            unresolved[-1,1] = link.split(%r{/}) #.scan(%r{[^/]+})
+          end
+        end
+        next if (filename = unresolved.pop) == '.'
+        if filename != '..' && resolved.first == '..'
+          resolved.shift
+        else
+          resolved.unshift filename
+        end
+      end
+    end
+
+    if top == '/'
+      resolved.shift while resolved[0] == '..'
+    end
+
+    if resolved.empty?
+      Pathname.new(top.empty? ? '.' : '/')
+    else
+      if top.empty?
+        Pathname.new(resolved)
+      else
+        Pathname.new(resolved, true)
+      end
+    end
+  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 = self.lstat
+      stat2 = self.parent.lstat
+      stat1.dev == stat2.dev && stat1.ino == stat2.ino ||
+        stat1.dev != stat2.dev
+    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?
+    #%r{\A/+\z} =~ @path ? true : false
+    @absolute and @path.empty?
+  end
+
+  def current?
+    #%r{\A/+\z} =~ @path ? true : false
+    (!@absolute) and @path.empty?
+  end
+
+  # Predicate method for testing whether a path is absolute.
+  # It returns +true+ if the pathname begins with a slash.
+  def absolute?
+    #%r{\A/} =~ @path ? true : false
+    @absolute
+  end
+
+  # The opposite of #absolute?
+  def relative?
+    !@absolute
+  end
+
+  def trail?
+    @trail
+  end
+
+  #
+  # Iterates over each component of the path.
+  #
+  #   Pathname.new("/usr/bin/ruby").each_filename {|filename| ... }
+  #     # yields "usr", "bin", and "ruby".
+  #
+  def each_filename # :yield: e
+    #@path.scan(%r{[^/]+}) { yield $& }
+    @path.each { |e| yield e }
+  end
+
+  #
+  # Pathname#+ appends a pathname fragment to this one to produce a new Pathname
+  # object.
+  #
+  #   p1 = Pathname.new("/usr")      # Pathname:/usr
+  #   p2 = p1 + "bin/ruby"           # Pathname:/usr/bin/ruby
+  #   p3 = p1 + "/etc/passwd"        # Pathname:/etc/passwd
+  #
+  # This method doesn't access the file system; it is pure string manipulation. 
+  #
+  def +(other)
+    File.join( to_s,other )
+
+    #other = Pathname.new(other) unless Pathname === other
+    #return other if other.absolute?
+    #pth = (@path + other.pathlist)
+    #pth.delete('.')
+    #Pathname.create(pth, @absolute, other.trail?)
+
+#    path1 = @path#
+#    path2 = other.to_s
+#    while m2 = %r{\A\.\.(?:/+|\z)}.match(path2) and
+#          m1 = %r{(\A|/+)([^/]+)\z}.match(path1) and
+#          %r{\A(?:\.|\.\.)\z} !~ m1[2]
+#      path1 = m1[1].empty? ? '.' : '/' if (path1 = m1.pre_match).empty?
+#      path2 = '.' if (path2 = m2.post_match).empty?
+#    end
+#    if %r{\A/+\z} =~ path1
+#      while m2 = %r{\A\.\.(?:/+|\z)}.match(path2)
+#        path2 = '.' if (path2 = m2.post_match).empty?
+#      end
+#    end
+#
+#    return Pathname.new(path2) if path1 == '.'
+#    return Pathname.new(path1) if path2 == '.'
+#
+#    if %r{/\z} =~ path1
+#      Pathname.new(path1 + path2)
+#    else
+#      Pathname.new(path1 + '/' + path2)
+#    end
+  end
+
+  #
+  # Pathname#join joins pathnames.
+  #
+  # <tt>path0.join(path1, ..., pathN)</tt> is the same as
+  # <tt>path0 + path1 + ... + pathN</tt>.
+  #
+  # HELP ME!!!
+  #
+  def join(*args)
+    Pathname.new(*args)
+    #args.unshift self
+    #result = args.pop
+    #result = Pathname.new(result) unless Pathname === result
+    #return result if result.absolute?
+    #args.reverse_each {|arg|
+    #  arg = Pathname.new(arg) unless Pathname === 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 Pathname 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:
+  #   p = Pathname("/usr/lib/ruby/1.8")
+  #   p.children
+  #       # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
+  #              Pathname:/usr/lib/ruby/1.8/Env.rb,
+  #              Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
+  #   p.children(false)
+  #       # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]
+  #
+  # Note that the result never contain the entries <tt>.</tt> and <tt>..</tt> in
+  # the directory because they are not children.
+  #
+  # This method has existed since 1.8.1.
+  #
+  def children(with_directory=true)
+    with_directory = false if @path == ['.']
+    result = []
+    Dir.foreach(to_s) {|e|
+      next if e == '.' || e == '..'
+      if with_directory
+        result << Pathname.create(@path + [e], absolute?)
+      else
+        result << Pathname.new(e)
+      end
+    }
+    result
+  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.
+  #
+  # This method has existed since 1.8.1.
+  #
+  def relative_path_from(base_directory)
+    if self.absolute? != base_directory.absolute?
+      raise ArgumentError,
+        "relative path between absolute and relative path: #{self.inspect}, #{base_directory.inspect}"
+    end
+
+    dest = []
+    self.cleanpath.each_filename {|f|
+      next if f == '.'
+      dest << f
+    }
+
+    base = []
+    base_directory.cleanpath.each_filename {|f|
+      next if f == '.'
+      base << f
+    }
+
+    while !base.empty? && !dest.empty? && base[0] == dest[0]
+      base.shift
+      dest.shift
+    end
+
+    if base.include? '..'
+      raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
+    end
+
+    base.fill '..'
+    relpath = base + dest
+    if relpath.empty?
+      Pathname.new('.')
+    else
+      Pathname.create(relpath, false) #.join('/'))
+    end
+  end
+
+end
+
+
+class Pathname    # * IO *
+  #
+  # #each_line iterates over the line in the file.  It yields a String object
+  # for each line.
+  #
+  # This method has existed since 1.8.1.
+  #
+  def each_line(*args, &block) # :yield: line
+    IO.foreach(path, *args, &block)
+  end
+
+  # Pathname#foreachline is *obsoleted* at 1.8.1.  Use #each_line.
+  def foreachline(*args, &block)
+    warn "Pathname#foreachline is obsoleted.  Use Pathname#each_line."
+    each_line(*args, &block)
+  end
+
+  # See <tt>IO.read</tt>.  Returns all the bytes from the file, or the first +N+
+  # if specified.
+  def read(*args) IO.read(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 Pathname    # * 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() Pathname.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) Pathname.new(File.basename(path, *args)) end
+
+  # See <tt>File.dirname</tt>.  Returns all but the last component of the path.
+  def dirname() Pathname.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) Pathname.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| Pathname.new(f) } end
+
+  # Pathname#link is confusing and *obsoleted* because the receiver/argument
+  # order is inverted to corresponding system call.
+  def link(old)
+    warn 'Pathname#link is obsoleted.  Use Pathname#make_link.'
+    File.link(old, path)
+  end
+
+  # Pathname#symlink is confusing and *obsoleted* because the receiver/argument
+  # order is inverted to corresponding system call.
+  def symlink(old)
+    warn 'Pathname#symlink is obsoleted.  Use Pathname#make_symlink.'
+    File.symlink(old, path)
+  end
+end
+
+
+class Pathname    # * 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
+
+  # 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
+
+  # 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 Pathname    # * Dir *
+  # See <tt>Dir.glob</tt>.  Returns or yields Pathname objects.
+  def Pathname.glob(*args) # :yield: p
+    if block_given?
+      Dir.glob(*args) {|f| yield Pathname.new(f) }
+    else
+      Dir.glob(*args).map {|f| Pathname.new(f) }
+    end
+  end
+
+  # See <tt>Dir.getwd</tt>.  Returns the current working directory as a Pathname.
+  def Pathname.getwd() Pathname.new(Dir.getwd) end
+  class << self; alias pwd getwd end
+
+  # Pathname#chdir is *obsoleted* at 1.8.1.
+  def chdir(&block)
+    warn "Pathname#chdir is obsoleted.  Use Dir.chdir."
+    Dir.chdir(path, &block)
+  end
+
+  # Pathname#chroot is *obsoleted* at 1.8.1.
+  def chroot
+    warn "Pathname#chroot is obsoleted.  Use Dir.chroot."
+    Dir.chroot(path)
+  end
+
+  # Return the entries (files and subdirectories) in the directory, each as a
+  # Pathname object.
+  def entries() Dir.entries(path).map {|f| Pathname.new(f) } end
+
+  # Iterates over the entries (files and subdirectories) in the directory.  It
+  # yields a Pathname object for each entry.
+  #
+  # This method has existed since 1.8.1.
+  def each_entry(&block) # :yield: p
+    Dir.foreach(path) {|f| yield Pathname.new(f) }
+  end
+
+  # Pathname#dir_foreach is *obsoleted* at 1.8.1.
+  def dir_foreach(*args, &block)
+    warn "Pathname#dir_foreach is obsoleted.  Use Pathname#each_entry."
+    each_entry(*args, &block)
+  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 Pathname    # * Find *
+  #
+  # Pathname#find is an iterator to traverse a directory tree in a depth first
+  # manner.  It yields a Pathname 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 traverse.
+  #
+  # If +self+ is <tt>.</tt>, yielded pathnames begin with a filename in the
+  # current directory, not <tt>./</tt>.
+  #
+  def find(&block) # :yield: p
+    require 'find'
+    if @path == ['.']
+      Find.find(path) {|f| yield Pathname.new(f.sub(%r{\A\./}, '')) }
+    else
+      Find.find(path) {|f| yield Pathname.new(f) }
+    end
+  end
+end
+
+
+class Pathname    # * FileUtils *
+  # See <tt>FileUtils.mkpath</tt>.  Creates a full path, including any
+  # intermediate directories that don't yet exist.
+  def mkpath
+    require 'fileutils'
+    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".
+    require 'fileutils'
+    FileUtils.rm_r(path)
+    nil
+  end
+end
+
+
+class Pathname    # * 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
+
+  # This method is *obsoleted* at 1.8.1.  Use #each_line or #each_entry.
+  def foreach(*args, &block)
+    warn "Pathname#foreach is obsoleted.  Use each_line or each_entry."
+    if FileTest.directory? path
+      # For polymorphism between Dir.foreach and IO.foreach,
+      # Pathname#foreach doesn't yield Pathname object.
+      Dir.foreach(path, *args, &block)
+    else
+      IO.foreach(path, *args, &block)
+    end
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+if $0 == __FILE__
+  require 'test/unit'
+
+  class PathnameTest < Test::Unit::TestCase # :nodoc:
+    def test_initialize
+      p1 = Pathname.new('a')
+      assert_equal('a', p1.to_s)
+      p2 = Pathname.new(p1)
+      assert_equal(p1, p2)
+    end
+
+    class AnotherStringLike # :nodoc:
+      def initialize(s) @s = s end
+      def to_str() @s end
+      def ==(other) @s == other end
+    end
+
+    def test_equality
+      obj = Pathname.new("a")
+      str = "a"
+      sym = :a
+      ano = AnotherStringLike.new("a")
+      assert_equal(false, obj == str)
+      assert_equal(false, str == obj)
+      assert_equal(false, obj == ano)
+      assert_equal(false, ano == obj)
+      assert_equal(false, obj == sym)
+      assert_equal(false, sym == obj)
+
+      obj2 = Pathname.new("a")
+      assert_equal(true, obj == obj2)
+      assert_equal(true, obj === obj2)
+      assert_equal(true, obj.eql?(obj2))
+    end
+
+    def test_hashkey
+      h = {}
+      h[Pathname.new("a")] = 1
+      h[Pathname.new("a")] = 2
+      assert_equal(1, h.size)
+    end
+
+    def assert_pathname_cmp(e, s1, s2)
+      p1 = Pathname.new(s1)
+      p2 = Pathname.new(s2)
+      r = p1 <=> p2
+      assert(e == r,
+        "#{p1.inspect} <=> #{p2.inspect}: <#{e}> expected but was <#{r}>")
+    end
+    def test_comparison
+      assert_pathname_cmp( 0, "a", "a")
+      assert_pathname_cmp( 1, "b", "a")
+      assert_pathname_cmp(-1, "a", "b")
+      ss = %w(
+        a
+        a/
+        a/b
+        a.
+        a0
+      )
+      s1 = ss.shift
+      ss.each {|s2|
+        assert_pathname_cmp(-1, s1, s2)
+        s1 = s2
+      }
+    end
+
+    def test_comparison_string
+      assert_equal(nil, Pathname.new("a") <=> "a")
+      assert_equal(nil, "a" <=> Pathname.new("a"))
+    end
+
+    def test_syntactical
+      assert_equal(true, Pathname.new("/").root?)
+      assert_equal(true, Pathname.new("//").root?)
+      assert_equal(true, Pathname.new("///").root?)
+      assert_equal(false, Pathname.new("").root?)
+      assert_equal(false, Pathname.new("a").root?)
+    end
+
+    def test_paths
+      assert_equal('/', Pathname.new('/').to_s)
+      assert_equal('a/', Pathname.new('a/').to_s)
+      assert_equal('/a', Pathname.new('/a').to_s)
+      assert_equal('.', Pathname.new('.').to_s)
+      assert_equal('..', Pathname.new('..').to_s)
+    end
+
+    def test_cleanpath
+
+      assert_equal('/', Pathname.new('/').cleanpath(true).to_s)
+      assert_equal('/', Pathname.new('//').cleanpath(true).to_s)
+      assert_equal('', Pathname.new('').cleanpath(true).to_s)
+
+      assert_equal('.', Pathname.new('.').cleanpath(true).to_s)
+      assert_equal('..', Pathname.new('..').cleanpath(true).to_s)
+      assert_equal('a', Pathname.new('a').cleanpath(true).to_s)
+      assert_equal('/', Pathname.new('/.').cleanpath(true).to_s)
+      assert_equal('/', Pathname.new('/..').cleanpath(true).to_s)
+      assert_equal('/a', Pathname.new('/a').cleanpath(true).to_s)
+      assert_equal('.', Pathname.new('./').cleanpath(true).to_s)
+      assert_equal('..', Pathname.new('../').cleanpath(true).to_s)
+      assert_equal('a/', Pathname.new('a/').cleanpath(true).to_s)
+
+      assert_equal('a/b', Pathname.new('a//b').cleanpath(true).to_s)
+      assert_equal('a/.', Pathname.new('a/.').cleanpath(true).to_s)
+      assert_equal('a/.', Pathname.new('a/./').cleanpath(true).to_s)
+      assert_equal('a/..', Pathname.new('a/../').cleanpath(true).to_s)
+      assert_equal('/a/.', Pathname.new('/a/.').cleanpath(true).to_s)
+      assert_equal('..', Pathname.new('./..').cleanpath(true).to_s)
+      assert_equal('..', Pathname.new('../.').cleanpath(true).to_s)
+      assert_equal('..', Pathname.new('./../').cleanpath(true).to_s)
+      assert_equal('..', Pathname.new('.././').cleanpath(true).to_s)
+      assert_equal('/', Pathname.new('/./..').cleanpath(true).to_s)
+      assert_equal('/', Pathname.new('/../.').cleanpath(true).to_s)
+      assert_equal('/', Pathname.new('/./../').cleanpath(true).to_s)
+      assert_equal('/', Pathname.new('/.././').cleanpath(true).to_s)
+
+      assert_equal('a/b/c', Pathname.new('a/b/c').cleanpath(true).to_s)
+      assert_equal('b/c', Pathname.new('./b/c').cleanpath(true).to_s)
+      assert_equal('a/c', Pathname.new('a/./c').cleanpath(true).to_s)
+      assert_equal('a/b/.', Pathname.new('a/b/.').cleanpath(true).to_s)
+      assert_equal('a/..', Pathname.new('a/../.').cleanpath(true).to_s)
+
+      assert_equal('/a', Pathname.new('/../.././../a').cleanpath(true).to_s)
+      assert_equal('a/b/../../../../c/../d',
+        Pathname.new('a/b/../../../../c/../d').cleanpath(true).to_s)
+    end
+
+    def test_cleanpath_no_symlink
+      assert_equal('/', Pathname.new('/').cleanpath.to_s)
+      assert_equal('/', Pathname.new('//').cleanpath.to_s)
+      assert_equal('', Pathname.new('').cleanpath.to_s)
+
+      assert_equal('.', Pathname.new('.').cleanpath.to_s)
+      assert_equal('..', Pathname.new('..').cleanpath.to_s)
+      assert_equal('a', Pathname.new('a').cleanpath.to_s)
+      assert_equal('/', Pathname.new('/.').cleanpath.to_s)
+      assert_equal('/', Pathname.new('/..').cleanpath.to_s)
+      assert_equal('/a', Pathname.new('/a').cleanpath.to_s)
+      assert_equal('.', Pathname.new('./').cleanpath.to_s)
+      assert_equal('..', Pathname.new('../').cleanpath.to_s)
+      assert_equal('a', Pathname.new('a/').cleanpath.to_s)
+
+      assert_equal('a/b', Pathname.new('a//b').cleanpath.to_s)
+      assert_equal('a', Pathname.new('a/.').cleanpath.to_s)
+      assert_equal('a', Pathname.new('a/./').cleanpath.to_s)
+      assert_equal('.', Pathname.new('a/../').cleanpath.to_s)
+      assert_equal('/a', Pathname.new('/a/.').cleanpath.to_s)
+      assert_equal('..', Pathname.new('./..').cleanpath.to_s)
+      assert_equal('..', Pathname.new('../.').cleanpath.to_s)
+      assert_equal('..', Pathname.new('./../').cleanpath.to_s)
+      assert_equal('..', Pathname.new('.././').cleanpath.to_s)
+      assert_equal('/', Pathname.new('/./..').cleanpath.to_s)
+      assert_equal('/', Pathname.new('/../.').cleanpath.to_s)
+      assert_equal('/', Pathname.new('/./../').cleanpath.to_s)
+      assert_equal('/', Pathname.new('/.././').cleanpath.to_s)
+
+      assert_equal('a/b/c', Pathname.new('a/b/c').cleanpath.to_s)
+      assert_equal('b/c', Pathname.new('./b/c').cleanpath.to_s)
+      assert_equal('a/c', Pathname.new('a/./c').cleanpath.to_s)
+      assert_equal('a/b', Pathname.new('a/b/.').cleanpath.to_s)
+      assert_equal('.', Pathname.new('a/../.').cleanpath.to_s)
+
+      assert_equal('/a', Pathname.new('/../.././../a').cleanpath.to_s)
+      assert_equal('../../d', Pathname.new('a/b/../../../../c/../d').cleanpath.to_s)
+    end
+
+    def test_destructive_update
+      path = Pathname.new("a")
+      path.to_s.replace "b"
+      assert_equal(Pathname.new("a"), path)
+    end
+
+    #def test_null_character
+    #  assert_raise(ArgumentError) { Pathname.new("\0") }
+    #end
+
+    def assert_relpath(result, dest, base)
+      assert_equal(Pathname.new(result),
+        Pathname.new(dest).relative_path_from(Pathname.new(base)))
+    end
+
+    def assert_relpath_err(dest, base)
+      assert_raise(ArgumentError) {
+        Pathname.new(dest).relative_path_from(Pathname.new(base))
+      }
+    end
+
+    def test_relative_path_from
+      assert_relpath("../a", "a", "b")
+      assert_relpath("../a", "a", "b/")
+      assert_relpath("../a", "a/", "b")
+      assert_relpath("../a", "a/", "b/")
+      assert_relpath("../a", "/a", "/b")
+      assert_relpath("../a", "/a", "/b/")
+      assert_relpath("../a", "/a/", "/b")
+      assert_relpath("../a", "/a/", "/b/")
+
+      assert_relpath("../b", "a/b", "a/c")
+      assert_relpath("../a", "../a", "../b")
+
+      assert_relpath("a", "a", ".")
+      assert_relpath("..", ".", "a")
+
+      assert_relpath(".", ".", ".")
+      assert_relpath(".", "..", "..")
+      assert_relpath("..", "..", ".")
+
+      assert_relpath("c/d", "/a/b/c/d", "/a/b")
+      assert_relpath("../..", "/a/b", "/a/b/c/d")
+      assert_relpath("../../../../e", "/e", "/a/b/c/d")
+      assert_relpath("../b/c", "a/b/c", "a/d")
+
+      assert_relpath("../a", "/../a", "/b")
+      assert_relpath("../../a", "../a", "b")
+      assert_relpath(".", "/a/../../b", "/b")
+      assert_relpath("..", "a/..", "a")
+      assert_relpath(".", "a/../b", "b")
+
+      assert_relpath("a", "a", "b/..")
+      assert_relpath("b/c", "b/c", "b/..")
+
+      assert_relpath_err("/", ".")
+      assert_relpath_err(".", "/")
+      assert_relpath_err("a", "..")
+      assert_relpath_err(".", "..")
+    end
+
+    def assert_pathname_plus(a, b, c)
+      a = Pathname.new(a)
+      b = Pathname.new(b)
+      c = Pathname.new(c)
+      d = b + c
+      assert(a == d,
+        "#{b.inspect} + #{c.inspect}: #{a.inspect} expected but was #{d.inspect}")
+    end
+
+    def test_plus
+      assert_pathname_plus('a/b', 'a', 'b')
+      assert_pathname_plus('a', 'a', '.')
+      assert_pathname_plus('b', '.', 'b')
+      assert_pathname_plus('.', '.', '.')
+      assert_pathname_plus('/b', 'a', '/b')
+
+      assert_pathname_plus('/', '/', '..')
+      assert_pathname_plus('.', 'a', '..')
+      assert_pathname_plus('a', 'a/b', '..')
+      assert_pathname_plus('../..', '..', '..')
+      assert_pathname_plus('/c', '/', '../c')
+      assert_pathname_plus('c', 'a', '../c')
+      assert_pathname_plus('a/c', 'a/b', '../c')
+      assert_pathname_plus('../../c', '..', '../c')
+    end
+
+    def test_taint
+      obj = Pathname.new("a"); assert_same(obj, obj.taint)
+      obj = Pathname.new("a"); assert_same(obj, obj.untaint)
+
+      assert_equal(false, Pathname.new("a"      )           .tainted?)
+      assert_equal(false, Pathname.new("a"      )      .to_s.tainted?)
+      assert_equal(true,  Pathname.new("a"      ).taint     .tainted?)
+      assert_equal(true,  Pathname.new("a"      ).taint.to_s.tainted?)
+      assert_equal(true,  Pathname.new("a".taint)           .tainted?)
+      assert_equal(true,  Pathname.new("a".taint)      .to_s.tainted?)
+      assert_equal(true,  Pathname.new("a".taint).taint     .tainted?)
+      assert_equal(true,  Pathname.new("a".taint).taint.to_s.tainted?)
+
+      str = "a"
+      path = Pathname.new(str)
+      str.taint
+      assert_equal(false, path     .tainted?)
+      assert_equal(false, path.to_s.tainted?)
+    end
+
+    def test_untaint
+      obj = Pathname.new("a"); assert_same(obj, obj.untaint)
+
+      assert_equal(false, Pathname.new("a").taint.untaint     .tainted?)
+      assert_equal(false, Pathname.new("a").taint.untaint.to_s.tainted?)
+
+      str = "a".taint
+      path = Pathname.new(str)
+      str.untaint
+      assert_equal(true, path     .tainted?)
+      assert_equal(true, path.to_s.tainted?)
+    end
+
+    def test_freeze
+      obj = Pathname.new("a"); assert_same(obj, obj.freeze)
+
+      assert_equal(false, Pathname.new("a"       )            .frozen?)
+      assert_equal(false, Pathname.new("a".freeze)            .frozen?)
+      assert_equal(true,  Pathname.new("a"       ).freeze     .frozen?)
+      assert_equal(true,  Pathname.new("a".freeze).freeze     .frozen?)
+      assert_equal(false, Pathname.new("a"       )       .to_s.frozen?)
+      assert_equal(false, Pathname.new("a".freeze)       .to_s.frozen?)
+      assert_equal(false, Pathname.new("a"       ).freeze.to_s.frozen?)
+      assert_equal(false, Pathname.new("a".freeze).freeze.to_s.frozen?)
+    end
+
+    def test_to_s
+      str = "a"
+      obj = Pathname.new(str)
+      assert_equal(str, obj.to_s)
+      assert_not_same(str, obj.to_s)
+      assert_not_same(obj.to_s, obj.to_s)
+    end
+
+    def test_kernel_open
+      count = 0
+      stat1 = File.stat(__FILE__)
+      result = Kernel.open(Pathname.new(__FILE__)) {|f|
+        stat2 = f.stat
+        assert_equal(stat1.dev, stat2.dev)
+        assert_equal(stat1.ino, stat2.ino)
+        assert_equal(stat1.size, stat2.size)
+        count += 1
+        2
+      }
+      assert_equal(1, count)
+      assert_equal(2, result)
+    end
+  end
+end