madpilot-fakefs 0.1.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,68 @@
+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 
+tightly coupling your tests with the implementation.
+
+    def test_creates_directory
+      FileUtils.expects(:mkdir).with("directory").once
+      Library.add "directory"
+    end
+
+The above test will break if we decide to use `mkdir_p` in our code. Refactoring
+code shouldn't necessitate refactoring tests.
+
+With FakeFS:
+
+    def test_creates_directory
+      Library.add "directory"
+      assert File.directory?("directory")
+    end
+
+Woot.
+
+
+Usage
+-----
+
+    require 'fakefs'
+
+    # That's it.
+
+
+Don't Fake the FS Immediately
+-----------------------------
+
+    require 'fakefs/safe'
+    
+    FakeFS.activate!
+    # your code
+    FakeFS.deactivate!
+    
+    # or
+    FakeFS do
+      # your code
+    end
+
+
+How is this different than MockFS?
+----------------------------------
+
+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
+
+
+Authors
+-------
+
+* Chris Wanstrath [chris@ozmm.org]
+* Pat Nakajima [http://github.com/nakajima]

data/Rakefile

@@ -0,0 +1,40 @@
+task :default do
+  Dir['test/*_test.rb'].each { |file| require file }
+end
+
+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."
+    gemspec.email = "chris@ozmm.org"
+    gemspec.homepage = "http://github.com/defunkt/fakefs"
+    gemspec.description = "A fake filesystem. Use it in your tests."
+    gemspec.authors = ["Chris Wanstrath"]
+    gemspec.has_rdoc = false
+  end
+rescue LoadError
+  puts "Jeweler not available."
+  puts "Install it with: gem install technicalpickles-jeweler"
+end

data/lib/fakefs/base.rb

@@ -0,0 +1,37 @@
+RealFile = File
+RealFileUtils = FileUtils
+RealDir = Dir
+RealFileUtils::Dir = RealDir
+RealFileUtils::File = RealFile
+
+module FakeFS
+  def self.activate!
+    Object.class_eval do
+      remove_const(:Dir)
+      remove_const(:File)
+      remove_const(:FileUtils)
+      const_set(:Dir, FakeFS::Dir)
+      const_set(:File, FakeFS::File)
+      const_set(:FileUtils, FakeFS::FileUtils)
+    end
+  end
+
+  def self.deactivate!
+    Object.class_eval do
+      remove_const(:Dir)
+      remove_const(:File)
+      remove_const(:FileUtils)
+      const_set(:Dir, RealDir)
+      const_set(:File, RealFile)
+      const_set(:FileUtils, RealFileUtils)
+    end
+  end
+end
+
+def FakeFS
+  return ::FakeFS unless block_given?
+  ::FakeFS.activate!
+  yield
+  ::FakeFS.deactivate!
+end
+

data/lib/fakefs/dir.rb

@@ -0,0 +1,114 @@
+module FakeFS
+  class Dir
+    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 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)
+      glob(pattern)
+    end
+
+    def self.chdir(dir, &blk)
+      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 tmpdir
+      '/tmp'
+    end
+
+    def self.pwd
+      FileSystem.current_dir.to_s
+    end
+
+    class << self
+      alias_method :getwd, :pwd
+      alias_method :rmdir, :delete
+      alias_method :unline, :delete
+    end
+  end
+end

data/lib/fakefs/fake/dir.rb

@@ -0,0 +1,37 @@
+module FakeFS
+  class FakeDir < Hash
+    attr_accessor :name, :parent
+
+    def initialize(name = nil, parent = nil)
+      @name = name
+      @parent = parent
+    end
+
+    def entry
+      self
+    end
+
+    def inspect
+      "(FakeDir name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{size})"
+    end
+
+    def clone(parent = nil)
+      clone = Marshal.load(Marshal.dump(self))
+      clone.each do |key, value|
+        value.parent = clone
+      end
+      clone.parent = parent if parent
+      clone
+    end
+
+    def to_s
+      if parent && parent.to_s != '.'
+        File.join(parent.to_s, name)
+      elsif parent && parent.to_s == '.'
+        "#{File::PATH_SEPARATOR}#{name}"
+      else
+        name
+      end
+    end
+  end
+end

