fakefs 0.4.0 → 0.4.1

data/lib/fakefs/fake/dir.rb

@@ -1,13 +1,19 @@
 module FakeFS
-  class FakeDir < Hash
-    attr_accessor :name, :parent
-    attr_reader :ctime, :mtime
+  class FakeDir
+    attr_accessor :name, :parent, :mode, :uid, :gid, :mtime, :atime
+    attr_reader :ctime, :content
 
     def initialize(name = nil, parent = nil)
-      @name   = name
-      @parent = parent
-      @ctime  = Time.now
-      @mtime  = @ctime
+      @name    = name
+      @parent  = parent
+      @ctime   = Time.now
+      @mtime   = @ctime
+      @atime   = @ctime
+      @mode    = 0100000 + (0777 - File.umask)
+      @uid     = Process.uid
+      @gid     = Process.gid
+      @content = ""
+      @entries = {}
     end
 
     def entry
@@ -15,12 +21,12 @@ module FakeFS
     end
 
     def inspect
-      "(FakeDir name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{size})"
+      "(FakeDir name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{@entries.size})"
     end
 
     def clone(parent = nil)
       clone = Marshal.load(Marshal.dump(self))
-      clone.each do |key, value|
+      clone.entries.each do |value|
         value.parent = clone
       end
       clone.parent = parent if parent
@@ -37,11 +43,31 @@ module FakeFS
       end
     end
 
+    def empty?
+      @entries.empty?
+    end
+
+    def entries
+      @entries.values
+    end
+
+    def matches(pattern)
+      @entries.reject {|k,v| pattern !~ k }.values
+    end
+
+    def [](name)
+      @entries[name]
+    end
+
+    def []=(name, value)
+      @entries[name] = value
+    end
+
     def delete(node = self)
       if node == self
         parent.delete(self)
       else
-        super(node.name)
+        @entries.delete(node.name)
       end
     end
   end

data/lib/fakefs/fake/file.rb

@@ -1,11 +1,12 @@
 module FakeFS
   class FakeFile
-    attr_accessor :name, :parent, :content, :mtime
+    attr_accessor :name, :parent, :content, :mtime, :atime, :mode, :uid, :gid
     attr_reader :ctime
 
     class Inode
       def initialize(file_owner)
-        @content = ""
+        #1.9.3 when possible set default external encoding
+        @content = "".respond_to?(:encode) ? "".encode(Encoding.default_external) : ""
         @links   = [file_owner]
       end
 
@@ -34,6 +35,10 @@ module FakeFS
       @inode  = Inode.new(self)
       @ctime  = Time.now
       @mtime  = @ctime
+      @atime  = @ctime
+      @mode   = 0100000 + (0666 - File.umask)
+      @uid    = Process.uid
+      @gid    = Process.gid      
     end
 
     attr_accessor :inode

data/lib/fakefs/file.rb

@@ -2,8 +2,6 @@ require 'stringio'
 
 module FakeFS
   class File < StringIO
