fakefs 0.1.0 → 0.2.1

data/.gitignore

@@ -0,0 +1 @@
+*.sw?

data/CONTRIBUTORS

@@ -0,0 +1,12 @@
+* Chris Wanstrath
+* Jeff Hodges
+* Scott Taylor
+* Pat Nakajima
+* Myles Eftos
+* Matt Freels
+* Nick Quaranto
+* Tymon Tobolski
+* msassak
+* Rob Sanheim
+* Jon Yurek
+* David Reese

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
@@ -48,21 +48,54 @@ Don't Fake the FS Immediately
     end
 
 
+RSpec
+-----------------------------
+The above approach works with RSpec as well. In addition to this you may use the
+'use_fakefs' macro to turn FakeFS on and off in a given example group.  See
+lib/spec_helpers for more details on it's usage.
+
+
 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.
 
 
+Caveats
+-------
+
+FakeFS internally uses the `Pathname` and `FileUtils` constants. If you use
+these in your app, be certain you're properly requiring them and not counting
+on FakeFS' own require.
+
+
 Speed?
 ------
-http://gist.github.com/156091
+<http://gist.github.com/156091>
 
 
-Authors
--------
+Installation
+------------
+
+### [Gemcutter](http://gemcutter.org/)
+
+    $ gem install fakefs
+
+### [Rip](http://hellorip.com)
+
+    $ rip install git://github.com/defunkt/fakefs.git
+
+
+Meta
+----
 
