Hello community, here is the log from the commit of package rubygem-zeitwerk for openSUSE:Factory checked in at 2020-11-02 10:36:07 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-zeitwerk (Old) and /work/SRC/openSUSE:Factory/.rubygem-zeitwerk.new.3463 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-zeitwerk" Mon Nov 2 10:36:07 2020 rev:7 rq:845263 version:2.4.1 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-zeitwerk/rubygem-zeitwerk.changes 2020-07-16 12:21:42.223161989 +0200 +++ /work/SRC/openSUSE:Factory/.rubygem-zeitwerk.new.3463/rubygem-zeitwerk.changes 2020-11-02 10:36:31.267301969 +0100 @@ -1,0 +2,7 @@ +Sun Nov 1 13:09:57 UTC 2020 - Manuel Schnitzer <mschnit...@suse.com> + +- updated to version 2.4.1 + + * Use `__send__` instead of `send` internally. + +------------------------------------------------------------------- Old: ---- zeitwerk-2.4.0.gem New: ---- zeitwerk-2.4.1.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-zeitwerk.spec ++++++ --- /var/tmp/diff_new_pack.WHLwOU/_old 2020-11-02 10:36:33.099303225 +0100 +++ /var/tmp/diff_new_pack.WHLwOU/_new 2020-11-02 10:36:33.103303228 +0100 @@ -24,7 +24,7 @@ # Name: rubygem-zeitwerk -Version: 2.4.0 +Version: 2.4.1 Release: 0 %define mod_name zeitwerk %define mod_full_name %{mod_name}-%{version} ++++++ zeitwerk-2.4.0.gem -> zeitwerk-2.4.1.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/README.md new/README.md --- old/README.md 2020-07-15 00:11:04.000000000 +0200 +++ new/README.md 2020-10-29 11:34:25.000000000 +0100 @@ -151,7 +151,7 @@ loader.push_dir("#{__dir__}/adapters", namespace: ActiveJob::QueueAdapters) ``` -your adapter can be stored directly in that directory instead of the canonical `lib/active_job/queue_adapters`. +your adapter can be stored directly in that directory instead of the canonical `#{__dir__}/active_job/queue_adapters`. Please, note that the given namespace must be non-reloadable, though autoloaded constants in that namespace can be. That is, if you associate `app/api` with an existing `Api` module, that module should not be reloadable. However, if the project defines and autoloads the class `Api::V2::Deliveries`, that one can be reloaded. @@ -202,7 +202,7 @@ To make it work that way, configure Zeitwerk to collapse said directory: ```ruby -loader.collapse("booking/actions") +loader.collapse("#{__dir__}/booking/actions") ``` This method accepts an arbitrary number of strings or `Pathname` objects, and also an array of them. @@ -212,7 +212,7 @@ To illustrate usage of glob patterns, if `actions` in the example above is part of a standardized structure, you could use a wildcard: ```ruby -loader.collapse("*/actions") +loader.collapse("#{__dir__}/*/actions") ``` <a id="markdown-nested-root-directories" name="nested-root-directories"></a> 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/explicit_namespace.rb new/lib/zeitwerk/explicit_namespace.rb --- old/lib/zeitwerk/explicit_namespace.rb 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/explicit_namespace.rb 2020-10-29 11:34:25.000000000 +0100 @@ -14,24 +14,22 @@ # the file system, to the loader responsible for them. # # @private - # @return [{String => Zeitwerk::Loader}] + # @sig Hash[String, Zeitwerk::Loader] attr_reader :cpaths # @private - # @return [Mutex] + # @sig Mutex attr_reader :mutex # @private - # @return [TracePoint] + # @sig 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] + # @sig (String, Zeitwerk::Loader) -> void def register(cpath, loader) mutex.synchronize do cpaths[cpath] = loader @@ -42,19 +40,22 @@ end # @private - # @param loader [Zeitwerk::Loader] - # @return [void] + # @sig (Zeitwerk::Loader) -> void def unregister(loader) cpaths.delete_if { |_cpath, l| l == loader } disable_tracer_if_unneeded end + private + + # @sig () -> void def disable_tracer_if_unneeded mutex.synchronize do tracer.disable if cpaths.empty? end end + # @sig (TracePoint) -> void 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/zeitwerk/gem_inflector.rb new/lib/zeitwerk/gem_inflector.rb --- old/lib/zeitwerk/gem_inflector.rb 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/gem_inflector.rb 2020-10-29 11:34:25.000000000 +0100 @@ -2,16 +2,14 @@ module Zeitwerk class GemInflector < Inflector - # @param root_file [String] + # @sig (String) -> void def initialize(root_file) namespace = File.basename(root_file, ".rb") lib_dir = File.dirname(root_file) @version_file = File.join(lib_dir, namespace, "version.rb") end - # @param basename [String] - # @param abspath [String] - # @return [String] + # @sig (String, String) -> String def camelize(basename, abspath) abspath == @version_file ? "VERSION" : super end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/zeitwerk/inflector.rb new/lib/zeitwerk/inflector.rb --- old/lib/zeitwerk/inflector.rb 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/inflector.rb 2020-10-29 11:34:25.000000000 +0100 @@ -11,9 +11,7 @@ # # Takes into account hard-coded mappings configured with `inflect`. # - # @param basename [String] - # @param _abspath [String] - # @return [String] + # @sig (String, String) -> String def camelize(basename, _abspath) overrides[basename] || basename.split('_').each(&:capitalize!).join end @@ -30,8 +28,7 @@ # inflector.camelize("mysql_adapter", abspath) # => "MySQLAdapter" # inflector.camelize("users_controller", abspath) # => "UsersController" # - # @param inflections [{String => String}] - # @return [void] + # @sig (Hash[String, String]) -> void def inflect(inflections) overrides.merge!(inflections) end @@ -41,7 +38,7 @@ # Hard-coded basename to constant name user maps that override the default # inflection logic. # - # @return [{String => String}] + # @sig () -> Hash[String, String] def overrides @overrides ||= {} end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/zeitwerk/kernel.rb new/lib/zeitwerk/kernel.rb --- old/lib/zeitwerk/kernel.rb 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/kernel.rb 2020-10-29 11:34:25.000000000 +0100 @@ -19,8 +19,7 @@ # already existing ancestor chains. alias_method :zeitwerk_original_require, :require - # @param path [String] - # @return [Boolean] + # @sig (String) -> true | false def require(path) if loader = Zeitwerk::Registry.loader_for(path) if path.end_with?(".rb") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/zeitwerk/loader/callbacks.rb new/lib/zeitwerk/loader/callbacks.rb --- old/lib/zeitwerk/loader/callbacks.rb 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/loader/callbacks.rb 2020-10-29 11:34:25.000000000 +0100 @@ -4,8 +4,7 @@ # Invoked from our decorated Kernel#require when a managed file is autoloaded. # # @private - # @param file [String] - # @return [void] + # @sig (String) -> void def on_file_autoloaded(file) cref = autoloads.delete(file) to_unload[cpath(*cref)] = [file, cref] if reloading_enabled? @@ -22,8 +21,7 @@ # autoloaded. # # @private - # @param dir [String] - # @return [void] + # @sig (String) -> void def on_dir_autoloaded(dir) # Module#autoload does not serialize concurrent requires, and we handle # directories ourselves, so the callback needs to account for concurrency. @@ -59,8 +57,7 @@ # subdirectories, we descend into them now. # # @private - # @param namespace [Module] - # @return [void] + # @sig (Module) -> void def on_namespace_loaded(namespace) if subdirs = lazy_subdirs.delete(real_mod_name(namespace)) subdirs.each do |subdir| 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 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/loader.rb 2020-10-29 11:34:25.000000000 +0100 @@ -9,13 +9,13 @@ include Callbacks include RealModName - # @return [String] + # @sig String attr_reader :tag - # @return [#camelize] + # @sig #camelize attr_accessor :inflector - # @return [#call, #debug, nil] + # @sig #call | #debug | nil attr_accessor :logger # Absolute paths of the root directories. Stored in a hash to preserve @@ -30,20 +30,20 @@ # interface for it is `push_dir` and `dirs`. # # @private - # @return [{String => true}] + # @sig Hash[String, true] attr_reader :root_dirs # Absolute paths of files or directories that have to be preloaded. # # @private - # @return [<String>] + # @sig Array[String] attr_reader :preloads # Absolute paths of files, directories, or glob patterns to be totally # ignored. # # @private - # @return [Set<String>] + # @sig Set[String] attr_reader :ignored_glob_patterns # The actual collection of absolute file and directory names at the time the @@ -51,20 +51,20 @@ # reload. # # @private - # @return [Set<String>] + # @sig Set[String] attr_reader :ignored_paths # Absolute paths of directories or glob patterns to be collapsed. # # @private - # @return [Set<String>] + # @sig Set[String] attr_reader :collapse_glob_patterns # The actual collection of absolute directory names at the time the collapse # glob patterns were expanded. Computed on setup, and recomputed on reload. # # @private - # @return [Set<String>] + # @sig Set[String] attr_reader :collapse_dirs # Maps real absolute paths for which an autoload has been set ---and not @@ -76,7 +76,7 @@ # ... # # @private - # @return [{String => (Module, Symbol)}] + # @sig Hash[String, [Module, Symbol]] attr_reader :autoloads # We keep track of autoloaded directories to remove them from the registry @@ -86,7 +86,7 @@ # to concurrency (see why in Zeitwerk::Loader::Callbacks#on_dir_autoloaded). # # @private - # @return [<String>] + # @sig Array[String] attr_reader :autoloaded_dirs # Stores metadata needed for unloading. Its entries look like this: @@ -102,7 +102,7 @@ # or eager loaded. Otherwise, the collection remains empty. # # @private - # @return [{String => (String, (Module, Symbol))}] + # @sig Hash[String, [String, [Module, Symbol]]] attr_reader :to_unload # Maps constant paths of namespaces to arrays of corresponding directories. @@ -120,21 +120,21 @@ # up the corresponding autoloads. # # @private - # @return [{String => <String>}] + # @sig Hash[String, Array[String]] attr_reader :lazy_subdirs # Absolute paths of files or directories not to be eager loaded. # # @private - # @return [Set<String>] + # @sig Set[String] attr_reader :eager_load_exclusions # @private - # @return [Mutex] + # @sig Mutex attr_reader :mutex # @private - # @return [Mutex] + # @sig Mutex attr_reader :mutex2 def initialize @@ -170,7 +170,7 @@ # Sets a tag for the loader, useful for logging. # # @param tag [#to_s] - # @return [void] + # @sig (#to_s) -> void def tag=(tag) @tag = tag.to_s end @@ -178,7 +178,7 @@ # Absolute paths of the root directories. This is a read-only collection, # please push here via `push_dir`. # - # @return [<String>] + # @sig () -> Array[String] def dirs root_dirs.keys.freeze end @@ -189,10 +189,8 @@ # the same process already manages that directory or one of its ascendants # or descendants. # - # @param path [<String, Pathname>] - # @param namespace [Class, Module] # @raise [Zeitwerk::Error] - # @return [void] + # @sig (String | Pathname, Module) -> void def push_dir(path, namespace: Object) # Note that Class < Module. unless namespace.is_a?(Module) @@ -212,7 +210,7 @@ # There is no way to undo this, either you want to reload or you don't. # # @raise [Zeitwerk::Error] - # @return [void] + # @sig () -> void def enable_reloading mutex.synchronize do break if @reloading_enabled @@ -225,15 +223,14 @@ end end - # @return [Boolean] + # @sig () -> bool def reloading_enabled? @reloading_enabled end # Files or directories to be preloaded instead of lazy loaded. # - # @param paths [<String, Pathname, <String, Pathname>>] - # @return [void] + # @sig (*(String | Pathname | Array[String | Pathname])) -> void def preload(*paths) mutex.synchronize do expand_paths(paths).each do |abspath| @@ -245,8 +242,7 @@ # Configure files, directories, or glob patterns to be totally ignored. # - # @param paths [<String, Pathname, <String, Pathname>>] - # @return [void] + # @sig (*(String | Pathname | Array[String | Pathname])) -> void def ignore(*glob_patterns) glob_patterns = expand_paths(glob_patterns) mutex.synchronize do @@ -257,8 +253,7 @@ # Configure directories or glob patterns to be collapsed. # - # @param paths [<String, Pathname, <String, Pathname>>] - # @return [void] + # @sig (*(String | Pathname | Array[String | Pathname])) -> void def collapse(*glob_patterns) glob_patterns = expand_paths(glob_patterns) mutex.synchronize do @@ -269,7 +264,7 @@ # Sets autoloads in the root namespace and preloads files, if any. # - # @return [void] + # @sig () -> void def setup mutex.synchronize do break if @setup @@ -291,7 +286,7 @@ # unload them. # # @private - # @return [void] + # @sig () -> void def unload mutex.synchronize do # We are going to keep track of the files that were required by our @@ -354,7 +349,7 @@ # client code in the README of the project. # # @raise [Zeitwerk::Error] - # @return [void] + # @sig () -> void def reload if reloading_enabled? unload @@ -371,7 +366,7 @@ # are not eager loaded. You can opt-out specifically in specific files and # directories with `do_not_eager_load`. # - # @return [void] + # @sig () -> void def eager_load mutex.synchronize do break if @eager_loaded @@ -414,8 +409,7 @@ # Let eager load ignore the given files or directories. The constants # defined in those files are still autoloadable. # - # @param paths [<String, Pathname, <String, Pathname>>] - # @return [void] + # @sig (*(String | Pathname | Array[String | Pathname])) -> void def do_not_eager_load(*paths) mutex.synchronize { eager_load_exclusions.merge(expand_paths(paths)) } end @@ -423,8 +417,7 @@ # Says if the given constant path would be unloaded on reload. This # predicate returns `false` if reloading is disabled. # - # @param cpath [String] - # @return [Boolean] + # @sig (String) -> bool def unloadable_cpath?(cpath) to_unload.key?(cpath) end @@ -432,21 +425,20 @@ # Returns an array with the constant paths that would be unloaded on reload. # This predicate returns an empty array if reloading is disabled. # - # @return [<String>] + # @sig () -> Array[String] def unloadable_cpaths to_unload.keys.freeze end # Logs to `$stdout`, handy shortcut for debugging. # - # @return [void] + # @sig () -> void def log! @logger = ->(msg) { puts msg } end # @private - # @param dir [String] - # @return [Boolean] + # @sig (String) -> bool def manages?(dir) dir = dir + "/" ignored_paths.each do |ignored_path| @@ -463,11 +455,11 @@ # --- Class methods --------------------------------------------------------------------------- class << self - # @return [#call, #debug, nil] + # @sig #call | #debug | nil attr_accessor :default_logger # @private - # @return [Mutex] + # @sig Mutex attr_accessor :mutex # This is a shortcut for @@ -481,7 +473,7 @@ # 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. # - # @return [Zeitwerk::Loader] + # @sig () -> Zeitwerk::Loader def for_gem called_from = caller_locations(1, 1).first.path Registry.loader_for_gem(called_from) @@ -489,7 +481,7 @@ # Broadcasts `eager_load` to all loaders. # - # @return [void] + # @sig () -> void def eager_load_all Registry.loaders.each(&:eager_load) end @@ -497,7 +489,7 @@ # Returns an array with the absolute paths of the root directories of all # registered loaders. This is a read-only collection. # - # @return [<String>] + # @sig () -> Array[String] def all_dirs Registry.loaders.flat_map(&:dirs).freeze end @@ -507,16 +499,14 @@ private # ------------------------------------------------------------------------------------- - # @return [<String>] + # @sig () -> Array[String] def actual_root_dirs root_dirs.reject do |root_dir, _namespace| !dir?(root_dir) || ignored_paths.member?(root_dir) end end - # @param dir [String] - # @param parent [Module] - # @return [void] + # @sig (String, Module) -> void def set_autoloads_in_dir(dir, parent) ls(dir) do |basename, abspath| begin @@ -559,10 +549,7 @@ end end - # @param parent [Module] - # @param cname [Symbol] - # @param subdir [String] - # @return [void] + # @sig (Module, Symbol, String) -> void def autoload_subdir(parent, cname, subdir) if autoload_path = autoload_for?(parent, cname) cpath = cpath(parent, cname) @@ -582,10 +569,7 @@ end end - # @param parent [Module] - # @param cname [Symbol] - # @param file [String] - # @return [void] + # @sig (Module, Symbol, String) -> void def autoload_file(parent, cname, file) if autoload_path = autoload_for?(parent, cname) # First autoload for a Ruby file wins, just ignore subsequent ones. @@ -606,11 +590,10 @@ end end - # @param dir [String] directory that would have autovivified a module - # @param file [String] the file where the namespace is explicitly defined - # @param parent [Module] - # @param cname [Symbol] - # @return [void] + # `dir` is the directory that would have autovivified a namespace. `file` is + # the file where we've found the namespace is explicitly defined. + # + # @sig (dir: String, file: String, parent: Module, cname: Symbol) -> void def promote_namespace_from_implicit_to_explicit(dir:, file:, parent:, cname:) autoloads.delete(dir) Registry.unregister_autoload(dir) @@ -619,10 +602,7 @@ register_explicit_namespace(cpath(parent, cname)) end - # @param parent [Module] - # @param cname [Symbol] - # @param abspath [String] - # @return [void] + # @sig (Module, Symbol, String) -> void def set_autoload(parent, cname, abspath) # $LOADED_FEATURES stores real paths since Ruby 2.4.4. We set and save the # real path to be able to delete it from $LOADED_FEATURES on unload, and to @@ -649,9 +629,7 @@ end end - # @param parent [Module] - # @param cname [Symbol] - # @return [String, nil] + # @sig (Module, Symbol) -> String? def autoload_for?(parent, cname) strict_autoload_path(parent, cname) || Registry.inception?(cpath(parent, cname)) end @@ -672,9 +650,7 @@ # # We need a way to strictly check in parent ignoring ancestors. # - # @param parent [Module] - # @param cname [Symbol] - # @return [String, nil] + # @sig (Module, Symbol) -> String? if method(:autoload?).arity == 1 def strict_autoload_path(parent, cname) parent.autoload?(cname) if cdef?(parent, cname) @@ -688,15 +664,14 @@ # This method is called this way because I prefer `preload` to be the method # name to configure preloads in the public interface. # - # @return [void] + # @sig () -> void def do_preload preloads.each do |abspath| do_preload_abspath(abspath) end end - # @param abspath [String] - # @return [void] + # @sig (String) -> void def do_preload_abspath(abspath) if ruby?(abspath) do_preload_file(abspath) @@ -705,31 +680,25 @@ end end - # @param dir [String] - # @return [void] + # @sig (String) -> void def do_preload_dir(dir) ls(dir) do |_basename, abspath| do_preload_abspath(abspath) end end - # @param file [String] - # @return [Boolean] + # @sig (String) -> bool def do_preload_file(file) log("preloading #{file}") if logger require file end - # @param parent [Module] - # @param cname [Symbol] - # @return [String] + # @sig (Module, Symbol) -> String def cpath(parent, cname) parent.equal?(Object) ? cname.to_s : "#{real_mod_name(parent)}::#{cname}" end - # @param dir [String] - # @yieldparam path [String, String] - # @return [void] + # @sig (String) { (String, String) -> void } -> void def ls(dir) Dir.foreach(dir) do |basename| next if basename.start_with?(".") @@ -743,57 +712,55 @@ end end - # @param path [String] - # @return [Boolean] + # @sig (String) -> bool def ruby?(path) path.end_with?(".rb") end - # @param path [String] - # @return [Boolean] + # @sig (String) -> bool def dir?(path) File.directory?(path) end - # @param paths [<String, Pathname, <String, Pathname>>] - # @return [<String>] + # @sig (String | Pathname | Array[String | Pathname]) -> Array[String] def expand_paths(paths) paths.flatten.map! { |path| File.expand_path(path) } end - # @param glob_patterns [<String>] - # @return [<String>] + # @sig (Array[String]) -> Array[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] + # @sig () -> void def recompute_ignored_paths ignored_paths.replace(expand_glob_patterns(ignored_glob_patterns)) end - # @return [void] + # @sig () -> void def recompute_collapse_dirs collapse_dirs.replace(expand_glob_patterns(collapse_glob_patterns)) end - # @param message [String] - # @return [void] + # @sig (String) -> void def log(message) method_name = logger.respond_to?(:debug) ? :debug : :call logger.send(method_name, "Zeitwerk@#{tag}: #{message}") end + # @sig (Module, Symbol) -> bool def cdef?(parent, cname) parent.const_defined?(cname, false) end + # @sig (String) -> void def register_explicit_namespace(cpath) ExplicitNamespace.register(cpath, self) end + # @sig (String) -> void def raise_if_conflicting_directory(dir) self.class.mutex.synchronize do Registry.loaders.each do |loader| @@ -808,19 +775,15 @@ end end - # @param parent [Module] - # @param cname [Symbol] - # @return [void] + # @sig (Module, Symbol) -> void def unload_autoload(parent, cname) - parent.send(:remove_const, cname) + parent.__send__(:remove_const, cname) log("autoload for #{cpath(parent, cname)} removed") if logger end - # @param parent [Module] - # @param cname [Symbol] - # @return [void] + # @sig (Module, Symbol) -> void def unload_cref(parent, cname) - parent.send(:remove_const, cname) + parent.__send__(:remove_const, cname) log("#{cpath(parent, cname)} unloaded") if logger end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/zeitwerk/real_mod_name.rb new/lib/zeitwerk/real_mod_name.rb --- old/lib/zeitwerk/real_mod_name.rb 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/real_mod_name.rb 2020-10-29 11:34:25.000000000 +0100 @@ -7,8 +7,7 @@ # # The name method can be overridden, hence the indirection in this method. # - # @param mod [Class, Module] - # @return [String, nil] + # @sig (Module) -> String? if UnboundMethod.method_defined?(:bind_call) def real_mod_name(mod) UNBOUND_METHOD_MODULE_NAME.bind_call(mod) 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 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/registry.rb 2020-10-29 11:34:25.000000000 +0100 @@ -7,14 +7,14 @@ # them from being garbage collected. # # @private - # @return [<Zeitwerk::Loader>] + # @sig Array[Zeitwerk::Loader] attr_reader :loaders # Registers loaders created with `for_gem` to make the method idempotent # in case of reload. # # @private - # @return [{String => Zeitwerk::Loader}] + # @sig Hash[String, Zeitwerk::Loader] attr_reader :loaders_managing_gems # Maps real paths to the loaders responsible for them. @@ -23,7 +23,7 @@ # invoke callbacks and autovivify modules. # # @private - # @return [{String => Zeitwerk::Loader}] + # @sig Hash[String, Zeitwerk::Loader] attr_reader :autoloads # This hash table addresses an edge case in which an autoload is ignored. @@ -62,14 +62,13 @@ # end # # @private - # @return [{String => (String, Zeitwerk::Loader)}] + # @sig Hash[String, [String, Zeitwerk::Loader]] attr_reader :inceptions # Registers a loader. # # @private - # @param loader [Zeitwerk::Loader] - # @return [void] + # @sig (Zeitwerk::Loader) -> void def register_loader(loader) loaders << loader end @@ -78,8 +77,7 @@ # file. That is how Zeitwerk::Loader.for_gem is idempotent. # # @private - # @param root_file [String] - # @return [Zeitwerk::Loader] + # @sig (String) -> Zeitwerk::Loader def loader_for_gem(root_file) loaders_managing_gems[root_file] ||= begin Loader.new.tap do |loader| @@ -91,32 +89,25 @@ end # @private - # @param loader [Zeitwerk::Loader] - # @param realpath [String] - # @return [void] + # @sig (Zeitwerk::Loader, String) -> String def register_autoload(loader, realpath) autoloads[realpath] = loader end # @private - # @param realpath [String] - # @return [void] + # @sig (String) -> void def unregister_autoload(realpath) autoloads.delete(realpath) end # @private - # @param cpath [String] - # @param realpath [String] - # @param loader [Zeitwerk::Loader] - # @return [void] + # @sig (String, String, Zeitwerk::Loader) -> void def register_inception(cpath, realpath, loader) inceptions[cpath] = [realpath, loader] end # @private - # @param cpath [String] - # @return [String, nil] + # @sig (String) -> String? def inception?(cpath) if pair = inceptions[cpath] pair.first @@ -124,15 +115,13 @@ end # @private - # @param path [String] - # @return [Zeitwerk::Loader, nil] + # @sig (String) -> Zeitwerk::Loader? def loader_for(path) autoloads[path] end # @private - # @param loader [Zeitwerk::Loader] - # @return [void] + # @sig (Zeitwerk::Loader) -> void def on_unload(loader) autoloads.delete_if { |_path, object| object == loader } inceptions.delete_if { |_cpath, (_path, object)| object == loader } 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 2020-07-15 00:11:04.000000000 +0200 +++ new/lib/zeitwerk/version.rb 2020-10-29 11:34:25.000000000 +0100 @@ -1,5 +1,5 @@ # frozen_string_literal: true module Zeitwerk - VERSION = "2.4.0" + VERSION = "2.4.1" end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2020-07-15 00:11:04.000000000 +0200 +++ new/metadata 2020-10-29 11:34:25.000000000 +0100 @@ -1,14 +1,14 @@ --- !ruby/object:Gem::Specification name: zeitwerk version: !ruby/object:Gem::Version - version: 2.4.0 + version: 2.4.1 platform: ruby authors: - Xavier Noria -autorequire: +autorequire: bindir: bin cert_chain: [] -date: 2020-07-14 00:00:00.000000000 Z +date: 2020-10-29 00:00:00.000000000 Z dependencies: [] description: |2 Zeitwerk implements constant autoloading with Ruby semantics. Each gem @@ -41,7 +41,7 @@ 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: +post_install_message: rdoc_options: [] require_paths: - lib @@ -57,7 +57,7 @@ version: '0' requirements: [] rubygems_version: 3.1.2 -signing_key: +signing_key: specification_version: 4 summary: Efficient and thread-safe constant autoloader test_files: []