fakefs 0.1.0 → 0.2.0

data/README.markdown

@@ -4,7 +4,7 @@ FakeFS
 Mocha is great. But when your library is all about manipulating the
 filesystem, you really want to test the behavior and not the implementation.
 
-If you're mocking and stubbing every call to FileUtils or File, you're 
+If you're mocking and stubbing every call to FileUtils or File, you're
 tightly coupling your tests with the implementation.
 
     def test_creates_directory
@@ -51,18 +51,51 @@ Don't Fake the FS Immediately
 How is this different than MockFS?
 ----------------------------------
 
-FakeFS provides a test suite and works with symlinks. It's also strictly a 
+FakeFS provides a test suite and works with symlinks. It's also strictly a
 test-time dependency: your actual library does not need to use or know about
 FakeFS.
 
 
 Speed?
 ------
-http://gist.github.com/156091
+<http://gist.github.com/156091>
 
 
-Authors
--------
+Installation
+------------
 
-* Chris Wanstrath [chris@ozmm.org]
-* Pat Nakajima [http://github.com/nakajima]
+### [Gemcutter](http://gemcutter.org/)
+
+    $ gem install fakefs
+
+### [Rip](http://hellorip.com)
+
+    $ rip install git://github.com/defunkt/fakefs.git
+
+
+Contributors
+------------
+
+* Chris Wanstrath
+* David Reese
+* Jeff Hodges
+* Jon Yurek
+* Matt Freels
+* Myles Eftos
+* Pat Nakajima
+* Rob Sanheim
+* Scott Taylor
+* Tymon Tobolski
+* msassak
+
+
+Meta
+----
+
+* Code: `git clone git://github.com/defunkt/fakefs.git`
+* Docs: <http://defunkt.github.com/fakefs>
+* Bugs: <http://github.com/defunkt/fakefs/issues>
+* List: <http://groups.google.com/group/fakefs>
+* Test: <http://runcoderun.com/defunkt/fakefs>
+* Gems: <http://gemcutter.org/gems/fakefs>
+* Boss: Chris Wanstrath :: <http://github.com/defunkt>

data/Rakefile

@@ -1,30 +1,16 @@
-task :default do
-  Dir['test/*_test.rb'].each { |file| require file }
+desc "Run tests"
+task :test do
+  Dir['test/**/*_test.rb'].each { |file| require file }
 end
 
+task :default => :test
+
 begin
   require 'jeweler'
 
-  # We're not putting VERSION or VERSION.yml in the root,
-  # so we have to help Jeweler find our version.
   $LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
   require 'fakefs/version'
 
-  FakeFS::Version.instance_eval do
-    def refresh
-    end
-  end
-
-  class Jeweler
-    def version_helper
-      FakeFS::Version
-    end
-
-    def version_exists?
-      true
-    end
-  end
-
   Jeweler::Tasks.new do |gemspec|
     gemspec.name = "fakefs"
     gemspec.summary = "A fake filesystem. Use it in your tests."
@@ -33,8 +19,15 @@ begin
     gemspec.description = "A fake filesystem. Use it in your tests."
     gemspec.authors = ["Chris Wanstrath"]
     gemspec.has_rdoc = false
+    gemspec.version = FakeFS::Version.to_s
   end
 rescue LoadError
   puts "Jeweler not available."
-  puts "Install it with: gem install technicalpickles-jeweler"
+  puts "Install it with: gem install jeweler"
+end
+
+begin
+  require 'sdoc_helpers'
+rescue LoadError
+  puts "sdoc support not enabled. Please gem install sdoc-helpers."
 end

data/lib/fakefs/base.rb

@@ -31,7 +31,8 @@ end
 def FakeFS
   return ::FakeFS unless block_given?
   ::FakeFS.activate!
-  yield
+  result = yield
   ::FakeFS.deactivate!
+  result
 end
 

data/lib/fakefs/dir.rb

@@ -1,7 +1,55 @@
 module FakeFS
   class Dir
-    def self.glob(pattern)
-      [FileSystem.find(pattern) || []].flatten.map{|e| e.to_s}.sort
+    include Enumerable
+
+    def initialize(string)
+      raise Errno::ENOENT, string unless FileSystem.find(string)
+      @path = string
+      @open = true
+      @pointer = 0
+      @contents = [ '.', '..', ] + FileSystem.find(@path).values
+    end
+
+    def close
+      @open = false
+      @pointer = nil
+      @contents = nil
+      nil
+    end
+
+    def each(&block)
+      while f = read
+        yield f
+      end
+    end
+
+    def path
+      @path
+    end
+
+    def pos
+      @pointer
+    end
+
+    def pos=(integer)
+      @pointer = integer
+    end
+
+    def read
+      raise IOError, "closed directory" if @pointer == nil
+      n = @contents[@pointer]
+      @pointer += 1
+      n.to_s.gsub(path + '/', '') if n
+    end
+
+    def rewind
+      @pointer = 0
+    end
+
+    def seek(integer)
+      raise IOError, "closed directory" if @pointer == nil
+      @pointer = integer
+      @contents[integer]
     end
 
     def self.[](pattern)
@@ -12,12 +60,55 @@ module FakeFS
       FileSystem.chdir(dir, &blk)
     end
 
+    def self.chroot(string)
+      # Not implemented yet
+    end
+
+    def self.delete(string)
+      raise SystemCallError, "No such file or directory - #{string}" unless FileSystem.find(string).values.empty?
+      FileSystem.delete(string)
+    end
+
+    def self.entries(dirname)
+      raise SystemCallError, dirname unless FileSystem.find(dirname)
+      Dir.new(dirname).map { |file| file }
+    end
+
+    def self.foreach(dirname, &block)
+      Dir.open(dirname) { |file| yield file }
+    end
+
+    def self.glob(pattern)
+      [FileSystem.find(pattern) || []].flatten.map{|e| e.to_s}.sort
+    end
+
+    def self.mkdir(string, integer = 0)
+      parent = string.split('/')
+      parent.pop
+      raise Errno::ENOENT, "No such file or directory - #{string}" unless parent.join == "" || FileSystem.find(parent.join('/'))
+      FileUtils.mkdir_p(string)
+    end
+
+    def self.open(string, &block)
+      if block_given?
+        Dir.new(string).each { |file| yield(file) }
+      else
+        Dir.new(string)
+      end
+    end
+
+    def self.tmpdir
+      '/tmp'
+    end
+
     def self.pwd
       FileSystem.current_dir.to_s
     end
 
     class << self
       alias_method :getwd, :pwd
+      alias_method :rmdir, :delete
+      alias_method :unlink, :delete
     end
   end
 end

data/lib/fakefs/fake/dir.rb

@@ -33,5 +33,13 @@ module FakeFS
         name
       end
     end
+
+    def delete(node = self)
+      if node == self
+        parent.delete(self)
+      else
+        super(node.name)
+      end
+    end
   end
 end

data/lib/fakefs/fake/file.rb

@@ -1,16 +1,54 @@
 module FakeFS
   class FakeFile
-    attr_accessor :name, :parent, :content
+    attr_accessor :name, :parent
+
+    class Inode
+      def initialize(file_owner)
+        @content = ""
+        @links   = [file_owner]
+      end
+
+      attr_accessor :content
+      attr_accessor :links
+
+      def link(file)
+        links << file unless links.include?(file)
+        file.inode = self
+      end
+
+      def unlink(file)
+        links.delete(file)
+      end
+    end
 
     def initialize(name = nil, parent = nil)
-      @name = name
+      @name   = name
       @parent = parent
-      @content = ''
+      @inode  = Inode.new(self)
+    end
+
+    attr_accessor :inode
+
+    def content
+      @inode.content
+    end
+
+    def content=(str)
+      @inode.content = str
+    end
+
+    def links
+      @inode.links
+    end
+
+    def link(other_file)
+      @inode.link(other_file)
     end
 
     def clone(parent = nil)
       clone = super()
       clone.parent = parent if parent
+      clone.inode  = inode.clone
       clone
     end
 
@@ -25,5 +63,10 @@ module FakeFS
     def to_s
       File.join(parent.to_s, name)
     end
+
+    def delete
+      inode.unlink(self)
+      parent.delete(self)
+    end
   end
 end

data/lib/fakefs/fake/symlink.rb

@@ -15,12 +15,18 @@ module FakeFS
       FileSystem.find(target)
     end
 
-    def method_missing(*args, &block)
-      entry.send(*args, &block)
+    def delete
+      parent.delete(self)
     end
 
     def respond_to?(method)
       entry.respond_to?(method)
     end
+
+  private
+    
+    def method_missing(*args, &block)
+      entry.send(*args, &block)
+    end
   end
 end

data/lib/fakefs/file.rb

@@ -2,6 +2,35 @@ module FakeFS
   class File
     PATH_SEPARATOR = '/'
 
+    MODES = [
+      READ_ONLY           = "r",
+      READ_WRITE          = "r+",
+      WRITE_ONLY          = "w",
+      READ_WRITE_TRUNCATE = "w+",
+      APPEND_WRITE_ONLY   = "a",
+      APPEND_READ_WRITE   = "a+"
+    ]
+
+    FILE_CREATION_MODES = MODES - [READ_ONLY, READ_WRITE]
+
+    READ_ONLY_MODES = [
+      READ_ONLY
+    ]
+
+    WRITE_ONLY_MODES = [
+      WRITE_ONLY,
+      APPEND_WRITE_ONLY
+    ]
+
+    TRUNCATION_MODES = [
+      WRITE_ONLY,
+      READ_WRITE_TRUNCATE
+    ]
+
+    def self.extname(path)
+      RealFile.extname(path)
+    end
+
     def self.join(*parts)
       parts * PATH_SEPARATOR
     end
@@ -14,6 +43,10 @@ module FakeFS
       alias_method :exists?, :exist?
     end
 
+    def self.size(path)
+      read(path).length
+    end
+
     def self.const_missing(name)
       RealFile.const_get(name)
     end
@@ -61,11 +94,11 @@ module FakeFS
       FileSystem.find(symlink.target).to_s
     end
 
-    def self.open(path, mode='r')
+    def self.open(path, mode=READ_ONLY, perm = 0644)
       if block_given?
-        yield new(path, mode)
+        yield new(path, mode, perm)
       else
-        new(path, mode)
+        new(path, mode, perm)
       end
     end
 
@@ -81,13 +114,86 @@ module FakeFS
     def self.readlines(path)
       read(path).split("\n")
     end
+    
+    def self.link(source, dest)
+      if directory?(source)
+        raise Errno::EPERM, "Operation not permitted - #{source} or #{dest}"
+      end
+
+      if !exists?(source)
+        raise Errno::ENOENT, "No such file or directory - #{source} or #{dest}"
+      end
+      
+      if exists?(dest)
+        raise Errno::EEXIST, "File exists - #{source} or #{dest}"
+      end
+      
+      source = FileSystem.find(source)
+      dest = FileSystem.add(dest, source.entry.clone)
+      source.link(dest)
+
+      0
+    end
+
+    def self.delete(file_name, *additional_file_names)
+      if !exists?(file_name)
+        raise Errno::ENOENT, "No such file or directory - #{file_name}"
+      end
+
+      FileUtils.rm(file_name)
+
+      additional_file_names.each do |file_name|
+        FileUtils.rm(file_name)
+      end
+
+      additional_file_names.size + 1
+    end
+
+    class << self
+      alias_method :unlink, :delete
+    end
+
+    def self.symlink(source, dest)
+      FileUtils.ln_s(source, dest)
+    end
+
+    def self.stat(file)
+      File::Stat.new(file)
+    end
+
+    class Stat
+      def initialize(file)
+        if !File.exists?(file)
+          raise(Errno::ENOENT, "No such file or directory - #{file}")
+        end
+
+        @file = file
+      end
+
+      def symlink?
+        File.symlink?(@file)
+      end
+
+      def directory?
+        File.directory?(@file)
+      end
+
+      def nlink
+        FileSystem.find(@file).links.size
+      end
+    end
 
     attr_reader :path
-    def initialize(path, mode = nil)
+
+    def initialize(path, mode = READ_ONLY, perm = nil)
       @path = path
       @mode = mode
       @file = FileSystem.find(path)
       @open = true
+
+      check_valid_mode
+      file_creation_mode? ? create_missing_file : check_file_existence!
+      truncate_file if truncation_mode?
     end
 
     def close
@@ -95,7 +201,9 @@ module FakeFS
     end
 
     def read
-      raise IOError.new('closed stream') unless @open
+      raise IOError, 'closed stream' unless @open
+      raise IOError, 'not opened for reading' if write_only?
+
       @file.content
     end
 
@@ -103,16 +211,15 @@ module FakeFS
       @file
     end
 
-    def puts(content)
-      write(content + "\n")
+    def puts(*content)
+      content.flatten.each do |obj|
+        write(obj.to_s + "\n")
+      end
     end
 
     def write(content)
-      raise IOError.new('closed stream') unless @open
-
-      if !File.exists?(@path)
-        @file = FileSystem.add(path, FakeFile.new)
-      end
+      raise IOError, 'closed stream' unless @open
+      raise IOError, 'not open for writing' if read_only?
 
       @file.content += content
     end
@@ -120,5 +227,49 @@ module FakeFS
     alias_method :<<, :write
 
     def flush; self; end
+
+  private
+
+    def check_file_existence!
+      unless @file
+        raise Errno::ENOENT, "No such file or directory - #{@file}"
+      end
+    end
+
+    def check_valid_mode
+      if !mode_in?(MODES)
+        raise ArgumentError, "illegal access mode #{@mode}"
+      end
+    end
+
+    def read_only?
+      mode_in? READ_ONLY_MODES
+    end
+
+    def file_creation_mode?
+      mode_in? FILE_CREATION_MODES
+    end
+
+    def write_only?
+      mode_in? WRITE_ONLY_MODES
+    end
+
+    def truncation_mode?
+      mode_in? TRUNCATION_MODES
+    end
+
+    def mode_in?(list)
+      list.include?(@mode)
+    end
+
+    def create_missing_file
+      if !File.exists?(@path)
+        @file = FileSystem.add(path, FakeFile.new)
+      end
+    end
+
+    def truncate_file
+      @file.content = ""
+    end
   end
 end