fakefs 0.5.4 → 0.6.0

data/lib/fakefs/kernel.rb

@@ -1,29 +1,31 @@
 module FakeFS
+  # Kernel Module
   module Kernel
+    @captives = { original: {}, hijacked: {} }
 
-    @captives = { :original => {}, :hijacked => {}}
     class << self
       attr_accessor :captives
     end
 
     def self.hijack!
-      captives[:hijacked].each do |name,prc|
+      captives[:hijacked].each do |name, prc|
         ::Kernel.send(:define_method, name.to_sym, &prc)
       end
     end
 
     def self.unhijack!
-      captives[:original].each do |name,prc|
-        ::Kernel.send(:define_method, name.to_sym, Proc.new do |*args, &block|
+      captives[:original].each do |name, _prc|
+        ::Kernel.send(:define_method, name.to_sym, proc do |*args, &block|
           ::FakeFS::Kernel.captives[:original][name].call(*args, &block)
         end)
       end
     end
 
     private
-    def self.hijack name, &block
+
+    def self.hijack(name, &block)
       captives[:original][name] = ::Kernel.method(name.to_sym)
-      captives[:hijacked][name] = block || Proc.new { |args| }
+      captives[:hijacked][name] = block || proc { |_args| }
     end
 
     hijack :open do |*args, &block|
@@ -35,6 +37,5 @@ module FakeFS
         FakeFS::File.open(name, *args, &block)
       end
     end
-
   end
 end

data/lib/fakefs/pathname.rb

@@ -1,6 +1,7 @@
+# FakeFS module
 module FakeFS
-  if RUBY_VERSION >= "1.9.3"
-  
+  if RUBY_VERSION >= '1.9.3'
+
     #
     # = pathname.rb - From MRI 1.9.2
     #
@@ -12,52 +13,68 @@ module FakeFS
     # For documentation, see class Pathname.
     #
     class Pathname
-
-      # to_path is implemented so Pathname objects are usable with File.open, etc.
+      # to_path is implemented so Pathname objects are
+      # usable with File.open, etc.
       TO_PATH = :to_path
 
       SAME_PATHS = if File::FNM_SYSCASE.nonzero?
-        proc {|a, b| a.casecmp(b).zero?}
-      else
-        proc {|a, b| a == b}
-      end
+                     proc { |a, b| a.casecmp(b).zero? }
+                   else
+                     proc { |a, b| a == b }
+                   end
 
       # :startdoc:
 
       #
       # 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.
+      # If +path+ contains a NUL character (<tt>\0</tt>),
+      # an ArgumentError is raised.
       #
       def initialize(path)
         path = path.__send__(TO_PATH) if path.respond_to? TO_PATH
         @path = path.dup
 
         if /\0/ =~ @path
-          raise ArgumentError, "pathname contains \\0: #{@path.inspect}"
+          fail ArgumentError, "pathname contains \\0: #{@path.inspect}"
         end
 
-        self.taint if @path.tainted?
+        taint if @path.tainted?
+      end
+
+      def freeze
+        super
+        @path.freeze
+        self
       end
 
-      def freeze() super; @path.freeze; self end
-      def taint() super; @path.taint; self end
-      def untaint() super; @path.untaint; 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.
+      # 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
+        return false unless other.is_a?(Pathname)
         other.to_s == @path
       end
-      alias === ==
-      alias eql? ==
+
+      alias_method :===, :==
+      alias_method :eql?, :==
 
       # Provides for comparing pathnames, case-sensitively.
       def <=>(other)
-        return nil unless Pathname === other
+        return nil unless other.is_a?(Pathname)
         @path.tr('/', "\0") <=> other.to_s.tr('/', "\0")
       end
 
@@ -70,7 +87,8 @@ module FakeFS
         @path.dup
       end
 
-      # to_path is implemented so Pathname objects are usable with File.open, etc.
+      # to_path is implemented so Pathname objects are usable
+      # with File.open, etc.
       alias_method TO_PATH, :to_s
 
       def inspect # :nodoc:
@@ -80,16 +98,17 @@ module FakeFS
       # Return a pathname which is substituted by String#sub.
       def sub(pattern, *rest, &block)
         if block
-          path = @path.sub(pattern, *rest) {|*args|
+          path = @path.sub(pattern, *rest) do |*args|
             begin
               old = Thread.current[:pathname_sub_matchdata]
-              Thread.current[:pathname_sub_matchdata] = $~
-              eval("$~ = Thread.current[:pathname_sub_matchdata]", block.binding)
+              Thread.current[:pathname_sub_matchdata] = $LAST_MATCH_INFO
+              eval('$~ = Thread.current[:pathname_sub_matchdata]',
+                   block.binding)
             ensure
               Thread.current[:pathname_sub_matchdata] = old
             end
             yield(*args)
-          }
+          end
         else
           path = @path.sub(pattern, *rest)
         end
@@ -97,7 +116,8 @@ module FakeFS
       end
 
       if File::ALT_SEPARATOR
-        SEPARATOR_LIST = "#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}"
+        SEPARATOR_LIST = "#{Regexp.quote File::ALT_SEPARATOR}" \
+        "#{Regexp.quote File::SEPARATOR}"
         SEPARATOR_PAT = /[#{SEPARATOR_LIST}]/
       else
         SEPARATOR_LIST = "#{Regexp.quote File::SEPARATOR}"
@@ -127,12 +147,14 @@ module FakeFS
       # split_names(path) -> prefix, [name, ...]
       def split_names(path)
         names = []
-        while r = chop_basename(path)
+        while (r = chop_basename(path))
           path, basename = r
           names.unshift basename
         end
-        return path, names
+
+        [path, names]
       end
+
       private :split_names
 
       def prepend_prefix(prefix, relpath)
@@ -140,7 +162,7 @@ module FakeFS
           File.dirname(prefix)
         elsif /#{SEPARATOR_PAT}/o =~ prefix
           prefix = File.dirname(prefix)
-          prefix = File.join(prefix, "") if File.basename(prefix + 'a') != 'a'
+          prefix = File.join(prefix, '') if File.basename(prefix + 'a') != 'a'
           prefix + relpath
         else
           prefix + relpath
@@ -148,15 +170,16 @@ module FakeFS
       end
       private :prepend_prefix
 
-      # Returns clean pathname of +self+ with consecutive slashes and useless dots
-      # removed.  The filesystem is not accessed.
+      # 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.
+      # 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)
+      def cleanpath(consider_symlink = false)
         if consider_symlink
           cleanpath_conservative
         else
@@ -165,14 +188,15 @@ module FakeFS
       end
 
       #
-      # Clean the path simply by resolving and removing excess "." and ".." entries.
+      # 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)
+        while (r = chop_basename(pre))
           pre, base = r
           case base
           when '.'
@@ -193,29 +217,31 @@ module FakeFS
       end
       private :cleanpath_aggressive
 
-      # has_trailing_separator?(path) -> bool
-      def has_trailing_separator?(path)
-        if r = chop_basename(path)
+      # trailing_separator?(path) -> bool
+      def 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?
+
+      private :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?
+          # xxx: Is File.join is appropriate to add separator?
+          File.join(path, '')
         end
       end
       private :add_trailing_separator
 
       def del_trailing_separator(path)
-        if r = chop_basename(path)
+        if (r = chop_basename(path))
           pre, basename = r
           pre + basename
         elsif /#{SEPARATOR_PAT}+\z/o =~ path
@@ -230,7 +256,7 @@ module FakeFS
         path = @path
         names = []
         pre = path
-        while r = chop_basename(pre)
+        while (r = chop_basename(pre))
           pre, base = r
           names.unshift base if base != '.'
         end
@@ -240,11 +266,10 @@ module FakeFS
         if names.empty?
           self.class.new(File.dirname(pre))
         else
-          if names.last != '..' && File.basename(path) == '.'
-            names << '.'
-          end
+          names << '.' if names.last != '..' && File.basename(path) == '.'
+
           result = prepend_prefix(pre, File.join(*names))
-          if /\A(?:\.|\.\.)\z/ !~ names.last && has_trailing_separator?(path)
+          if /\A(?:\.|\.\.)\z/ !~ names.last && trailing_separator?(path)
             self.class.new(add_trailing_separator(result))
           else
             self.class.new(result)
@@ -260,7 +285,7 @@ module FakeFS
       # All components of the pathname must exist when this method is
       # called.
       #
-      def realpath(basedir=nil)
+      def realpath(basedir = nil)
         self.class.new(File.realpath(@path, basedir))
       end
 
@@ -270,7 +295,7 @@ module FakeFS
       #
       # The last component of the real pathname can be nonexistent.
       #
-      def realdirpath(basedir=nil)
+      def realdirpath(basedir = nil)
         self.class.new(File.realdirpath(@path, basedir))
       end
 
@@ -283,9 +308,9 @@ module FakeFS
 
       # #mountpoint? returns +true+ if <tt>self</tt> points to a mountpoint.
       def mountpoint?
+        stat1 = lstat
         begin
-          stat1 = self.lstat
-          stat2 = self.parent.lstat
+          stat2 = parent.lstat
           stat1.dev == stat2.dev && stat1.ino == stat2.ino ||
             stat1.dev != stat2.dev
         rescue Errno::ENOENT
@@ -294,14 +319,15 @@ module FakeFS
       end
 
       #
-      # #root? is a predicate for root directories.  I.e. it returns +true+ if the
+      # #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)
+        !(chop_basename(@path).nil? && /#{SEPARATOR_PAT}/o =~ @path).nil?
       end
 
       # Predicate method for testing whether a path is absolute.
@@ -313,8 +339,8 @@ module FakeFS
       # The opposite of #absolute?
       def relative?
         path = @path
-        while r = chop_basename(path)
-          path, basename = r
+        while (r = chop_basename(path))
+          path, _basename = r
         end
         path == ''
       end
@@ -322,27 +348,27 @@ module FakeFS
       #
       # Iterates over each component of the path.
       #
-      #   Pathname.new("/usr/bin/ruby").each_filename {|filename| ... }
+      #   Pathname.new("/usr/bin/ruby").each_filename { |filename| ... }
       #     # yields "usr", "bin", and "ruby".
       #
       def each_filename # :yield: filename
         return to_enum(__method__) unless block_given?
-        prefix, names = split_names(@path)
-        names.each {|filename| yield filename }
+        _prefix, names = split_names(@path)
+        names.each { |filename| yield filename }
         nil
       end
 
       # Iterates over and yields a new Pathname object
       # for each element in the given path in descending order.
       #
-      #  Pathname.new('/path/to/some/file.rb').descend {|v| p v}
+      #  Pathname.new('/path/to/some/file.rb').descend { |v| p v}
       #     #<Pathname:/>
       #     #<Pathname:/path>
       #     #<Pathname:/path/to>
       #     #<Pathname:/path/to/some>
       #     #<Pathname:/path/to/some/file.rb>
       #
-      #  Pathname.new('path/to/some/file.rb').descend {|v| p v}
+      #  Pathname.new('path/to/some/file.rb').descend { |v| p v}
       #     #<Pathname:path>
       #     #<Pathname:path/to>
       #     #<Pathname:path/to/some>
@@ -354,22 +380,22 @@ module FakeFS
       #
       def descend
         vs = []
-        ascend {|v| vs << v }
-        vs.reverse_each {|v| yield v }
+        ascend { |v| vs << v }
+        vs.reverse_each { |v| yield v }
         nil
       end
 
       # Iterates over and yields a new Pathname object
       # for each element in the given path in ascending order.
       #
-      #  Pathname.new('/path/to/some/file.rb').ascend {|v| p v}
+      #  Pathname.new('/path/to/some/file.rb').ascend { |v| p v}
       #     #<Pathname:/path/to/some/file.rb>
       #     #<Pathname:/path/to/some>
       #     #<Pathname:/path/to>
       #     #<Pathname:/path>
       #     #<Pathname:/>
       #
-      #  Pathname.new('path/to/some/file.rb').ascend {|v| p v}
+      #  Pathname.new('path/to/some/file.rb').ascend { |v| p v}
       #     #<Pathname:path/to/some/file.rb>
       #     #<Pathname:path/to/some>
       #     #<Pathname:path/to>
@@ -382,25 +408,27 @@ module FakeFS
       def ascend
         path = @path
         yield self
-        while r = chop_basename(path)
-          path, name = r
+        while (r = chop_basename(path))
+          path, _name = r
           break if path.empty?
           yield self.class.new(del_trailing_separator(path))
         end
       end
 
       #
-      # Pathname#+ appends a pathname fragment to this one to produce a new Pathname
+      # 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.
+      # This method doesn't access the file system; it is pure string
+      # manipulation.
       #
       def +(other)
-        other = Pathname.new(other) unless Pathname === other
+        other = Pathname.new(other) unless other.is_a?(Pathname)
         Pathname.new(plus(@path, other.to_s))
       end
 
@@ -408,28 +436,33 @@ module FakeFS
         prefix2 = path2
         index_list2 = []
         basename_list2 = []
-        while r2 = chop_basename(prefix2)
+        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 (r1 = chop_basename(prefix1))
           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
+          if basename1 == '..' ||
+              basename_list2.empty? ||
+              basename_list2.first != '..'
+            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 == '..'
@@ -437,6 +470,7 @@ module FakeFS
             basename_list2.shift
           end
         end
+
         if !basename_list2.empty?
           suffix2 = path2[index_list2.first..-1]
           r1 ? File.join(prefix1, suffix2) : prefix1 + suffix2
@@ -455,13 +489,13 @@ module FakeFS
       def join(*args)
         args.unshift self
         result = args.pop
-        result = Pathname.new(result) unless Pathname === result
+        result = Pathname.new(result) unless result.is_a?(Pathname)
         return result if result.absolute?
-        args.reverse_each {|arg|
-          arg = Pathname.new(arg) unless Pathname === arg
+        args.reverse_each do |arg|
+          arg = Pathname.new(arg) unless arg.is_a?(Pathname)
           result = arg + result
           return result if result.absolute?
-        }
+        end
         result
       end
 
@@ -469,44 +503,50 @@ module FakeFS
       # 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
+      # +with_directory+ to +false+, then the returned
+      # pathnames will contain the
       # filename only.
       #
       # For example:
       #   pn = Pathname("/usr/lib/ruby/1.8")
       #   pn.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, ... ]
+      #     # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
+      #            Pathname:/usr/lib/ruby/1.8/Env.rb,
+      #            Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
       #   pn.children(false)
-      #       # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]
+      #     # -> [ Pathname:English.rb,
+      #            Pathname:Env.rb,
+      #            Pathname:abbrev.rb, ... ]
       #
-      # Note that the result never contain the entries <tt>.</tt> and <tt>..</tt> in
+      # 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)
+      def children(with_directory = true)
         with_directory = false if @path == '.'
         result = []
-        Dir.foreach(@path) {|e|
+        Dir.foreach(@path) do |e|
           next if e == '.' || e == '..'
           if with_directory
             result << self.class.new(File.join(@path, e))
           else
             result << self.class.new(e)
           end
-        }
+        end
         result
       end
 
       # Iterates over the children of the directory
       # (files and subdirectories, not recursive).
       # It yields Pathname 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.
+      # 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.
       #
-      #   Pathname("/usr/local").each_child {|f| p f }
+      #   Pathname("/usr/local").each_child { |f| p f }
       #   #=> #<Pathname:/usr/local/share>
       #   #   #<Pathname:/usr/local/bin>
       #   #   #<Pathname:/usr/local/games>
@@ -516,7 +556,7 @@ module FakeFS
       #   #   #<Pathname:/usr/local/src>
       #   #   #<Pathname:/usr/local/man>
       #
-      #   Pathname("/usr/local").each_child(false) {|f| p f }
+      #   Pathname("/usr/local").each_child(false) { |f| p f }
       #   #=> #<Pathname:share>
       #   #   #<Pathname:bin>
       #   #   #<Pathname:games>
@@ -526,38 +566,40 @@ module FakeFS
       #   #   #<Pathname:src>
       #   #   #<Pathname:man>
       #
-      def each_child(with_directory=true, &b)
+      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
+      # 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.
+      # #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)
-        dest_directory = self.cleanpath.to_s
+        dest_directory = cleanpath.to_s
         base_directory = base_directory.cleanpath.to_s
         dest_prefix = dest_directory
         dest_names = []
-        while r = chop_basename(dest_prefix)
+        while (r = chop_basename(dest_prefix)) == true
           dest_prefix, basename = r
           dest_names.unshift basename if basename != '.'
         end
         base_prefix = base_directory
         base_names = []
-        while r = chop_basename(base_prefix)
+        while (r = chop_basename(base_prefix)) == true
           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}"
+          fail ArgumentError, "different prefix: #{dest_prefix.inspect} " \
+          "and #{base_directory.inspect}"
         end
         while !dest_names.empty? &&
               !base_names.empty? &&
@@ -566,7 +608,7 @@ module FakeFS
           base_names.shift
         end
         if base_names.include? '..'
-          raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
+          fail ArgumentError, "base_directory has ..: #{base_directory.inspect}"
         end
         base_names.fill('..')
         relpath_names = base_names + dest_names
@@ -578,10 +620,11 @@ module FakeFS
       end
     end
 
+    # Pathname class
     class Pathname    # * IO *
       #
-      # #each_line iterates over the line in the file.  It yields a String object
-      # for each line.
+      # #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.
       #
@@ -589,58 +632,88 @@ module FakeFS
         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.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.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
+      def readlines(*args)
+        IO.readlines(@path, *args)
+      end
 
       # See <tt>IO.sysopen</tt>.
-      def sysopen(*args) IO.sysopen(@path, *args) end
+      def sysopen(*args)
+        IO.sysopen(@path, *args)
+      end
     end
 
-
+    # Pathnam class
     class Pathname    # * File *
-
       # See <tt>File.atime</tt>.  Returns last access time.
-      def atime() File.atime(@path) end
+      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.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
+      def mtime
+        File.mtime(@path)
+      end
 
       # See <tt>File.chmod</tt>.  Changes permissions.
-      def chmod(mode) File.chmod(mode, @path) end
+      def chmod(mode)
+        File.chmod(mode, @path)
+      end
 
       # See <tt>File.lchmod</tt>.
-      def lchmod(mode) File.lchmod(mode, @path) end
+      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
+      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
+      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>.  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
+      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
+      def ftype
+        File.ftype(@path)
+      end
 
       # See <tt>File.link</tt>.  Creates a hard link.
-      def make_link(old) File.link(old, @path) end
+      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
@@ -648,151 +721,233 @@ module FakeFS
       end
 
       # See <tt>File.readlink</tt>.  Read symbolic link.
-      def readlink() self.class.new(File.readlink(@path)) end
+      def readlink
+        self.class.new(File.readlink(@path))
+      end
 
       # See <tt>File.rename</tt>.  Rename the file.
-      def rename(to) File.rename(@path, to) end
+      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
+      def stat
+        File.stat(@path)
+      end
 
       # See <tt>File.lstat</tt>.
-      def lstat() File.lstat(@path) end
+      def lstat
+        File.lstat(@path)
+      end
 
       # See <tt>File.symlink</tt>.  Creates a symbolic link.
-      def make_symlink(old) File.symlink(old, @path) end
+      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
+      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
+      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) self.class.new(File.basename(@path, *args)) end
+      def basename(*args)
+        self.class.new(File.basename(@path, *args))
+      end
 
-      # See <tt>File.dirname</tt>.  Returns all but the last component of the path.
-      def dirname() self.class.new(File.dirname(@path)) end
+      # See <tt>File.dirname</tt>.  Returns all but the last
+      # component of the path.
+      def dirname
+        self.class.new(File.dirname(@path))
+      end
 
       # See <tt>File.extname</tt>.  Returns the file's extension.
-      def extname() File.extname(@path) end
+      def extname
+        File.extname(@path)
+      end
 
       # See <tt>File.expand_path</tt>.
-      def expand_path(*args) self.class.new(File.expand_path(@path, *args)) end
+      def expand_path(*args)
+        self.class.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| self.class.new(f) } end
+      def split
+        File.split(@path).map { |f| self.class.new(f) }
+      end
     end
 
