fakefs 2.6.0 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 765257209fdbaff32e467e7e5f0acbd9d324d6066fe569d5722a0568368a3288
-  data.tar.gz: fe4e318738464fd61e4b4d150a06285ea1a1923c92fc51bf244f27afa31b30a2
+  metadata.gz: 4c651948e15e48a7fc0a55e795e637b8a7f416b3346d6b7732f9c9db36750b6b
+  data.tar.gz: e5b0f2eea98fe2a4d58a34daf9ad8af627186eff773fc42f93790a1ca048d5d5
 SHA512:
-  metadata.gz: 0b2d56c157243b4a95961f35c946697b229358af469692e91e72ac82eec1c0bdb6b97da19215335f26dd0837b731701bf9d072cb41fbb069f14868f7768d66fc
-  data.tar.gz: 46b48334206cd89958b8f3177f0e4050580a7c84891f8027e0e768cdfcc8685c22b5cadf03e0bdccb4ae4b9f7bbf788623be644377c53e6ab9277955b8472d9f
+  metadata.gz: 8c356f48b8cab450871cffbf4dca4ca48bdf7631201c624c5cabf4a8482867cc07258900de12ee49aa0409a9b2b186c99f2654c0a564b5bdcf796347c0e68f1a
+  data.tar.gz: 8ad9c0fa9d589ef555c6c25514e1f743afe43da096092ae4e8b3c21d5a0291014ef30cc4ed4829724a660a2ebaf033b50097ebcf47f0a35e943649df9b368b8f

data/lib/fakefs/file.rb

@@ -12,8 +12,26 @@ module FakeFS
       APPEND_READ_WRITE   = 'a+'.freeze
     ].freeze
 
+    FMODE_READABLE = 0x00000001
+    FMODE_WRITABLE = 0x00000002
+    FMODE_READWRITE = (FMODE_READABLE | FMODE_WRITABLE)
+    FMODE_BINMODE = 0x00000004
+    FMODE_APPEND = 0x00000040
+    FMODE_CREATE = 0x00000080
+    FMODE_EXCL = 0x00000400
+    FMODE_TRUNC = 0x00000800
+    FMODE_TEXTMODE = 0x00001000
+
+    TEXT_MODES = {
+      'r' => FMODE_READABLE,
+      'w' => FMODE_WRITABLE | FMODE_TRUNC | FMODE_CREATE,
+      'a' => FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE
+    }.freeze
+
     FILE_CREATION_MODES = (MODES - [READ_ONLY, READ_WRITE]).freeze
+    FILE_ACCESS_MODE = (RealFile::RDONLY | RealFile::WRONLY | RealFile::RDWR)
 
+    # copied from https://github.com/ruby/ruby/blob/v2_7_8/include/ruby/io.h#L108
     MODE_BITMASK = (
       RealFile::RDONLY |
       RealFile::WRONLY |
@@ -23,12 +41,11 @@ module FakeFS
       RealFile::EXCL |
       RealFile::NONBLOCK |
       RealFile::TRUNC |
+      RealFile::BINARY |
       (RealFile.const_defined?(:NOCTTY) ? RealFile::NOCTTY : 0) |
       (RealFile.const_defined?(:SYNC) ? RealFile::SYNC : 0)
     )
 
-    FILE_CREATION_BITMASK = RealFile::CREAT
-
     def self.extname(path)
       RealFile.extname(path)
     end
@@ -181,6 +198,7 @@ module FakeFS
       symlink.target
     end
 
+    # TODO: support open_key_args
     def self.read(path, *args)
       options = args[-1].is_a?(Hash) ? args.pop : {}
       length = args.empty? ? nil : args.shift
@@ -490,17 +508,102 @@ module FakeFS
 
     attr_reader :path
 
-    def initialize(path, mode = READ_ONLY, _perm = nil)
+    def initialize(path, *args)
+      # unable to pass args otherwise on jruby, it may cause false passes on MRI, though
+      # because explicit hash isn't supported
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      if args.size > 2
+        raise ArgumentError, "wrong number of arguments (given #{args.size + 1}, expected 1..3)"
+      end
+      mode, _perm = args
+
       @path = path
