zeitwerk 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 172e4bb51ab526d5f4f606f0c4099cd9d4b8bdfe15a2ec851ed58e7095018f07
-  data.tar.gz: 74b2d3f010de6374d919e7cae4d759a86490d91bfb7cd3f743b314e10569d2e9
+  metadata.gz: 40e2919df324c67a85e00ac31349b96349b1a74a39e97e3f41c513258f108542
+  data.tar.gz: 17c8c31d6a89e4ead544d1bc35143f548331923106decb05be67ebf57daf1bce
 SHA512:
-  metadata.gz: 57531ede94526489ffb47235b0113ff6cb290c5d21c4b03dbbdea79a55b0e6b74d685b8f5d57f5b0bf9ec85986e731368bd57b9f5dd0ccfdc40033e5b570bbaa
-  data.tar.gz: d50a101226b04214af4bcc6961422501044a4b9bede6d18bc06a622736bedd7d19fa9b8b9191b8f08042382d0bebcfb8e0162aa7aef37eddd2e17dbcdc6ee8a6
+  metadata.gz: 455ff00c99726bb3003cebfcd4d264a4288a84d3d6d5bc7e8005ed4f0e7d66eff2abf3670b474bbeb5ca0a5517e1e7e316df64ccc065775b60e9b1822e5664cc
+  data.tar.gz: 4971b4baec41fcffa1075248dbb714e456b2a0c37e193bd4ad47f81c658751dcf9de687ed023d4b0e00a67e57c4fa219ff7db6fe82437901774c6a0e59861dbf

data/README.md

@@ -60,7 +60,9 @@ Main interface for gems:
 # lib/my_gem.rb (main file)
 
 require "zeitwerk"
-Zeitwerk::Loader.for_gem.setup # ready!
+loader = Zeitwerk::Loader.for_gem
+loader.setup # ready!
+# loader.eager_load, optionally
 
 module MyGem
   # ...
@@ -150,6 +152,8 @@ class Hotel < ApplicationRecord
 end
 ```
 
+An explicit namespace must be managed by one single loader. Loaders that reopen namespaces owned by other projects are responsible for loading their constants before setup.
+
 ### Nested root directories
 
 Root directories should not be ideally nested, but Zeitwerk supports them because in Rails, for example, both `app/models` and `app/models/concerns` belong to the autoload paths.
@@ -172,6 +176,8 @@ Loaders are ready to load code right after calling `setup` on them:
 loader.setup
 ```
 
+This method is synchronized and idempotent.
+
 Customization should generally be done before that call. In particular, in the generic interface you may set the root directories from which you want to load files:
 
 ```ruby
@@ -212,6 +218,8 @@ loader.eager_load
 
 That skips ignored files and directories.
 
+Eager loading is synchronized and idempotent.
+
 If you want to eager load yourself and all dependencies using Zeitwerk, you can broadcast the `eager_load` call to all instances:
 
 ```ruby
@@ -220,6 +228,8 @@ Zeitwerk::Loader.eager_load_all
 
 This may be handy in top-level services, like web applications.
 
+Note that thanks to idempotence `Zeitwerk::Loader.eager_load_all` won't eager load twice if any of the instances already eager loaded.
+
 ### Preloading
 
 Zeitwerk instances are able to preload files and directories.

data/lib/zeitwerk.rb

@@ -3,6 +3,7 @@
 module Zeitwerk
   require_relative "zeitwerk/loader"
   require_relative "zeitwerk/registry"
+  require_relative "zeitwerk/explicit_namespace"
   require_relative "zeitwerk/inflector"
   require_relative "zeitwerk/gem_inflector"
   require_relative "zeitwerk/kernel"

data/lib/zeitwerk/explicit_namespace.rb

@@ -0,0 +1,77 @@
+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
+      # Maps constant paths that correspond to explicit namespaces according to
+      # the file system, to the loader responsible for them.
+      #
+      # @private
+      # @return [{String => Zeitwerk::Loader}]
+      attr_reader :cpaths
+
+      # @private
+      # @return [Mutex]
+      attr_reader :mutex
+
+      # @private
+      # @return [TracePoint]
+      attr_reader :tracer
+
+      # Asserts `cpath` corresponds to an explicit namespace for which `loader`
+      # is responsible.
+      #
+      # @private
+      # @param cpath [String]
+      # @param loader [Zeitwerk::Loader]
+      # @return [void]
+      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
+
+      # @private
+      # @param loader [Zeitwerk::Loader]
+      # @return [void]
+      def unregister(loader)
+        cpaths.delete_if { |_cpath, l| l == loader }
+        disable_tracer_if_unneeded
+      end
+
+      # Utility for the test suite
+      #
+      # @private
+      # @return [void]
+      def teardown
+        cpaths.clear
+        tracer.disable
+      end
+
+      def disable_tracer_if_unneeded
+        mutex.synchronize do
+          tracer.disable if cpaths.empty?
+        end
+      end
+    end
+
+    @cpaths = {}
+    @mutex  = Mutex.new
+    @tracer = TracePoint.new(:class) do |event|
+      # Note that it makes sense to compute the hash code unconditionally,
+      # because if cpaths was empty the trace point would be disabled.
+      if loader = cpaths.delete(event.self.name)
+        loader.on_namespace_loaded(event.self)
+        disable_tracer_if_unneeded
+      end
+    end
+  end
+end