-
+    # Pathname class
     class Pathname    # * FileTest *
-
       # See <tt>FileTest.blockdev?</tt>.
-      def blockdev?() FileTest.blockdev?(@path) end
+      def blockdev?
+        FileTest.blockdev?(@path)
+      end
 
       # See <tt>FileTest.chardev?</tt>.
-      def chardev?() FileTest.chardev?(@path) end
+      def chardev?
+        FileTest.chardev?(@path)
+      end
 
       # See <tt>FileTest.executable?</tt>.
-      def executable?() FileTest.executable?(@path) end
+      def executable?
+        FileTest.executable?(@path)
+      end
 
       # See <tt>FileTest.executable_real?</tt>.
-      def executable_real?() FileTest.executable_real?(@path) end
+      def executable_real?
+        FileTest.executable_real?(@path)
+      end
 
       # See <tt>FileTest.exist?</tt>.
-      def exist?() FileTest.exist?(@path) end
+      def exist?
+        FileTest.exist?(@path)
+      end
 
       # See <tt>FileTest.grpowned?</tt>.
-      def grpowned?() FileTest.grpowned?(@path) end
+      def grpowned?
+        FileTest.grpowned?(@path)
+      end
 
       # See <tt>FileTest.directory?</tt>.
-      def directory?() FileTest.directory?(@path) end
+      def directory?
+        FileTest.directory?(@path)
+      end
 
       # See <tt>FileTest.file?</tt>.
