zeitwerk 2.7.1 → 2.7.3

data/lib/zeitwerk/registry/loaders.rb

@@ -0,0 +1,33 @@
+module Zeitwerk::Registry
+  class Loaders # :nodoc:
+    #: () -> void
+    def initialize
+      @loaders = [] #: Array[Zeitwerk::Loader]
+    end
+
+    #: ({ (Zeitwerk::Loader) -> void }) -> void
+    def each(&block)
+      @loaders.each(&block)
+    end
+
+    #: (Zeitwerk::Loader) -> void
+    def register(loader)
+      @loaders << loader
+    end
+
+    #: (Zeitwerk::Loader) -> Zeitwerk::Loader?
+    def unregister(loader)
+      @loaders.delete(loader)
+    end
+
+    #: (Zeitwerk::Loader) -> bool
+    def registered?(loader) # for tests
+      @loaders.include?(loader)
+    end
+
+    #: () -> void
+    def clear # for tests
+      @loaders.clear
+    end
+  end
+end

data/lib/zeitwerk/registry.rb

@@ -2,18 +2,23 @@
 
 module Zeitwerk
   module Registry # :nodoc: all
+    require_relative "registry/autoloads"
+    require_relative "registry/explicit_namespaces"
+    require_relative "registry/inceptions"
+    require_relative "registry/loaders"
+
     class << self
       # Keeps track of all loaders. Useful to broadcast messages and to prevent
       # them from being garbage collected.
       #
       # @private
-      # @sig Array[Zeitwerk::Loader]
+      #: Zeitwerk::Registry::Loaders
       attr_reader :loaders
 
       # Registers gem loaders to let `for_gem` be idempotent in case of reload.
       #
       # @private
-      # @sig Hash[String, Zeitwerk::Loader]
+      #: Hash[String, Zeitwerk::Loader]
       attr_reader :gem_loaders_by_root_file
 
       # Maps absolute paths to the loaders responsible for them.
@@ -22,120 +27,37 @@ module Zeitwerk
       # invoke callbacks and autovivify modules.
       #
       # @private
-      # @sig Hash[String, Zeitwerk::Loader]
+      #: Zeitwerk::Registry::Autoloads
       attr_reader :autoloads
 
-      # This hash table addresses an edge case in which an autoload is ignored.
-      #
-      # For example, let's suppose we want to autoload in a gem like this:
-      #
-      #   # lib/my_gem.rb
-      #   loader = Zeitwerk::Loader.new
-      #   loader.push_dir(__dir__)
-      #   loader.setup
-      #
-      #   module MyGem
-      #   end
-      #
-      # if you require "my_gem", as Bundler would do, this happens while setting
-      # up autoloads:
-      #
-      #   1. Object.autoload?(:MyGem) returns `nil` because the autoload for
-      #      the constant is issued by Zeitwerk while the same file is being
-      #      required.
-      #   2. The constant `MyGem` is undefined while setup runs.
-      #
-      # Therefore, a directory `lib/my_gem` would autovivify a module according to
-      # the existing information. But that would be wrong.
-      #
-      # To overcome this fundamental limitation, we keep track of the constant
-      # paths that are in this situation ---in the example above, "MyGem"--- and
-      # take this collection into account for the autovivification logic.
-      #
-      # Note that you cannot generally address this by moving the setup code
-      # below the constant definition, because we want libraries to be able to
-      # use managed constants in the module body:
-      #
-      #   module MyGem
-      #     include MyConcern
-      #   end
-      #
       # @private
-      # @sig Hash[String, [String, Zeitwerk::Loader]]
-      attr_reader :inceptions
+      #: Zeitwerk::Registry::ExplicitNamespaces
+      attr_reader :explicit_namespaces
 
-      # Registers a loader.
-      #
       # @private
-      # @sig (Zeitwerk::Loader) -> void
-      def register_loader(loader)
-        loaders << loader
-      end
+      #: Zeitwerk::Registry::Inceptions
+      attr_reader :inceptions
 
       # @private
-      # @sig (Zeitwerk::Loader) -> void
+      #: (Zeitwerk::Loader) -> void
       def unregister_loader(loader)
