memfs 1.0.0 → 2.0.0

data/lib/memfs/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'memfs/filesystem_access'
 require 'memfs/io'
@@ -10,50 +12,51 @@ module MemFs
     include Enumerable
     include FilesystemAccess
 
+    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 = '/'.freeze
+    SEPARATOR = '/'
     SUCCESS = 0
 
     @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|
       # def directory?(path)
       #   stat_query(path, :directory?)
@@ -63,15 +66,17 @@ module MemFs
       end
     end
 
-    [
-      :world_readable?,
-      :world_writable?
+    class << self; alias empty? zero?; end
+
+    %i[
+      world_readable?
+      world_writable?
     ].each do |query_method|
       # def directory?(path)
       #   stat_query(path, :directory?, false)
       # end
       define_singleton_method(query_method) do |path|
-        stat_query(path, query_method, false)
+        stat_query(path, query_method, force_boolean: false)
       end
     end
 
@@ -83,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
@@ -103,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)
@@ -113,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
@@ -183,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)
@@ -200,7 +209,7 @@ module MemFs
     end
 
     def self.symlink?(path)
-      lstat_query(path, :symlink?)
+      lstat_query?(path, :symlink?)
     end
 
     def self.truncate(path, length)
@@ -217,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|
@@ -232,18 +239,20 @@ 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_and_or_opt.shift
-      if perm_and_or_opt.any?
-        fail ArgumentError, 'wrong number of arguments (4 for 1..3)'
-      end
+
+      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)
@@ -254,16 +263,19 @@ module MemFs
       # 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.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
@@ -300,11 +312,7 @@ module MemFs
 
     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
 
@@ -328,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
     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
     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,9 +9,9 @@ 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)
@@ -27,9 +29,10 @@ module MemFs
     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

data/lib/memfs/io.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'memfs/filesystem_access'
 
@@ -6,23 +8,17 @@ module MemFs
     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
+    (OriginalIO.constants - OriginalFile::Constants.constants).each do |const_name|
+      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]]
+      options = { encoding: nil, mode: File::RDONLY, open_args: nil }.merge(options)
+      open_args = options[:open_args] || [options[:mode], { encoding: options[:encoding] }]
 
       length, offset = args
 
@@ -30,11 +26,12 @@ module MemFs
       file.seek(offset || 0)
       file.read(length)
     ensure
-      file.close if file
+      file&.close
     end
 
+    # rubocop:disable Metrics/MethodLength
     def self.write(path, string, offset = 0, open_args = nil)
-      open_args ||= [File::WRONLY, encoding: nil]
+      open_args ||= [File::WRONLY, { encoding: nil }]
 
       offset = 0 if offset.nil?
       unless offset.respond_to?(:to_int)
@@ -42,17 +39,17 @@ module MemFs
       end
       offset = offset.to_int
 
-      if offset > 0
-        fail NotImplementedError,
-             'MemFs::IO.write with offset not yet supported.'
+      if offset.positive?
+        fail(NotImplementedError, 'MemFs::IO.write with offset not yet supported.')
       end
 
       file = open(path, *open_args)
       file.seek(offset)
       file.write(string)
     ensure
-      file.close if file
+      file&.close
     end
+    # rubocop:enable Metrics/MethodLength
 
     def self.original_io_class
       MemFs::OriginalIO
@@ -60,7 +57,7 @@ module MemFs
     private_class_method :original_io_class
 
     attr_writer :autoclose,
-                :close_on_exec
+      :close_on_exec
 
     def <<(object)
       fail IOError, 'not opened for writing' unless writable?
@@ -69,18 +66,11 @@ module MemFs
     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
+      advice_types = %i[dontneed noreuse normal random sequential willneed]
+
+      return if advice_types.include?(advice_type)
+
+      fail NotImplementedError, "Unsupported advice: #{advice_type.inspect}"
     end
 
     def autoclose?
@@ -112,7 +102,7 @@ module MemFs
     def eof?
       pos >= content.size
     end
-    alias_method :eof, :eof?
+    alias eof eof?
 
     def external_encoding
       if writable?
@@ -122,28 +112,32 @@ module MemFs
       end
     end
 
-    def each(sep = $/)
-      return to_enum(__callee__) unless block_given?
+    def each(sep = $/, &block)
+      return to_enum(__callee__, sep) unless block_given?
       fail IOError, 'not opened for reading' unless readable?
-      content.each_line(sep) { |line| yield(line) }
+      content.each_line(sep, &block)
       self
     end
 
-    def each_byte
+    def each_byte(&block)
       return to_enum(__callee__) unless block_given?
       fail IOError, 'not opened for reading' unless readable?
-      content.each_byte { |byte| yield(byte) }
+      content.each_byte(&block)
       self
     end
-    alias_method :bytes, :each_byte
+    alias bytes each_byte
 
-    def each_char
+    def each_char(&block)
       return to_enum(__callee__) unless block_given?
       fail IOError, 'not opened for reading' unless readable?
-      content.each_char { |char| yield(char) }
+      content.each_char(&block)
       self
     end
-    alias_method :chars, :each_char
+    alias chars each_char
+
+    def fileno
+      entry.fileno
+    end
 
     def pos
       entry.pos
@@ -165,22 +159,22 @@ module MemFs
       content.puts text
     end
 
-    def read(length = nil, buffer = '')
-      unless entry
-        fail(Errno::ENOENT, path)
-      end
+    def read(length = nil, buffer = +'')
+      fail(Errno::ENOENT, path) unless entry
+
       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
+      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
 
-      fail Errno::EINVAL, path if new_pos.nil? || new_pos < 0
+      fail Errno::EINVAL, path if new_pos.nil? || new_pos.negative?
 
       entry.pos = new_pos
       0