-      def file?() FileTest.file?(@path) end
+      def file?
+        FileTest.file?(@path)
+      end
 
       # See <tt>FileTest.pipe?</tt>.
-      def pipe?() FileTest.pipe?(@path) end
+      def pipe?
+        FileTest.pipe?(@path)
+      end
 
       # See <tt>FileTest.socket?</tt>.
-      def socket?() FileTest.socket?(@path) end
+      def socket?
+        FileTest.socket?(@path)
+      end
 
       # See <tt>FileTest.owned?</tt>.
-      def owned?() FileTest.owned?(@path) end
+      def owned?
+        FileTest.owned?(@path)
+      end
 
       # See <tt>FileTest.readable?</tt>.
-      def readable?() FileTest.readable?(@path) end
+      def readable?
+        FileTest.readable?(@path)
+      end
 
       # See <tt>FileTest.world_readable?</tt>.
-      def world_readable?() FileTest.world_readable?(@path) end
+      def world_readable?
+        FileTest.world_readable?(@path)
+      end
 
       # See <tt>FileTest.readable_real?</tt>.
-      def readable_real?() FileTest.readable_real?(@path) end
+      def readable_real?
+        FileTest.readable_real?(@path)
+      end
 
       # See <tt>FileTest.setuid?</tt>.
