memfs 0.0.1

data/lib/memfs/file_system.rb

@@ -0,0 +1,157 @@
+require 'singleton'
+require 'memfs/fake/directory'
+require 'memfs/fake/file'
+require 'memfs/fake/symlink'
+
+module MemFs
+  class FileSystem
+    include Singleton
+
+    attr_accessor :working_directory
+    attr_accessor :registred_entries
+    attr_accessor :root
+
+    def basename(path)
+      File.basename(path)
+    end
+
+    def chdir(path, &block)
+      destination = find_directory!(path)
+
+      previous_directory = working_directory
+      self.working_directory = destination
+
+      block.call if block
+    ensure
+      if block
+        self.working_directory = previous_directory
+      end
+    end
+
+    def clear!
+      self.root = Fake::Directory.new('/')
+      self.chdir('/')
+    end
+
+    def chmod(mode_int, file_name)
+      find!(file_name).mode = mode_int
+    end
+
+    def chown(uid, gid, path)
+      entry = find!(path).dereferenced
+      entry.uid = uid if uid && uid != -1
+      entry.gid = gid if gid && gid != -1
+    end
+
+    def directory?(path)
+      find(path).is_a?(Fake::Directory)
+    end
+
+    def dirname(path)
+      File.dirname(path)
+    end
+
+    def entries(path)
+      find_directory!(path).entry_names
+    end
+
+    def find(path)
+      if path == '/'
+        root
+      elsif dirname(path) == '.'
+        working_directory.find(path)
+      else
+        root.find(path)
+      end
+    end
+
+    def find!(path)
+      find(path) || raise(Errno::ENOENT, path)
+    end
+
+    def find_directory!(path)
+      entry = find!(path).dereferenced
+
+      raise Errno::ENOTDIR, path unless entry.is_a?(Fake::Directory)
+
+      entry
+    end
+
+    def find_parent!(path)
+      parent_path = dirname(path)
+      find_directory!(parent_path)
+    end
+
+    def getwd
+      working_directory.path
+    end
+    alias :pwd :getwd
+
+    def initialize
+      clear!
+    end
+
+    def link(old_name, new_name)
+      file = find!(old_name)
+
+      raise Errno::EEXIST, "(#{old_name}, #{new_name})" if find(new_name)
+
+      link = file.dup
+      link.name = basename(new_name)
+      find_parent!(new_name).add_entry link
+    end
+
+    def mkdir(path)
+      raise Errno::EEXIST, path if find(path)
+      find_parent!(path).add_entry Fake::Directory.new(path)
+    end
+
+    def rename(old_name, new_name)
+      file = find!(old_name)
+      file.delete
+
+      file.name = basename(new_name)
+      find_parent!(new_name).add_entry(file)
+    end
+
+    def rmdir(path)
+      directory = find!(path)
+
+      raise Errno::ENOTEMPTY, path unless directory.empty?
+
+      directory.delete
+    end
+
+    def symlink(old_name, new_name)
+      raise Errno::EEXIST, new_name if find(new_name)
+
+      find_parent!(new_name).add_entry Fake::Symlink.new(new_name, old_name)
+    end
+
+    def symlink?(path)
+      find(path).is_a?(Fake::Symlink)
+    end
+
+    def touch(*paths)
+      paths.each do |path|
+        entry = find(path)
+
+        unless entry
+          entry = Fake::File.new(path)
+          parent_dir = find_parent!(path)
+          parent_dir.add_entry entry
+        end
+
+        entry.touch
+      end
+    end
+
+    def unlink(path)
+      entry = find!(path)
+
+      raise Errno::EPERM, path if entry.is_a?(Fake::Directory)
+
+      entry.delete
+    end
+  end
+end

data/lib/memfs/filesystem_access.rb

@@ -0,0 +1,7 @@
+module MemFs
+  module FilesystemAccess
+    def fs
+      FileSystem.instance
+    end
+  end
+end