-        loaders.delete(loader)
         gem_loaders_by_root_file.delete_if { |_, l| l == loader }
-        autoloads.delete_if { |_, l| l == loader }
-        inceptions.delete_if { |_, (_, l)| l == loader }
       end
 
       # This method returns always a loader, the same instance for the same root
       # file. That is how Zeitwerk::Loader.for_gem is idempotent.
       #
       # @private
-      # @sig (String) -> Zeitwerk::Loader
+      #: (String, namespace: Module, warn_on_extra_files: boolish) -> Zeitwerk::Loader
       def loader_for_gem(root_file, namespace:, warn_on_extra_files:)
         gem_loaders_by_root_file[root_file] ||= GemLoader.__new(root_file, namespace: namespace, warn_on_extra_files: warn_on_extra_files)
       end
-
-      # @private
-      # @sig (Zeitwerk::Loader, String) -> String
-      def register_autoload(loader, abspath)
-        autoloads[abspath] = loader
-      end
-
-      # @private
-      # @sig (String) -> void
-      def unregister_autoload(abspath)
-        autoloads.delete(abspath)
-      end
-
-      # @private
-      # @sig (String, String, Zeitwerk::Loader) -> void
-      def register_inception(cpath, abspath, loader)
-        inceptions[cpath] = [abspath, loader]
-      end
-
-      # @private
-      # @sig (String) -> String?
-      def inception?(cpath, registered_by_loader=nil)
-        if pair = inceptions[cpath]
-          abspath, loader = pair
-          if registered_by_loader.nil? || registered_by_loader.equal?(loader)
-            abspath
-          end
-        end
-      end
-
-      # @private
-      # @sig (String) -> Zeitwerk::Loader?
-      def loader_for(path)
-        autoloads[path]
-      end
-
-      # @private
-      # @sig (Zeitwerk::Loader) -> void
-      def on_unload(loader)
-        autoloads.delete_if { |_path, object| object == loader }
-        inceptions.delete_if { |_cpath, (_path, object)| object == loader }
-      end
     end
 
-    @loaders                  = []
+    @loaders                  = Loaders.new
     @gem_loaders_by_root_file = {}
-    @autoloads                = {}
-    @inceptions               = {}
+    @autoloads                = Autoloads.new
+    @explicit_namespaces      = ExplicitNamespaces.new
+    @inceptions               = Inceptions.new
   end
 end

data/lib/zeitwerk/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Zeitwerk
-  VERSION = "2.7.1"
+  #: String
+  VERSION = "2.7.3"
 end

data/lib/zeitwerk.rb

@@ -7,7 +7,6 @@ module Zeitwerk
   require_relative "zeitwerk/loader"
   require_relative "zeitwerk/gem_loader"
   require_relative "zeitwerk/registry"
-  require_relative "zeitwerk/explicit_namespace"
   require_relative "zeitwerk/inflector"
   require_relative "zeitwerk/gem_inflector"
   require_relative "zeitwerk/null_inflector"
@@ -20,7 +19,7 @@ module Zeitwerk
   # This is a dangerous method.
   #
   # @experimental
-  # @sig () -> void
+  #: () -> void
   def self.with_loader
     loader = Zeitwerk::Loader.new
     yield loader

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: zeitwerk
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 2.7.3
 platform: ruby
 authors:
 - Xavier Noria
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zeitwerk implements constant autoloading with Ruby semantics. Each gem
@@ -26,8 +25,8 @@ files:
 - lib/zeitwerk/core_ext/kernel.rb
 - lib/zeitwerk/core_ext/module.rb
 - lib/zeitwerk/cref.rb
+- lib/zeitwerk/cref/map.rb
 - lib/zeitwerk/error.rb
-- lib/zeitwerk/explicit_namespace.rb
 - lib/zeitwerk/gem_inflector.rb
 - lib/zeitwerk/gem_loader.rb
 - lib/zeitwerk/inflector.rb
@@ -40,6 +39,10 @@ files:
 - lib/zeitwerk/null_inflector.rb
 - lib/zeitwerk/real_mod_name.rb
 - lib/zeitwerk/registry.rb