-      def setuid?() FileTest.setuid?(@path) end
+      def setuid?
+        FileTest.setuid?(@path)
+      end
 
       # See <tt>FileTest.setgid?</tt>.
-      def setgid?() FileTest.setgid?(@path) end
+      def setgid?
+        FileTest.setgid?(@path)
+      end
 
       # See <tt>FileTest.size</tt>.
-      def size() FileTest.size(@path) end
+      def size
+        FileTest.size(@path)
+      end
 
       # See <tt>FileTest.size?</tt>.
-      def size?() FileTest.size?(@path) end
+      def size?
+        FileTest.size?(@path)
+      end
 
       # See <tt>FileTest.sticky?</tt>.
-      def sticky?() FileTest.sticky?(@path) end
+      def sticky?
+        FileTest.sticky?(@path)
+      end
 
       # See <tt>FileTest.symlink?</tt>.
-      def symlink?() FileTest.symlink?(@path) end
+      def symlink?
+        FileTest.symlink?(@path)
+      end
 
       # See <tt>FileTest.writable?</tt>.
-      def writable?() FileTest.writable?(@path) end
+      def writable?
+        FileTest.writable?(@path)
+      end
 
       # See <tt>FileTest.world_writable?</tt>.
-      def world_writable?() FileTest.world_writable?(@path) end
+      def world_writable?
+        FileTest.world_writable?(@path)
+      end
 
       # See <tt>FileTest.writable_real?</tt>.
