ktheory-fakefs 0.2.1.1

data/lib/fakefs/file_system.rb

@@ -0,0 +1,136 @@
+module FakeFS
+  module FileSystem
+    extend self
+
+    def dir_levels
+      @dir_levels ||= []
+    end
+
+    def fs
+      @fs ||= FakeDir.new('.')
+    end
+
+    def clear
+      @dir_levels = nil
+      @fs = nil
+    end
+
+    def files
+      fs.values
+    end
+
+    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
+      else entries
+      end
+    end
+
+    def add(path, object=FakeDir.new)
+      parts = path_parts(normalize_path(path))
+
+      d = parts[0...-1].inject(fs) do |dir, part|
+        dir[part] ||= FakeDir.new(part, dir)
+      end
+
+      object.name = parts.last
+      object.parent = d
+      d[parts.last] ||= object
+    end
+
+    # copies directories and files from the real filesystem
+    # into our fake one
+    def clone(path)
+      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|
+        if RealFile.file?(f)
+          FileUtils.mkdir_p(File.dirname(f))
+          File.open(f, File::WRITE_ONLY) do |g|
+            g.print RealFile.open(f){|h| h.read }
+          end
+        elsif RealFile.directory?(f)
+          FileUtils.mkdir_p(f)
+        elsif RealFile.symlink?(f)
+          FileUtils.ln_s()
+        end
+      end
+    end
+
+    def delete(path)
+      if node = FileSystem.find(path)
+        node.delete
+      end
+    end
+
+    def chdir(dir, &blk)
+      new_dir = find(dir)
+      dir_levels.push dir if blk
+
+      raise Errno::ENOENT, dir unless new_dir
+
+      dir_levels.push dir if !blk
+      blk.call if blk
+    ensure
+      dir_levels.pop if blk
+    end
+
+    def path_parts(path)
+      path.split(File::PATH_SEPARATOR).reject { |part| part.empty? }
+    end
+
+    def normalize_path(path)
+      if Pathname.new(path).absolute?
+        File.expand_path(path)
+      else
+        parts = dir_levels + [path]
+        File.expand_path(File.join(*parts))
+      end
+    end
+
+    def current_dir
+      find(normalize_path('.'))
+    end
+
+    private
+
+    def find_recurser(dir, parts)
+      return [] unless dir.respond_to? :[]
+
+      pattern , *parts = parts
+      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
+
+    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

data/lib/fakefs/file_test.rb

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

data/lib/fakefs/fileutils.rb

@@ -0,0 +1,131 @@
+module FakeFS
+  module FileUtils
+    extend self
+
+    def mkdir_p(path)
+      FileSystem.add(path, FakeDir.new)
+    end
+    alias_method :mkpath, :mkdir_p
+
+    def rmdir(list, options = {})
+      list = [ list ] unless list.is_a?(Array)
+      list.each do |l|
+        parent = l.split('/')
+        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?
+        rm(l)
+      end
+    end
+
+    def rm(list, options = {})
+      Array(list).each do |path|
+        FileSystem.delete(path)
+      end
+    end
+
+    alias_method :rm_rf, :rm
+    alias_method :rm_r, :rm
+    alias_method :rm_f, :rm
+
+    def ln_s(target, path, options = {})
+      options = { :force => false }.merge(options)
+      (FileSystem.find(path) and !options[:force]) ? raise(Errno::EEXIST, path) : FileSystem.delete(path)
+      FileSystem.add(path, FakeSymlink.new(target))
+    end
+    def ln_sf(target, path)
+      ln_s(target, path, { :force => true })
+    end
+
+
+
+    def cp(src, dest)
+      dst_file = FileSystem.find(dest)
+      src_file = FileSystem.find(src)
+
+      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
+
+    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)
+
+      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
+
+      # 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) }
+        else
+          new_dir[dir.name] = dir.entry.clone(new_dir)
+        end
+      else
+        FileSystem.add(dest, dir.entry.clone)
+      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
+      end
+    end
+
+    def chown(user, group, list, options={})
+      list = Array(list)
+      list.each do |f|
+        unless File.exists?(f)
+          raise Errno::ENOENT, f
+        end
+      end
+      list
+    end
+
+    def chown_R(user, group, list, options={})
+      chown(user, group, list, options={})
+    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)
+        else
+          raise Errno::ENOENT, f
+        end
+      end
+    end
+
+    def cd(dir)
+      FileSystem.chdir(dir)
+    end
+    alias_method :chdir, :cd
+  end
+end