+- lib/zeitwerk/registry/autoloads.rb
+- lib/zeitwerk/registry/explicit_namespaces.rb
+- lib/zeitwerk/registry/inceptions.rb
+- lib/zeitwerk/registry/loaders.rb
 - lib/zeitwerk/version.rb
 homepage: https://github.com/fxn/zeitwerk
 licenses:
@@ -49,7 +52,6 @@ metadata:
   changelog_uri: https://github.com/fxn/zeitwerk/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/fxn/zeitwerk
   bug_tracker_uri: https://github.com/fxn/zeitwerk/issues
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -64,8 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.21
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Efficient and thread-safe constant autoloader
 test_files: []

data/lib/zeitwerk/explicit_namespace.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  # This module is essentially a registry for explicit namespaces.
-  #
-  # When a loader determines that a certain file should define an explicit
-  # namespace, it registers it here, associating its cref with itself.
-  #
-  # If the namespace is autoloaded, our const_added callback retrieves its
-  # loader by calling loader_for. That way, the loader is able to scan the
-  # subdirectories that conform the namespace and set autoloads for their
-  # expected constants just in time.
-  #
-  # Once autoloaded, the namespace is unregistered.
-  #
-  # The implementation assumes an explicit namespace is managed by one loader.
-  # Loaders that reopen namespaces owned by other projects are responsible for
-  # loading their constant before setup. This is documented.
-  module ExplicitNamespace # :nodoc: all
-    # Maps cnames or cpaths of explicit namespaces with their corresponding
-    # loader. They are symbols for top-level ones, and strings for nested ones:
-    #
-    #   {
-    #     :Admin => #<Zeitwerk::Loader:...>,
-    #     "Hotel::Pricing" => #<Zeitwerk::Loader:...>
-    #   }
-    #
-    # There are two types of keys to make loader_for as fast as possible, since
-    # it is invoked by our const_added for all autoloads and constant actually
-    # added. Globally. With this trick, for top-level constants we do not need
-    # to call Symbol#name and perform a string lookup. Instead, we can directly
-    # perform a fast symbol lookup.
-    #
-    # Entries are added as the namespaces are found, and removed as they are
-    # autoloaded.
-    #
-    # @sig Hash[(Symbol | String) => Zeitwerk::Loader]
-    @loaders = {}
-
-    class << self
-      include RealModName
-      extend Internal
-
-      # Registers `cref` as being the constant path of an explicit namespace
-      # managed by `loader`.
-      #
-      # @sig (String, Zeitwerk::Loader) -> void
-      internal def register(cref, loader)
-        if Object.equal?(cref.mod)
-          @loaders[cref.cname] = loader
-        else
-          @loaders[cref.path] = loader
-        end
-      end
-
-      # @sig (Module, Symbol) -> Zeitwerk::Loader?
-      internal def loader_for(mod, cname)
-        if Object.equal?(mod)
-          @loaders.delete(cname)
-        else
-          @loaders.delete("#{real_mod_name(mod)}::#{cname}")
-        end
-      end
-
-      # @sig (Zeitwerk::Loader) -> void
-      internal def unregister_loader(loader)
-        @loaders.delete_if { _2.equal?(loader) }
-      end
-
-      # This is an internal method only used by the test suite.
-      #
-      # @sig (String) -> Zeitwerk::Loader?
-      internal def registered?(cname_or_cpath)
-        @loaders[cname_or_cpath]
-      end
-
-      # This is an internal method only used by the test suite.
-      #
-      # @sig () -> void
-      internal def clear
-        @loaders.clear
-      end
-
-      module Synchronized
-        extend Internal
-
-        MUTEX = Mutex.new
-
-        internal def register(...)
-          MUTEX.synchronize { super }
-        end
-
-        internal def loader_for(...)
-          MUTEX.synchronize { super }
-        end
-
-        internal def unregister_loader(...)
-          MUTEX.synchronize { super }
-        end
-
-        internal def registered?(...)
-          MUTEX.synchronize { super }
-        end
-
-        internal def clear
-          MUTEX.synchronize { super }
-        end
-      end
-
-      prepend Synchronized unless RUBY_ENGINE == "ruby"
-    end
-  end
-end