-      @mode = mode.is_a?(Hash) ? (mode[:mode] || READ_ONLY) : mode
-      @file = FileSystem.find(path)
-      @autoclose = true
+      @file = FileSystem.find(@path)
+      # real rb_scan_open_args - and rb_io_extract_modeenc - is much more complex
+      raise ArgumentError, 'mode specified twice' unless mode.nil? || opts[:mode].nil?
+
+      mode_opt = mode.nil? ? opts[:mode] : mode
+      # see vmode_handle
+      if mode_opt.nil?
+        @oflags = RealFile::RDONLY
+      elsif mode_opt.respond_to?(:to_int) && (intmode = mode_opt.to_int).instance_of?(Integer)
+        @oflags = intmode
+      else
+        unless mode_opt.is_a?(String)
+          unless mode_opt.respond_to?(:to_str)
+            raise TypeError, "no implicit conversion of #{mode_opt.class} into String"
+          end
+
+          strmode = mode_opt.to_str
+          unless strmode.is_a?(String)
+            raise TypeError, "can't convert #{mode_opt.class} to String " \
+              "(#{mode_opt.class}#to_str gives #{strmode.class})"
+          end
+
+          mode_opt = strmode
+        end
+
+        @oflags, @fmode = parse_strmode_oflags(mode_opt)
+      end
+      unless opts[:flags].nil?
+        if opts[:flags].is_a?(Integer)
+          @oflags |= opts[:flags]
+        elsif opts[:flags].respond_to?(:to_int)
+          intflags = opts[:flags].to_int
+          unless intflags.instance_of?(Integer)
+            raise TypeError, "can't convert #{opts[:flags].class} to Integer " \
+              "(#{opts[:flags].class}#to_int gives #{intflags.class})"
+          end
 
-      check_modes!
+          @oflags |= intflags
+          @fmode = create_fmode(@oflags)
+        else
+          raise TypeError, "no implicit conversion of #{opts[:flags].class} into Integer"
+        end
+      end
+      @fmode ||= create_fmode(@oflags)
+      @fmode = extract_binmode(opts, @fmode)
 
+      @autoclose = true
       file_creation_mode? ? create_missing_file : check_file_existence!
+      # StringIO changes enciding of the underlying string to binary
+      # when binary data is written if it's opened in binary mode,
+      # so content might have binary encoding. StringIO also switches to
+      # binary mode if its string have binary encoding, but it might not
+      # be what we want, so insteed we use encoding parsed after super call
+      # and force set it back.
+
+      # truncate doesn't work
+      @file.content.force_encoding(Encoding.default_external)
+      # StringIO.new 'content', nil, **{} # works in MRI, but fails in JRuby
+      # but File.open 'filename', nil, **{} is ok both in MRI and JRuby
+
+      # JRuby StringIO doesn't support kwargs without mode
+      #  StringIO.new "buff", encoding: 'binary' # work on MRI, fails on JRuby
+      if RUBY_PLATFORM == "java"
+        # other opts aren't supported
+        super(@file.content, mode_opt || 'r')
+        binmode if binmode? # Looks like it doesn't care about 'b'
+        mode_opt_str = mode_opt.is_a?(String) ? mode_opt : ''
+        raise ArgumentError, 'encoding specified twice' if mode_opt_str[':'] && opts[:encoding]
+
+        # Might raise where real File just warns
+        str_encoding = mode_opt_str.split(':')[1] # internal encoding is ignored anyway
+        if opts[:encoding]
+          set_encoding(opts[:encoding])
+        elsif str_encoding && str_encoding != ''
+          set_encoding(str_encoding)
+        elsif opts[:binmode]
+          set_encoding(Encoding::BINARY)
+        end
+      else
+        super(@file.content, mode, **opts)
+      end
 
-      super(@file.content, @mode)
+      # StringIO is wrtable and readable by default, so we need to disable it
+      # but maybe it was explicitly disabled by opts
+      close_write if @fmode & FMODE_WRITABLE == 0 && !StringIO.instance_method(:closed_write?).bind(self).call
+      close_read if @fmode & FMODE_READABLE == 0 && !StringIO.instance_method(:closed_read?).bind(self).call
     end
 
     def exists?
@@ -622,10 +725,8 @@ module FakeFS
     end
 
     def binmode?
-      @mode.is_a?(String) && (
-        @mode.include?('b') ||
-        @mode.include?('binary')
-      ) && !@mode.include?('bom')
+      # File.open('test_mode', mode: 'w:binary').binmode? # => false
+      @fmode & FMODE_BINMODE != 0
     end
 
     def close_on_exec=(_bool)
@@ -662,31 +763,34 @@ module FakeFS
 
     def advise(_advice, _offset = 0, _len = 0); end
 
-    def self.write(filename, contents, offset = nil, open_args = {})
-      offset, open_args = nil, offset if offset.is_a?(Hash)
+    def self.write(filename, contents, offset = nil, **open_args)
       mode = offset ? 'r+' : 'w'
