memfs 0.5.0 → 2.0.0

data/lib/memfs/file.rb

@@ -1,28 +1,28 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 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
 
+    PATH_SEPARATOR = '/'
     ALT_SEPARATOR = nil
 
     MODE_MAP = {
-      'r'  => RDONLY,
+      'r' => RDONLY,
       'r+' => RDWR,
-      'w'  => CREAT | TRUNC | WRONLY,
+      'w' => CREAT | TRUNC | WRONLY,
       'w+' => CREAT | TRUNC | RDWR,
-      'a'  => CREAT | APPEND | WRONLY,
+      'a' => CREAT | APPEND | WRONLY,
       'a+' => CREAT | APPEND | RDWR
-    }
+    }.freeze
 
     SEPARATOR = '/'
     SUCCESS = 0
@@ -30,46 +30,54 @@ module MemFs
     @umask = nil
 
     def_delegators :original_file_class,
-                   :basename,
-                   :dirname,
-                   :extname,
-                   :fnmatch,
-                   :join,
-                   :path,
-                   :split
-
-    [
-      :blockdev?,
-      :chardev?,
-      :directory?,
-      :executable?,
-      :executable_real?,
-      :file?,
-      :grpowned?,
-      :owned?,
-      :pipe?,
-      :readable?,
-      :readable_real?,
-      :setgid?,
-      :setuid?,
-      :socket?,
-      :sticky?,
-      :writable?,
-      :writable_real?,
-      :zero?
+      :basename,
+      :dirname,
+      :extname,
+      :fnmatch,
+      :join,
+      :path,
+      :split
+
+    %i[
+      blockdev?
+      chardev?
+      directory?
+      executable?
+      executable_real?
+      file?
+      grpowned?
+      owned?
+      pipe?
+      readable?
+      readable_real?
+      setgid?
+      setuid?
+      socket?
+      sticky?
+      writable?
+      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?
+    class << self; alias empty? zero?; end
+
+    %i[
+      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, force_boolean: false)
+      end
     end
 
     def self.absolute_path(path, dir_string = fs.pwd)
@@ -80,6 +88,10 @@ module MemFs
       stat(path).atime
     end
 
+    def self.birthtime(path)
+      stat(path).birthtime
+    end
+
     def self.chmod(mode_int, *paths)
       paths.each do |path|
         fs.chmod mode_int, path
@@ -100,7 +112,7 @@ module MemFs
     def self.exists?(path)
       !!fs.find(path)
     end
-    class << self; alias_method :exist?, :exists?; 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)
@@ -110,10 +122,12 @@ module MemFs
       fs.find!(path) && lstat(path).ftype
     end
 
-    class << self; alias_method :fnmatch?, :fnmatch; end
+    class << self; alias fnmatch? fnmatch; end
 
     def self.identical?(path1, path2)
-      fs.find!(path1).dereferenced === fs.find!(path2).dereferenced
+      path1 = path1.path if path1.respond_to?(:path)
+      path2 = path2.path if path2.respond_to?(:path)
+      fs.find!(path1).dereferenced.equal? fs.find!(path2).dereferenced
     rescue Errno::ENOENT
       false
     end
@@ -180,15 +194,13 @@ module MemFs
 
     def self.size?(path)
       file = fs.find(path)
-      if file && file.size > 0
-        file.size
-      else
-        false
-      end
+      size = file&.size.to_i
+
+      size.positive? ? size : false
     end
 
     def self.stat(path)
-      Stat.new(path, true)
+      Stat.new(path, dereference: true)
     end
 
     def self.symlink(old_name, new_name)
@@ -197,7 +209,7 @@ module MemFs
     end
 
     def self.symlink?(path)
-      lstat_query(path, :symlink?)
+      lstat_query?(path, :symlink?)
     end
 
     def self.truncate(path, length)
@@ -214,12 +226,10 @@ module MemFs
     end
 
     def self.unlink(*paths)
-      paths.each do |path|
-        fs.unlink(path)
-      end
+      paths.each { |path| fs.unlink(path) }
       paths.size
     end
-    class << self; alias_method :delete, :unlink; end
+    class << self; alias delete unlink; end
 
     def self.utime(atime, mtime, *file_names)
       file_names.each do |file_name|
@@ -229,32 +239,43 @@ module MemFs
       file_names.size
     end
 
-    attr_reader :path
+    attr_reader :path # rubocop:disable Lint/DuplicateMethods
 
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def initialize(filename, mode = File::RDONLY, *perm_and_or_opt)
+      super()
+
       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
-        fail ArgumentError, 'wrong number of arguments (4 for 1..3)'
-      end
+      perm_and_or_opt.shift
+
+      fail ArgumentError, 'wrong number of arguments (4 for 1..3)' if perm_and_or_opt.any?
 
       @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
 
+      entry.pos = 0 if entry.respond_to?(:pos=)
       entry.content.clear if truncate_file?
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def atime
       File.atime(path)
     end
 
+    def birthtime
+      File.birthtime(path)
+    end
+
     def chmod(mode_int)
       fs.chmod(mode_int, path)
       SUCCESS
@@ -289,15 +310,9 @@ module MemFs
       File.truncate(path, integer)
     end
 
-    private
-
     def self.dereference_name(path)
       entry = fs.find(path)
-      if entry
-        entry.dereferenced_name
-      else
-        basename(path)
-      end
+      entry ? entry.dereferenced_name : basename(path)
     end
     private_class_method :dereference_name
 
@@ -321,16 +336,16 @@ module MemFs
     end
     private_class_method :original_file_class
 
-    def self.stat_query(path, query, force_boolean = true)
+    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)
+    def self.lstat_query?(path, query)
       response = fs.find(path) && lstat(path).public_send(query)
-      !!(response)
+      !!response
     end
-    private_class_method :lstat_query
+    private_class_method :lstat_query?
   end
 end

data/lib/memfs/file_system.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require 'memfs/fake/directory'
 require 'memfs/fake/file'
@@ -7,29 +9,30 @@ module MemFs
   class FileSystem
     include Singleton
 
-    attr_accessor :working_directory
-    attr_accessor :registred_entries
-    attr_accessor :root
+    attr_accessor :registred_entries,
+      :root,
+      :working_directory
 
     def basename(path)
       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!
-      self.root = Fake::Directory.new('/')
-      mkdir '/tmp'
-      chdir '/'
+      MemFs.reset_platform_root!
+      self.root = Fake::Directory.new(MemFs.platform_root)
+      mkdir File.join(MemFs.platform_root, 'tmp')
+      chdir MemFs.platform_root
     end
 
     def chmod(mode_int, file_name)
@@ -51,7 +54,9 @@ module MemFs
     end
 
     def find(path)
-      if path == '/'
+      path = MemFs.normalize_path(path)
+
+      if MemFs.root_path?(path)
         root
       elsif dirname(path) == '.'
         working_directory.find(path)
@@ -80,7 +85,7 @@ module MemFs
     def getwd
       working_directory.path
     end
-    alias_method :pwd, :getwd
+    alias pwd getwd
 
     def initialize
       clear!
@@ -96,7 +101,7 @@ module MemFs
       find_parent!(new_name).add_entry link
     end
 
-    def mkdir(path, mode = 0777)
+    def mkdir(path, mode = 0o777)
       fail Errno::EEXIST, path if find(path)
       directory = Fake::Directory.new(path)
       directory.mode = mode

data/lib/memfs/filesystem_access.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MemFs
   module FilesystemAccess
     private