memfs 0.5.0 → 1.0.0

data/lib/memfs/dir.rb

@@ -47,7 +47,7 @@ module MemFs
     class << self; alias_method :pwd, :getwd; end
 
     def self.glob(patterns, flags = 0)
-      patterns = [*patterns]
+      patterns = [*patterns].map(&:to_s)
       list = fs.paths.select do |path|
         patterns.any? do |pattern|
           File.fnmatch?(pattern, path, flags | GLOB_FLAGS)
@@ -143,11 +143,11 @@ module MemFs
 
     private
 
-    if defined?(File::FNM_EXTGLOB)
-      GLOB_FLAGS = File::FNM_EXTGLOB | File::FNM_PATHNAME
-    else
-      GLOB_FLAGS = File::FNM_PATHNAME
-    end
+    GLOB_FLAGS = if defined?(File::FNM_EXTGLOB)
+                   File::FNM_EXTGLOB | File::FNM_PATHNAME
+                 else
+                   File::FNM_PATHNAME
+                 end
 
     attr_accessor :entry, :max_seek, :state
 

data/lib/memfs/fake/directory.rb

@@ -19,7 +19,7 @@ module MemFs
       end
 
       def find(path)
-        path = path.sub(/\A\/+/, '')
+        path = path.sub(%r{\A/+}, '').sub(%r{/+\z}, '')
         parts = path.split('/', 2)
 
         if entry_names.include?(path)
@@ -44,7 +44,10 @@ module MemFs
       end
 
       def paths
-        [path] + entries.reject { |p| %w[. ..].include?(p) }.values.map(&:paths).flatten
+        [path] + entries.reject { |p| %w[. ..].include?(p) }
+                 .values
+                 .map(&:paths)
+                 .flatten
       end
 
       def remove_entry(entry)

data/lib/memfs/fake/file.rb

@@ -33,11 +33,10 @@ module MemFs
       end
 
       def type
-        case
-        when block_device     then 'blockSpecial'
-        when character_device then 'characterSpecial'
-        else 'file'
-        end
+        return 'blockSpecial' if block_device
+        return 'characterSpecial' if character_device
+
+        'file'
       end
     end
   end

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

@@ -3,7 +3,6 @@ require 'delegate'
 module MemFs
   module Fake
     class File < Entry
-
       class Content < SimpleDelegator
         attr_accessor :pos
 
@@ -46,7 +45,6 @@ module MemFs
           text.size
         end
       end
-
     end
   end
 end

data/lib/memfs/file.rb

@@ -3,15 +3,12 @@ require 'memfs/filesystem_access'
 require 'memfs/io'
 
 module MemFs
-  class File
+  class File < IO
     extend FilesystemAccess
     extend SingleForwardable
-    extend IO::ClassMethods
 
     include Enumerable
     include FilesystemAccess
-    include OriginalFile::Constants
-    include IO::InstanceMethods
 
     ALT_SEPARATOR = nil
 
@@ -22,9 +19,9 @@ module MemFs
       'w+' => CREAT | TRUNC | RDWR,
       'a'  => CREAT | APPEND | WRONLY,
       'a+' => CREAT | APPEND | RDWR
-    }
+    }.freeze
 
-    SEPARATOR = '/'
+    SEPARATOR = '/'.freeze
     SUCCESS = 0
 
     @umask = nil
@@ -58,18 +55,24 @@ module MemFs
       :writable_real?,
       :zero?
     ].each do |query_method|
-      define_singleton_method(query_method) do |path|    # def directory?(path)
-        stat_query(path, query_method)                   #   stat_query(path, :directory?)
-      end                                                # end
+      # def directory?(path)
+      #   stat_query(path, :directory?)
+      # end
+      define_singleton_method(query_method) do |path|
+        stat_query(path, query_method)
+      end
     end
 
     [
       :world_readable?,
       :world_writable?
     ].each do |query_method|
-      define_singleton_method(query_method) do |path|    # def directory?(path)
-        stat_query(path, query_method, false)            #   stat_query(path, :directory?, false)
-      end                                                # end
+      # def directory?(path)
+      #   stat_query(path, :directory?, false)
+      # end
+      define_singleton_method(query_method) do |path|
+        stat_query(path, query_method, false)
+      end
     end
 
     def self.absolute_path(path, dir_string = fs.pwd)
