memfs 1.0.0 → 2.0.0

data/lib/memfs/dir.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
 require 'memfs/filesystem_access'
 
 module MemFs
@@ -6,6 +9,8 @@ module MemFs
     include Enumerable
     include FilesystemAccess
 
+    Tmpname = MemFs::OriginalDir::Tmpname
+
     attr_reader :pos
 
     def self.[](*patterns)
@@ -17,15 +22,26 @@ module MemFs
       0
     end
 
+    if MemFs.ruby_version_gte?('2.6')
+      def self.children(dirname, opts = {})
+        entries(dirname, opts) - %w[. ..]
+      end
+    end
+
     def self.chroot(path)
       fail Errno::EPERM, path unless Process.uid.zero?
 
       dir = fs.find_directory!(path)
-      dir.name = '/'
+      dir.name = MemFs.platform_root
       fs.root = dir
       0
     end
 
+    def self.empty?(path)
+      entry = fs.find!(path)
+      File.directory?(path) && entry.empty?
+    end
+
     def self.entries(dirname, _opts = {})
       fs.entries(dirname)
     end
@@ -33,7 +49,7 @@ module MemFs
     def self.exists?(path)
       File.directory?(path)
     end
-    class << self; alias_method :exist?, :exists?; end
+    class << self; alias exist? exists?; end
 
     def self.foreach(dirname, &block)
       return to_enum(__callee__, dirname) unless block
@@ -44,27 +60,44 @@ module MemFs
     def self.getwd
       fs.getwd
     end
-    class << self; alias_method :pwd, :getwd; end
+    class << self; alias pwd getwd; end
 
-    def self.glob(patterns, flags = 0)
-      patterns = [*patterns].map(&:to_s)
+    # rubocop:disable Lint/UnderscorePrefixedVariableName, Lint/UnusedMethodArgument
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:disable Metrics/PerceivedComplexity
+    def self.glob(patterns, _flags = 0, flags: _flags, base: nil, sort: true, &block)
+      # rubocop:enable Lint/UnderscorePrefixedVariableName, Lint/UnusedMethodArgument
+      original_patterns = [*patterns].map(&:to_s)
+      # Normalize patterns for platform (e.g., '/test' -> 'D:/test' on Windows)
+      normalized_patterns = original_patterns.map { |p| MemFs.normalize_path(p) }
       list = fs.paths.select do |path|
-        patterns.any? do |pattern|
+        normalized_patterns.any? do |pattern|
           File.fnmatch?(pattern, path, flags | GLOB_FLAGS)
         end
       end
-      # FIXME: ugly special case for /* and /
-      list.delete('/') if patterns.first == '/*'
+
+      # Special case for /* and /
+      # A scenario where /* is not the only pattern and / should be returned is
+      # considered an edge-case (platform-aware root handling).
+      root_pattern = MemFs.windows? ? "#{MemFs.platform_root}*" : '/*'
+      if ['/*', root_pattern].include?(original_patterns.first)
+        list.delete(MemFs.platform_root)
+        list.delete('/') # Also handle Unix-style if passed
+      end
+
       return list unless block_given?
-      list.each { |path| yield path }
+
+      list.each(&block)
       nil
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def self.home(*args)
       original_dir_class.home(*args)
     end
 
-    def self.mkdir(path, mode = 0777)
+    def self.mkdir(path, mode = 0o777)
       fs.mkdir path, mode
     end
 
@@ -77,7 +110,7 @@ module MemFs
         dir
       end
     ensure
-      dir && dir.close if block_given?
+      dir&.close if block_given?
     end
 
     def self.rmdir(path)
@@ -85,12 +118,37 @@ module MemFs
     end
 
     def self.tmpdir
-      '/tmp'
+      File.join(MemFs.platform_root, 'tmp')
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def self.mktmpdir(prefix_suffix = nil, tmpdir = nil, **options)
+      tmpdir = MemFs.normalize_path(tmpdir || self.tmpdir)
+      path = MemFs::OriginalDir::Tmpname.create(
+        prefix_suffix || 'd',
+        tmpdir,
+        **options) { |p, _, _, _d| mkdir(p, 0o700) }
+
+      # Normalize the returned path for consistent handling across platforms
+      path = MemFs.normalize_path(path)
+
+      return path unless block_given?
+
+      begin
+        yield path.dup
+      ensure
+        begin
+          rmdir(path) if exists?(path)
+        rescue StandardError
+          # Ignore cleanup errors
+        end
+      end
     end
