zeitwerk 2.6.2 → 2.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7faace5f41a2ea580759f539f13136531f9291010d68821fe430ee0e0b89cbb
-  data.tar.gz: c1da4a297fc7339d19bbfecf453972576b22f27498a780cc2534ff4d1a2731e7
+  metadata.gz: 8c7bbcbb7fa03b5ef6389335805145cabf2a4fdd203c15b3c6ecdf68f229e499
+  data.tar.gz: 3581c99a8d4431eeeed3b6139aca5363f9c13d136dddb22aa5c88b55d2ff2dac
 SHA512:
-  metadata.gz: dc9ba4bd627b775bdd01bcc0ef5d902c348519b63ac12d4bfb3177f1da1f9b4c0308a611327cad9c092b84ebecc50b72e419ad51e4c44f95c8ed029d2f073a8e
-  data.tar.gz: addc0120d3b187668e0a8128eaf904dbe406f9bd78bd1192eef4ada7bcc35c252396a9f01c2e07bf7e1ba5d1aff3ae5646ca05cec498d7cc4b659f1f6ebd5388
+  metadata.gz: 3575d2cd414fe45f4c42ce286fbf9cbf648ed0cf5c3643db82167023adde590058cbe88c2348fe2c9f6f8d56f04858ef49441115544dca88b18b48f2eb36d886
+  data.tar.gz: 4d9fc1a1c72df9233e742f22ad2a0bd636301e55cd9078e856cdfb9a8b2727345d86f278e592fb0294959e9aad92895619e69133050afa943192a61477bad64d

data/README.md

@@ -536,7 +536,7 @@ The method `Zeitwerk::Loader.eager_load_namespace` broadcasts `eager_load_namesp
 Zeitwerk::Loader.eager_load_namespace(MyFramework::Routes)
 ```
 
-This may be handy, for example, if a framework supports plugins and a shared namespace needs to be eager loaded for the project to function properly.
+This may be handy, for example, if a framework supports plugins and a shared namespace needs to be eager loaded for the framework to function properly.
 
 Please, note that loaders only eager load namespaces they manage, as documented above. Therefore, this method does not allow you to eager load namespaces not managed by Zeitwerk loaders.
 

data/lib/zeitwerk/internal.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# This is a private module.
+module Zeitwerk::Internal
+  def internal(method_name)
+    private method_name
+
+    mangled = "__#{method_name}"
+    alias_method mangled, method_name
+    public mangled
+  end
+end

data/lib/zeitwerk/loader/config.rb

@@ -4,6 +4,14 @@ require "set"
 require "securerandom"
 
 module Zeitwerk::Loader::Config
+  extend Zeitwerk::Internal
+
+  # @sig #camelize
+  attr_accessor :inflector
+
+  # @sig #call | #debug | nil
+  attr_accessor :logger
+
   # Absolute paths of the root directories. Stored in a hash to preserve order,
   # easily handle duplicates, have a fast lookup needed for detecting nested
   # paths, and store namespaces as values.
@@ -15,74 +23,70 @@ module Zeitwerk::Loader::Config
   # This is a private collection maintained by the loader. The public
   # interface for it is `push_dir` and `dirs`.
   #
-  # @private
   # @sig Hash[String, Module]
-  attr_reader :root_dirs
-
-  # @sig #camelize
-  attr_accessor :inflector
+  attr_reader :roots
+  internal :roots
 
   # Absolute paths of files, directories, or glob patterns to be totally
   # ignored.
   #
-  # @private
   # @sig Set[String]
   attr_reader :ignored_glob_patterns
+  private :ignored_glob_patterns
 
   # The actual collection of absolute file and directory names at the time the
   # ignored glob patterns were expanded. Computed on setup, and recomputed on
   # reload.
   #
-  # @private
   # @sig Set[String]
   attr_reader :ignored_paths
+  private :ignored_paths
 
   # Absolute paths of directories or glob patterns to be collapsed.
   #
-  # @private
   # @sig Set[String]
   attr_reader :collapse_glob_patterns