@@ -233,21 +236,27 @@ module MemFs
 
     def initialize(filename, mode = File::RDONLY, *perm_and_or_opt)
       opt = perm_and_or_opt.last.is_a?(Hash) ? perm_and_or_opt.pop : {}
-      perm = perm_and_or_opt.shift
-      if perm_and_or_opt.size > 0
+      perm_and_or_opt.shift
+      if perm_and_or_opt.any?
         fail ArgumentError, 'wrong number of arguments (4 for 1..3)'
       end
 
       @path = filename
-      @external_encoding = opt[:external_encoding] && Encoding.find(opt[:external_encoding])
+      @external_encoding = opt[:external_encoding] &&
+                           Encoding.find(opt[:external_encoding])
 
       self.closed = false
       self.opening_mode = str_to_mode_int(mode)
 
       fs.touch(filename) if create_file?
 
-      self.entry = fs.find(filename)
+      self.entry = fs.find!(filename)
+      # FIXME: this is an ugly way to ensure a symlink has a target
+      entry.dereferenced
 
+      if entry.respond_to?(:pos=)
+        entry.pos = 0
+      end
       entry.content.clear if truncate_file?
     end
 
@@ -289,8 +298,6 @@ module MemFs
       File.truncate(path, integer)
     end
 
-    private
-
     def self.dereference_name(path)
       entry = fs.find(path)
       if entry
@@ -323,13 +330,13 @@ module MemFs
 
     def self.stat_query(path, query, force_boolean = true)
       response = fs.find(path) && stat(path).public_send(query)
-      force_boolean ? !!(response) : response
+      force_boolean ? !!response : response
     end
     private_class_method :stat_query
 
     def self.lstat_query(path, query)
       response = fs.find(path) && lstat(path).public_send(query)
-      !!(response)
+      !!response
     end
     private_class_method :lstat_query
   end

data/lib/memfs/file/stat.rb

@@ -21,7 +21,7 @@ module MemFs
                      :uid
 
       def blockdev?
-        !!(entry.block_device)
+        !!entry.block_device
       end
 
       def chardev?

data/lib/memfs/file_system.rb

@@ -15,15 +15,15 @@ module MemFs
       File.basename(path)
     end
 
-    def chdir(path, &block)
+    def chdir(path)
       destination = find_directory!(path)
 
       previous_directory = working_directory
       self.working_directory = destination
 
-      block.call if block
+      yield if block_given?
     ensure
-      self.working_directory = previous_directory if block
+      self.working_directory = previous_directory if block_given?
     end
 
     def clear!

data/lib/memfs/io.rb

@@ -2,203 +2,239 @@ require 'forwardable'
 require 'memfs/filesystem_access'
 
 module MemFs
