zeitwerk 2.6.13 → 2.7.2

data/lib/zeitwerk/registry/explicit_namespaces.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Zeitwerk::Registry
+  # This module is 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 ExplicitNamespaces # :nodoc: all
+    # Maps crefs of explicit namespaces with their corresponding loader.
+    #
+    # Entries are added as the namespaces are found, and removed as they are
+    # autoloaded.
+    #
+    # @sig Zeitwerk::Cref::Map[Zeitwerk::Loader]
+    @loaders = Zeitwerk::Cref::Map.new
+
+    class << self
+      extend Zeitwerk::Internal
+
+      # Registers `cref` as being the constant path of an explicit namespace
+      # managed by `loader`.
+      #
+      # @sig (Zeitwerk::Cref, Zeitwerk::Loader) -> void
+      internal def register(cref, loader)
+        @loaders[cref] = loader
+      end
+
+      # @sig (Module, Symbol) -> Zeitwerk::Loader?
+      internal def loader_for(mod, cname)
+        @loaders.delete_mod_cname(mod, cname)
+      end
+
+      # @sig (Zeitwerk::Loader) -> void
+      internal def unregister_loader(loader)
+        @loaders.delete_by_value(loader)
+      end
+
+      # This is an internal method only used by the test suite.
+      #
+      # @sig (Symbol | String) -> Zeitwerk::Loader?
+      internal def registered?(cref)
+        @loaders[cref]
+      end
+
+      # This is an internal method only used by the test suite.
+      #
+      # @sig () -> void
+      internal def clear
+        @loaders.clear
+      end
+    end
+  end
+end

data/lib/zeitwerk/registry/inceptions.rb

@@ -0,0 +1,31 @@
+module Zeitwerk::Registry
+  # Loaders know their own inceptions, but there is a use case in which we need
+  # to know if a given cpath is an inception globally. This is what this
+  # registry is for.
+  module Inceptions # :nodoc: all
+    # @sig Zeitwerk::Cref::Map[String]
+    @inceptions = Zeitwerk::Cref::Map.new
+
+    class << self
+      # @sig (Zeitwerk::Cref, String) -> void
+      def register(cref, autoload_path)
+        @inceptions[cref] = autoload_path
+      end
+
+      # @sig (String) -> String?
+      def registered?(cref)
+        @inceptions[cref]
+      end
+
+      # @sig (String) -> void
+      def unregister(cref)
+        @inceptions.delete(cref)
+      end
+
+      # @sig () -> void
+      def clear # for tests
+        @inceptions.clear
+      end
+    end
+  end
+end

data/lib/zeitwerk/registry.rb

@@ -2,6 +2,9 @@
 
 module Zeitwerk
   module Registry # :nodoc: all
+    require_relative "registry/explicit_namespaces"
+    require_relative "registry/inceptions"
+
     class << self
       # Keeps track of all loaders. Useful to broadcast messages and to prevent
       # them from being garbage collected.
@@ -25,45 +28,6 @@ module Zeitwerk
       # @sig Hash[String, Zeitwerk::Loader]
       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
-
       # Registers a loader.
       #
       # @private
@@ -78,7 +42,6 @@ module Zeitwerk
         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
@@ -102,20 +65,6 @@ module Zeitwerk
         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)
-        if pair = inceptions[cpath]
-          pair.first
-        end
-      end
-
       # @private
       # @sig (String) -> Zeitwerk::Loader?
       def loader_for(path)
@@ -126,13 +75,11 @@ module Zeitwerk
       # @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                  = []
     @gem_loaders_by_root_file = {}
     @autoloads                = {}
-    @inceptions               = {}
   end
 end

data/lib/zeitwerk/version.rb

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

data/lib/zeitwerk.rb

@@ -3,17 +3,19 @@
 module Zeitwerk
   require_relative "zeitwerk/real_mod_name"
   require_relative "zeitwerk/internal"
+  require_relative "zeitwerk/cref"
   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"
-  require_relative "zeitwerk/kernel"
   require_relative "zeitwerk/error"
   require_relative "zeitwerk/version"
 
+  require_relative "zeitwerk/core_ext/kernel"
+  require_relative "zeitwerk/core_ext/module"
+
   # This is a dangerous method.
   #
   # @experimental

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: zeitwerk
 version: !ruby/object:Gem::Version
