memfs 0.0.1

data/lib/memfs/dir.rb

@@ -0,0 +1,33 @@
+require 'memfs/filesystem_access'
+
+module MemFs
+  class Dir
+    extend FilesystemAccess
+
+    def self.chdir(path, &block)
+      fs.chdir path, &block
+      return 0
+    end
+
+    def self.entries(dirname, opts = {})
+      fs.entries(dirname)
+    end
+
+    def self.exists?(path)
+      fs.directory?(path)
+    end
+
+    def self.getwd
+      fs.getwd
+    end
+    class << self; alias :pwd :getwd; end
+
+    def self.mkdir(path)
+      fs.mkdir path
+    end
+
+    def self.rmdir(path)
+      fs.rmdir path
+    end
+  end
+end

data/lib/memfs/fake/directory.rb

@@ -0,0 +1,51 @@
+require 'memfs/fake/entry'
+
+module MemFs
+  module Fake
+    class Directory < Entry
+      attr_accessor :entries
+
+      def add_entry(entry)
+        entries[entry.name] = entry
+        entry.parent = self
+      end
+
+      def empty?
+        (entries.keys - %w[. ..]).empty?
+      end
+
+      def entry_names
+        entries.keys
+      end
+
+      def find(path)
+        path = path.sub(/\A\/+/, '')
+        parts = path.split('/', 2)
+
+        if entry_names.include?(path)
+          entries[path]
+        elsif entry_names.include?(parts.first)
+          entries[parts.first].find(parts.last)
+        end
+      end
+
+      def initialize(*args)
+        super
+        self.entries = { '.' => self, '..' => nil }
+      end
+
+      def parent=(parent)
+        super
+        entries['..'] = parent
+      end
+
+      def path
+        name == '/' ? '/' : super
+      end
+
+      def remove_entry(entry)
+        entries.delete(entry.name)
+      end
+    end
+  end
+end

data/lib/memfs/fake/entry.rb

@@ -0,0 +1,73 @@
+module MemFs
+  module Fake
+    class Entry
+      UREAD  = 00100
+      UWRITE = 00200
+      UEXEC  = 00400
+      GREAD  = 00010
+      GWRITE = 00020
+      GEXEC  = 00040
+      OREAD  = 00001
+      OWRITE = 00002
+      OEXEC  = 00004
+      RSTICK = 01000
+      USTICK = 05000
+
+      attr_accessor :atime,
+                    :gid,
+                    :mtime,
+                    :name,
+                    :parent,
+                    :uid
+      attr_reader :mode
+
+      def blksize
+        4096
+      end
+
+      def delete
+        parent.remove_entry self
+      end
+
+      def dereferenced
+        self
+      end
+
+      def dev
+        @dev ||= rand(1000)
+      end
+
+      def find(path)
+        raise Errno::ENOTDIR, self.path
+      end
+
+      def initialize(path = nil)
+        current_user = Etc.getpwuid
+        time = Time.now
+        self.atime = time
+        self.gid = current_user.gid
+        self.mode = 0666 - MemFs::File.umask
+        self.mtime = time
+        self.name = MemFs::File.basename(path || '')
+        self.uid = current_user.uid
+      end
+
+      def ino
+        @ino ||= rand(1000)
+      end
+
+      def mode=(mode_int)
+        @mode = 0100000 | mode_int
+      end
+
+      def path
+        parts = [parent && parent.path, name].compact
+        MemFs::File.join(parts)
+      end
+
+      def touch
+        self.atime = self.mtime = Time.now
+      end
+    end
+  end
+end

data/lib/memfs/fake/file/content.rb

@@ -0,0 +1,47 @@
+require "delegate"
+
+module MemFs
+  module Fake
+    class File < Entry
+
+      class Content < SimpleDelegator
+        attr_accessor :pos
+
+        def close
+        end
+
+        def initialize(obj = '')
+          @string = obj.to_s.dup
+          @pos = 0
+
+          __setobj__ @string
+        end
+
+        def puts(*strings)
+          strings.each do |str|
+            @string << str
+            @string << $/ unless str.end_with?($/)
+          end
+        end
+
+        def read(length = nil, buffer = '')
+          length ||= @string.length - @pos
+          buffer.replace @string[@pos, length]
+          @pos += buffer.bytesize
+          buffer.empty? ? nil : buffer
+        end
+
+        def to_s
+          @string
+        end
+
+        def write(string)
+          text = string.to_s
+          @string << text
+          text.size
+        end
+      end
+
+    end
+  end
+end