-  module IO
-    module ClassMethods
-      def read(path, *args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        options = { mode: File::RDONLY, encoding: nil, open_args: nil }.merge(options)
-        open_args = options[:open_args] ||
-                    [options[:mode], encoding: options[:encoding]]
-
-        length, offset = args
-
-        file = open(path, *open_args)
-        file.seek(offset || 0)
-        file.read(length)
-      ensure
-        file.close if file
-      end
+  class IO
+    extend SingleForwardable
+    include OriginalFile::Constants
+
+    (OriginalIO.constants - OriginalFile::Constants.constants)
+      .each do |const_name|
+        self.const_set(const_name, OriginalIO.const_get(const_name))
+      end
+
+    def_delegators :original_io_class,
+      :copy_stream
+
+    def self.read(path, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options = {
+        mode: File::RDONLY,
+        encoding: nil,
+        open_args: nil
+      }.merge(options)
+      open_args = options[:open_args] ||
+                  [options[:mode], encoding: options[:encoding]]
+
+      length, offset = args
+
+      file = open(path, *open_args)
+      file.seek(offset || 0)
+      file.read(length)
+    ensure
+      file.close if file
     end
 
-    module InstanceMethods
-      attr_writer :autoclose,
-                  :close_on_exec
-
-      def <<(object)
-        fail IOError, 'not opened for writing' unless writable?
+    def self.write(path, string, offset = 0, open_args = nil)
+      open_args ||= [File::WRONLY, encoding: nil]
 
-        content << object.to_s
+      offset = 0 if offset.nil?
+      unless offset.respond_to?(:to_int)
+        fail TypeError, "no implicit conversion from #{offset.class}"
       end
+      offset = offset.to_int
 
-      def advise(advice_type, offset = 0, len = 0)
-        advice_types = [
-          :dontneed,
-          :noreuse,
-          :normal,
-          :random,
-          :sequential,
-          :willneed
-        ]
-        unless advice_types.include?(advice_type)
-          fail NotImplementedError, "Unsupported advice: #{advice_type.inspect}"
-        end
-        nil
+      if offset > 0
+        fail NotImplementedError,
+             'MemFs::IO.write with offset not yet supported.'
       end
 
-      def autoclose?
-        @autoclose.nil? ? true : !!@autoclose
-      end
+      file = open(path, *open_args)
+      file.seek(offset)
+      file.write(string)
+    ensure
+      file.close if file
+    end
 
-      def binmode
-        @binmode = true
-        @external_encoding = Encoding::ASCII_8BIT
-        self
-      end
+    def self.original_io_class
+      MemFs::OriginalIO
+    end
+    private_class_method :original_io_class
 
-      def binmode?
-        @binmode.nil? ? false : @binmode
-      end
+    attr_writer :autoclose,
+                :close_on_exec
 
-      def close
-        self.closed = true
-      end
+    def <<(object)
+      fail IOError, 'not opened for writing' unless writable?
 
-      def closed?
-        closed
-      end
+      content << object.to_s
+    end
 
-      def close_on_exec?
-        @close_on_exec.nil? ? true : !!@close_on_exec
-      end
+    def advise(advice_type, _offset = 0, _len = 0)
+      advice_types = [
+        :dontneed,
+        :noreuse,
+        :normal,
+        :random,
+        :sequential,
+        :willneed
+      ]
+      unless advice_types.include?(advice_type)
+        fail NotImplementedError, "Unsupported advice: #{advice_type.inspect}"
+      end
+      nil
+    end
 
-      def eof?
-        pos >= content.size
-      end
-      alias_method :eof, :eof?
-
-      def external_encoding
-        if writable?
-          @external_encoding
-        else
-          @external_encoding ||= Encoding.default_external
-        end
-      end
+    def autoclose?
+      defined?(@autoclose) ? !!@autoclose : true
+    end
 
-      def each(sep = $/, &block)
-        return to_enum(__callee__) unless block_given?
-        fail IOError, 'not opened for reading' unless readable?
-        content.each_line(sep) { |line| block.call(line) }
-        self
-      end
+    def binmode
+      @binmode = true
+      @external_encoding = Encoding::ASCII_8BIT
+      self
+    end
 
-      def each_byte(&block)
-        return to_enum(__callee__) unless block_given?
-        fail IOError, 'not opened for reading' unless readable?
-        content.each_byte { |byte| block.call(byte) }
-        self
-      end
-      alias_method :bytes, :each_byte
+    def binmode?
+      defined?(@binmode) ? @binmode : false
+    end
 
-      def each_char(&block)
-        return to_enum(__callee__) unless block_given?
-        fail IOError, 'not opened for reading' unless readable?
-        content.each_char { |char| block.call(char) }
-        self
-      end
-      alias_method :chars, :each_char
+    def close
+      self.closed = true
+    end
 
-      def pos
-        entry.pos
-      end
+    def closed?
+      closed
+    end
 
-      def print(*objs)
-        $stdout.puts $_.inspect
-        objs << $_ if objs.empty?
-        self << objs.join($,) << $\.to_s
-        nil
-      end
+    def close_on_exec?
+      defined?(@close_on_exec) ? !!@close_on_exec : true
+    end
+
+    def eof?
+      pos >= content.size
+    end
+    alias_method :eof, :eof?
 
-      def printf(format_string, *objs)
-        print format_string % objs
+    def external_encoding
+      if writable?
+        @external_encoding
+      else
+        @external_encoding ||= Encoding.default_external
       end
+    end
 
-      def puts(text)
-        fail IOError, 'not opened for writing' unless writable?
+    def each(sep = $/)
+      return to_enum(__callee__) unless block_given?
+      fail IOError, 'not opened for reading' unless readable?
+      content.each_line(sep) { |line| yield(line) }
+      self
+    end
 
-        content.puts text
-      end
+    def each_byte
+      return to_enum(__callee__) unless block_given?
+      fail IOError, 'not opened for reading' unless readable?
+      content.each_byte { |byte| yield(byte) }
+      self
+    end
+    alias_method :bytes, :each_byte
 
-      def read(length = nil, buffer = '')
-        unless entry
-          fail(Errno::ENOENT, path)
-        end
-        default = length ? nil : ''
-        content.read(length, buffer) || default
-      end
+    def each_char
+      return to_enum(__callee__) unless block_given?
+      fail IOError, 'not opened for reading' unless readable?
+      content.each_char { |char| yield(char) }
+      self
+    end
+    alias_method :chars, :each_char
 
-      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
+    def pos
+      entry.pos
+    end
 
-        fail Errno::EINVAL, path if new_pos.nil? || new_pos < 0
+    def print(*objs)
+      objs << $_ if objs.empty?
+      self << objs.join($,) << $\.to_s
+      nil
+    end
 
-        entry.pos = new_pos
-        0
-      end
+    def printf(format_string, *objs)
+      print format_string % objs
+    end
 
-      def stat
-        File.stat(path)
-      end
+    def puts(text)
+      fail IOError, 'not opened for writing' unless writable?
 
-      def write(string)
-        fail IOError, 'not opened for writing' unless writable?
+      content.puts text
+    end
 
-        content.write(string.to_s)
+    def read(length = nil, buffer = '')
+      unless entry
+        fail(Errno::ENOENT, path)
       end
+      default = length ? nil : ''
+      content.read(length, buffer) || default
+    end
 
-      private
+    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
 
-      attr_accessor :closed,
-                    :entry,
-                    :opening_mode
+      fail Errno::EINVAL, path if new_pos.nil? || new_pos < 0
 
-      attr_reader :path
+      entry.pos = new_pos
+      0
+    end
 
-      def content
-        entry.content
-      end
+    def stat
+      File.stat(path)
+    end
 
-      def create_file?
-        (opening_mode & File::CREAT).nonzero?
-      end
+    def write(string)
+      fail IOError, 'not opened for writing' unless writable?
 
-      def readable?
-        (opening_mode & File::RDWR).nonzero? ||
-        (opening_mode | File::RDONLY).zero?
-      end
+      content.write(string.to_s)
+    end
 
-      def str_to_mode_int(mode)
-        return mode unless mode.is_a?(String)
+    private
 
-        unless mode =~ /\A([rwa]\+?)([bt])?(:bom)?(\|.+)?\z/
-          fail ArgumentError, "invalid access mode #{mode}"
-        end
+    attr_accessor :closed,
+                  :entry,
+                  :opening_mode
 
-        mode_str = $~[1]
-        File::MODE_MAP[mode_str]
-      end
+    attr_reader :path
+
+    def content
+      entry.content
+    end
 
-      def truncate_file?
-        (opening_mode & File::TRUNC).nonzero?
+    def create_file?
+      (opening_mode & File::CREAT).nonzero?
+    end
+
+    def readable?
+      (opening_mode & File::RDWR).nonzero? ||
+        (opening_mode | File::RDONLY).zero?
+    end
+
+    def str_to_mode_int(mode)
+      return mode unless mode.is_a?(String)
+
+      unless mode =~ /\A([rwa]\+?)([bt])?(:bom)?(\|.+)?\z/
+        fail ArgumentError, "invalid access mode #{mode}"
       end
 
-      def writable?
-        (opening_mode & File::WRONLY).nonzero? ||
+      mode_str = $~[1]
+      File::MODE_MAP[mode_str]
+    end
+
+    def truncate_file?
+      (opening_mode & File::TRUNC).nonzero?
+    end
+
+    def writable?
+      (opening_mode & File::WRONLY).nonzero? ||
         (opening_mode & File::RDWR).nonzero?
-      end
     end
   end
 end