-      if open_args.any?
-        if open_args[:open_args]
-          args = [filename, *open_args[:open_args]]
+      if open_args[:open_args]
+        # see open_key_args
+        # todo: foreach, readlines, read also use it
+        # Treat a final argument as keywords if it is a hash, and not as keywords otherwise.
+        open_args = open_args[:open_args]
+        if open_args.last.is_a?(Hash)
+          args = open_args[0...-1]
+          opt = open_args.last
         else
-          mode = open_args[:mode] || mode
-          args = [filename, mode, open_args]
+          args = open_args
+          opt = {}
         end
       else
-        args = [filename, mode]
+        args = [open_args.delete(:mode) || mode]
+        opt = open_args
       end
       if offset
-        open(*args) do |f| # rubocop:disable Security/Open
+        open(filename, *args, **opt) do |f| # rubocop:disable Security/Open
           f.seek(offset)
           f.write(contents)
         end
       else
-        open(*args) do |f| # rubocop:disable Security/Open
-          f << contents
+        open(filename, *args, **opt) do |f| # rubocop:disable Security/Open
+          f.write(contents)
         end
       end
-
-      contents.length
     end
 
     def self.birthtime(path)
@@ -701,16 +805,6 @@ module FakeFS
       self.class.birthtime(@path)
     end
 
-    def read(length = nil, buf = '')
-      read_buf = super(length, buf)
-      if binmode?
-        read_buf&.force_encoding('ASCII-8BIT')
-      else
-        read_buf&.force_encoding(Encoding.default_external)
-      end
-      read_buf
-    end
-
     def self.convert_symbolic_chmod_to_absolute(new_mode, current_mode)
       # mode always must be of form <GROUP1>=<FLAGS>,<GROUP2>=<FLAGS,...
       # e.g.: u=wr,go=x
@@ -832,7 +926,7 @@ module FakeFS
       elsif assignment_mode == '-'
         current_group_mode & ~chmod_perm_num
       else
-        raise ArguementError "Unknown assignment mode #{assignment_mode}"
+        raise ArgumentError, "Unknown assignment mode #{assignment_mode}"
       end
     end
 
@@ -866,8 +960,95 @@ module FakeFS
 
     private
 
-    def check_modes!
-      StringIO.new('', @mode)
+    def extract_binmode(opts, fmode)
+      textmode = opts[:textmode]
+      unless textmode.nil?
+        raise ArgumentError, "textmode specified twice" if fmode & FMODE_TEXTMODE != 0
+        raise ArgumentError, "both textmode and binmode specified" if fmode & FMODE_BINMODE != 0
+
+        # yep, false has no effect here, but still causes ArgumentError
+        fmode |= FMODE_TEXTMODE if textmode
+      end
+
+      binmode = opts[:binmode]
+      unless binmode.nil?
+        raise ArgumentError, "binmode specified twice" if fmode & FMODE_BINMODE != 0
+        raise ArgumentError, "both textmode and binmode specified" if fmode & FMODE_TEXTMODE != 0
+
+        fmode |= FMODE_BINMODE if binmode
+      end
+
+      if fmode & FMODE_BINMODE != 0 && fmode & FMODE_TEXTMODE != 0
+        raise ArgumentError, "both textmode and binmode specified"
+      end
+
+      fmode
+    end
+
+    def create_fmode(oflags)
+      # rb_io_oflags_fmode
+      fmode = 0
+      case oflags & FILE_ACCESS_MODE
+      when RealFile::RDONLY
+        fmode = FMODE_READABLE
+      when RealFile::WRONLY
+        fmode = FMODE_WRITABLE
+      when RealFile::RDWR
+        fmode = FMODE_READWRITE
+      end
+      fmode |= FMODE_APPEND if (oflags & RealFile::APPEND) != 0
+      fmode |= FMODE_TRUNC if (oflags & RealFile::TRUNC) != 0
+      fmode |= FMODE_CREATE if (oflags & RealFile::CREAT) != 0
+      fmode |= FMODE_EXCL if (oflags & RealFile::EXCL) != 0
+      fmode |= FMODE_BINMODE if (oflags & RealFile::BINARY) != 0
+      fmode
+    end
+
+    def parse_strmode_oflags(mode)
+      # rb_io_modestr_fmode
+      access_mode = mode[0]
+      mode_modificators = mode[1..-1].split(':', 2).first
+      fmode = TEXT_MODES[access_mode]
+      raise ArgumentError, "invalid access mode #{mode}" unless fmode
+
+      mode_modificators&.each_char do |m|
+        case m
+        when 'b'
+          fmode |= FMODE_BINMODE
+        when 't'
+          fmode |= FMODE_TEXTMODE
+        when '+'
+          fmode |= FMODE_READWRITE
+        when 'x'
+          raise ArgumentError, "invalid access mode #{mode}" unless access_mode == 'w'
+
+          fmode |= FMODE_EXCL
+        else
+          raise ArgumentError, "invalid access mode #{mode}"
+        end
+      end
+      if (fmode & FMODE_BINMODE).nonzero? && (fmode & FMODE_TEXTMODE).nonzero?
+        raise ArgumentError, "invalid access mode #{mode}"
+      end
+
+      # rb_io_fmode_oflags
+      oflags = 0
+      case fmode & FMODE_READWRITE
+      when FMODE_READABLE
+        oflags |= RealFile::RDONLY
+      when FMODE_WRITABLE
+        oflags |= RealFile::WRONLY
+      when FMODE_READWRITE
+        oflags |= RealFile::RDWR
+      end
+
+      oflags |= RealFile::APPEND if (fmode & FMODE_APPEND).nonzero?
+      oflags |= RealFile::TRUNC if (fmode & FMODE_TRUNC).nonzero?
+      oflags |= RealFile::CREAT if (fmode & FMODE_CREATE).nonzero?
+      oflags |= RealFile::EXCL if (fmode & FMODE_EXCL).nonzero?
+      oflags |= RealFile::BINARY if (fmode & FMODE_BINMODE).nonzero?
+
+      [oflags, fmode]
     end
 
     def check_file_existence!
