memfs 0.5.0 → 2.0.0

data/lib/memfs/io.rb

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

data/lib/memfs/version.rb

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

data/lib/memfs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'memfs/version'
 require 'fileutils'
 
@@ -22,6 +24,89 @@ module MemFs
   # Keeps track of the original Ruby File class.
   OriginalFile = ::File
 
+  # 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'
@@ -70,16 +155,18 @@ module MemFs
   #
   # @see #deactivate!
   # @return nothing.
-  def activate!
+  def activate!(clear: true)
     Object.class_eval do
       remove_const :Dir
       remove_const :File
+      remove_const :IO
 
       const_set :Dir, MemFs::Dir
+      const_set :IO, MemFs::IO
       const_set :File, MemFs::File
     end
 
-    MemFs::FileSystem.instance.clear!
+    MemFs::FileSystem.instance.clear! if clear
   end
   module_function :activate!
 
@@ -93,22 +180,42 @@ module MemFs
     Object.class_eval do
       remove_const :Dir
       remove_const :File
+      remove_const :IO
 
       const_set :Dir, MemFs::OriginalDir
+      const_set :IO, MemFs::OriginalIO
       const_set :File, MemFs::OriginalFile
     end
   end
   module_function :deactivate!
 
+  # Switches back to the original file system, calls the given block (if any),
+  # and switches back afterwards.
+  #
+  # If a block is given, all file & dir operations (like reading dir contents or
+  # requiring files) will operate on the original fs.
+  #
+  # @example
+  #   MemFs.halt do
+  #     puts Dir.getwd
+  #   end
+  # @return nothing
+  def halt
+    deactivate!
+
+    yield if block_given?
+  ensure
+    activate!(clear: false)
+  end
+  module_function :halt
+
   # Creates a file and all its parent directories.
   #
   # @param path: The path of the file to create.
   #
   # @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,20 +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', '~> 10.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'
 end