zeitwerk 2.1.5 → 2.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e89de8ad7897a95ccc14f71e1688eb826c7e01f2c0c9381e09de5dd8815d1974
-  data.tar.gz: 11bf19ab1b396399afc3110e8122cb783d2a2d64a889fa5ac7e506e65a8cc9be
+  metadata.gz: 3dbf7502d4126651ab645926f072af5f5164fcb495c06ae32e9748aa2807670e
+  data.tar.gz: e124bca82ed054d1ca304e95605ad011a2c6411792653c3c86b785a3cc956e06
 SHA512:
-  metadata.gz: b9a3e74bde3eec64186834b010f3c047d0b1c849a95c89747c6195b3a5fef974d4b1018cf4fca64a46e27aa5768c543d73b6203af80b170c20dab108544833e0
-  data.tar.gz: 2055af7e3b74fa7c6c3e0c1e7dc6bb1888736c5d8204106ed0504b83a3cba74f7db2a24a72a0e2afc995cf780d4ebcd5965c74262150bb9c90fc3abf4ae97310
+  metadata.gz: 7efe14aeb7e16563d6a1b69b2aac82d75dd1c4e79dae2fb4654e7c93742e15018f16fad4591f8763bf03b2f9d9d71a6e95209907a0765952dafa8dedc957d2ef
+  data.tar.gz: 8dea5ad3b1979cacb619b13385b337e81cc08efc39e0411f890229f0a9d17035fdfb17cf2ac84f6dcd3eeec4b4daa732e796e51fc1fdf707c210d9943481edcf

data/README.md