-      def writable_real?() FileTest.writable_real?(@path) end
+      def writable_real?
+        FileTest.writable_real?(@path)
+      end
 
       # See <tt>FileTest.zero?</tt>.
-      def zero?() FileTest.zero?(@path) end
+      def zero?
+        FileTest.zero?(@path)
+      end
     end
 
-
+    # Pathname class
     class Pathname    # * Dir *
       # See <tt>Dir.glob</tt>.  Returns or yields Pathname objects.
-      def Pathname.glob(*args) # :yield: pathname
+      def self.glob(*args) # :yield: pathname
         if block_given?
-          Dir.glob(*args) {|f| yield self.new(f) }
+          Dir.glob(*args) { |f| yield new(f) }
         else
-          Dir.glob(*args).map {|f| self.new(f) }
+          Dir.glob(*args).map { |f| new(f) }
         end
       end
 
-      # See <tt>Dir.getwd</tt>.  Returns the current working directory as a Pathname.
-      def Pathname.getwd() self.new(Dir.getwd) end
-      class << self; alias pwd getwd end
+      # See <tt>Dir.getwd</tt>.  Returns the current working directory
+      # as a Pathname.
+      def self.getwd
+        new(Dir.getwd)
+      end
 
-      # Return the entries (files and subdirectories) in the directory, each as a
-      # Pathname object.
-      def entries() Dir.entries(@path).map {|f| self.class.new(f) } end
+      class << self; alias_method :pwd, :getwd end
 
