fakefs 0.5.4 → 0.6.0

data/lib/fakefs/file_system.rb

@@ -1,4 +1,5 @@
 module FakeFS
+  # FileSystem module
   module FileSystem
     extend self
 
@@ -32,10 +33,10 @@ module FakeFS
       end
     end
 
-    def add(path, object=FakeDir.new)
+    def add(path, object = FakeDir.new)
       parts = path_parts(normalize_path(path))
 
-      d = parts[0...-1].inject(fs) do |dir, part|
+      d = parts[0...-1].reduce(fs) do |dir, part|
         assert_dir dir[part] if dir[part]
         dir[part] ||= FakeDir.new(part, dir)
       end
@@ -51,7 +52,11 @@ module FakeFS
     def clone(path, target = nil)
       path    = RealFile.expand_path(path)
       pattern = File.join(path, '**', '*')
-      files   = RealFile.file?(path) ? [path] : [path] + RealDir.glob(pattern, RealFile::FNM_DOTMATCH)
+      files   = if RealFile.file?(path)
+                  [path]
+                else
+                  [path] + RealDir.glob(pattern, RealFile::FNM_DOTMATCH)
+                end
 
       files.each do |f|
         target_path = target ? f.gsub(path, target) : f
@@ -60,7 +65,7 @@ module FakeFS
         elsif RealFile.file?(f)
           FileUtils.mkdir_p(File.dirname(f))
           File.open(target_path, File::WRITE_ONLY) do |g|
-            g.print RealFile.open(f){|h| h.read }
+            g.print RealFile.open(f) { |h| h.read }
           end
         elsif RealFile.directory?(f)
           FileUtils.mkdir_p(target_path)
@@ -69,26 +74,25 @@ module FakeFS
     end
 
     def delete(path)
-      if node = FileSystem.find(path)
-        node.delete
-        true
-      end
+      return unless (node = FileSystem.find(path))
+      node.delete
+      true
     end
 
     def chdir(dir, &blk)
       new_dir = find(dir)
       dir_levels.push dir if blk
 
-      raise Errno::ENOENT, dir unless new_dir
+      fail Errno::ENOENT, dir unless new_dir
 
-      dir_levels.push dir if !blk
+      dir_levels.push dir unless blk
       blk.call if blk
     ensure
       dir_levels.pop if blk
     end
 
     def path_parts(path)
-      drop_root(path.split(File::SEPARATOR)).reject { |part| part.empty? }
+      drop_root(path.split(File::SEPARATOR)).reject(&:empty?)
     end
 
     def normalize_path(path)
@@ -96,7 +100,9 @@ module FakeFS
         RealFile.expand_path(path)
       else
         parts = dir_levels + [path]
-        RealFile.expand_path(parts.inject {|base, part| Pathname(base) + part }.to_s)
+        RealFile.expand_path(parts.reduce do |base, part|
+                               Pathname(base) + part
+                             end.to_s)
       end
     end
 
@@ -117,39 +123,50 @@ module FakeFS
     def find_recurser(dir, parts)
       return [] unless dir.respond_to? :[]
 
-      pattern , *parts = parts
+      pattern, *parts = parts
       matches = case pattern