-    PATH_SEPARATOR = '/'
-
     MODES = [
       READ_ONLY           = "r",
       READ_WRITE          = "r+",
@@ -23,8 +21,8 @@ module FakeFS
                    RealFile::EXCL     |
                    RealFile::NONBLOCK |
                    RealFile::TRUNC    |
-                   RealFile::NOCTTY   |
-                   RealFile::SYNC
+                   (RealFile.const_defined?(:NOCTTY) ? RealFile::NOCTTY : 0)   |
+                   (RealFile.const_defined?(:SYNC) ? RealFile::SYNC : 0)
 
     FILE_CREATION_BITMASK = RealFile::CREAT
 
@@ -69,9 +67,18 @@ module FakeFS
       end
     end
 
+    def self.atime(path)
+      if exists?(path)
+        FileSystem.find(path).atime
+      else
+        raise Errno::ENOENT
+      end
+    end
+
     def self.utime(atime, mtime, *paths)
       paths.each do |path|
         if exists?(path)
+          FileSystem.find(path).atime = atime
           FileSystem.find(path).mtime = mtime
         else
           raise Errno::ENOENT
@@ -140,9 +147,10 @@ module FakeFS
       symlink.target
     end
 
-    def self.read(path)
+    def self.read(path, *args)
       file = new(path)
       if file.exists?
+        FileSystem.find(path).atime = Time.now
         file.read
       else
         raise Errno::ENOENT
@@ -224,8 +232,24 @@ module FakeFS
       return RealFile.split(path)
     end
 
+    def self.chmod(mode_int, filename)
+      FileSystem.find(filename).mode = 0100000 + mode_int
+    end
+
+    def self.chown(owner_int, group_int, filename)
+      file = FileSystem.find(filename)
+      owner_int.is_a?(Fixnum) or raise TypeError, "can't convert String into Integer"
+      group_int.is_a?(Fixnum) or raise TypeError, "can't convert String into Integer"
+      file.uid = owner_int
+      file.gid = group_int
+    end
+
+    def self.umask
+      RealFile.umask
+    end
+
     class Stat
-      attr_reader :ctime, :mtime
+      attr_reader :ctime, :mtime, :atime, :mode, :uid, :gid
 
       def initialize(file, __lstat = false)
         if !File.exists?(file)
@@ -237,6 +261,10 @@ module FakeFS
         @__lstat   = __lstat
         @ctime     = @fake_file.ctime
         @mtime     = @fake_file.mtime
+        @atime     = @fake_file.atime
+        @mode      = @fake_file.mode
+        @uid       = @fake_file.uid
+        @gid       = @fake_file.gid
       end
 
       def symlink?
@@ -247,6 +275,14 @@ module FakeFS
         File.directory?(@file)
       end
 
+      # assumes, like above, that all files are readable and writable
+      def readable?
+        true
+      end
+      def writable?
+        true
+      end
+
       def nlink
         @fake_file.links.size
       end
@@ -258,13 +294,23 @@ module FakeFS
           File.size(@file)
         end
       end
+
+      def zero?
+        size == 0
+      end
+
+      include Comparable
+
+      def <=>(other)
+        @mtime <=> other.mtime
+      end
     end
 
     attr_reader :path
 
     def initialize(path, mode = READ_ONLY, perm = nil)
       @path = path
-      @mode = mode
+      @mode = mode.is_a?(Hash) ? (mode[:mode] || READ_ONLY) : mode
       @file = FileSystem.find(path)
       @autoclose = true
 
@@ -272,13 +318,19 @@ module FakeFS
 
       file_creation_mode? ? create_missing_file : check_file_existence!
 
-      super(@file.content, mode)
+      super(@file.content, @mode)
     end
 
     def exists?
       true
     end
 
+    def write(str)
+      val = super(str)
+      @file.mtime = Time.now
+      val
+    end
+
     alias_method :tell=,    :pos=
     alias_method :sysread,  :read
     alias_method :syswrite, :write
@@ -289,6 +341,11 @@ module FakeFS
     undef_method :size
     undef_method :string
     undef_method :string=
+    if RUBY_PLATFORM == 'java'
+      undef_method :to_channel
+      undef_method :to_outputstream
+      undef_method :to_inputstream
+    end
 
     def ioctl(integer_cmd, arg)
       raise NotImplementedError
@@ -326,15 +383,7 @@ module FakeFS
     end
 
     def atime
-      raise NotImplementedError
-    end
-
-    def chmod(mode_int)
-      raise NotImplementedError
-    end
-
-    def chown(owner_int, group_int)
-      raise NotImplementedError
+      self.class.atime(@path)
     end
 
     def ctime
@@ -349,6 +398,17 @@ module FakeFS
       self.class.mtime(@path)
     end
 
+    def chmod(mode_int)
+      @file.mode = 0100000 + mode_int
+    end
+
+    def chown(owner_int, group_int)
+      owner_int.is_a?(Fixnum) or raise TypeError, "can't convert String into Integer"
+      group_int.is_a?(Fixnum) or raise TypeError, "can't convert String into Integer"
+      @file.uid = owner_int
+      @file.gid = group_int
+    end
+
     if RUBY_VERSION >= "1.9"
       def binmode?
         raise NotImplementedError
@@ -374,6 +434,14 @@ module FakeFS
         @autoclose
       end
 
+      def autoclose?
+        @autoclose ? true : false
+      end
+
+      def autoclose=(autoclose)
+        @autoclose = autoclose
+      end
+
       alias_method :fdatasync, :flush
 
       def size
@@ -381,6 +449,11 @@ module FakeFS
       end
     end
 
+    if RUBY_VERSION >= "1.9.3"
+      def advise(advice, offset=0, len=0)
+      end
+    end
+
   private
 
     def check_modes!

data/lib/fakefs/file_system.rb

@@ -16,7 +16,7 @@ module FakeFS
     end
 
     def files
-      fs.values
+      fs.entries
     end
 
     def find(path)
@@ -46,19 +46,20 @@ module FakeFS
 
     # copies directories and files from the real filesystem
     # into our fake one
-    def clone(path)
+    def clone(path, target = nil)
       path    = File.expand_path(path)
       pattern = File.join(path, '**', '*')
       files   = RealFile.file?(path) ? [path] : [path] + RealDir.glob(pattern, RealFile::FNM_DOTMATCH)
 
       files.each do |f|
+        target_path = target ? f.gsub(path, target) : f
         if RealFile.file?(f)
           FileUtils.mkdir_p(File.dirname(f))
-          File.open(f, File::WRITE_ONLY) do |g|
+          File.open(target_path, File::WRITE_ONLY) do |g|
             g.print RealFile.open(f){|h| h.read }
           end
         elsif RealFile.directory?(f)
-          FileUtils.mkdir_p(f)
+          FileUtils.mkdir_p(target_path)
         elsif RealFile.symlink?(f)
           FileUtils.ln_s()
         end
@@ -85,7 +86,7 @@ module FakeFS
     end
 
     def path_parts(path)
-      path.split(File::PATH_SEPARATOR).reject { |part| part.empty? }
+      drop_root(path.split(File::SEPARATOR)).reject { |part| part.empty? }
     end
 
     def normalize_path(path)
@@ -103,6 +104,14 @@ module FakeFS
 
     private
 
+    def drop_root(path_parts)
+      # we need to remove parts from root dir at least for windows and jruby
+      return path_parts if path_parts.nil? || path_parts.empty?
+      root = File.expand_path('/').split(File::SEPARATOR).first
+      path_parts.shift if path_parts.first == root
+      path_parts
+    end
+
     def find_recurser(dir, parts)
       return [] unless dir.respond_to? :[]
 
@@ -113,17 +122,16 @@ module FakeFS
         when ['*']
           parts = [] # end recursion
           directories_under(dir).map do |d|
-            d.values.select{|f| f.is_a?(FakeFile) || f.is_a?(FakeDir) }
+            d.entries.select{|f| f.is_a?(FakeFile) || f.is_a?(FakeDir) }
           end.flatten.uniq
         when []
           parts = [] # end recursion
-          dir.values.flatten.uniq
+          dir.entries.flatten.uniq
         else
           directories_under(dir)
         end
       else
-        regexp_pattern = /\A#{pattern.gsub('?','.').gsub('*', '.*').gsub(/\{(.*?)\}/) { "(#{$1.gsub(',', '|')})" }}\Z/
-        dir.reject {|k,v| regexp_pattern !~ k }.values
+        dir.matches /\A#{pattern.gsub('.', '\.').gsub('?','.').gsub('*', '.*').gsub(/\{(.*?)\}/) { "(#{$1.gsub(',', '|')})" }}\Z/
       end
 
       if parts.empty? # we're done recursing
@@ -134,7 +142,7 @@ module FakeFS
     end
 
     def directories_under(dir)
-      children = dir.values.select{|f| f.is_a? FakeDir}
+      children = dir.entries.select{|f| f.is_a? FakeDir}
       ([dir] + children + children.map{|c| directories_under(c)}).flatten.uniq
     end
   end

data/lib/fakefs/fileutils.rb

@@ -11,7 +11,7 @@ module FakeFS
     def mkdir(path)
       parent = path.split('/')
       parent.pop
-      raise Errno::ENOENT, "No such file or directory - #{path}" unless parent.join == "" || FileSystem.find(parent.join('/'))
+      raise Errno::ENOENT, "No such file or directory - #{path}" unless parent.join == "" || parent.join == "." || FileSystem.find(parent.join('/'))
       raise Errno::EEXIST, "File exists - #{path}" if FileSystem.find(path)
       FileSystem.add(path, FakeDir.new)
     end
@@ -23,14 +23,14 @@ module FakeFS
         parent.pop
         raise Errno::ENOENT, "No such file or directory - #{l}" unless parent.join == "" || FileSystem.find(parent.join('/'))
         raise Errno::ENOENT, l unless FileSystem.find(l)
-        raise Errno::ENOTEMPTY, l unless FileSystem.find(l).values.empty?
+        raise Errno::ENOTEMPTY, l unless FileSystem.find(l).empty?
         rm(l)
       end
     end
 
     def rm(list, options = {})
       Array(list).each do |path|
-        FileSystem.delete(path) or raise Errno::ENOENT.new(path)
+        FileSystem.delete(path) or (!options[:force] && raise(Errno::ENOENT.new(path)))
       end
     end
 
@@ -56,50 +56,58 @@ module FakeFS
     end
 
     def cp(src, dest)
-      dst_file = FileSystem.find(dest)
-      src_file = FileSystem.find(src)
-
-      if !src_file
-        raise Errno::ENOENT, src
+      if src.is_a?(Array) && !File.directory?(dest)
+        raise Errno::ENOTDIR, dest
       end
 
-      if File.directory? src_file
-        raise Errno::EISDIR, src
-      end
+      Array(src).each do |src|
+        dst_file = FileSystem.find(dest)
+        src_file = FileSystem.find(src)
 
-      if dst_file && File.directory?(dst_file)
-        FileSystem.add(File.join(dest, src), src_file.entry.clone(dst_file))
-      else
-        FileSystem.delete(dest)
-        FileSystem.add(dest, src_file.entry.clone)
+        if !src_file
+          raise Errno::ENOENT, src
+        end
+
+        if File.directory? src_file
+          raise Errno::EISDIR, src
+        end
+
+        if dst_file && File.directory?(dst_file)
+          FileSystem.add(File.join(dest, src), src_file.entry.clone(dst_file))
+        else
+          FileSystem.delete(dest)
+          FileSystem.add(dest, src_file.entry.clone)
+        end
       end
     end
 
     def cp_r(src, dest)
-      # This error sucks, but it conforms to the original Ruby
-      # method.
-      raise "unknown file type: #{src}" unless dir = FileSystem.find(src)
+      Array(src).each do |src|
+        # This error sucks, but it conforms to the original Ruby
+        # method.
+        raise "unknown file type: #{src}" unless dir = FileSystem.find(src)
 
-      new_dir = FileSystem.find(dest)
+        new_dir = FileSystem.find(dest)
 
-      if new_dir && !File.directory?(dest)
-        raise Errno::EEXIST, dest
-      end
+        if new_dir && !File.directory?(dest)
+          raise Errno::EEXIST, dest
+        end
 
-      if !new_dir && !FileSystem.find(dest+'/../')
-        raise Errno::ENOENT, dest
-      end
+        if !new_dir && !FileSystem.find(dest+'/../')
+          raise Errno::ENOENT, dest
+        end
 
-      # This last bit is a total abuse and should be thought hard
-      # about and cleaned up.
-      if new_dir
-        if src[-2..-1] == '/.'
-          dir.values.each{|f| new_dir[f.name] = f.clone(new_dir) }
+        # This last bit is a total abuse and should be thought hard
+        # about and cleaned up.
+        if new_dir
+          if src[-2..-1] == '/.'
+            dir.entries.each{|f| new_dir[f.name] = f.clone(new_dir) }
+          else
+            new_dir[dir.name] = dir.entry.clone(new_dir)
+          end
         else
-          new_dir[dir.name] = dir.entry.clone(new_dir)
+          FileSystem.add(dest, dir.entry.clone)
         end
-      else
-        FileSystem.add(dest, dir.entry.clone)
       end
     end
 
@@ -118,7 +126,11 @@ module FakeFS
     def chown(user, group, list, options={})
       list = Array(list)
       list.each do |f|
-        unless File.exists?(f)
+        if File.exists?(f)
+          uid = (user.to_s.match(/[0-9]+/) ? user.to_i : Etc.getpwnam(user).uid)
+          gid = (group.to_s.match(/[0-9]+/) ? group.to_i : Etc.getgrnam(group).gid)
+          File.chown(uid, gid, f)
+        else
           raise Errno::ENOENT, f
         end
       end
@@ -126,17 +138,48 @@ module FakeFS
     end
 
     def chown_R(user, group, list, options={})
-      chown(user, group, list, options={})
+      list = Array(list)
+      list.each do |file|
+        chown(user, group, file)
+        [FileSystem.find("#{file}/**/**")].flatten.each do |f|
+          chown(user, group, f.to_s)
+        end
+      end
+      list
+    end
+
+    def chmod(mode, list, options={})
+      list = Array(list)
+      list.each do |f|
+        if File.exists?(f)
+          File.chmod(mode, f)
+        else
+          raise Errno::ENOENT, f
+        end
+      end
+      list
+    end
+
+    def chmod_R(mode, list, options={})
+      list = Array(list)
+      list.each do |file|
+        chmod(mode, file)
+        [FileSystem.find("#{file}/**/**")].flatten.each do |f|
+          chmod(mode, f.to_s)
+        end
+      end
+      list
     end
 
     def touch(list, options={})
       Array(list).each do |f|
-        directory = File.dirname(f)
-        # FIXME this explicit check for '.' shouldn't need to happen
-        if File.exists?(directory) || directory == '.'
-          FileSystem.add(f, FakeFile.new)
+        if fs = FileSystem.find(f)
+          now = Time.now
+          fs.mtime = now
+          fs.atime = now
         else
-          raise Errno::ENOENT, f
+          f = File.open(f, 'w')
+          f.close
         end
       end
     end