-      # Iterates over the entries (files and subdirectories) in the directory.  It
-      # yields a Pathname object for each entry.
+      # Return the entries (files and subdirectories) in the directory, each as
+      # a Pathname object.
+      def entries
+        Dir.entries(@path).map { |f| self.class.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: pathname
-        Dir.foreach(@path) {|f| yield self.class.new(f) }
+      def each_entry(*) # :yield: pathname
+        Dir.foreach(@path) { |f| yield self.class.new(f) }
       end
 
       # See <tt>Dir.mkdir</tt>.  Create the referenced directory.
-      def mkdir(*args) Dir.mkdir(@path, *args) end
+      def mkdir(*args)
+        Dir.mkdir(@path, *args)
+      end
 
       # See <tt>Dir.rmdir</tt>.  Remove the referenced directory.
-      def rmdir() Dir.rmdir(@path) end
+      def rmdir
+        Dir.rmdir(@path)
+      end
 
       # See <tt>Dir.open</tt>.
       def opendir(&block) # :yield: dir
@@ -800,29 +955,30 @@ module FakeFS
       end
     end
 
-
+    # Pathname class
     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.
+      # 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.
+      # 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>.
+      # If +self+ is <tt>.</tt>, yielded pathnames begin with
+      # a filename in the current directory, not <tt>./</tt>.
       #
-      def find(&block) # :yield: pathname
+      def find(*) # :yield: pathname
         require 'find'
         if @path == '.'
-          Find.find(@path) {|f| yield self.class.new(f.sub(%r{\A\./}, '')) }
+          Find.find(@path) { |f| yield self.class.new(f.sub(%r{/\A\./}, '')) }
         else
-          Find.find(@path) {|f| yield self.class.new(f) }
+          Find.find(@path) { |f| yield self.class.new(f) }
         end
       end
     end
 
-
+    # Pathname class
     class Pathname    # * FileUtils *
       # See <tt>FileUtils.mkpath</tt>.  Creates a full path, including any
       # intermediate directories that don't yet exist.
@@ -842,23 +998,21 @@ module FakeFS
       end
     end
 
-
+    # Pathname class
     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
+      def unlink
+        Dir.unlink @path if File.directory? @path
+        File.unlink @path unless File.directory? @path
       end
-      alias delete unlink
+
+      alias_method :delete, :unlink
     end
 
+    # Pathname class
     class Pathname
       undef =~
     end
   end # RUBY_VERSION >= 1.9.3
 end
-