+  private :collapse_glob_patterns
 
   # The actual collection of absolute directory names at the time the collapse
   # glob patterns were expanded. Computed on setup, and recomputed on reload.
   #
-  # @private
   # @sig Set[String]
   attr_reader :collapse_dirs
+  private :collapse_dirs
 
   # Absolute paths of files or directories not to be eager loaded.
   #
-  # @private
   # @sig Set[String]
   attr_reader :eager_load_exclusions
+  private :eager_load_exclusions
 
   # User-oriented callbacks to be fired on setup and on reload.
   #
-  # @private
   # @sig Array[{ () -> void }]
   attr_reader :on_setup_callbacks
+  private :on_setup_callbacks
 
   # User-oriented callbacks to be fired when a constant is loaded.
   #
-  # @private
   # @sig Hash[String, Array[{ (Object, String) -> void }]]
   #      Hash[Symbol, Array[{ (String, Object, String) -> void }]]
   attr_reader :on_load_callbacks
+  private :on_load_callbacks
 
   # User-oriented callbacks to be fired before constants are removed.
   #
-  # @private
   # @sig Hash[String, Array[{ (Object, String) -> void }]]
   #      Hash[Symbol, Array[{ (String, Object, String) -> void }]]
   attr_reader :on_unload_callbacks
-
-  # @sig #call | #debug | nil
-  attr_accessor :logger
+  private :on_unload_callbacks
 
   def initialize
-    @initialized_at         = Time.now
-    @root_dirs              = {}
     @inflector              = Zeitwerk::Inflector.new
+    @logger                 = self.class.default_logger
+    @tag                    = SecureRandom.hex(3)
+    @initialized_at         = Time.now
+    @roots                  = {}
     @ignored_glob_patterns  = Set.new
     @ignored_paths          = Set.new
     @collapse_glob_patterns = Set.new
@@ -92,8 +96,6 @@ module Zeitwerk::Loader::Config
     @on_setup_callbacks     = []
     @on_load_callbacks      = {}
     @on_unload_callbacks    = {}
-    @logger                 = self.class.default_logger
-    @tag                    = SecureRandom.hex(3)
   end
 
   # Pushes `path` to the list of root directories.
@@ -113,7 +115,7 @@ module Zeitwerk::Loader::Config
     abspath = File.expand_path(path)
     if dir?(abspath)
       raise_if_conflicting_directory(abspath)
-      root_dirs[abspath] = namespace
+      roots[abspath] = namespace
     else
       raise Zeitwerk::Error, "the root directory #{abspath} does not exist"
     end
@@ -146,9 +148,9 @@ module Zeitwerk::Loader::Config
   # @sig () -> Array[String] | Hash[String, Module]
   def dirs(namespaces: false)
     if namespaces
-      root_dirs.clone
+      roots.clone
     else
-      root_dirs.keys
+      roots.keys
     end.freeze
   end
 
@@ -275,71 +277,68 @@ module Zeitwerk::Loader::Config
   # Returns true if the argument has been configured to be ignored, or is a
   # descendant of an ignored directory.
   #
-  # @private
   # @sig (String) -> bool
-  def ignores?(abspath)
+  internal def ignores?(abspath)
     # Common use case.
     return false if ignored_paths.empty?
 
     walk_up(abspath) do |abspath|
       return true  if ignored_paths.member?(abspath)
-      return false if root_dirs.key?(abspath)
+      return false if roots.key?(abspath)
     end
 
     false
   end
 
-  private
-
   # @sig () -> Array[String]
-  def actual_root_dirs
-    root_dirs.reject do |root_dir, _namespace|
+  private def actual_roots
+    roots.reject do |root_dir, _root_namespace|
       !dir?(root_dir) || ignored_paths.member?(root_dir)
     end
   end
 
   # @sig (String) -> bool
-  def root_dir?(dir)
-    root_dirs.key?(dir)
+  private def root_dir?(dir)
+    roots.key?(dir)
   end
 
   # @sig (String) -> bool
