fakefs 0.2.1 → 0.3.2

data/lib/fakefs/file.rb

@@ -1,5 +1,7 @@
+require 'stringio'
+
 module FakeFS
-  class File
+  class File < StringIO
     PATH_SEPARATOR = '/'
 
     MODES = [
@@ -31,7 +33,7 @@ module FakeFS
     end
 
     def self.join(*parts)
-      parts * PATH_SEPARATOR
+      RealFile.join(parts)
     end
 
     def self.exist?(path)
@@ -54,6 +56,26 @@ module FakeFS
       end
     end
 
+    def self.ctime(path)
+      if exists?(path)
+        FileSystem.find(path).ctime
+      else
+        raise Errno::ENOENT
+      end
+    end
+
+    def self.utime(atime, mtime, *paths)
+      paths.each do |path|
+        if exists?(path)
+          FileSystem.find(path).mtime = mtime
+        else
+          raise Errno::ENOENT
+        end
+      end
+
+      paths.size
+    end
+
     def self.size(path)
       read(path).length
     end
@@ -113,14 +135,6 @@ module FakeFS
       FileSystem.find(symlink.target).to_s
     end
 
-    def self.open(path, mode=READ_ONLY, perm = 0644)
-      if block_given?
-        yield new(path, mode, perm)
-      else
-        new(path, mode, perm)
-      end
-    end
-
     def self.read(path)
       file = new(path)
       if file.exists?
@@ -134,6 +148,23 @@ module FakeFS
       read(path).split("\n")
     end
 
+    def self.rename(source, dest)
+      if directory?(source) && file?(dest)
+        raise Errno::ENOTDIR, "Not a directory - #{source} or #{dest}"
+      elsif file?(source) && directory?(dest)
+        raise Errno::EISDIR, "Is a directory - #{source} or #{dest}"
+      end
+
+      if target = FileSystem.find(source)
+        FileSystem.add(dest, target.entry.clone)
+        FileSystem.delete(source)
+      else
+        raise Errno::ENOENT,  "No such file or directory - #{source} or #{dest}"
+      end
+
+      0
+    end
+
     def self.link(source, dest)
       if directory?(source)
         raise Errno::EPERM, "Operation not permitted - #{source} or #{dest}"
@@ -180,13 +211,27 @@ module FakeFS
       File::Stat.new(file)
     end
 
+    def self.lstat(file)
+      File::Stat.new(file, true)
+    end
+
+    def self.split(path)
+      return RealFile.split(path)
+    end
+
     class Stat
-      def initialize(file)
+      attr_reader :ctime, :mtime
+
+      def initialize(file, __lstat = false)
         if !File.exists?(file)
           raise(Errno::ENOENT, "No such file or directory - #{file}")
         end
 
-        @file = file
+        @file      = file
+        @fake_file = FileSystem.find(@file)
+        @__lstat   = __lstat
+        @ctime     = @fake_file.ctime
+        @mtime     = @fake_file.mtime
       end
 
       def symlink?
@@ -198,7 +243,15 @@ module FakeFS
       end
 
       def nlink
-        FileSystem.find(@file).links.size
+        @fake_file.links.size
+      end
+
+      def size
+        if @__lstat && symlink?
+          @fake_file.target.size
+        else
+          File.size(@file)
+        end
       end
     end
 
@@ -208,45 +261,119 @@ module FakeFS
       @path = path
       @mode = mode
       @file = FileSystem.find(path)
-      @open = true
+      @autoclose = true
 
       check_modes!
 
       file_creation_mode? ? create_missing_file : check_file_existence!
 
-      @stream = StringIO.new(@file.content, mode)
+      super(@file.content, mode)
     end
 
-    def close
-      @open = false
+    def exists?
+      true
     end
 
-    def read(chunk = nil)
-      @stream.read(chunk)
+    alias_method :tell=,    :pos=
+    alias_method :sysread,  :read
+    alias_method :syswrite, :write
+
+    undef_method :closed_read?
+    undef_method :closed_write?
+    undef_method :length
+    undef_method :size
+    undef_method :string
+    undef_method :string=
+
+    def ioctl(integer_cmd, arg)
+      raise NotImplementedError
     end
 
-    def rewind
-      @stream.rewind
+    def read_nonblock(maxlen, outbuf = nil)
+      raise NotImplementedError
     end
 
-    def exists?
-      true
+    def stat
+      self.class.stat(@path)
+    end
+
+    def lstat
+      self.class.lstat(@path)
+    end
+
+    def sysseek(position, whence = SEEK_SET)
+      seek(position, whence)
+      pos
+    end
+
+    alias_method :to_i, :fileno
+
+    def to_io
+      self
     end
 
-    def puts(*content)
-      @stream.puts(*content)
+    def write_nonblock(string)
+      raise NotImplementedError
     end
 
-    def write(content)
-      @stream.write(content)
+    def readpartial(maxlen, outbuf = nil)
+      raise NotImplementedError
     end
-    alias_method :print, :write
-    alias_method :<<, :write
 
-    def flush; self; end
+    def atime
+      raise NotImplementedError
+    end
+
+    def chmod(mode_int)
+      raise NotImplementedError
+    end
+
+    def chown(owner_int, group_int)
+      raise NotImplementedError
+    end
+
+    def ctime
+      self.class.ctime(@path)
+    end
+
+    def flock(locking_constant)
+      raise NotImplementedError
+    end
 
-    def seek(amount, whence = SEEK_SET)
-      @stream.seek(amount, whence)
+    def mtime
+      self.class.mtime(@path)
+    end
+
+    if RUBY_VERSION >= "1.9"
+      def binmode?
+        raise NotImplementedError
+      end
+
+      def close_on_exec=(bool)
+        raise NotImplementedError
+      end
+
+      def close_on_exec?
+        raise NotImplementedError
+      end
+
+      def to_path
+        raise NotImplementedError
+      end
+    end
+
+    if RUBY_VERSION >= "1.9.2"
+      attr_writer :autoclose
+
+      def autoclose?
+        @autoclose
+      end
+
+      alias_method :fdatasync, :flush
+
+      def size
+        File.size(@path)
+      end
     end
 
   private
@@ -256,9 +383,7 @@ module FakeFS
     end
 
     def check_file_existence!
-      unless @file
-        raise Errno::ENOENT, "No such file or directory - #{@file}"
-      end
+      raise Errno::ENOENT, @path unless @file
     end
 
     def file_creation_mode?

data/lib/fakefs/file_system.rb

@@ -109,11 +109,14 @@ module FakeFS
       matches = case pattern
       when '**'
         case parts
-        when ['*'], []
+        when ['*']
           parts = [] # end recursion
           directories_under(dir).map do |d|
-            d.values.select{|f| f.is_a? FakeFile }
+            d.values.select{|f| f.is_a?(FakeFile) || f.is_a?(FakeDir) }
           end.flatten.uniq
+        when []
+          parts = [] # end recursion
+          dir.values.flatten.uniq
         else
           directories_under(dir)
         end

data/lib/fakefs/file_test.rb

@@ -0,0 +1,11 @@
+module FakeFS
+  class FileTest
+    def self.exist?(file_name)
+      File.exist?(file_name)
+    end
+
+    def self.directory?(file_name)
+      File.directory?(file_name)
+    end
+  end
+end

data/lib/fakefs/fileutils.rb

@@ -2,10 +2,19 @@ module FakeFS
   module FileUtils
     extend self
 
-    def mkdir_p(path)
+    def mkdir_p(path, options = {})
       FileSystem.add(path, FakeDir.new)
     end
     alias_method :mkpath, :mkdir_p
+    alias_method :makedirs, :mkdir_p
+
+    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::EEXIST, "File exists - #{path}" if FileSystem.find(path)
+      FileSystem.add(path, FakeDir.new)
+    end
 
     def rmdir(list, options = {})
       list = [ list ] unless list.is_a?(Array)
@@ -19,8 +28,10 @@ module FakeFS
       end
     end
 
-    def rm(path)
-      FileSystem.delete(path)
+    def rm(list, options = {})
+      Array(list).each do |path|
+        FileSystem.delete(path)
+      end
     end
 
     alias_method :rm_rf, :rm
@@ -36,8 +47,6 @@ module FakeFS
       ln_s(target, path, { :force => true })
     end
 
-    
-
     def cp(src, dest)
       dst_file = FileSystem.find(dest)
       src_file = FileSystem.find(src)
@@ -86,12 +95,15 @@ module FakeFS
       end
     end
 
-    def mv(src, dest)
-      if target = FileSystem.find(src)
-        FileSystem.add(dest, target.entry.clone)
-        FileSystem.delete(src)
-      else
-        raise Errno::ENOENT, src
+    def mv(src, dest, options={})
+      Array(src).each do |path|
+        if target = FileSystem.find(path)
+          dest_path = File.directory?(dest) ? File.join(dest, File.basename(path)) : dest
+          FileSystem.add(dest_path, target.entry.clone)
+          FileSystem.delete(path)
+        else
+          raise Errno::ENOENT, path
+        end
       end
     end
 

data/lib/fakefs/safe.rb

@@ -7,5 +7,5 @@ require 'fakefs/fake/symlink'
 require 'fakefs/file_system'
 require 'fakefs/fileutils'
 require 'fakefs/file'
+require 'fakefs/file_test'
 require 'fakefs/dir'
-

data/lib/fakefs/version.rb

@@ -1,6 +1,6 @@
 module FakeFS
   module Version
-    VERSION = "0.2.1"
+    VERSION = "0.3.2"
 
     def self.to_s
       VERSION

data/spec/fakefs/spec_helpers_spec.rb

@@ -54,4 +54,4 @@ module FakeFS
       end
     end
   end
-end
+end

data/spec/spec.opts

@@ -1 +1 @@
---color
+--color

data/spec/spec_helper.rb

@@ -1,3 +1,3 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 
-require 'fakefs/spec_helpers'
+require 'fakefs/spec_helpers'

data/test/fake/file/join_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+class FileJoin < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  [
+    ["a", "b"],  ["a/", "b"], ["a", "/b"], ["a/", "/b"], ["a", "/", "b"]
+  ].each_with_index do |args, i|
+    define_method "test_file_join_#{i}" do
+      assert_equal RealFile.join(args), File.join(args)
+    end
+  end
+end

data/test/fake/file/lstat_test.rb

@@ -0,0 +1,59 @@
+require "test_helper"
+
+class FileStat < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_calling_lstat_should_create_a_new_file_stat_object
+    File.open("foo", "w") do |f|
+      f << "bar"
+    end
+
+    File.open("foo") do |f|
+      assert_equal File::Stat, f.lstat.class
+    end
+  end
+
+  def test_lstat_should_use_correct_file
+    File.open("bar", "w") do |f|
+      f << "1"
+    end
+
+    File.open("bar") do |f|
+      assert_equal 1, f.lstat.size
+    end
+  end
+
+  def test_lstat_should_report_on_symlink_itself
+    File.open("foo", "w") { |f| f << "some content" }
+    File.symlink "foo", "my_symlink"
+
+    assert_not_equal File.lstat("my_symlink").size, File.lstat("foo").size
+  end
+
+  def test_should_report_on_symlink_itself_with_size_instance_method
+    File.open("foo", "w") { |f| f << "some content" }
+    File.symlink "foo", "my_symlink"
+
+    file = File.open("foo")
+    symlink = File.open("my_symlink")
+
+    assert_not_equal file.lstat.size, symlink.lstat.size
+  end
+
+  def test_symlink_size_is_size_of_path_pointed_to
+    File.open("a", "w") { |x| x << "foobarbazfoobarbaz" }
+    File.symlink "a", "one_char_symlink"
+    assert_equal 1, File.lstat("one_char_symlink").size
+
+    File.open("ab", "w") { |x| x << "foobarbazfoobarbaz" }
+    File.symlink "ab", "two_char_symlink"
+    assert_equal 2, File.lstat("two_char_symlink").size
+  end
+end

data/test/fake/file/stat_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+
+class FileStat < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_calling_stat_should_create_a_new_file_stat_object
+    File.open("foo", "w") do |f|
+      f << "bar"
+    end
+
+    File.open("foo") do |f|
+      assert_equal File::Stat, f.stat.class
+    end
+  end
+
+  def test_stat_should_use_correct_file
+    File.open("bar", "w") do |f|
+      f << "1"
+    end
+
+    File.open("bar") do |f|
+      assert_equal 1, f.stat.size
+    end
+  end
+
+  def test_stat_should_report_on_symlink_pointer
+    File.open("foo", "w") { |f| f << "some content" }
+    File.symlink "foo", "my_symlink"
+
+    assert_equal File.stat("my_symlink").size, File.stat("foo").size
+  end
+end

data/test/fake/file/sysseek_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class FileSysSeek < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_should_seek_to_position
+    file = File.open("foo", "w") do |f|
+      f << "0123456789"
+    end
+
+    File.open("foo", "r") do |f|
+      f.sysseek(3)
+      assert_equal 3, f.pos
+
+      f.sysseek(0)
+      assert_equal 0, f.pos
+    end
+  end
+
+  def test_seek_returns_offset_into_file
+    File.open("foo", "w") do |f|
+      # 66 chars long
+      str = "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "0123456789" +
+            "012345"
+
+      f << str
+    end
+
+    f = File.open("foo")
+    assert_equal 53, f.sysseek(-13, IO::SEEK_END)
+  end
+end

data/test/fake/file/syswrite_test.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+class FileSysWriteTest < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    FakeFS::FileSystem.clear
+  end
+
+  def teardown
+    FakeFS.deactivate!
+  end
+
+  def test_returns_one_byte_when_written
+    f = File.open "foo", "w"
+    result = f.syswrite "a"
+    assert_equal 1, result
+  end
+
+  def test_returns_two_bytes_when_two_written
+    f = File.open "foo", "w"
+    result = f.syswrite "ab"
+    assert_equal 2, result
+  end
+
+  def test_syswrite_writes_file
+    f = File.open "foo", "w"
+    f.syswrite "abcdef"
+    f.close
+
+    assert_equal "abcdef", File.read("foo")
+  end
+
+  def test_writes_to_the_actual_position_when_called_after_buffered_io_read
+    File.open("foo", "w") do |file|
+      file.syswrite("012345678901234567890123456789")
+    end
+
+    file = File.open("foo", "r+")
+    file.read(5)
+    file.syswrite("abcde")
+
+    File.open("foo") do |file|
+      assert_equal "01234abcde", file.sysread(10)
+    end
+  end
+
+  def test_writes_all_of_the_strings_bytes_but_does_not_buffer_them
+    File.open("foo", "w") do |file|
+      file.syswrite("012345678901234567890123456789")
+    end
+
+    file = File.open("foo", "r+")
+    written = file.syswrite("abcde")
+
+    File.open("foo") do |file|
+      assert_equal "abcde56789", file.sysread(10)
+      file.seek(0)
+      file.fsync
+      assert_equal "abcde56789", file.sysread(10)
+    end
+  end
+end

data/test/fake/file_test.rb

@@ -1,13 +1,11 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
-require 'fakefs/safe'
-require 'test/unit'
+require "test_helper"
 
 class FakeFileTest < Test::Unit::TestCase
   include FakeFS
 
   def setup
     FileSystem.clear
-    
+
     @file = FakeFile.new
   end
 
@@ -43,9 +41,9 @@ class FakeFileTest < Test::Unit::TestCase
 
   def test_links_are_mutual
     other_file = FakeFile.new
-  
+
     @file.link(other_file)
-  
+
     assert_equal [@file, other_file], other_file.links
   end
 
@@ -85,4 +83,15 @@ class FakeFileTest < Test::Unit::TestCase
     assert_equal "foo", clone.content
     assert_equal "bar", @file.content
   end
+
+  def test_raises_an_error_with_the_correct_path
+    path = "/some/non/existing/file"
+    begin
+      FakeFS::File.new path
+      msg = nil
+    rescue Errno::ENOENT => e
+      msg = e.message
+    end
+    assert_equal "No such file or directory - #{path}", msg
+  end
 end

data/test/fake/symlink_test.rb

@@ -1,6 +1,4 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
-require 'fakefs/safe'
-require 'test/unit'
+require "test_helper"
 
 class FakeSymlinkTest < Test::Unit::TestCase
   include FakeFS