fakefs 2.5.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4a0f94695c0070ec3847b3177acebdf1160f2064ba02d950d04a31385c43207
-  data.tar.gz: bb0e627c6a32b31b8a1068cae3a5d4542b150d2ed06fecc0719a029889a0815c
+  metadata.gz: ae15dc7d6aeb86af398a96ad824d7e53fa9ea82d73a207b23e404e8abfa3815f
+  data.tar.gz: 3f2794b9dd3db6a5596c90d9c556fd3ef2493244daca68f1328490a95dc205d8
 SHA512:
-  metadata.gz: 646053f9768a3a408c3d365ee2230f089131477decf9ccdb4e51bcd6c9080e1fb56bada71f2f661a685fa41866de408cab4b9de7c07cf50df3fe21b2dde09a85
-  data.tar.gz: 87d29cda1d981939b941023104f5b7a1ee6f58ea9ca983ca16e379a4471c55ce1aea045a2a6c560b07bd760dc238d14f56b68dd7881a651991a587ca0294e0f8
+  metadata.gz: c8160c6d4d18841aa27ca9886923721897144f2543c133374dc0df81ebea56e79ea93cb1b2409138cd89a46772b4fe8232633ff72e898f286f115961652f5886
+  data.tar.gz: c77ced5468712332efde9928a22c7ba56070ab4c16598cc6662211f0e95273df39dc019860a234161513bec8d17d54e80997a4b52f5717f374321ce1aa8122ed

data/README.md

@@ -128,7 +128,6 @@ describe "my spec" do
 end
 ```
 
-
 FakeFs --- `TypeError: superclass mismatch for class File`
 --------------
 
@@ -168,7 +167,7 @@ yourself on the equivalent FakeFS classes. For example,
 [FileMagic](https://rubygems.org/gems/ruby-filemagic) adds `File#content_type`.
 A fake version can be provided as follows:
 
-``` ruby
+```ruby
 FakeFS::File.class_eval do
   def content_type
     'fake/file'
@@ -176,6 +175,15 @@ FakeFS::File.class_eval do
 end
 ```
 
+File.lock
+---------
+
+Warning: experimental and might break if you obtain more that one flock per file using different descriptors
+
+```ruby
+require 'fakefs/flockable_file'
+```
+
 Caveats
 -------
 

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 |= File::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/file_system.rb

@@ -56,7 +56,11 @@ module FakeFS
       assert_dir d
       object.name = parts.last
       object.parent = d
-      d[parts.last] ||= object
+      if object.is_a? FakeDir
+        d[parts.last] ||= object
+      else
+        d[parts.last] = object
+      end
     end
 
     # copies directories and files from the real filesystem

data/lib/fakefs/flockable_file.rb

@@ -0,0 +1,50 @@
+require_relative 'file'
+
+module FakeFS
+  # Be careful using this, as it may break things if
+  # you obtain more that one flock per file using
+  # different descriptors.
+  # Real flock call blocks/returns false in that case -
+  # see https://man7.org/linux/man-pages/man2/flock.2.html,
+  # it says it "may be denied", but it does, it fact, deny.
+  # This implementation simply returns 0.
+  # This may also be a problem if you, it fact, are accessing a
+  # real file, which is locked by another process.
+  class File < StringIO
+    # yep, File::LOCK_UN | File::LOCK_NB is allowed
+    FAKE_FS_ALLOWED_FLOCK_MODES = [RealFile::LOCK_EX, RealFile::LOCK_SH, RealFile::LOCK_UN].flat_map do |mode|
+      [mode, mode | RealFile::LOCK_NB]
+    end.freeze
+
+    remove_method :flock
+
+    def flock(mode)
+      # all successful calls - even UN - seem to return 0
+      unless mode.is_a?(Integer)
+        unless mode.respond_to?(:to_int)
+          raise TypeError, "no implicit conversion of #{mode.class} into Integer"
+        end
+        int_mode = mode.to_int
+
+        unless int_mode.is_a?(Integer)
+          raise TypeError, "can't convert #{mode.class} to Integer (#{mode.class}#to_int gives #{int_mode.class})"
+        end
+        mode = int_mode
+      end
+
+      # 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')
+        # represents it better, but fails on JRuby
+        raise Errno::EINVAL, @path
+      end
+      0
+    end
+  end
+end

data/lib/fakefs/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakefs
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Chris Wanstrath
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-23 00:00:00.000000000 Z
+date: 2024-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bump
@@ -118,6 +118,7 @@ files:
 - lib/fakefs/file_system.rb
 - lib/fakefs/file_test.rb
 - lib/fakefs/fileutils.rb
+- lib/fakefs/flockable_file.rb
 - lib/fakefs/globber.rb
 - lib/fakefs/io.rb
 - lib/fakefs/irb.rb
@@ -146,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A fake filesystem. Use it in your tests.