@@ -191,7 +185,7 @@ module MemFs
     end
 
     def write(string)
-      fail IOError, 'not opened for writing' unless writable?
+      fail(IOError, 'not opened for writing') unless writable?
 
       content.write(string.to_s)
     end
@@ -199,8 +193,8 @@ module MemFs
     private
 
     attr_accessor :closed,
-                  :entry,
-                  :opening_mode
+      :entry,
+      :opening_mode
 
     attr_reader :path
 
@@ -220,7 +214,7 @@ module MemFs
     def str_to_mode_int(mode)
       return mode unless mode.is_a?(String)
 
-      unless mode =~ /\A([rwa]\+?)([bt])?(:bom)?(\|.+)?\z/
+      unless mode =~ /\A([rwa]\+?)([bt])?(:(bom|UTF-8|utf-8))?(\|.+)?\z/
         fail ArgumentError, "invalid access mode #{mode}"
       end
 

data/lib/memfs/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MemFs
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.0'
 end

data/lib/memfs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'memfs/version'
 require 'fileutils'
 
@@ -25,6 +27,86 @@ module MemFs
   # Keeps track of the original Ruby IO class.
   OriginalIO = ::IO
 
+  def self.ruby_version_gte?(version) # :nodoc:
+    Gem::Version.new(RUBY_VERSION) >= Gem::Version.new(version)
+  end
+
+  def self.windows?
+    /mswin|bccwin|mingw/ =~ RUBY_PLATFORM
+  end
+
+  # Returns the platform-specific root path (e.g., '/' on Unix, 'D:/' on Windows)
+  def self.platform_root
+    @platform_root || default_platform_root
+  end
+
+  # Allows setting a custom platform root (mainly for testing)
+  def self.platform_root=(value)
+    @platform_root = value
+  end
+
+  # Resets platform_root to the default value
+  def self.reset_platform_root!
+    @platform_root = nil
+  end
+
+  # Returns the default platform root based on the current OS
+  def self.default_platform_root
+    if windows?
+      # Normalize drive letter to uppercase
+      OriginalFile.expand_path('/').sub(/\A([a-z]):/) { "#{::Regexp.last_match(1).upcase}:" }
+    else
+      '/'
+    end
+  end
+
+  # Check if a path is the root path (handles both '/' and 'D:/')
+  def self.root_path?(path)
+    return false if path.nil?
+
+    normalized = normalize_path(path)
+    normalized == platform_root || normalized == '/'
+  end
+
+  # Normalize path for consistent handling
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  # rubocop:disable Metrics/PerceivedComplexity
+  def self.normalize_path(path)
+    return path unless path.is_a?(String)
+
+    # Reject UNC paths
+    fail ArgumentError, "UNC paths are not supported: #{path}" if path.start_with?('\\\\', '//')
+
+    # Convert backslashes to forward slashes
+    path = path.tr('\\', '/')
+
+    return path unless windows?
+
+    # Normalize drive letter to uppercase
+    path = path.sub(/\A([a-z]):/) { "#{::Regexp.last_match(1).upcase}:" }
+
+    # Handle drive-relative paths like 'D:foo' or 'D:.' (no slash after colon)
+    # and bare drive letters like 'D:' (current directory on drive D)
+    # Convert to absolute paths since our fake fs doesn't support per-drive working directories
+    if path.match?(/\A[A-Z]:\z/) # Bare drive like 'D:'
+      path = "#{path}/"
+    elsif path.match?(%r{\A[A-Z]:[^/]}) # Drive-relative like 'D:foo' or 'D:.'
+      path = path.sub(/\A([A-Z]):/, '\1:/')
+    end
+
+    # Convert bare '/' to platform root on Windows
+    if path == '/'
+      platform_root
+    elsif path.start_with?('/') && !path.match?(%r{\A[A-Z]:/})
+      # Convert '/foo' to 'D:/foo' on Windows
+      "#{platform_root}#{path[1..]}"
+    else
+      path
+    end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  # rubocop:enable Metrics/PerceivedComplexity
+
   require 'memfs/file_system'
   require 'memfs/dir'
   require 'memfs/file'
@@ -133,9 +215,7 @@ module MemFs
   #
   # @return nothing.
   def touch(*paths)
-    if ::File != MemFs::File
-      fail 'Always call MemFs.touch inside a MemFs active context.'
-    end
+    fail 'Always call MemFs.touch inside a MemFs active context.' if ::File != MemFs::File
 
     paths.each do |path|
       FileUtils.mkdir_p File.dirname(path)

data/memfs.gemspec

@@ -12,23 +12,6 @@ Gem::Specification.new do |gem|
                       'for tests. Strongly inspired by FakeFS.'
   gem.summary       = "memfs-#{MemFs::VERSION}"
   gem.homepage      = 'http://github.com/simonc/memfs'
-
   gem.license       = 'MIT'
-
   gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(/^bin\//).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(/^(test|spec|features)\//)
-  gem.require_paths = ['lib']
-
-  gem.add_development_dependency 'coveralls', '~> 0.6'
-  gem.add_development_dependency 'rake', '~> 12.0'
-  gem.add_development_dependency 'rspec', '~> 3.0'
-  gem.add_development_dependency 'guard', '~> 2.6'
-  gem.add_development_dependency 'guard-rspec', '~> 4.3'
-  gem.add_development_dependency 'rb-inotify', '~> 0.8'
-  gem.add_development_dependency 'rb-fsevent', '~> 0.9'
-  gem.add_development_dependency 'rb-fchange', '~> 0.0'
-
-  listen_version = RUBY_VERSION >= '2.2.3' ? '~> 3.1' : '~> 3.0.7'
-  gem.add_development_dependency 'listen', listen_version
 end