data/lib/memfs/version.rb

@@ -0,0 +1,3 @@
+module MemFs
+  VERSION = '0.0.1'
+end

data/lib/memfs.rb

@@ -0,0 +1,100 @@
+require 'memfs/version'
+
+# Provides a clean way to interact with a fake file system.
+#
+# @example Calling activate with a block.
+#   MemFs.activate do
+#     Dir.mkdir '/hello_world'
+#     # /hello_world exists here, in memory
+#   end
+#   # /hello_world doesn't exist and has never been on the real FS
+#
+# @example Calling activate! and deactivate!.
+#   MemFs.activate!
+#     # The fake file system is running here
+#   MemFs.deactivate!
+#   # Everything back to normal
+module MemFs
+  extend self
+
+  # Keeps track of the original Ruby Dir class.
+  OriginalDir  = ::Dir
+
+  # Keeps track of the original Ruby File class.
+  OriginalFile = ::File
+
+  require 'memfs/file_system'
+  require 'memfs/dir'
+  require 'memfs/file'
+  require 'memfs/file/stat'
+
+  # Calls the given block with MemFs activated.
+  #
+  # The advantage of using {#activate} against {#activate!} is that, in case an
+  # exception occurs, MemFs is deactivated.
+  #
+  # @yield with no argument.
+  #
+  # @example
+  #   MemFs.activate do
+  #     Dir.mkdir '/hello_world'
+  #     # /hello_world exists here, in memory
+  #   end
+  #   # /hello_world doesn't exist and has never been on the real FS
+  #
+  # @example Exception in activate block.
+  #   MemFs.activate do
+  #     raise "Some Error"
+  #   end
+  #   # Still back to the original Ruby classes
+  #
+  # @return nothing.
+  def activate
+    activate!
+    yield
+  ensure
+    deactivate!
+  end
+
+  # Activates the fake file system.
+  #
+  # @note Don't forget to call {#deactivate!} to disable the fake file system,
+  #   you may have some issues in your scripts or tests otherwise.
+  #
+  # @example
+  #   MemFs.activate!
+  #   Dir.mkdir '/hello_world'
+  #   # /hello_world exists here, in memory
+  #   MemFs.deactivate!
+  #   # /hello_world doesn't exist and has never been on the real FS
+  #
+  # @see #deactivate!
+  # @return nothing.
+  def activate!
+    Object.class_eval do
+      remove_const :Dir
+      remove_const :File
+
+      const_set :Dir,  MemFs::Dir
+      const_set :File, MemFs::File
+    end
+
+    MemFs::FileSystem.instance.clear!
+  end
+
+  # Deactivates the fake file system.
+  #
+  # @note This method should always be called when using activate!
+  #
+  # @see #activate!
+  # @return nothing.
+  def deactivate!
+    Object.class_eval do
+      remove_const :Dir
+      remove_const :File
+
+      const_set :Dir,  MemFs::OriginalDir
+      const_set :File, MemFs::OriginalFile
+    end
+  end
+end

data/memfs.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'memfs/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "memfs"
+  gem.version       = MemFs::VERSION
+  gem.authors       = ["Simon COURTOIS"]
+  gem.email         = ["scourtois@cubyx.fr"]
+  gem.description   = "MemFs provides a fake file system that can be used " \
+                      "for tests. Strongly inspired by FakeFS."
+  gem.summary       = "memfs-#{MemFs::VERSION}"
+  gem.homepage      = "http://github.com/simonc/memfs"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "coveralls", "~> 0.6"
+  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "rspec", "~> 2.12"
+  gem.add_development_dependency "guard", "~> 1.5"
+  gem.add_development_dependency "guard-rspec", "~> 2.1"
+  gem.add_development_dependency "rb-inotify", "~> 0.8"
+  gem.add_development_dependency "rb-fsevent", "~> 0.9"
+  gem.add_development_dependency "rb-fchange", "~> 0.0"
+end