+    # rubocop:enable Metrics/MethodLength
 
     class << self
-      alias_method :delete, :rmdir
-      alias_method :unlink, :rmdir
+      alias delete rmdir
+      alias unlink rmdir
     end
 
     def initialize(path)
@@ -110,15 +168,21 @@ module MemFs
       entry.entry_names.each(&block)
     end
 
+    def fileno
+      entry.fileno
+    end
+
     def path
       entry.path
     end
-    alias_method :to_path, :path
+    alias to_path path
 
+    # rubocop:disable Lint/Void
     def pos=(position)
       seek(position)
       position
     end
+    # rubocop:enable Lint/Void
 
     def read
       name = entries[pos]
@@ -141,13 +205,14 @@ module MemFs
       @pos
     end
 
-    private
-
     GLOB_FLAGS = if defined?(File::FNM_EXTGLOB)
                    File::FNM_EXTGLOB | File::FNM_PATHNAME
                  else
                    File::FNM_PATHNAME
                  end
+    private_constant :GLOB_FLAGS
+
+    private
 
     attr_accessor :entry, :max_seek, :state
 

data/lib/memfs/fake/directory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'memfs/fake/entry'
 
 module MemFs
@@ -18,8 +20,20 @@ module MemFs
         entries.keys
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find(path)
-        path = path.sub(%r{\A/+}, '').sub(%r{/+\z}, '')
+        path = MemFs.normalize_path(path)
+
+        # Strip root prefix if present (platform_root first, then directory name for root dirs)
+        if path.start_with?(MemFs.platform_root)
+          path = path[MemFs.platform_root.length..]
+        elsif root_directory? && path.start_with?(name)
+          path = path[name.length..]
+        end
+
+        path = path.gsub(%r{(\A/+|/+\z)}, '')
+        return self if path.empty?
+
         parts = path.split('/', 2)
 
         if entry_names.include?(path)
@@ -28,6 +42,7 @@ module MemFs
           entries[parts.first].find(parts.last)
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       def initialize(*args)
         super
@@ -40,14 +55,18 @@ module MemFs
       end
 
       def path
-        name == '/' ? '/' : super
+        root_directory? ? name : super
       end
 
       def paths
-        [path] + entries.reject { |p| %w[. ..].include?(p) }
-                 .values
-                 .map(&:paths)
-                 .flatten
+        current_or_parent_dirs = %w[. ..]
+
+        [path] +
+          entries
+          .reject { current_or_parent_dirs.include?(_1) }
+          .values
+          .map(&:paths)
+          .flatten
       end
 
       def remove_entry(entry)
@@ -57,6 +76,12 @@ module MemFs
       def type
         'directory'
       end
+
+      private
+
+      def root_directory?
+        parent.nil? || MemFs.root_path?(name)
+      end
     end
   end
 end

data/lib/memfs/fake/entry.rb

@@ -1,29 +1,32 @@
+# frozen_string_literal: true
+
 module MemFs
   module Fake
     class Entry
-      UREAD  = 00100
-      UWRITE = 00200
-      UEXEC  = 00400
-      GREAD  = 00010
-      GWRITE = 00020
-      GEXEC  = 00040
-      OREAD  = 00001
-      OWRITE = 00002
-      OEXEC  = 00004
-      RSTICK = 01000
-      USTICK = 05000
-      SETUID = 04000
-      SETGID = 02000
+      UREAD  = 0o0400
+      UWRITE = 0o0200
+      UEXEC  = 0o0100
+      GREAD  = 0o0040
+      GWRITE = 0o0020
+      GEXEC  = 0o0010
+      OREAD  = 0o0004
+      OWRITE = 0o0002
+      OEXEC  = 0o0001
+      RSTICK = 0o1000
+      USTICK = 0o5000
+      SETUID = 0o4000
+      SETGID = 0o2000
 
       attr_accessor :atime,