data/lib/fakefs/fake/file.rb

@@ -0,0 +1,29 @@
+module FakeFS
+  class FakeFile
+    attr_accessor :name, :parent, :content
+
+    def initialize(name = nil, parent = nil)
+      @name = name
+      @parent = parent
+      @content = ''
+    end
+
+    def clone(parent = nil)
+      clone = super()
+      clone.parent = parent if parent
+      clone
+    end
+
+    def entry
+      self
+    end
+
+    def inspect
+      "(FakeFile name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{content.size})"
+    end
+
+    def to_s
+      File.join(parent.to_s, name)
+    end
+  end
+end

data/lib/fakefs/fake/symlink.rb

@@ -0,0 +1,26 @@
+module FakeFS
+  class FakeSymlink
+    attr_accessor :name, :target
+    alias_method  :to_s, :name
+
+    def initialize(target)
+      @target = target
+    end
+
+    def inspect
+      "symlink(#{target.split('/').last})"
+    end
+
+    def entry
+      FileSystem.find(target)
+    end
+
+    def method_missing(*args, &block)
+      entry.send(*args, &block)
+    end
+
+    def respond_to?(method)
+      entry.respond_to?(method)
+    end
+  end
+end

data/lib/fakefs/file.rb

@@ -0,0 +1,126 @@
+module FakeFS
+  class File
+    PATH_SEPARATOR = '/'
+
+    def self.join(*parts)
+      parts * PATH_SEPARATOR
+    end
+
+    def self.exist?(path)
+      !!FileSystem.find(path)
+    end
+
+    class << self
+      alias_method :exists?, :exist?
+    end
+
+    def self.const_missing(name)
+      RealFile.const_get(name)
+    end
+
+    def self.directory?(path)
+      if path.respond_to? :entry
+        path.entry.is_a? FakeDir
+      else
+        result = FileSystem.find(path)
+        result ? result.entry.is_a?(FakeDir) : false
+      end
+    end
+
+    def self.symlink?(path)
+      if path.respond_to? :entry
+        path.is_a? FakeSymlink
+      else
+        FileSystem.find(path).is_a? FakeSymlink
+      end
+    end
+
+    def self.file?(path)
+      if path.respond_to? :entry
+        path.entry.is_a? FakeFile
+      else
+        result = FileSystem.find(path)
+        result ? result.entry.is_a?(FakeFile) : false
+      end
+    end
+
+    def self.expand_path(*args)
+      RealFile.expand_path(*args)
+    end
+
+    def self.basename(*args)
+      RealFile.basename(*args)
+    end
+
+    def self.dirname(path)
+      RealFile.dirname(path)
+    end
+
+    def self.readlink(path)
+      symlink = FileSystem.find(path)
+      FileSystem.find(symlink.target).to_s
+    end
+
+    def self.open(path, mode='r')
+      if block_given?
+        yield new(path, mode)
+      else
+        new(path, mode)
+      end
+    end
+
+    def self.read(path)
+      file = new(path)
+      if file.exists?
+        file.read
+      else
+        raise Errno::ENOENT
+      end
+    end
+
+    def self.readlines(path)
+      read(path).split("\n")
+    end
+
+    attr_reader :path
+    def initialize(path, mode = nil)
+      @path = path
+      @mode = mode
+      @file = FileSystem.find(path)
+      @open = true
+    end
+
+    def close
+      @open = false
+    end
+
+    def read
+      raise IOError.new('closed stream') unless @open
+      @file.content
+    end
+
+    def exists?
+      @file
+    end
+
+    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
+
+      @file.content += content
+    end
+    alias_method :print, :write
+    alias_method :<<, :write
+
+    def flush; self; end
+  end
+end

data/lib/fakefs/file_system.rb

@@ -0,0 +1,118 @@
+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, 'w') 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 dir = FileSystem.find(path)
+        dir.parent.delete(dir.name)
+      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 = dir.reject {|k,v| /\A#{pattern.gsub('?','.').gsub('*', '.*')}\Z/ !~ k }.values
+
+      if parts.empty? # we're done recursing
+        matches
+      else
+        matches.map{|entry| find_recurser(entry, parts) }
+      end
+    end    
+  end
+end