data/lib/memfs/fake/file.rb

@@ -0,0 +1,36 @@
+require 'memfs/fake/entry'
+require 'memfs/fake/file/content'
+
+module MemFs
+  module Fake
+    class File < Entry
+      attr_accessor :content
+
+      def close
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+
+      def initialize(*args)
+        super
+        @content = Content.new
+        @closed = false
+      end
+
+      def pos
+        content.pos
+      end
+
+      def pos=(value)
+        content.pos = value
+      end
+
+      def size
+        content.size
+      end
+    end
+  end
+end

data/lib/memfs/fake/symlink.rb

@@ -0,0 +1,32 @@
+require 'memfs/filesystem_access'
+
+module MemFs
+  module Fake
+    class Symlink < Entry
+      include MemFs::FilesystemAccess
+
+      attr_reader :target
+
+      def dereferenced
+        @dereferenced ||= fs.find!(target).dereferenced
+      end
+
+      def initialize(path, target)
+        super(path)
+        @target = target
+      end
+
+      def method_missing(meth, *args, &block)
+        if dereferenced.respond_to?(meth)
+          dereferenced.public_send(meth, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(meth, include_private)
+        dereferenced.respond_to?(meth, include_private) || super
+      end
+    end
+  end
+end

data/lib/memfs/file/stat.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+require 'memfs/filesystem_access'
+
+module MemFs
+  class File
+    class Stat
+      extend Forwardable
+      include FilesystemAccess
+
+      attr_reader :entry
+
+      def_delegators :entry,
+                     :atime,
+                     :blksize,
+                     :dev,
+                     :gid,
+                     :ino,
+                     :mode,
+                     :mtime,
+                     :uid
+
+      def directory?
+        File.directory? entry.path
+      end
+
+      def file?
+        File.file? entry.path
+      end
+
+      def initialize(path, dereference = false)
+        entry = fs.find!(path)
+        @entry = dereference ? entry.dereferenced : entry
+      end
+
+      def sticky?
+        !!(entry.mode & Fake::Entry::USTICK).nonzero?
+      end
+
+      def symlink?
+        File.symlink? entry.path
+      end
+
+      def world_writable?
+        entry.mode if (entry.mode & Fake::Entry::OWRITE).nonzero?
+      end
+    end
+  end
+end

data/lib/memfs/file.rb

@@ -0,0 +1,284 @@
+require 'forwardable'
+require 'memfs/filesystem_access'
+
+module MemFs
+  class File
+    extend FilesystemAccess
+    extend SingleForwardable
+    include FilesystemAccess
+
+    OriginalFile.constants.grep(/^[A-Z_]+$/).each do |const|
+      const_set const, OriginalFile.const_get(const)
+    end
+
+    MODE_MAP = {
+      'r'  => RDONLY,
+      'r+' => RDWR,
+      'w'  => CREAT|TRUNC|WRONLY,
+      'w+' => CREAT|TRUNC|RDWR,
+      'a'  => CREAT|APPEND|WRONLY,
+      'a+' => CREAT|APPEND|RDWR
+    }
+
+    SUCCESS = 0
+
+    def_delegators :original_file_class,
+                   :basename,
+                   :dirname,
+                   :join,
+                   :path
+
+    def self.atime(path)
+      stat(path).atime
+    end
+
+    def self.chmod(mode_int, *paths)
+      paths.each do |path|
+        fs.chmod mode_int, path
+      end
+    end
+
+    def self.chown(uid, gid, *paths)
+      paths.each do |path|
+        fs.chown(uid, gid, path)
+      end
+      paths.size
+    end
+
+    def self.directory?(path)
+      fs.directory? path
+    end
+
+    def self.exists?(path)
+      not fs.find(path).nil?
+    end
+    class << self; alias :exist? :exists?; end
+
+    def self.expand_path(file_name, dir_string = fs.pwd)
+      original_file_class.expand_path(file_name, dir_string)
+    end
+
+    def self.file?(path)
+      fs.find(path).is_a?(Fake::File)
+    end
+
+    def self.identical?(path1, path2)
+      fs.find!(path1).dereferenced === fs.find!(path2).dereferenced
+    rescue Errno::ENOENT
+      false
+    end
+
+    def self.lchmod(mode_int, *file_names)
+      file_names.each do |file_name|
+        fs.chmod mode_int, file_name
+      end
+    end
+
+    def self.lchown(uid, gid, *paths)
+      chown uid, gid, *paths
+    end
+
+    def self.link(old_name, new_name)
+      fs.link old_name, new_name
+      SUCCESS
+    end
+
+    def self.lstat(path)
+      Stat.new(path)
+    end
+
+    def self.mtime(path)
+      stat(path).mtime
+    end
+
+    def self.open(filename, mode = RDONLY, *perm_and_opt)
+      file = self.new(filename, mode, *perm_and_opt)
+
+      if block_given?
+        yield file
+      else
+        file
+      end
+    ensure
+      file.close if file && block_given?
+    end
+
+    def self.read(path, length = nil, offset = 0, mode: RDONLY, encoding: nil, open_args: nil)
+      open_args ||= [mode, encoding: encoding]
+
+      file = open(path, *open_args)
+      file.seek(offset)
+      file.read(length)
+    ensure
+      file.close if file
+    end
+
+    def self.readlink(path)
+      fs.find!(path).target
+    end
+
+    def self.rename(old_name, new_name)
+      fs.rename(old_name, new_name)
+      SUCCESS
+    end
+
+    def self.reset!
+      @umask = original_file_class.umask
+    end
+
+    def self.size(path)
+      fs.find!(path).size
+    end
+
+    def self.stat(path)
+      Stat.new(path, true)
+    end
+
+    def self.symlink(old_name, new_name)
+      fs.symlink old_name, new_name
+      SUCCESS
+    end
+
+    def self.symlink?(path)
+      fs.symlink? path
+    end
+
+    def self.umask(integer = nil)
+      old_value = @umask || original_file_class.umask
+
+      @umask = integer if integer
+
+      old_value
+    end
+
+    def self.unlink(*paths)
+      paths.each do |path|
+        fs.unlink(path)
+      end
+      paths.size
+    end
+    class << self; alias :delete :unlink; end
+
+    def self.utime(atime, mtime, *file_names)
+      file_names.each do |file_name|
+        fs.find!(file_name).atime = atime
+        fs.find!(file_name).mtime = mtime
+      end
+      file_names.size
+    end
+
+    attr_accessor :closed,
+                  :entry,
+                  :opening_mode
+    attr_reader :path
+
+    def initialize(filename, mode = RDONLY, perm = nil, opt = nil)
+      unless opt.nil? || opt.is_a?(Hash)
+        raise ArgumentError, "wrong number of arguments (4 for 1..3)"
+      end
+
+      @path = filename
+
+      self.opening_mode = str_to_mode_int(mode)
+
+      fs.touch(filename) if create_file?
+
+      self.entry = fs.find(filename)
+    end
+
+    def chmod(mode_int)
+      fs.chmod(mode_int, path)
+      SUCCESS
+    end
+
+    def chown(uid, gid = nil)
+      fs.chown(uid, gid, path)
+      SUCCESS
+    end
+
+    def close
+      self.closed = true
+    end
+
+    def closed?
+      closed
+    end
+
+    def content
+      entry.content
+    end
+
+    def lstat
+      File.lstat(path)
+    end
+
+    def pos
+      entry.pos
+    end
+
+    def puts(text)
+      raise IOError, 'not opened for writing' unless writable?
+
+      content.puts text
+    end
+
+    def read(length = nil, buffer = '')
+      default = length ? nil : ''
+      content.read(length, buffer) || default
+    end
+
+    def seek(amount, whence = IO::SEEK_SET)
+      new_pos = case whence
+      when IO::SEEK_CUR then entry.pos + amount
+      when IO::SEEK_END then content.to_s.length + amount
+      when IO::SEEK_SET then amount
+      end
+
+      if new_pos.nil? || new_pos < 0
+        raise Errno::EINVAL, path
+      end
+
+      entry.pos = new_pos and 0
+    end
+
+    def size
+      entry.size
+    end
+
+    def stat
+      File.stat(path)
+    end
+
+    def write(string)
+      raise IOError, 'not opened for writing' unless writable?
+
+      content.write(string.to_s)
+    end
+
+    private
+
+    def self.original_file_class
+      MemFs::OriginalFile
+    end
+
+    def str_to_mode_int(mode)
+      return mode unless mode.is_a?(String)
+
+      unless mode =~ /\A([rwa]\+?)([bt])?\z/
+        raise ArgumentError, "invalid access mode #{mode}"
+      end
+
+      mode_str = $~[1]
+      MODE_MAP[mode_str]
+    end
+
+    def create_file?
+      (opening_mode & File::CREAT).nonzero?
+    end
+
+    def writable?
+      (opening_mode & File::WRONLY).nonzero? ||
+      (opening_mode & File::RDWR).nonzero?
+    end
+  end
+end