-      when '**'
-        case parts
-        when ['*']
-          parts = [] # end recursion
-          directories_under(dir).map do |d|
-            d.entries.select{|f| f.is_a?(FakeFile) || f.is_a?(FakeDir) }
-          end.flatten.uniq
-        when []
-          parts = [] # end recursion
-          dir.entries.flatten.uniq
-        else
-          directories_under(dir)
-        end
-      else
-        dir.matches(/\A#{pattern.gsub('.', '\.').gsub('?','.').gsub('*', '.*').gsub('(', '\(').gsub(')', '\)').gsub(/\{(.*?)\}/) { "(#{$1.gsub(',', '|')})" }}\Z/)
-      end
+                when '**'
+                  case parts
+                  when ['*']
+                    parts = [] # end recursion
+                    directories_under(dir).map do |d|
+                      d.entries.select do |f|
+                        f.is_a?(FakeFile) || f.is_a?(FakeDir)
+                      end
+                    end.flatten.uniq
+                  when []
+                    parts = [] # end recursion
+                    dir.entries.flatten.uniq
+                  else
+                    directories_under(dir)
+                  end
+                else
+                  regex_body = pattern.gsub('.', '\.')
+                    .gsub('?', '.')
+                    .gsub('*', '.*')
+                    .gsub('(', '\(')
+                    .gsub(')', '\)')
+                    .gsub(/\{(.*?)\}/) do
+                      "(#{Regexp.last_match[1].gsub(',', '|')})"
+                    end
+                  dir.matches(/\A#{regex_body}\Z/)
+                end
 
       if parts.empty? # we're done recursing
         matches
       else
-        matches.map{|entry| find_recurser(entry, parts) }
+        matches.map { |entry| find_recurser(entry, parts) }
       end
     end
 
     def directories_under(dir)
-      children = dir.entries.select{|f| f.is_a? FakeDir}
-      ([dir] + children + children.map{|c| directories_under(c)}).flatten.uniq
+      children = dir.entries.select { |f| f.is_a? FakeDir }
+      ([dir] + children + children.map { |c| directories_under(c) })
+        .flatten.uniq
     end
 
     def assert_dir(dir)
-      raise Errno::EEXIST, dir.name unless dir.is_a?(FakeDir)
+      fail Errno::EEXIST, dir.name unless dir.is_a?(FakeDir)
     end
   end
 end

data/lib/fakefs/file_test.rb

@@ -1,4 +1,5 @@
 module FakeFS
+  # FileTest
   module FileTest
     extend self
 

data/lib/fakefs/fileutils.rb

@@ -1,42 +1,47 @@
 module FakeFS
+  # FileUtils module
   module FileUtils
     extend self
 
-    def mkdir_p(list, options = {})
-      list = [ list ] unless list.is_a?(Array)
+    def mkdir_p(list, _options = {})
+      list = [list] unless list.is_a?(Array)
       list.each do |path|
         FileSystem.add(path, FakeDir.new)
       end
     end
+
     alias_method :mkpath, :mkdir_p
     alias_method :makedirs, :mkdir_p
 
-    def mkdir(list, ignored_options={})
-      list = [ list ] unless list.is_a?(Array)
+    def mkdir(list, _ignored_options = {})
+      list = [list] unless list.is_a?(Array)
       list.each do |path|
         parent = path.split('/')
         parent.pop
-        raise Errno::ENOENT, path unless parent.join == "" || parent.join == "." || FileSystem.find(parent.join('/'))
-        raise Errno::EEXIST, path if FileSystem.find(path)
+        fail Errno::ENOENT, path unless parent.join == '' ||
+          parent.join == '.' || FileSystem.find(parent.join('/'))
+        fail Errno::EEXIST, path if FileSystem.find(path)
         FileSystem.add(path, FakeDir.new)
       end
     end
 
-    def rmdir(list, options = {})
-      list = [ list ] unless list.is_a?(Array)
+    def rmdir(list, _options = {})
+      list = [list] unless list.is_a?(Array)
       list.each do |l|
         parent = l.split('/')
         parent.pop
-        raise Errno::ENOENT, l unless parent.join == "" || FileSystem.find(parent.join('/'))
-        raise Errno::ENOENT, l unless FileSystem.find(l)
-        raise Errno::ENOTEMPTY, l unless FileSystem.find(l).empty?
+        fail Errno::ENOENT, l unless parent.join == '' ||
+          FileSystem.find(parent.join('/'))
+        fail Errno::ENOENT, l unless FileSystem.find(l)
+        fail 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 (!options[:force] && raise(Errno::ENOENT.new(path)))
+        FileSystem.delete(path) ||
+          (!options[:force] && fail(Errno::ENOENT, path))
       end
     end
 
@@ -49,92 +54,81 @@ module FakeFS
     alias_method :remove_entry_secure, :rm_rf
 
     def ln_s(target, path, options = {})
-      options = { :force => false }.merge(options)
-      (FileSystem.find(path) && !options[:force]) ?
-        raise(Errno::EEXIST, path) :
-        FileSystem.delete(path)
+      options = { force: false }.merge(options)
+      fail(Errno::EEXIST, path) if FileSystem.find(path) && !options[:force]
+      FileSystem.delete(path)
 
-      if !options[:force] && !Dir.exists?(File.dirname(path))
-        raise Errno::ENOENT, path
+      if !options[:force] && !Dir.exist?(File.dirname(path))
+        fail Errno::ENOENT, path
       end
 
       FileSystem.add(path, FakeSymlink.new(target))
     end
 
     def ln_sf(target, path)
-      ln_s(target, path, { :force => true })
+      ln_s(target, path, force: true)
     end
 
     alias_method :symlink, :ln_s
 
-    def cp(src, dest, options={})
-      if src.is_a?(Array) && !File.directory?(dest)
-        raise Errno::ENOTDIR, dest
-      end
+    def cp(src, dest, options = {})
+      fail Errno::ENOTDIR, dest if src.is_a?(Array) && !File.directory?(dest)
 
       # handle `verbose' flag
-      RealFileUtils.cp src, dest, options.merge(:noop => true)
+      RealFileUtils.cp src, dest, options.merge(noop: true)
 
       # handle `noop' flag
       return if options[:noop]
 
-      Array(src).each do |src|
+      Array(src).each do |source|
         dst_file = FileSystem.find(dest)
-        src_file = FileSystem.find(src)
+        src_file = FileSystem.find(source)
 
-        if !src_file
-          raise Errno::ENOENT, src
-        end
-
-        if File.directory? src_file
-          raise Errno::EISDIR, src
-        end
+        fail Errno::ENOENT, source unless src_file
+        fail Errno::EISDIR, source if File.directory? src_file
 
         if dst_file && File.directory?(dst_file)
-          FileSystem.add(File.join(dest, File.basename(src)), src_file.entry.clone(dst_file))
+          FileSystem.add(
+            File.join(
+              dest, File.basename(source)), src_file.entry.clone(dst_file))
         else
           FileSystem.delete(dest)
           FileSystem.add(dest, src_file.entry.clone)
         end
       end
 
-      return nil
+      nil
     end
 
     alias_method :copy, :cp
 
-    def copy_file(src, dest, preserve = false, dereference = true)
+    def copy_file(src, dest, _preserve = false, _dereference = true)
       # Not a perfect match, but similar to what regular FileUtils does.
       cp(src, dest)
     end
 
-    def cp_r(src, dest, options={})
+    def cp_r(src, dest, options = {})
       # handle `verbose' flag
-      RealFileUtils.cp_r src, dest, options.merge(:noop => true)
+      RealFileUtils.cp_r src, dest, options.merge(noop: true)
 
       # handle `noop' flag
       return if options[:noop]
 
-      Array(src).each do |src|
+      Array(src).each do |source|
         # This error sucks, but it conforms to the original Ruby
         # method.
-        raise "unknown file type: #{src}" unless dir = FileSystem.find(src)
-
+        fail "unknown file type: #{source}" unless
+          (dir = FileSystem.find(source))
         new_dir = FileSystem.find(dest)
 
-        if new_dir && !File.directory?(dest)
-          raise Errno::EEXIST, dest
-        end
-
-        if !new_dir && !FileSystem.find(dest+'/../')
-          raise Errno::ENOENT, dest
-        end
+        fail Errno::EEXIST, dest if new_dir && !File.directory?(dest)
+        fail Errno::ENOENT, dest if !new_dir && !FileSystem.find(dest + '/../')
 
         # 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) }
+            dir.entries.each { |f| new_dir[f.name] = f.clone(new_dir) }
           else
             new_dir[dir.name] = dir.entry.clone(new_dir)
           end
@@ -143,61 +137,67 @@ module FakeFS
         end
       end
 
-      return nil
+      nil
     end
 
-    def mv(src, dest, options={})
+    def mv(src, dest, options = {})
       # handle `verbose' flag
-      RealFileUtils.mv src, dest, options.merge(:noop => true)
+      RealFileUtils.mv src, dest, options.merge(noop: true)
 
       # handle `noop' flag
       return if options[:noop]
 
       Array(src).each do |path|
-        if target = FileSystem.find(path)
-          dest_path = File.directory?(dest) ? File.join(dest, File.basename(path)) : dest
+        if (target = FileSystem.find(path))
+          dest_path = if File.directory?(dest)
+                        File.join(dest, File.basename(path))
+                      else
+                        dest
+                      end
           if File.directory?(dest_path)
-            raise Errno::EEXIST, dest_path unless options[:force]
+            fail Errno::EEXIST, dest_path unless options[:force]
           elsif File.directory?(File.dirname(dest_path))
             FileSystem.delete(dest_path)
             FileSystem.add(dest_path, target.entry.clone)
             FileSystem.delete(path)
           else
-            raise Errno::ENOENT, dest_path unless options[:force]
+            fail Errno::ENOENT, dest_path unless options[:force]
           end
         else
-          raise Errno::ENOENT, path
+          fail Errno::ENOENT, path
         end
       end
 
-      return nil
+      nil
     end
 
     alias_method :move, :mv
 
-    def chown(user, group, list, options={})
+    def chown(user, group, list, _options = {})
       list = Array(list)
       list.each do |f|
-        if File.exists?(f)
+        if File.exist?(f)
           uid = if user
-                  user.to_s.match(/[0-9]+/) ? user.to_i : Etc.getpwnam(user).uid
+                  user.to_s.match(/[0-9]+/) ? user.to_i :
+                    Etc.getpwnam(user).uid
                 else
                   nil
                 end
           gid = if group
-                  group.to_s.match(/[0-9]+/) ? group.to_i : Etc.getgrnam(group).gid
+                  group.to_s.match(/[0-9]+/) ? group.to_i :
+                    Etc.getgrnam(group).gid
                 else
                   nil
                 end
           File.chown(uid, gid, f)
         else
-          raise Errno::ENOENT, f
+          fail Errno::ENOENT, f
         end
       end
       list
     end
 
-    def chown_R(user, group, list, options={})
+    def chown_R(user, group, list, _options = {})
       list = Array(list)
       list.each do |file|
         chown(user, group, file)
@@ -208,19 +208,19 @@ module FakeFS
       list
     end
 
-    def chmod(mode, list, options={})
+    def chmod(mode, list, _options = {})
       list = Array(list)
       list.each do |f|
-        if File.exists?(f)
+        if File.exist?(f)
           File.chmod(mode, f)
         else
-          raise Errno::ENOENT, f
+          fail Errno::ENOENT, f
         end
       end
       list
     end
 
-    def chmod_R(mode, list, options={})
+    def chmod_R(mode, list, _options = {})
       list = Array(list)
       list.each do |file|
         chmod(mode, file)
@@ -231,9 +231,9 @@ module FakeFS
       list
     end
 
-    def touch(list, options={})
+    def touch(list, options = {})
       Array(list).each do |f|
-        if fs = FileSystem.find(f)
+        if (fs = FileSystem.find(f))
           now = Time.now
           fs.mtime = options[:mtime] || now
           fs.atime = now
@@ -241,7 +241,7 @@ module FakeFS
           file = File.open(f, 'w')
           file.close
 
-          if mtime = options[:mtime]
+          if (mtime = options[:mtime])
             fs = FileSystem.find(f)
             fs.mtime = mtime
           end
@@ -258,6 +258,7 @@ module FakeFS
       # we do a strict comparison of both files content
       File.readlines(file1) == File.readlines(file2)
     end
+
     alias_method :cmp, :compare_file
     alias_method :identical?, :compare_file
   end