-                    :block_device,
-                    :character_device,
-                    :ctime,
-                    :gid,
-                    :mtime,
-                    :name,
-                    :parent,
-                    :uid
+        :birthtime,
+        :block_device,
+        :character_device,
+        :ctime,
+        :gid,
+        :mtime,
+        :name,
+        :parent,
+        :uid
       attr_reader :mode
 
       def blksize
@@ -50,31 +53,44 @@ module MemFs
         @dev ||= rand(1000)
       end
 
+      def fileno
+        fail NotImplementedError
+      end
+
       def find(_path)
         fail Errno::ENOTDIR, path
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def initialize(path = nil)
         time = Time.now
         self.atime = time
+        self.birthtime = time
         self.ctime = time
         self.gid = Process.egid
-        self.mode = 0666 - MemFs::File.umask
+        self.mode = 0o666 - MemFs::File.umask
         self.mtime = time
-        self.name = MemFs::File.basename(path || '')
+        # Preserve full path for root directories (e.g., 'D:/' on Windows)
+        # since File.basename('D:/') returns '/' which breaks path matching
+        self.name = if path && MemFs.root_path?(path)
+                      MemFs.normalize_path(path)
+                    else
+                      MemFs::File.basename(path || '')
+                    end
         self.uid = Process.euid
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def ino
         @ino ||= rand(1000)
       end
 
       def mode=(mode_int)
-        @mode = 0100000 | mode_int
+        @mode = 0o100000 | mode_int
       end
 
       def path
-        parts = [parent && parent.path, name].compact
+        parts = [parent&.path, name].compact
         MemFs::File.join(parts)
       end
 

data/lib/memfs/fake/file/content.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'delegate'
 
 module MemFs
@@ -6,10 +8,11 @@ module MemFs
       class Content < SimpleDelegator
         attr_accessor :pos
 
-        def close
-        end
+        def close; end
 
         def initialize(obj = '')
+          super
+
           @string = obj.to_s.dup
           @pos = 0
 
@@ -24,7 +27,7 @@ module MemFs
           end
         end
 
-        def read(length = nil, buffer = '')
+        def read(length = nil, buffer = +'')
           length ||= @string.length - @pos
           buffer.replace @string[@pos, length]
           @pos += buffer.bytesize

data/lib/memfs/fake/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'memfs/fake/entry'
 require 'memfs/fake/file/content'
 

data/lib/memfs/fake/symlink.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'memfs/filesystem_access'
 
 module MemFs

data/lib/memfs/file/stat.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'memfs/filesystem_access'
 
@@ -10,15 +12,16 @@ module MemFs
       attr_reader :entry
 
       def_delegators :entry,
-                     :atime,
-                     :blksize,
-                     :ctime,
-                     :dev,
-                     :gid,
-                     :ino,
-                     :mode,
-                     :mtime,
-                     :uid
+        :atime,
+        :birthtime,
+        :blksize,
+        :ctime,
+        :dev,
+        :gid,
+        :ino,
+        :mode,
+        :mtime,
+        :uid
 
       def blockdev?
         !!entry.block_device
@@ -52,11 +55,15 @@ module MemFs
         gid == Process.egid
       end
 
-      def initialize(path, dereference = false)
+      def initialize(path, dereference: false)
         entry = fs.find!(path)
         @entry = dereference ? entry.dereferenced : entry
       end
 
+      def nlink
+        directory? ? 2 : 1
+      end
+
       def owned?
         uid == Process.euid
       end
@@ -94,11 +101,11 @@ module MemFs
       end
 
       def world_readable?
-        entry.mode - 0100000 if (entry.mode & Fake::Entry::OREAD).nonzero?
+        entry.mode - 0o100000 if (entry.mode & Fake::Entry::OREAD).nonzero?
       end
 
       def world_writable?
-        entry.mode - 0100000 if (entry.mode & Fake::Entry::OWRITE).nonzero?
+        entry.mode - 0o100000 if (entry.mode & Fake::Entry::OWRITE).nonzero?
       end
 
       def writable?
@@ -164,7 +171,7 @@ module MemFs
       end
 
       def world_executable?
-        entry.mode - 0100000 if (entry.mode & Fake::Entry::OEXEC).nonzero?
+        entry.mode - 0o100000 if (entry.mode & Fake::Entry::OEXEC).nonzero?
       end
     end
   end