-* Chris Wanstrath [chris@ozmm.org]
-* Pat Nakajima [http://github.com/nakajima]
+* Code: `git clone git://github.com/defunkt/fakefs.git`
+* Home: <http://github.com/defunkt/fakefs>
+* 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,29 @@ 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
+
+desc "Build a gem"
+task :gem => [ :gemspec, :build ]
+
+desc "Push a new version to Gemcutter"
+task :publish => [ :gemspec, :build ] do
+  abort("Tests failed!") unless system("rake test")
+  system "git tag v#{FakeFS::Version}"
+  system "git push origin v#{FakeFS::Version}"
+  system "git push origin master"
+  system "gem push pkg/fakefs-#{FakeFS::Version}.gem"
+  system "git clean -fd"
+  exec "rake pages"
 end

data/lib/fakefs/base.rb

@@ -32,6 +32,7 @@ def FakeFS
   return ::FakeFS unless block_given?
   ::FakeFS.activate!
   yield
-  ::FakeFS.deactivate!
+ensure
+::FakeFS.deactivate!
 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.basename(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,61 @@
 module FakeFS
   class FakeFile
-    attr_accessor :name, :parent, :content
+    attr_accessor :name, :parent, :content, :mtime
+
+    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
+
+      def clone
+        clone = super
+        clone.content = content.dup
+        clone
+      end
+    end
 
     def initialize(name = nil, parent = nil)
-      @name = name
+      @name   = name
       @parent = parent
-      @content = ''
+      @inode  = Inode.new(self)
+      @mtime  = Time.now
+    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 +70,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,34 @@ 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]
+
+    MODE_BITMASK = RealFile::RDONLY   |
+                   RealFile::WRONLY   |
+                   RealFile::RDWR     |
+                   RealFile::APPEND   |
+                   RealFile::CREAT    |
+                   RealFile::EXCL     |
+                   RealFile::NONBLOCK |
+                   RealFile::TRUNC    |
+                   RealFile::NOCTTY   |
+                   RealFile::SYNC
+
+    FILE_CREATION_BITMASK = RealFile::CREAT
+
+    def self.extname(path)
+      RealFile.extname(path)
+    end
+
     def self.join(*parts)
       parts * PATH_SEPARATOR
     end
@@ -12,6 +40,30 @@ module FakeFS
 
     class << self
       alias_method :exists?, :exist?
+
+      # Assuming that everyone can read and write files
+      alias_method :readable?, :exist?
+      alias_method :writable?, :exist?
+    end
+
+    def self.mtime(path)
+      if exists?(path)
+        FileSystem.find(path).mtime
+      else
+        raise Errno::ENOENT
+      end
+    end
+
+    def self.size(path)
+      read(path).length
+    end
+
+    def self.size?(path)
+      if exists?(path) && !size(path).zero?
+        true
+      else
+        nil
+      end
     end
 
     def self.const_missing(name)
@@ -61,11 +113,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
 
@@ -82,43 +134,149 @@ module FakeFS
       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_modes!
+
+      file_creation_mode? ? create_missing_file : check_file_existence!
+
+      @stream = StringIO.new(@file.content, mode)
     end
 
     def close
       @open = false
     end
 
-    def read
-      raise IOError.new('closed stream') unless @open
-      @file.content
+    def read(chunk = nil)
+      @stream.read(chunk)
+    end
+
+    def rewind
+      @stream.rewind
     end
 
     def exists?
-      @file
+      true
     end
 
-    def puts(content)
-      write(content + "\n")
+    def puts(*content)
+      @stream.puts(*content)
     end
 
     def write(content)
-      raise IOError.new('closed stream') unless @open
-
-      if !File.exists?(@path)
-        @file = FileSystem.add(path, FakeFile.new)
-      end
-
-      @file.content += content
+      @stream.write(content)
     end
     alias_method :print, :write
     alias_method :<<, :write
 
     def flush; self; end
+
+    def seek(amount, whence = SEEK_SET)
+      @stream.seek(amount, whence)
+    end
+
+  private
+
+    def check_modes!
+      StringIO.new("", @mode)
+    end
+
+    def check_file_existence!
+      unless @file
+        raise Errno::ENOENT, "No such file or directory - #{@file}"
+      end
+    end
+
+    def file_creation_mode?
+      mode_in?(FILE_CREATION_MODES) || mode_in_bitmask?(FILE_CREATION_BITMASK)
+    end
+
+    def mode_in?(list)
+      list.any? { |element| @mode.include?(element) } if @mode.respond_to?(:include?)
+    end
+
+    def mode_in_bitmask?(mask)
+      (@mode & mask) != 0 if @mode.is_a?(Integer)
+    end
+
+    def create_missing_file
+      if !File.exists?(@path)
+        @file = FileSystem.add(path, FakeFile.new)
+      end
+    end
   end
 end

data/lib/fakefs/file_system.rb

@@ -22,9 +22,9 @@ module FakeFS
     def find(path)
       parts = path_parts(normalize_path(path))
       return fs if parts.empty? # '/'
-      
+
       entries = find_recurser(fs, parts).flatten
-      
+
       case entries.length
       when 0 then nil
       when 1 then entries.first
@@ -54,7 +54,7 @@ module FakeFS
       files.each do |f|
         if RealFile.file?(f)
           FileUtils.mkdir_p(File.dirname(f))
-          File.open(f, 'w') do |g|
+          File.open(f, File::WRITE_ONLY) do |g|
             g.print RealFile.open(f){|h| h.read }
           end
         elsif RealFile.directory?(f)
@@ -66,8 +66,8 @@ module FakeFS
     end
 
     def delete(path)
-      if dir = FileSystem.find(path)
-        dir.parent.delete(dir.name)
+      if node = FileSystem.find(path)
+        node.delete
       end
     end
 
@@ -106,13 +106,31 @@ module FakeFS
       return [] unless dir.respond_to? :[]
 
       pattern , *parts = parts
-      matches = dir.reject {|k,v| /\A#{pattern.gsub('?','.').gsub('*', '.*')}\Z/ !~ k }.values
+      matches = case pattern
+      when '**'
+        case parts
+        when ['*'], []
+          parts = [] # end recursion
+          directories_under(dir).map do |d|
+            d.values.select{|f| f.is_a? FakeFile }
+          end.flatten.uniq
+        else
+          directories_under(dir)
+        end
+      else
+        dir.reject {|k,v| /\A#{pattern.gsub('?','.').gsub('*', '.*')}\Z/ !~ k }.values
+      end
 
       if parts.empty? # we're done recursing
         matches
       else
         matches.map{|entry| find_recurser(entry, parts) }
       end
-    end    
+    end
+
+    def directories_under(dir)
+      children = dir.values.select{|f| f.is_a? FakeDir}
+      ([dir] + children + children.map{|c| directories_under(c)}).flatten.uniq
+    end
   end
 end