@@ -17,7 +17,6 @@
     - [Setup](#setup)
     - [Reloading](#reloading)
     - [Eager loading](#eager-loading)
-    - [Preloading](#preloading)
     - [Inflection](#inflection)
         - [Zeitwerk::Inflector](#zeitwerkinflector)
         - [Zeitwerk::GemInflector](#zeitwerkgeminflector)
@@ -29,6 +28,7 @@
         - [Use case: The adapter pattern](#use-case-the-adapter-pattern)
         - [Use case: Test files mixed with implementation files](#use-case-test-files-mixed-with-implementation-files)
     - [Edge cases](#edge-cases)
+    - [Rules of thumb](#rules-of-thumb)
 - [Pronunciation](#pronunciation)
 - [Supported Ruby versions](#supported-ruby-versions)
 - [Motivation](#motivation)
@@ -42,15 +42,13 @@
 
 Zeitwerk is an efficient and thread-safe code loader for Ruby.
 
-Given a conventional file structure, Zeitwerk loads your project's classes and modules on demand. You don't need to write `require` calls for your own files, rather, you can streamline your programming knowing that your classes and modules are available everywhere. This feature is efficient, thread-safe, and matches Ruby's semantics for constants.
+Given a [conventional file structure](#file-structure), Zeitwerk is able to load your project's classes and modules on demand (autoloading), or upfront (eager loading). You don't need to write `require` calls for your own files, rather, you can streamline your programming knowing that your classes and modules are available everywhere. This feature is efficient, thread-safe, and matches Ruby's semantics for constants.
 
-Zeitwerk issues `require` calls exclusively using absolute file names, so there are no costly file system lookups in `$LOAD_PATH`. Technically, the directories managed by Zeitwerk do not even need to be in `$LOAD_PATH`. Furthermore, by design, Zeitwerk does only one single scan of the project tree, and it descends into subdirectories lazily, only if their namespaces are used.
+Zeitwerk is also able to reload code, which may be handy while developing web applications. Coordination is needed to reload in a thread-safe manner. The documentation below explains how to do this.
 
-The library is designed so that each gem and application can have their own loader, independent of each other. Each loader has its own configuration, inflector, and optional logger.
+The gem is designed so that any project, gem dependency, application, etc. can have their own independent loader, coexisting in the same process, managing their own project trees, and independent of each other. Each loader has its own configuration, inflector, and optional logger.
 
-Zeitwerk is also able to reload code, which may be handy for web applications. Coordination is needed to reload in a thread-safe manner. The documentation below explains how to do this.
-
-Finally, in some production setups it may be optimal to eager load all code upfront. Zeitwerk is able to do that too.
+Internally, Zeitwerk issues `require` calls exclusively using absolute file names, so there are no costly file system lookups in `$LOAD_PATH`. Technically, the directories managed by Zeitwerk do not even need to be in `$LOAD_PATH`. Furthermore, Zeitwerk does only one single scan of the project tree, and it descends into subdirectories lazily, only if their namespaces are used.
 
 <a id="markdown-synopsis" name="synopsis"></a>
 ## Synopsis
@@ -63,11 +61,12 @@ Main interface for gems:
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.setup # ready!
-# loader.eager_load, optionally
 
 module MyGem
   # ...
 end
+
+loader.eager_load # optionally
 ```
 
 Main generic interface:
@@ -205,7 +204,7 @@ Zeitwerk works internally only with absolute paths to avoid costly file searches
 <a id="markdown-reloading" name="reloading"></a>
 ### Reloading
 
-Zeitwer is able to reload code, but you need to enable this feature:
+Zeitwerk is able to reload code, but you need to enable this feature:
 
 ```ruby
 loader = Zeitwerk::Loader.new
@@ -222,7 +221,7 @@ Enabling reloading after setup raises `Zeitwerk::Error`. Similarly, calling `rel
 
 Generally speaking, reloading is useful while developing running services like web applications. Gems that implement regular libraries, so to speak, or services running in testing or production environments, won't normally have a use case for reloading. If reloading is not enabled, Zeitwerk is able to use less memory.
 
-Reloading removes the currently loaded classes and modules, resets the loader so that it will pick whatever is in the file system now, and runs preloads if there are any.
+Reloading removes the currently loaded classes and modules and resets the loader so that it will pick whatever is in the file system now.
 
 It is important to highlight that this is an instance method. Don't worry about project dependencies managed by Zeitwerk, their loaders are independent.
 
@@ -260,22 +259,6 @@ 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.
 
-<a id="markdown-preloading" name="preloading"></a>
-### Preloading
-
-Zeitwerk instances are able to preload files and directories.
-
-```ruby
-loader.preload("app/models/videogame.rb")
-loader.preload("app/models/book.rb")
-```
-
-The call can happen before `setup` (preloads during setup), or after `setup` (preloads on the spot). Each reload preloads too.
-
-This is a feature specifically thought for STIs in Rails, preloading the leafs of a STI tree ensures all classes are known when doing a query.
-
-The example above depicts several calls are supported, but `preload` accepts multiple arguments and arrays of strings as well.
-
 <a id="markdown-inflection" name="inflection"></a>
 ### Inflection
 
@@ -338,7 +321,15 @@ This needs to be done before calling `setup`.
 <a id="markdown-logging" name="logging"></a>
 ### Logging
 
-Zeitwerk is silent by default, but you can configure a callable as logger:
+Zeitwerk is silent by default, but you can ask loaders to trace their activity. Logging is meant just for troubleshooting, shouldn't normally be enabled.
+
+The `log!` method is a quick shortcut to let the loader log to `$stdout`:
+
+```
+loader.log!
+```
+
+If you want more control, a logger can be configured as a callable
 
 ```ruby
 loader.logger = method(:puts)
@@ -392,7 +383,7 @@ Zeitwerk ignores automatically any file or directory whose name starts with a do
 
 However, sometimes it might still be convenient to tell Zeitwerk to completely ignore some particular Ruby file or directory. That is possible with `ignore`, which accepts an arbitrary number of strings or `Pathname` objects, and also an array of them.
 
-You can ignore file names, directory names, and glob patterns. Glob patterns are expanded on setup and on reload.
+You can ignore file names, directory names, and glob patterns. Glob patterns are expanded when they are added and again on each reload.
 
 Let's see some use cases.
 
@@ -453,6 +444,8 @@ The chosen adapter, then, has to be loaded by hand somehow:
 require "my_gem/db_adapters/#{config[:db_adapter]}"
 ```
 
+Note that since the directory is ignored, the required adapter can instantiate another loader to manage its subtree, if desired. Such loader would coexist with the main one just fine.
+
 <a id="markdown-use-case-test-files-mixed-with-implementation-files" name="use-case-test-files-mixed-with-implementation-files"></a>
 #### Use case: Test files mixed with implementation files
 
@@ -493,6 +486,21 @@ Trip = Struct.new { ... } # NOT SUPPORTED
 
 This only affects explicit namespaces, those idioms work well for any other ordinary class or module.
 
+<a id="markdown-rules-of-thumb" name="rules-of-thumb"></a>
+### Rules of thumb
+
+1. Different loaders should manage different directory trees. It is an error condition to configure overlapping root directories in different loaders.
+
+2. Think the mere existence of a file is effectively like writing a `require` call for them, which is executed on demand (autoload) or upfront (eager load).
+
+3. In that line, if two loaders manage files that translate to the same constant in the same namespace, the first one wins, the rest are ignored. Similar to what happens with `require` and `$LOAD_PATH`, only the first occurrence matters.
+
+4. Projects that reopen a namespace defined by some dependency have to ensure said namespace is loaded before setup. That is, the project has to make sure it reopens, rather than define. This is often accomplished just loading the dependency.
+
+5. Objects stored in reloadable constants should not be cached in places that are not reloaded. For example, non-reloadable classes should not subclass a reloadable class, or mixin a reloadable module. Otherwise, after reloading, those classes or module objects would become stale. Referring to constants in dynamic places like method calls or lambdas is fine.
+
+6. In a given process, ideally, there should be at most one loader with reloading enabled. Technically, you can have more, but it may get tricky if one refers to constants managed by the other one. Do that only if you know what you are doing.
+
 <a id="markdown-pronunciation" name="pronunciation"></a>
 ## Pronunciation
 

data/lib/zeitwerk.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Zeitwerk
+  require_relative "zeitwerk/real_mod_name"
   require_relative "zeitwerk/loader"
   require_relative "zeitwerk/registry"
   require_relative "zeitwerk/explicit_namespace"

data/lib/zeitwerk/error.rb

@@ -4,4 +4,7 @@ module Zeitwerk
 
   class ReloadingDisabledError < Error
   end
+
+  class NameError < ::NameError
+  end
 end

data/lib/zeitwerk/explicit_namespace.rb

@@ -8,6 +8,8 @@ module Zeitwerk
   # loading their constant before setup. This is documented.
   module ExplicitNamespace # :nodoc: all
     class << self
+      include RealModName
+
       # Maps constant paths that correspond to explicit namespaces according to
       # the file system, to the loader responsible for them.
       #
@@ -52,21 +54,27 @@ module Zeitwerk
           tracer.disable if cpaths.empty?
         end
       end
+
+      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?
+
+        # Note that it makes sense to compute the hash code unconditionally,
+        # because the trace point is disabled if cpaths is empty.
+        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
-    @tracer = TracePoint.new(:class) do |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 `Module#name`.
-      next if event.self.singleton_class?
 
-      # Note that it makes sense to compute the hash code unconditionally,
-      # because the trace point is disabled if cpaths is empty.
-      if loader = cpaths.delete(event.self.name)
-        loader.on_namespace_loaded(event.self)
-        disable_tracer_if_unneeded
-      end
-    end
+    # 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

data/lib/zeitwerk/gem_inflector.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Zeitwerk
-  class GemInflector < Inflector
+  class GemInflector < Inflector # :nodoc:
     # @param root_file [String]
     def initialize(root_file)
       namespace     = File.basename(root_file, ".rb")

data/lib/zeitwerk/inflector.rb

@@ -13,7 +13,7 @@ module Zeitwerk
     # @param _abspath [String]
     # @return [String]
     def camelize(basename, _abspath)
-      basename.split('_').map!(&:capitalize!).join
+      basename.split('_').map!(&:capitalize).join
     end
   end
 end

data/lib/zeitwerk/loader.rb

@@ -7,6 +7,7 @@ module Zeitwerk
   class Loader
     require_relative "loader/callbacks"
     include Callbacks
+    include RealModName
 
     # @return [String]
     attr_reader :tag
@@ -43,7 +44,7 @@ module Zeitwerk
     #
     # @private
     # @return [Set<String>]
-    attr_reader :ignored
+    attr_reader :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
@@ -132,7 +133,7 @@ module Zeitwerk
 
       @root_dirs             = {}
       @preloads              = []
-      @ignored               = Set.new
+      @ignored_glob_patterns = Set.new
       @ignored_paths         = Set.new
       @autoloads             = {}
       @autoloaded_dirs       = []
@@ -224,16 +225,12 @@ module Zeitwerk
     #
     # @param paths [<String, Pathname, <String, Pathname>>]
     # @return [void]
-    def ignore(*paths)
-      mutex.synchronize { ignored.merge(expand_paths(paths)) }
-    end
-
-    # @private
-    # @return [void]
-    def expand_ignored_glob_patterns
-      # Note that Dir.glob works with regular file names just fine. That is,
-      # glob patterns technically need no wildcards.
-      ignored_paths.replace(ignored.flat_map { |path| Dir.glob(path) })
+    def ignore(*glob_patterns)
+      glob_patterns = expand_paths(glob_patterns)
+      mutex.synchronize do
+        ignored_glob_patterns.merge(glob_patterns)
+        ignored_paths.merge(expand_glob_patterns(glob_patterns))
+      end
     end
 
     # Sets autoloads in the root namespace and preloads files, if any.
@@ -243,7 +240,6 @@ module Zeitwerk
       mutex.synchronize do
         break if @setup
 
-        expand_ignored_glob_patterns
         actual_root_dirs.each { |root_dir| set_autoloads_in_dir(root_dir, Object) }
         do_preload
 
@@ -325,6 +321,7 @@ module Zeitwerk
     def reload
       if reloading_enabled?
         unload
+        recompute_ignored_paths
         setup
       else
         raise ReloadingDisabledError, "can't reload, please call loader.enable_reloading before setup"
@@ -342,16 +339,20 @@ module Zeitwerk
         break if @eager_loaded
 
         queue = actual_root_dirs.reject { |dir| eager_load_exclusions.member?(dir) }
-        while dir = queue.shift
-          const_get_if_autoload(dir)
+        queue.map! { |dir| [Object, dir] }
+        while to_eager_load = queue.shift
+          namespace, dir = to_eager_load
 
-          each_abspath(dir) do |abspath|
+          ls(dir) do |basename, abspath|
             next if eager_load_exclusions.member?(abspath)
 
             if ruby?(abspath)
-              const_get_if_autoload(abspath)
-            elsif dir?(abspath)
-              queue << abspath
+              if cref = autoloads[File.realpath(abspath)]
+                cref[0].const_get(cref[1], false)
+              end
+            elsif dir?(abspath) && !root_dirs.key?(abspath)
+              cname = inflector.camelize(basename, abspath)
+              queue << [namespace.const_get(cname, false), abspath]
             end
           end
         end
@@ -391,6 +392,29 @@ module Zeitwerk
       to_unload.keys.freeze
     end
 
+    # Logs to `$stdout`, handy shortcut for debugging.
+    #
+    # @return [void]
+    def log!
+      @logger = ->(msg) { puts msg }
+    end
+
+    # @private
+    # @param dir [String]
+    # @return [Boolean]
+    def manages?(dir)
+      dir = dir + "/"
+      ignored_paths.each do |ignored_path|
+        return false if dir.start_with?(ignored_path + "/")
+      end
+
+      root_dirs.each_key do |root_dir|
+        return true if root_dir.start_with?(dir) || dir.start_with?(root_dir + "/")
+      end
+
+      false
+    end
+
     # --- Class methods ---------------------------------------------------------------------------
 
     class << self
@@ -414,7 +438,7 @@ module Zeitwerk
       #
       # @return [Zeitwerk::Loader]
       def for_gem
-        called_from = caller_locations.first.path
+        called_from = caller_locations(1, 1).first.path
         Registry.loader_for_gem(called_from)
       end
 
@@ -449,18 +473,39 @@ module Zeitwerk
     # @param parent [Module]
     # @return [void]
     def set_autoloads_in_dir(dir, parent)
-      each_abspath(dir) do |abspath|
-        cname = inflector.camelize(File.basename(abspath, ".rb"), abspath).to_sym
-        if ruby?(abspath)
-          autoload_file(parent, cname, abspath)
-        elsif dir?(abspath)
-          # In a Rails application, `app/models/concerns` is a subdirectory of
-          # `app/models`, but both of them are root directories.
-          #
-          # To resolve the ambiguity file name -> constant path this introduces,
-          # the `app/models/concerns` directory is totally ignored as a namespace,
-          # it counts only as root. The guard checks that.
-          autoload_subdir(parent, cname, abspath) unless root_dirs.key?(abspath)
+      ls(dir) do |basename, abspath|
+        begin
+          if ruby?(basename)
+            basename.slice!(-3, 3)
+            cname = inflector.camelize(basename, abspath).to_sym
+            autoload_file(parent, cname, abspath)
+          elsif dir?(abspath)
+            # In a Rails application, `app/models/concerns` is a subdirectory of
+            # `app/models`, but both of them are root directories.
+            #
+            # To resolve the ambiguity file name -> constant path this introduces,
+            # the `app/models/concerns` directory is totally ignored as a namespace,
+            # it counts only as root. The guard checks that.
+            unless root_dirs.key?(abspath)
+              cname = inflector.camelize(basename, abspath).to_sym
+              autoload_subdir(parent, cname, abspath)
+            end
+          end
+        rescue ::NameError => error
+          path_type = ruby?(abspath) ? "file" : "directory"
+
+          raise NameError, <<~MESSAGE
+            #{error.message} inferred by #{inflector.class} from #{path_type}
+
+              #{abspath}
+
+            Possible ways to address this:
+
+              * Tell Zeitwerk to ignore this particular #{path_type}.
+              * Tell Zeitwerk to ignore one of its parent directories.
+              * Rename the #{path_type} to comply with the naming conventions.
+              * Modify the inflector to handle this case.
+          MESSAGE
         end
       end
     end
@@ -605,7 +650,7 @@ module Zeitwerk
     # @param dir [String]
     # @return [void]
     def do_preload_dir(dir)
-      each_abspath(dir) do |abspath|
+      ls(dir) do |_basename, abspath|
         do_preload_abspath(abspath)
       end
     end
@@ -621,17 +666,17 @@ module Zeitwerk
     # @param cname [Symbol]
     # @return [String]
     def cpath(parent, cname)
-      parent.equal?(Object) ? cname.to_s : "#{parent.name}::#{cname}"
+      parent.equal?(Object) ? cname.to_s : "#{real_mod_name(parent)}::#{cname}"
     end
 
     # @param dir [String]
-    # @yieldparam path [String]
+    # @yieldparam path [String, String]
     # @return [void]
-    def each_abspath(dir)
-      Dir.foreach(dir) do |entry|
-        next if entry.start_with?(".")
-        abspath = File.join(dir, entry)
-        yield abspath unless ignored_paths.member?(abspath)
+    def ls(dir)
+      Dir.foreach(dir) do |basename|
+        next if basename.start_with?(".")
+        abspath = File.join(dir, basename)
+        yield basename, abspath unless ignored_paths.member?(abspath)
       end
     end
 
@@ -650,7 +695,20 @@ module Zeitwerk
     # @param paths [<String, Pathname, <String, Pathname>>]
     # @return [<String>]
     def expand_paths(paths)
-      Array(paths).flatten.map! { |path| File.expand_path(path) }
+      paths.flatten.map! { |path| File.expand_path(path) }
+    end
+
+    # @param glob_patterns [<String>]
+    # @return [<String>]
+    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
+
+    # @return [void]
+    def recompute_ignored_paths
+      ignored_paths.replace(expand_glob_patterns(ignored_glob_patterns))
     end
 
     # @param message [String]
@@ -664,12 +722,6 @@ module Zeitwerk
       parent.const_defined?(cname, false)
     end
 
-    def const_get_if_autoload(abspath)
-      if cref = autoloads[File.realpath(abspath)]
-        cref[0].const_get(cref[1], false)
-      end
-    end
-
     def register_explicit_namespace(cpath)
       ExplicitNamespace.register(cpath, self)
     end
@@ -677,16 +729,12 @@ module Zeitwerk
     def raise_if_conflicting_directory(dir)
       self.class.mutex.synchronize do
         Registry.loaders.each do |loader|
-          next if loader == self
-
-          loader.dirs.each do |already_managed_dir|
-            if dir.start_with?(already_managed_dir) || already_managed_dir.start_with?(dir)
-              require "pp"
-              raise Error,
-                "loader\n\n#{pretty_inspect}\n\nwants to manage directory #{dir}," \
-                " which is already managed by\n\n#{loader.pretty_inspect}\n"
-              EOS
-            end
+          if loader != self && loader.manages?(dir)
+            require "pp"
+            raise Error,
+              "loader\n\n#{pretty_inspect}\n\nwants to manage directory #{dir}," \
+              " which is already managed by\n\n#{loader.pretty_inspect}\n"
+            EOS
           end
         end
       end

data/lib/zeitwerk/loader/callbacks.rb

@@ -1,4 +1,6 @@
 module Zeitwerk::Loader::Callbacks
+  include Zeitwerk::RealModName
+
   # Invoked from our decorated Kernel#require when a managed file is autoloaded.
   #
   # @private
@@ -60,7 +62,7 @@ module Zeitwerk::Loader::Callbacks
   # @param namespace [Module]
   # @return [void]
   def on_namespace_loaded(namespace)
-    if subdirs = lazy_subdirs.delete(namespace.name)
+    if subdirs = lazy_subdirs.delete(real_mod_name(namespace))
       subdirs.each do |subdir|
         set_autoloads_in_dir(subdir, namespace)
       end

data/lib/zeitwerk/real_mod_name.rb

@@ -0,0 +1,15 @@
+module Zeitwerk::RealModName
+  UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
+  private_constant :UNBOUND_METHOD_MODULE_NAME
+
+  # Returns the real name of the class or module, as set after the first
+  # constant to which it was assigned (or nil).
+  #
+  # The name method can be overridden, hence the indirection in this method.
+  #
+  # @param mod [Class, Module]
+  # @return [String, nil]
+  def real_mod_name(mod)
+    UNBOUND_METHOD_MODULE_NAME.bind(mod).call
+  end
+end

data/lib/zeitwerk/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zeitwerk
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.1.10
 platform: ruby
 authors:
 - Xavier Noria
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-24 00:00:00.000000000 Z
+date: 2019-09-06 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zeitwerk implements constant autoloading with Ruby semantics. Each gem
@@ -29,6 +29,7 @@ files:
 - lib/zeitwerk/kernel.rb
 - lib/zeitwerk/loader.rb
 - lib/zeitwerk/loader/callbacks.rb
+- lib/zeitwerk/real_mod_name.rb
 - lib/zeitwerk/registry.rb
 - lib/zeitwerk/version.rb
 homepage: https://github.com/fxn/zeitwerk
@@ -50,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Efficient and thread-safe constant autoloader