-  def excluded_from_eager_load?(abspath)
+  private def excluded_from_eager_load?(abspath)
     # Optimize this common use case.
     return false if eager_load_exclusions.empty?
 
     walk_up(abspath) do |abspath|
       return true  if eager_load_exclusions.member?(abspath)
-      return false if root_dirs.key?(abspath)
+      return false if roots.key?(abspath)
     end
 
     false
   end
 
   # @sig (String) -> bool
-  def collapse?(dir)
+  private def collapse?(dir)
     collapse_dirs.member?(dir)
   end
 
   # @sig (String | Pathname | Array[String | Pathname]) -> Array[String]
-  def expand_paths(paths)
+  private def expand_paths(paths)
     paths.flatten.map! { |path| File.expand_path(path) }
   end
 
   # @sig (Array[String]) -> Array[String]
-  def expand_glob_patterns(glob_patterns)
+  private def expand_glob_patterns(glob_patterns)
     # Note that Dir.glob works with regular file names just fine. That is,
     # glob patterns technically need no wildcards.
     glob_patterns.flat_map { |glob_pattern| Dir.glob(glob_pattern) }
   end
 
   # @sig () -> void
-  def recompute_ignored_paths
+  private def recompute_ignored_paths
     ignored_paths.replace(expand_glob_patterns(ignored_glob_patterns))
   end
 
   # @sig () -> void
-  def recompute_collapse_dirs
+  private def recompute_collapse_dirs
     collapse_dirs.replace(expand_glob_patterns(collapse_glob_patterns))
   end
 end

data/lib/zeitwerk/loader/eager_load.rb

@@ -12,8 +12,8 @@ module Zeitwerk::Loader::EagerLoad
 
       log("eager load start") if logger
 
-      actual_root_dirs.each do |root_dir, namespace|
-        actual_eager_load_dir(root_dir, namespace, force: force)
+      actual_roots.each do |root_dir, root_namespace|
+        actual_eager_load_dir(root_dir, root_namespace, force: force)
       end
 
       autoloaded_dirs.each do |autoloaded_dir|
@@ -40,7 +40,7 @@ module Zeitwerk::Loader::EagerLoad
       return if ignored_paths.member?(dir)
       return if eager_load_exclusions.member?(dir)
 
-      break if root_namespace = root_dirs[dir]
+      break if root_namespace = roots[dir]
 
       unless collapse?(dir)
         basename = File.basename(dir)
@@ -73,23 +73,24 @@ module Zeitwerk::Loader::EagerLoad
 
     return if @eager_loaded
 
-    actual_root_dirs.each do |root_dir, root_namespace|
+    mod_name = real_mod_name(mod)
+    return unless mod_name
+
+    actual_roots.each do |root_dir, root_namespace|
       if mod.equal?(Object)
         # A shortcircuiting test depends on the invocation of this method.
         # Please keep them in sync if refactored.
         actual_eager_load_dir(root_dir, root_namespace)
       elsif root_namespace.equal?(Object)
-        eager_load_child_namespace(mod, root_dir, root_namespace)
+        eager_load_child_namespace(mod, mod_name, root_dir, root_namespace)
       else
-        mod_name = real_mod_name(mod)
         root_namespace_name = real_mod_name(root_namespace)
-
         if root_namespace_name.start_with?(mod_name + "::")
           actual_eager_load_dir(root_dir, root_namespace)
         elsif mod_name == root_namespace_name
           actual_eager_load_dir(root_dir, root_namespace)
         elsif mod_name.start_with?(root_namespace_name + "::")
-          eager_load_child_namespace(mod, root_dir, root_namespace)
+          eager_load_child_namespace(mod, mod_name, root_dir, root_namespace)
         else
           # Unrelated constant hierarchies, do nothing.
         end
@@ -121,7 +122,7 @@ module Zeitwerk::Loader::EagerLoad
     walk_up(File.dirname(abspath)) do |dir|
       raise Zeitwerk::Error.new("#{abspath} is ignored") if ignored_paths.member?(dir)
 