data/lib/fakefs/safe.rb

@@ -0,0 +1,11 @@
+require 'fileutils'
+require 'pathname'
+require 'fakefs/base'
+require 'fakefs/fake/file'
+require 'fakefs/fake/dir'
+require 'fakefs/fake/symlink'
+require 'fakefs/file_system'
+require 'fakefs/fileutils'
+require 'fakefs/file'
+require 'fakefs/file_test'
+require 'fakefs/dir'

data/lib/fakefs/spec_helpers.rb

@@ -0,0 +1,46 @@
+# FakeFS::SpecHelpers provides a simple macro for RSpec example groups to turn FakeFS on and off.
+# To use it simply require 'fakefs/spec_helpers', then include FakeFS::SpecHelpers into any
+# example groups that you wish to use FakeFS in. For example:
+#
+#   require 'fakefs/spec_helpers'
+#
+#   describe "Some specs that deal with files" do
+#     include FakeFS::SpecHelpers
+#     ...
+#   end
+#
+# Alternatively, you can include FakeFS::SpecHelpers in all your example groups using RSpec's
+# configuration block in your spec helper:
+#
+#   require 'fakefs/spec_helpers'
+#
+#   Spec::Runner.configure do |config|
+#     config.include FakeFS::SpecHelpers
+#   end
+#
+# If you do the above then use_fakefs will be available in all of your example groups.
+#
+require 'fakefs/safe'
+
+module FakeFS
+  module SpecHelpers
+    def self.extended(example_group)
+      example_group.use_fakefs(example_group)
+    end
+
+    def self.included(example_group)
+      example_group.extend self
+    end
+
+    def use_fakefs(describe_block)
+      describe_block.before :each do
+        FakeFS.activate!
+      end
+
+      describe_block.after :each do
+        FakeFS.deactivate!
+        FakeFS::FileSystem.clear
+      end
+    end
+  end
+end

data/lib/fakefs/version.rb

@@ -0,0 +1,9 @@
+module FakeFS
+  module Version
+    VERSION = "0.2.1"
+
+    def self.to_s
+      VERSION
+    end
+  end
+end

data/spec/fakefs/spec_helpers_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module FakeFS
+  describe SpecHelpers do
+    before do
+      @rspec_example_group = Class.new do
+        def self.before(sym = :each)
+          yield if block_given?
+        end
+
+        def self.after(sym = :each)
+          yield if block_given?
+        end
+      end
+    end
+
+    describe "when extending" do
+      context "before each" do
+        it "should call it" do
+          @rspec_example_group.should_receive(:before).with(:each)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should call FakeFS.activate!" do
+          FakeFS.should_receive(:activate!)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+      end
+
+      context "after each" do
+        it "should call it" do
+          @rspec_example_group.should_receive(:after).with(:each)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should deactivate fakefs" do
+          FakeFS.should_receive(:deactivate!)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+
+        it "should clear the fakefs filesystem for the next run" do
+          FakeFS::FileSystem.should_receive(:clear)
+          @rspec_example_group.extend FakeFS::SpecHelpers
+        end
+      end
+    end
+
+    describe "when including" do
+      it "should call before :each" do
+        @rspec_example_group.should_receive(:before)
+        @rspec_example_group.class_eval do
+          include FakeFS::SpecHelpers
+        end
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+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