Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package rubygem-zeitwerk for
openSUSE:Factory checked in at 2022-06-17 21:21:22
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/rubygem-zeitwerk (Old)
and /work/SRC/openSUSE:Factory/.rubygem-zeitwerk.new.1548 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-zeitwerk"
Fri Jun 17 21:21:22 2022 rev:13 rq:983439 version:2.6.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/rubygem-zeitwerk/rubygem-zeitwerk.changes
2022-02-24 18:23:41.630654718 +0100
+++
/work/SRC/openSUSE:Factory/.rubygem-zeitwerk.new.1548/rubygem-zeitwerk.changes
2022-06-17 21:23:38.490810093 +0200
@@ -1,0 +2,51 @@
+Wed Jun 15 14:01:10 UTC 2022 - Manuel Schnitzer <[email protected]>
+
+- updated to version 2.6.0
+
+ * Directories are processed in lexicographic order.
+
+ Different file systems may list directories in different order, and with
this
+ change we ensure that client code eager loads consistently across
platforms,
+ for example.
+
+ * Before this release, subdirectories of root directories always represented
+ namespaces (unless ignored or collapsed). From now on, to be considered
+ namespaces they also have to contain at least one non-ignored Ruby file
with
+ extension `.rb`, directly or recursively.
+
+ If you know beforehand a certain directory or directory pattern does not
+ represent a namespace, it is intentional and more efficient to tell
Zeitwerk
+ to [ignore](https://github.com/fxn/zeitwerk#ignoring-parts-of-the-project)
it.
+
+ However, if you don't do so and have a directory `tasks` that only contains
+ Rake files, arguably that directory is not meant to represent a Ruby
module.
+ Before, Zeitwerk would define a top-level `Tasks` module after it; now, it
+ does not.
+
+ This feature is also handy for projects that have directories with
auxiliary
+ resources mixed in the project tree in a way that is too dynamic for an
ignore
+ pattern to be practical. See https://github.com/fxn/zeitwerk/issues/216.
+
+ In the unlikely case that an existing project has an empty directory for
the
+ sole purpose of defining a totally empty module (no code, and no nested
+ classes or modules), such module has now to be defined in a file.
+
+ Directories are scanned again on reloads.
+
+ * On setup, loaders created with `Zeitwerk::Loader.for_gem` issue warnings if
+ `lib` has extra, non-ignored Ruby files or directories.
+
+ This is motivated by existing gems with directories under `lib` that are
not
+ meant to define Ruby modules, like directories for Rails generators, for
+ instance.
+
+ This warning can be silenced in the unlikely case that the extra stuff is
+ actually autoloadable and has to be managed by Zeitwerk.
+
+ Please, check the [documentation](https://github.com/fxn/zeitwerk#for_gem)
for
+ further details.
+
+ This method returns an instance of a private subclass of `Zeitwerk::Loader`
+ now, but you cannot rely on the type, just on the interface.
+
+-------------------------------------------------------------------
Old:
----
zeitwerk-2.5.4.gem
New:
----
zeitwerk-2.6.0.gem
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ rubygem-zeitwerk.spec ++++++
--- /var/tmp/diff_new_pack.2ZLb5y/_old 2022-06-17 21:23:38.898810314 +0200
+++ /var/tmp/diff_new_pack.2ZLb5y/_new 2022-06-17 21:23:38.906810319 +0200
@@ -24,7 +24,7 @@
#
Name: rubygem-zeitwerk
-Version: 2.5.4
+Version: 2.6.0
Release: 0
%define mod_name zeitwerk
%define mod_full_name %{mod_name}-%{version}
++++++ zeitwerk-2.5.4.gem -> zeitwerk-2.6.0.gem ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/README.md new/README.md
--- old/README.md 2022-01-28 00:17:23.000000000 +0100
+++ new/README.md 2022-06-13 18:42:15.000000000 +0200
@@ -47,6 +47,7 @@
- [Edge cases](#edge-cases)
- [Beware of circular dependencies](#beware-of-circular-dependencies)
- [Reopening third-party namespaces](#reopening-third-party-namespaces)
+ - [Encodings](#encodings)
- [Rules of thumb](#rules-of-thumb)
- [Debuggers](#debuggers)
- [debug.rb](#debugrb)
@@ -58,6 +59,7 @@
- [Motivation](#motivation)
- [Kernel#require is brittle](#kernelrequire-is-brittle)
- [Rails autoloading was brittle](#rails-autoloading-was-brittle)
+- [Awards](#awards)
- [Thanks](#thanks)
- [License](#license)
@@ -237,13 +239,17 @@
<a id="markdown-implicit-namespaces" name="implicit-namespaces"></a>
### Implicit namespaces
-Directories without a matching Ruby file get modules autovivified
automatically by Zeitwerk. For example, in
+If a namespace is just a simple module with no code, you do not need to define
it in a file: Directories without a matching Ruby file get modules created
automatically on your behalf.
+
+For example, if a project has an `admin` directory:
```
app/controllers/admin/users_controller.rb -> Admin::UsersController
```
-`Admin` is autovivified as a module on demand, you do not need to define an
`Admin` class or module in an `admin.rb` file explicitly.
+and does not have a file called `admin.rb`, Zeitwerk automatically creates an
`Admin` module on your behalf the first time `Admin` is used.
+
+For this to happen, the directory has to contain non-ignored Ruby files,
directly or recursively, otherwise it is ignored. This condition is evaluated
again on reloads.
<a id="markdown-explicit-namespaces" name="explicit-namespaces"></a>
### Explicit namespaces
@@ -349,8 +355,6 @@
Neither a gemspec nor a version file are technically required, this helper
works as long as the code is organized using that standard structure.
-If the entry point of your gem lives in a subdirectory of `lib` because it is
reopening a namespace defined somewhere else, please use the generic API to
setup the loader, and make sure you check the section [_Reopening third-party
namespaces_](https://github.com/fxn/zeitwerk#reopening-third-party-namespaces)
down below.
-
Conceptually, `for_gem` translates to:
```ruby
@@ -363,8 +367,6 @@
loader.push_dir(__dir__)
```
-except that this method returns the same object in subsequent calls from the
same file, in the unlikely case the gem wants to be able to reload.
-
If the main module references project constants at the top-level, Zeitwerk has
to be ready to load them. Their definitions, in turn, may reference other
project constants. And this is recursive. Therefore, it is important that the
`setup` call happens above the main module definition:
```ruby
@@ -381,6 +383,26 @@
end
```
+Loaders returned by `Zeitwerk::Loader.for_gem` issue warnings if `lib` has
extra Ruby files or directories.
+
+For example, if the gem has Rails generators under `lib/generators`, by
convention that directory defines a `Generators` Ruby module. If `generators`
is just a container for non-autoloadable code and templates, not acting as a
project namespace, you need to setup things accordingly.
+
+If the warning is legit, just tell the loader to ignore the offending file or
directory:
+
+```ruby
+loader.ignore("#{__dir__}/generators")
+```
+
+Otherwise, there's a flag to say the extra stuff is OK:
+
+```ruby
+Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+```
+
+This method is idempotent when invoked from the same file, to support gems
that want to reload (unlikely).
+
+If the entry point of your gem lives in a subdirectory of `lib` because it is
reopening a namespace defined somewhere else, please use the generic API to
setup the loader, and make sure you check the section [_Reopening third-party
namespaces_](https://github.com/fxn/zeitwerk#reopening-third-party-namespaces)
down below.
+
<a id="markdown-autoloading" name="autoloading"></a>
### Autoloading
@@ -480,9 +502,14 @@
It is important to highlight that this is an instance method. Don't worry
about project dependencies managed by Zeitwerk, their loaders are independent.
-In order for reloading to be thread-safe, you need to implement some
coordination. For example, a web framework that serves each request with its
own thread may have a globally accessible RW lock. When a request comes in, the
framework acquires the lock for reading at the beginning, and the code in the
framework that calls `loader.reload` needs to acquire the lock for writing.
+Reloading is not thread-safe:
-On reloading, client code has to update anything that would otherwise be
storing a stale object. For example, if the routing layer of a web framework
stores controller class objects or instances in internal structures, on reload
it has to refresh them somehow, possibly reevaluating routes.
+* You should not reload while another thread is reloading.
+* You should not autoload while another thread is reloading.
+
+In order to reload in a thread-safe manner, frameworks need to implement some
coordination. For example, a web framework that serves each request with its
own thread may have a globally accessible read/write lock: When a request comes
in, the framework acquires the lock for reading at the beginning, and releases
it at the end. On the other hand, the code in the framework responsible for the
call to `Zeitwerk::Loader#reload` needs to acquire the lock for writing.
+
+On reloading, client code has to update anything that would otherwise be
storing a stale object. For example, if the routing layer of a web framework
stores reloadable controller class objects or instances in internal structures,
on reload it has to refresh them somehow, possibly reevaluating routes.
<a id="markdown-inflection" name="inflection"></a>
### Inflection
@@ -962,6 +989,18 @@
With that, when Zeitwerk scans the file system and reaches the gem directories
`lib/active_job` and `lib/active_job/queue_adapters`, it detects the
corresponding modules already exist and therefore understands it does not have
to manage them. The loader just descends into those directories. Eventually
will reach `lib/active_job/queue_adapters/awesome_queue.rb`, and since
`ActiveJob::QueueAdapters::AwesomeQueue` is unknown, Zeitwerk will manage it.
Which is what happens regularly with the files in your gem. On reload, the
namespaces are safe, won't be reloaded. The loader only reloads what it
manages, which in this case is the adapter itself.
+<a id="markdown-encodings" name="encodings"></a>
+### Encodings
+
+Zeitwerk supports projects whose files and file system are in UTF-8. The
encoding of the file system can be checked this way:
+
+```
+% ruby -e "puts Encoding.find('filesystem')"
+UTF-8
+```
+
+The test suite passes on Windows with codepage `Windows-1252` if all the
involved absolute paths are ASCII. Other supersets of ASCII may work too, but
you have to try.
+
<a id="markdown-rules-of-thumb" name="rules-of-thumb"></a>
### Rules of thumb
@@ -1054,6 +1093,11 @@
Autoloading in Rails was based on `const_missing` up to Rails 5. That callback
lacks fundamental information like the nesting or the resolution algorithm
being used. Because of that, Rails autoloading was not able to match Ruby's
semantics, and that introduced a [series of
issues](https://guides.rubyonrails.org/v5.2/autoloading_and_reloading_constants.html#common-gotchas).
Zeitwerk is based on a different technique and fixed Rails autoloading
starting with Rails 6.
+<a id="markdown-awards" name="awards"></a>
+## Awards
+
+Zeitwerk has been awarded an "Outstanding Performance Award" Fukuoka Ruby
Award 2022.
+
<a id="markdown-thanks" name="thanks"></a>
## Thanks
Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk/error.rb new/lib/zeitwerk/error.rb
--- old/lib/zeitwerk/error.rb 2022-01-28 00:17:23.000000000 +0100
+++ new/lib/zeitwerk/error.rb 2022-06-13 18:42:15.000000000 +0200
@@ -5,6 +5,9 @@
end
class ReloadingDisabledError < Error
+ def initialize
+ super("can't reload, please call loader.enable_reloading before setup")
+ end
end
class NameError < ::NameError
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk/gem_loader.rb
new/lib/zeitwerk/gem_loader.rb
--- old/lib/zeitwerk/gem_loader.rb 1970-01-01 01:00:00.000000000 +0100
+++ new/lib/zeitwerk/gem_loader.rb 2022-06-13 18:42:15.000000000 +0200
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Zeitwerk
+ # @private
+ class GemLoader < Loader
+ # Users should not create instances directly, the public interface is
+ # `Zeitwerk::Loader.for_gem`.
+ private_class_method :new
+
+ # @private
+ # @sig (String, bool) -> Zeitwerk::GemLoader
+ def self._new(root_file, warn_on_extra_files:)
+ new(root_file, warn_on_extra_files: warn_on_extra_files)
+ end
+
+ # @sig (String, bool) -> void
+ def initialize(root_file, warn_on_extra_files:)
+ super()
+
+ @tag = File.basename(root_file, ".rb")
+ @inflector = GemInflector.new(root_file)
+ @root_file = File.expand_path(root_file)
+ @lib = File.dirname(root_file)
+ @warn_on_extra_files = warn_on_extra_files
+
+ push_dir(@lib)
+ end
+
+ # @sig () -> void
+ def setup
+ warn_on_extra_files if @warn_on_extra_files
+ super
+ end
+
+ private
+
+ # @sig () -> void
+ def warn_on_extra_files
+ expected_namespace_dir = @root_file.delete_suffix(".rb")
+
+ ls(@lib) do |basename, abspath|
+ next if abspath == @root_file
+ next if abspath == expected_namespace_dir
+
+ basename_without_ext = basename.delete_suffix(".rb")
+ cname = inflector.camelize(basename_without_ext, abspath)
+ ftype = dir?(abspath) ? "directory" : "file"
+
+ warn(<<~EOS)
+ WARNING: Zeitwerk defines the constant #{cname} after the #{ftype}
+
+ #{abspath}
+
+ To prevent that, please configure the loader to ignore it:
+
+ loader.ignore("\#{__dir__}/#{basename}")
+
+ Otherwise, there is a flag to silence this warning:
+
+ Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+ EOS
+ end
+ end
+ end
+end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk/loader/config.rb
new/lib/zeitwerk/loader/config.rb
--- old/lib/zeitwerk/loader/config.rb 2022-01-28 00:17:23.000000000 +0100
+++ new/lib/zeitwerk/loader/config.rb 2022-06-13 18:42:15.000000000 +0200
@@ -131,7 +131,6 @@
# Sets a tag for the loader, useful for logging.
#
- # @param tag [#to_s]
# @sig (#to_s) -> void
def tag=(tag)
@tag = tag.to_s
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk/loader/helpers.rb
new/lib/zeitwerk/loader/helpers.rb
--- old/lib/zeitwerk/loader/helpers.rb 2022-01-28 00:17:23.000000000 +0100
+++ new/lib/zeitwerk/loader/helpers.rb 2022-06-13 18:42:15.000000000 +0200
@@ -15,12 +15,27 @@
# @sig (String) { (String, String) -> void } -> void
def ls(dir)
- Dir.each_child(dir) do |basename|
+ children = Dir.children(dir)
+
+ # The order in which a directory is listed depends on the file system.
+ #
+ # Since client code may run in different platforms, it seems convenient to
+ # order directory entries. This provides consistent eager loading across
+ # platforms, for example.
+ children.sort!
+
+ children.each do |basename|
next if hidden?(basename)
abspath = File.join(dir, basename)
next if ignored_paths.member?(abspath)
+ if dir?(abspath)
+ next unless has_at_least_one_ruby_file?(abspath)
+ else
+ next unless ruby?(abspath)
+ end
+
# We freeze abspath because that saves allocations when passed later to
# File methods. See #125.
yield basename, abspath.freeze
@@ -28,6 +43,23 @@
end
# @sig (String) -> bool
+ def has_at_least_one_ruby_file?(dir)
+ to_visit = [dir]
+
+ while dir = to_visit.shift
+ ls(dir) do |_basename, abspath|
+ if dir?(abspath)
+ to_visit << abspath
+ else
+ return true
+ end
+ end
+ end
+
+ false
+ end
+
+ # @sig (String) -> bool
def ruby?(path)
path.end_with?(".rb")
end
@@ -37,7 +69,7 @@
File.directory?(path)
end
- # @sig String -> bool
+ # @sig (String) -> bool
def hidden?(basename)
basename.start_with?(".")
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk/loader.rb new/lib/zeitwerk/loader.rb
--- old/lib/zeitwerk/loader.rb 2022-01-28 00:17:23.000000000 +0100
+++ new/lib/zeitwerk/loader.rb 2022-06-13 18:42:15.000000000 +0200
@@ -13,6 +13,9 @@
include Helpers
include Config
+ MUTEX = Mutex.new
+ private_constant :MUTEX
+
# Maps absolute paths for which an autoload has been set ---and not
# executed--- to their corresponding parent class or module and constant
# name.
@@ -144,15 +147,16 @@
end
to_unload.each do |cpath, (abspath, (parent, cname))|
- # We have to check cdef? in this condition. Reason is, constants
whose
- # file does not define them have to be kept in to_unload as explained
- # in the implementation of on_file_autoloaded.
- #
- # If the constant is not defined, on_unload should not be triggered
- # for it.
- if !on_unload_callbacks.empty? && cdef?(parent, cname)
- value = parent.const_get(cname)
- run_on_unload_callbacks(cpath, value, abspath)
+ unless on_unload_callbacks.empty?
+ begin
+ value = cget(parent, cname)
+ rescue ::NameError
+ # Perhaps the user deleted the constant by hand, or perhaps an
+ # autoload failed to define the expected constant but the user
+ # rescued the exception.
+ else
+ run_on_unload_callbacks(cpath, value, abspath)
+ end
end
unload_cref(parent, cname)
@@ -196,14 +200,12 @@
# @raise [Zeitwerk::Error]
# @sig () -> void
def reload
- if reloading_enabled?
- unload
- recompute_ignored_paths
- recompute_collapse_dirs
- setup
- else
- raise ReloadingDisabledError, "can't reload, please call
loader.enable_reloading before setup"
- end
+ raise ReloadingDisabledError unless reloading_enabled?
+
+ unload
+ recompute_ignored_paths
+ recompute_collapse_dirs
+ setup
end
# Eager loads all files in the root directories, recursively. Files do not
@@ -236,7 +238,7 @@
if cref = autoloads[abspath]
cget(*cref)
end
- elsif dir?(abspath) && !root_dirs.key?(abspath)
+ elsif !root_dirs.key?(abspath)
if collapse?(abspath)
queue << [namespace, abspath]
else
@@ -289,10 +291,6 @@
# @sig #call | #debug | nil
attr_accessor :default_logger
- # @private
- # @sig Mutex
- attr_accessor :mutex
-
# This is a shortcut for
#
# require "zeitwerk"
@@ -304,10 +302,13 @@
# except that this method returns the same object in subsequent calls
from
# the same file, in the unlikely case the gem wants to be able to reload.
#
- # @sig () -> Zeitwerk::Loader
- def for_gem
+ # This method returns a subclass of Zeitwerk::Loader, but the exact type
+ # is private, client code can only rely on the interface.
+ #
+ # @sig (bool) -> Zeitwerk::GemLoader
+ def for_gem(warn_on_extra_files: true)
called_from = caller_locations(1, 1).first.path
- Registry.loader_for_gem(called_from)
+ Registry.loader_for_gem(called_from, warn_on_extra_files:
warn_on_extra_files)
end
# Broadcasts `eager_load` to all loaders.
@@ -326,8 +327,6 @@
end
end
- self.mutex = Mutex.new
-
private #
-------------------------------------------------------------------------------------
# @sig (String, Module) -> void
@@ -338,7 +337,7 @@
basename.delete_suffix!(".rb")
cname = inflector.camelize(basename, abspath).to_sym
autoload_file(parent, cname, abspath)
- elsif dir?(abspath)
+ else
# In a Rails application, `app/models/concerns` is a subdirectory
of
# `app/models`, but both of them are root directories.
#
@@ -466,7 +465,7 @@
# @sig (String) -> void
def raise_if_conflicting_directory(dir)
- self.class.mutex.synchronize do
+ MUTEX.synchronize do
Registry.loaders.each do |loader|
next if loader == self
next if loader.ignores?(dir)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk/registry.rb new/lib/zeitwerk/registry.rb
--- old/lib/zeitwerk/registry.rb 2022-01-28 00:17:23.000000000 +0100
+++ new/lib/zeitwerk/registry.rb 2022-06-13 18:42:15.000000000 +0200
@@ -10,12 +10,11 @@
# @sig Array[Zeitwerk::Loader]
attr_reader :loaders
- # Registers loaders created with `for_gem` to make the method idempotent
- # in case of reload.
+ # Registers gem loaders to let `for_gem` be idempotent in case of reload.
#
# @private
# @sig Hash[String, Zeitwerk::Loader]
- attr_reader :loaders_managing_gems
+ attr_reader :gem_loaders_by_root_file
# Maps absolute paths to the loaders responsible for them.
#
@@ -77,7 +76,7 @@
# @sig (Zeitwerk::Loader) -> void
def unregister_loader(loader)
loaders.delete(loader)
- loaders_managing_gems.delete_if { |_, l| l == loader }
+ gem_loaders_by_root_file.delete_if { |_, l| l == loader }
autoloads.delete_if { |_, l| l == loader }
inceptions.delete_if { |_, (_, l)| l == loader }
end
@@ -87,14 +86,8 @@
#
# @private
# @sig (String) -> Zeitwerk::Loader
- def loader_for_gem(root_file)
- loaders_managing_gems[root_file] ||= begin
- Loader.new.tap do |loader|
- loader.tag = File.basename(root_file, ".rb")
- loader.inflector = GemInflector.new(root_file)
- loader.push_dir(File.dirname(root_file))
- end
- end
+ def loader_for_gem(root_file, warn_on_extra_files:)
+ gem_loaders_by_root_file[root_file] ||= GemLoader._new(root_file,
warn_on_extra_files: warn_on_extra_files)
end
# @private
@@ -137,9 +130,9 @@
end
end
- @loaders = []
- @loaders_managing_gems = {}
- @autoloads = {}
- @inceptions = {}
+ @loaders = []
+ @gem_loaders_by_root_file = {}
+ @autoloads = {}
+ @inceptions = {}
end
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk/version.rb new/lib/zeitwerk/version.rb
--- old/lib/zeitwerk/version.rb 2022-01-28 00:17:23.000000000 +0100
+++ new/lib/zeitwerk/version.rb 2022-06-13 18:42:15.000000000 +0200
@@ -1,5 +1,5 @@
# frozen_string_literal: true
module Zeitwerk
- VERSION = "2.5.4"
+ VERSION = "2.6.0"
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/zeitwerk.rb new/lib/zeitwerk.rb
--- old/lib/zeitwerk.rb 2022-01-28 00:17:23.000000000 +0100
+++ new/lib/zeitwerk.rb 2022-06-13 18:42:15.000000000 +0200
@@ -3,6 +3,7 @@
module Zeitwerk
require_relative "zeitwerk/real_mod_name"
require_relative "zeitwerk/loader"
+ require_relative "zeitwerk/gem_loader"
require_relative "zeitwerk/registry"
require_relative "zeitwerk/explicit_namespace"
require_relative "zeitwerk/inflector"
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/metadata new/metadata
--- old/metadata 2022-01-28 00:17:23.000000000 +0100
+++ new/metadata 2022-06-13 18:42:15.000000000 +0200
@@ -1,14 +1,14 @@
--- !ruby/object:Gem::Specification
name: zeitwerk
version: !ruby/object:Gem::Version
- version: 2.5.4
+ version: 2.6.0
platform: ruby
authors:
- Xavier Noria
autorequire:
bindir: bin
cert_chain: []
-date: 2022-01-27 00:00:00.000000000 Z
+date: 2022-06-13 00:00:00.000000000 Z
dependencies: []
description: |2
Zeitwerk implements constant autoloading with Ruby semantics. Each gem
@@ -26,6 +26,7 @@
- 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/kernel.rb
- lib/zeitwerk/loader.rb