-      break if root_namespace = root_dirs[dir]
+      break if root_namespace = roots[dir]
 
       unless collapse?(dir)
         basename = File.basename(dir)
@@ -180,8 +181,8 @@ module Zeitwerk::Loader::EagerLoad
   # strict namespace descendendant of `root_namespace`.
   #
   # @sig (Module, String, Module, Boolean) -> void
-  private def eager_load_child_namespace(child, root_dir, root_namespace)
-    suffix = real_mod_name(child)
+  private def eager_load_child_namespace(child, child_name, root_dir, root_namespace)
+    suffix = child_name
     unless root_namespace.equal?(Object)
       suffix = suffix.delete_prefix(real_mod_name(root_namespace) + "::")
     end

data/lib/zeitwerk/loader/helpers.rb

@@ -31,7 +31,7 @@ module Zeitwerk::Loader::Helpers
       next if ignored_paths.member?(abspath)
 
       if dir?(abspath)
-        next if root_dirs.key?(abspath)
+        next if roots.key?(abspath)
         next if !has_at_least_one_ruby_file?(abspath)
       else
         next unless ruby?(abspath)

data/lib/zeitwerk/loader.rb

@@ -116,8 +116,8 @@ module Zeitwerk
       mutex.synchronize do
         break if @setup
 
-        actual_root_dirs.each do |root_dir, namespace|
-          set_autoloads_in_dir(root_dir, namespace)
+        actual_roots.each do |root_dir, root_namespace|
+          set_autoloads_in_dir(root_dir, root_namespace)
         end
 
         on_setup_callbacks.each(&:call)
@@ -441,19 +441,20 @@ module Zeitwerk
     # @sig (String) -> void
     def raise_if_conflicting_directory(dir)
       MUTEX.synchronize do
+        dir_slash = dir + "/"
+
         Registry.loaders.each do |loader|
           next if loader == self
-          next if loader.ignores?(dir)
+          next if loader.__ignores?(dir)
 
-          dir = dir + "/"
-          loader.root_dirs.each do |root_dir, _namespace|
+          loader.__roots.each_key do |root_dir|
             next if ignores?(root_dir)
 
-            root_dir = root_dir + "/"
-            if dir.start_with?(root_dir) || root_dir.start_with?(dir)
+            root_dir_slash = root_dir + "/"
+            if dir_slash.start_with?(root_dir_slash) || root_dir_slash.start_with?(dir_slash)
               require "pp" # Needed for pretty_inspect, even in Ruby 2.5.
               raise Error,
-                "loader\n\n#{pretty_inspect}\n\nwants to manage directory #{dir.chop}," \
+                "loader\n\n#{pretty_inspect}\n\nwants to manage directory #{dir}," \
                 " which is already managed by\n\n#{loader.pretty_inspect}\n"
               EOS
             end

data/lib/zeitwerk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zeitwerk
-  VERSION = "2.6.2"
+  VERSION = "2.6.4"
 end

data/lib/zeitwerk.rb

@@ -2,6 +2,7 @@
 
 module Zeitwerk
   require_relative "zeitwerk/real_mod_name"
+  require_relative "zeitwerk/internal"
   require_relative "zeitwerk/loader"
   require_relative "zeitwerk/gem_loader"
   require_relative "zeitwerk/registry"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zeitwerk
 version: !ruby/object:Gem::Version
-  version: 2.6.2
+  version: 2.6.4
 platform: ruby
 authors:
 - Xavier Noria
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-31 00:00:00.000000000 Z
+date: 2022-11-01 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zeitwerk implements constant autoloading with Ruby semantics. Each gem
@@ -28,6 +28,7 @@ files:
 - lib/zeitwerk/gem_inflector.rb
 - lib/zeitwerk/gem_loader.rb
 - lib/zeitwerk/inflector.rb
+- lib/zeitwerk/internal.rb
 - lib/zeitwerk/kernel.rb
 - lib/zeitwerk/loader.rb
 - lib/zeitwerk/loader/callbacks.rb