-  version: 2.6.13
+  version: 2.7.2
 platform: ruby
 authors:
 - Xavier Noria
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-06 00:00:00.000000000 Z
+date: 2025-02-18 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zeitwerk implements constant autoloading with Ruby semantics. Each gem
@@ -23,13 +22,15 @@ files:
 - MIT-LICENSE
 - README.md
 - lib/zeitwerk.rb
+- 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
 - lib/zeitwerk/internal.rb
-- lib/zeitwerk/kernel.rb
 - lib/zeitwerk/loader.rb
 - lib/zeitwerk/loader/callbacks.rb
 - lib/zeitwerk/loader/config.rb
@@ -38,6 +39,8 @@ files:
 - lib/zeitwerk/null_inflector.rb
 - lib/zeitwerk/real_mod_name.rb
 - lib/zeitwerk/registry.rb
+- lib/zeitwerk/registry/explicit_namespaces.rb
+- lib/zeitwerk/registry/inceptions.rb
 - lib/zeitwerk/version.rb
 homepage: https://github.com/fxn/zeitwerk
 licenses:
@@ -47,7 +50,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
@@ -55,15 +57,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
-signing_key:
+rubygems_version: 3.6.4
 specification_version: 4
 summary: Efficient and thread-safe constant autoloader
 test_files: []

data/lib/zeitwerk/explicit_namespace.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  # Centralizes the logic for the trace point used to detect the creation of
-  # explicit namespaces, needed to descend into matching subdirectories right
-  # after the constant has been defined.
-  #
-  # 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
-    class << self
-      include RealModName
-      extend Internal
-
-      # Maps constant paths that correspond to explicit namespaces according to
-      # the file system, to the loader responsible for them.
-      #
-      # @sig Hash[String, Zeitwerk::Loader]
-      attr_reader :cpaths
-      private :cpaths
-
-      # @sig Mutex
-      attr_reader :mutex
-      private :mutex
-
-      # @sig TracePoint
-      attr_reader :tracer
-      private :tracer
-
-      # Asserts `cpath` corresponds to an explicit namespace for which `loader`
-      # is responsible.
-      #
-      # @sig (String, Zeitwerk::Loader) -> void
-      internal def register(cpath, loader)
-        mutex.synchronize do
-          cpaths[cpath] = loader
-          # We check enabled? because, looking at the C source code, enabling an
-          # enabled tracer does not seem to be a simple no-op.
-          tracer.enable unless tracer.enabled?
-        end
-      end
-
-      # @sig (Zeitwerk::Loader) -> void
-      internal def unregister_loader(loader)
-        cpaths.delete_if { |_cpath, l| l == loader }
-        disable_tracer_if_unneeded
-      end
-
-      # This is an internal method only used by the test suite.
-      #
-      # @sig (String) -> bool
-      internal def registered?(cpath)
-        cpaths.key?(cpath)
-      end
-
-      # @sig () -> void
-      private def disable_tracer_if_unneeded
-        mutex.synchronize do
-          tracer.disable if cpaths.empty?
-        end
-      end
-
-      # @sig (TracePoint) -> void
-      private def tracepoint_class_callback(event)
-        # If the class is a singleton class, we won't do anything with it so we
-        # can bail out immediately. This is several orders of magnitude faster
-        # than accessing its name.
-        return if event.self.singleton_class?
-
-        # It might be tempting to return if name.nil?, to avoid the computation
-        # of a hash code and delete call. But Ruby does not trigger the :class
-        # event on Class.new or Module.new, so that would incur in an extra call
-        # for nothing.
-        #
-        # On the other hand, if we were called, cpaths is not empty. Otherwise
-        # the tracer is disabled. So we do need to go ahead with the hash code
-        # computation and delete call.
-        if loader = cpaths.delete(real_mod_name(event.self))
-          loader.on_namespace_loaded(event.self)
-          disable_tracer_if_unneeded
-        end
-      end
-    end
-
-    @cpaths = {}
-    @mutex  = Mutex.new
-
-    # We go through a method instead of defining a block mainly to have a better
-    # label when profiling.
-    @tracer = TracePoint.new(:class, &method(:tracepoint_class_callback))
-  end
-end