@@ -875,27 +1056,21 @@ module FakeFS
     end
 
     def file_creation_mode?
-      mode_in?(FILE_CREATION_MODES) || mode_in_bitmask?(FILE_CREATION_BITMASK)
+      mode_in?(RealFile::CREAT)
     end
 
-    def mode_in?(list)
-      if @mode.respond_to?(:include?)
-        list.any? do |element|
-          @mode.include?(element)
-        end
-      end
-    end
-
-    def mode_in_bitmask?(mask)
-      (@mode & mask) != 0 if @mode.is_a?(Integer)
+    def mode_in?(mask)
+      (@oflags & mask) != 0
     end
 
     # Create a missing file if the path is valid.
     #
     def create_missing_file
-      raise Errno::EISDIR, path.to_s if File.directory?(@path)
-
-      return if File.exist?(@path) # Unnecessary check, probably.
+      if @file
+        raise Errno::EEXIST, @path.to_s if mode_in?(RealFile::EXCL)
+        raise Errno::EISDIR, path.to_s if File.directory?(@path)
+        return
+      end
       dirname = RealFile.dirname @path
 
       unless dirname == '.'

data/lib/fakefs/flockable_file.rb

@@ -27,18 +27,22 @@ module FakeFS
         int_mode = mode.to_int
 
         unless int_mode.is_a?(Integer)
-          raise TypeError, "can't convert Object to Integer (#{mode.class}#to_int gives #{int_mode.class})"
+          raise TypeError, "can't convert #{mode.class} to Integer (#{mode.class}#to_int gives #{int_mode.class})"
         end
         mode = int_mode
       end
 
-      # real implementation may not fail on `flock 11111` - but fails with `f1.flock 11111111` - or may fail
-      # with another error - `f1.flock 1111111111111` gives `integer 1111111111111 too big to convert to `int'
-      # but I think it's safer to allow only documented modes.
+      # In fact, real implementation may not fail on `flock 11111` -
+      # - but fails with `f1.flock 11111111` - or may fail
+      # with another error - `f1.flock 1111111111111` gives
+      # `integer 1111111111111 too big to convert to `int' (RangeError)`
+      # - but I think it's safer to allow only documented modes.
       unless FAKE_FS_ALLOWED_FLOCK_MODES.include?(mode)
         # real exception
         # Invalid argument @ rb_file_flock - filepath (Errno::EINVAL)
-        raise Errno::EINVAL.new(@path, 'rb_file_flock')
+        # raise Errno::EINVAL.new(@path, 'rb_file_flock')
+        # represents it better, but fails on JRuby
+        raise Errno::EINVAL, @path
       end
       0
     end

data/lib/fakefs/version.rb

@@ -1,7 +1,7 @@
 module FakeFS
   # Version module
   module Version
-    VERSION = '2.6.0'.freeze
+    VERSION = '2.7.1'.freeze
 
     def self.to_s
       VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakefs
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.1
 platform: ruby
 authors:
 - Chris Wanstrath