data/lib/zeitwerk/loader.rb

@@ -92,14 +92,6 @@ module Zeitwerk
     # @return [Mutex]
     attr_reader :mutex
 
-    # This tracer listens to `:class` events, and it is used to support explicit
-    # namespaces. Benchmarks have shown the tracer does not impact performance
-    # in any measurable way.
-    #
-    # @private
-    # @return [TracePoint]
-    attr_reader :tracer
-
     def initialize
       @initialized_at = Time.now
 
@@ -119,10 +111,6 @@ module Zeitwerk
       @setup        = false
       @eager_loaded = false
 
-      @tracer = TracePoint.new(:class) do |tp|
-        on_namespace_loaded(tp.self)
-      end
-
       Registry.register_loader(self)
     end
 
@@ -230,8 +218,8 @@ module Zeitwerk
         lazy_subdirs.clear
 
         Registry.on_unload(self)
+        ExplicitNamespace.unregister(self)
 
-        disable_tracer
         @setup = false
       end
     end
@@ -268,7 +256,6 @@ module Zeitwerk
           end
         end
 
-        disable_tracer
         @eager_loaded = true
       end
     end
@@ -359,11 +346,12 @@ module Zeitwerk
     # @return [void]
     def autoload_subdir(parent, cname, subdir)
       if autoload_path = autoload_for?(parent, cname)
-        enable_tracer if ruby?(autoload_path)
+        cpath = cpath(parent, cname)
+        register_explicit_namespace(cpath) if ruby?(autoload_path)
         # We do not need to issue another autoload, the existing one is enough
         # no matter if it is for a file or a directory. Just remember the
         # subdirectory has to be visited if the namespace is used.
-        (lazy_subdirs[cpath(parent, cname)] ||= []) << subdir
+        (lazy_subdirs[cpath] ||= []) << subdir
       elsif !cdef?(parent, cname)
         # First time we find this namespace, set an autoload for it.
         (lazy_subdirs[cpath(parent, cname)] ||= []) << subdir
@@ -390,7 +378,7 @@ module Zeitwerk
         Registry.unregister_autoload(autoload_path)
 
         set_autoload(parent, cname, file)
-        enable_tracer
+        register_explicit_namespace(cpath(parent, cname))
       elsif !cdef?(parent, cname)
         set_autoload(parent, cname, file)
       end
@@ -508,20 +496,14 @@ module Zeitwerk
       logger.send(method_name, "Zeitwerk@#{tag}: #{message}")
     end
 
-    def enable_tracer
-      # 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 if !tracer.enabled?
-    end
-
-    def disable_tracer
-      tracer.disable if tracer.enabled?
-    end
-
     def cdef?(parent, cname)
       parent.const_defined?(cname, false)
     end
 
+    def register_explicit_namespace(cpath)
+      ExplicitNamespace.register(cpath, self)
+    end
+
     def raise_if_conflicting_directory(dir)
       self.class.mutex.synchronize do
         Registry.loaders.each do |loader|

data/lib/zeitwerk/ordered_set.rb

@@ -0,0 +1,21 @@
+module Zeitwerk
+  class OrderedSet
+    def initialize
+      @set = {}
+    end
+
+    def add(object)
+      @set[object] = true
+    end
+
+    def del(object)
+      @set.delete(object)
+    end
+
+    def each
+      @set.each_key do |key|
+        yield key
+      end
+    end
+  end
+end

data/lib/zeitwerk/registry.rb

@@ -137,6 +137,16 @@ module Zeitwerk
         autoloads.delete_if { |_path, object| object == loader }
         inceptions.delete_if { |_cpath, (_path, object)| object == loader }
       end
+
+      # Utility for the test suite
+      #
+      # @private
+      # @return [void]
+      def teardown
+        loaders.each(&:unload)
+        loaders.clear
+        loaders_managing_gems.clear
+      end
     end
 
     @loaders               = []

data/lib/zeitwerk/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zeitwerk
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Xavier Noria
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-23 00:00:00.000000000 Z
+date: 2019-03-06 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zeitwerk implements constant autoloading with Ruby semantics. Each gem
@@ -23,11 +23,13 @@ files:
 - README.md
 - lib/zeitwerk.rb
 - lib/zeitwerk/conflicting_directory.rb
+- lib/zeitwerk/explicit_namespace.rb
 - lib/zeitwerk/gem_inflector.rb
 - lib/zeitwerk/inflector.rb
 - lib/zeitwerk/kernel.rb
 - lib/zeitwerk/loader.rb
 - lib/zeitwerk/loader/callbacks.rb
+- lib/zeitwerk/ordered_set.rb
 - lib/zeitwerk/registry.rb
 - lib/zeitwerk/version.rb
 homepage: https://github.com/fxn/zeitwerk