dry-system 0.18.1 → 1.0.1

data/lib/dry/system/{manual_registrar.rb → manifest_registrar.rb}

@@ -4,19 +4,21 @@ require "dry/system/constants"
 
 module Dry
   module System
-    # Default manual registration implementation
+    # Default manifest registration implementation
     #
-    # This is currently configured by default for every System::Container.
-    # Manual registrar objects are responsible for loading files from configured
-    # manual registration paths, which should hold code to explicitly register
+    # This is configured by default for every System::Container. The manifest registrar is
+    # responsible for loading manifest files that contain code to manually register
     # certain objects with the container.
     #
     # @api private
-    class ManualRegistrar
+    class ManifestRegistrar
+      # @api private
       attr_reader :container
 
+      # @api private
       attr_reader :config
 
+      # @api private
       def initialize(container)
         @container = container
         @config = container.config
@@ -25,21 +27,18 @@ module Dry
       # @api private
       def finalize!
         ::Dir[registrations_dir.join(RB_GLOB)].sort.each do |file|
-          call(File.basename(file, RB_EXT))
+          call(Identifier.new(File.basename(file, RB_EXT)))
         end
       end
 
       # @api private
-      def call(name)
-        name = name.respond_to?(:root_key) ? name.root_key.to_s : name
-
-        require(root.join(config.registrations_dir, name))
+      def call(component)
+        require(root.join(config.registrations_dir, component.root_key.to_s))
       end
 
-      def file_exists?(name)
-        name = name.respond_to?(:root_key) ? name.root_key.to_s : name
-
-        File.exist?(File.join(registrations_dir, "#{name}#{RB_EXT}"))
+      # @api private
+      def file_exists?(component)
+        File.exist?(File.join(registrations_dir, "#{component.root_key}#{RB_EXT}"))
       end
 
       private

data/lib/dry/system/plugins/bootsnap.rb

@@ -15,8 +15,9 @@ module Dry
         # @api private
         def self.extended(system)
           super
+
           system.use(:env)
-          system.before(:configure) { setting :bootsnap, DEFAULT_OPTIONS }
+          system.setting :bootsnap, default: DEFAULT_OPTIONS
           system.after(:configure, &:setup_bootsnap)
         end
 
@@ -36,7 +37,7 @@ module Dry
 
         # @api private
         def bootsnap_available?
-          RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.3.0" && RUBY_VERSION < "2.5.0"
+          RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.3.0" && RUBY_VERSION < "3.1.0"
         end
       end
     end

data/lib/dry/system/plugins/dependency_graph/strategies.rb

@@ -6,7 +6,7 @@ module Dry
       module DependencyGraph
         # @api private
         class Strategies
-          extend Dry::Container::Mixin
+          extend Core::Container::Mixin
 
           # @api private
           class Kwargs < Dry::AutoInject::Strategies::Kwargs
@@ -15,13 +15,49 @@ module Dry
             # @api private
             def define_initialize(klass)
               @container["notifications"].instrument(
-                :resolved_dependency, dependency_map: dependency_map.to_h, target_class: klass
+                :resolved_dependency,
+                dependency_map: dependency_map.to_h,
+                target_class: klass
               )
+
+              super(klass)
+            end
+          end
+
+          # @api private
+          class Args < Dry::AutoInject::Strategies::Args
+            private
+
+            # @api private
+            def define_initialize(klass)
+              @container["notifications"].instrument(
+                :resolved_dependency,
+                dependency_map: dependency_map.to_h,
+                target_class: klass
+              )
+
+              super(klass)
+            end
+          end
+
+          class Hash < Dry::AutoInject::Strategies::Hash
+            private
+
+            # @api private
+            def define_initialize(klass)
+              @container["notifications"].instrument(
+                :resolved_dependency,
+                dependency_map: dependency_map.to_h,
+                target_class: klass
+              )
+
               super(klass)
             end
           end
 
           register :kwargs, Kwargs
+          register :args, Args
+          register :hash, Hash
           register :default, Kwargs
         end
       end

data/lib/dry/system/plugins/dependency_graph.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/system/constants"
-require "dry/system/plugins/dependency_graph/strategies"
-
 module Dry
   module System
     module Plugins
@@ -12,36 +9,43 @@ module Dry
         def self.extended(system)
           super
 
-          system.use(:notifications)
-
-          system.before(:configure) do
-            setting :ignored_dependencies, []
-          end
+          system.instance_eval do
+            use(:notifications)
 
-          system.after(:configure) do
-            self[:notifications].register_event(:resolved_dependency)
-            self[:notifications].register_event(:registered_dependency)
+            setting :dependency_graph do
+              setting :ignored_dependencies, default: []
+            end
 
-            strategies(Strategies)
+            after(:configure) do
+              self[:notifications].register_event(:resolved_dependency)
+              self[:notifications].register_event(:registered_dependency)
+            end
           end
         end
 
         # @api private
         def self.dependencies
-          {'dry-events': "dry/events/publisher"}
+          {"dry-events" => "dry/events/publisher"}
         end
 
         # @api private
-        def register(key, contents = nil, options = {}, &block)
-          super
+        def injector(**options)
+          super(**options, strategies: DependencyGraph::Strategies)
+        end
 
-          unless config.ignored_dependencies.include?(key.to_sym)
-            self[:notifications].instrument(
-              :registered_dependency, key: key, class: self[key].class
-            )
+        # @api private
+        def register(key, contents = nil, options = {}, &block)
+          super.tap do
+            key = key.to_s
+
+            unless config.dependency_graph.ignored_dependencies.include?(key)
+              self[:notifications].instrument(
+                :registered_dependency,
+                key: key,
+                class: self[key].class
+              )
+            end
           end
-
-          self
         end
       end
     end

data/lib/dry/system/plugins/env.rb

@@ -10,8 +10,9 @@ module Dry
         attr_reader :options
 
         # @api private
-        def initialize(options)
+        def initialize(**options)
           @options = options
+          super()
         end
 
         def inferrer
@@ -20,7 +21,7 @@ module Dry
 
         # @api private
         def extended(system)
-          system.setting :env, inferrer.(), reader: true
+          system.setting :env, default: inferrer.(), reader: true
           super
         end
       end

data/lib/dry/system/plugins/logging.rb

@@ -8,17 +8,18 @@ module Dry
       module Logging
         # @api private
         def self.extended(system)
-          system.before(:configure) do
+          system.instance_eval do
             setting :logger, reader: true
 
-            setting :log_dir, "log"
+            setting :log_dir, default: "log"
 
-            setting :log_levels,
-                    development: Logger::DEBUG,
-                    test: Logger::DEBUG,
-                    production: Logger::ERROR
+            setting :log_levels, default: {
+              development: Logger::DEBUG,
+              test: Logger::DEBUG,
+              production: Logger::ERROR
+            }
 
-            setting :logger_class, ::Logger, reader: true
+            setting :logger_class, default: ::Logger, reader: true
           end
 
           system.after(:configure, &:register_logger)
@@ -39,7 +40,7 @@ module Dry
           elsif config.logger
             register(:logger, config.logger)
           else
-            config.logger = logger = config.logger_class.new(log_file_path)
+            config.logger = config.logger_class.new(log_file_path)
             config.logger.level = log_level
 
             register(:logger, config.logger)

data/lib/dry/system/plugins/monitoring.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "dry/system/constants"
-require "dry/system/plugins/monitoring/proxy"
 
 module Dry
   module System
@@ -21,7 +20,7 @@ module Dry
 
         # @api private
         def self.dependencies
-          {'dry-events': "dry/events/publisher"}
+          {"dry-events": "dry/events/publisher"}
         end
 
         # @api private

data/lib/dry/system/plugins/notifications.rb

@@ -12,7 +12,7 @@ module Dry
 
         # @api private
         def self.dependencies
-          {'dry-monitor': "dry/monitor/notifications"}
+          {"dry-monitor": "dry/monitor"}
         end
 
         # @api private

data/lib/dry/system/plugins/plugin.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      # @api private
+      class Plugin
+        attr_reader :name
+
+        attr_reader :mod
+
+        attr_reader :block
+
+        # @api private
+        def initialize(name, mod, &block)
+          @name = name
+          @mod = mod
+          @block = block
+        end
+
+        # @api private
+        def apply_to(system, **options)
+          system.extend(stateful? ? mod.new(**options) : mod)
+          system.instance_eval(&block) if block
+          system
+        end
+
+        # @api private
+        def load_dependencies(dependencies = mod_dependencies, gem = nil)
+          Array(dependencies).each do |dependency|
+            if dependency.is_a?(Array) || dependency.is_a?(Hash)
+              dependency.each { |value| load_dependencies(*Array(value).reverse) }
+            elsif !Plugins.loaded_dependencies.include?(dependency.to_s)
+              load_dependency(dependency, gem)
+            end
+          end
+        end
+
+        # @api private
+        def load_dependency(dependency, gem)
+          Kernel.require dependency
+          Plugins.loaded_dependencies << dependency.to_s
+        rescue LoadError => e
+          raise PluginDependencyMissing.new(name, e.message, gem)
+        end
+
+        # @api private
+        def stateful?
+          mod < Module
+        end
+
+        # @api private
+        def mod_dependencies
+          return EMPTY_ARRAY unless mod.respond_to?(:dependencies)
+
+          mod.dependencies.is_a?(Array) ? mod.dependencies : [mod.dependencies]
+        end
+      end
+    end
+  end
+end

data/lib/dry/system/plugins/zeitwerk/compat_inflector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dry
+  module System
+    module Plugins
+      class Zeitwerk < Module
+        # @api private
+        class CompatInflector
+          attr_reader :config
+
+          def initialize(config)
+            @config = config
+          end
+
+          def camelize(string, _)
+            config.inflector.camelize(string)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/system/plugins/zeitwerk.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "dry/system/constants"
+
+module Dry
+  module System
+    module Plugins
+      # @api private
+      class Zeitwerk < Module
+        # @api private
+        def self.dependencies
+          [
+            "dry/system/loader/autoloading",
+            "dry/system/plugins/zeitwerk/compat_inflector",
+            {"zeitwerk" => "zeitwerk"}
+          ]
+        end
+
+        # @api private
+        attr_reader :loader, :run_setup, :eager_load, :debug
+
+        # @api private
+        def initialize(loader: nil, run_setup: true, eager_load: nil, debug: false)
+          @loader = loader || ::Zeitwerk::Loader.new
+          @run_setup = run_setup
+          @eager_load = eager_load
+          @debug = debug
+          super()
+        end
+
+        # @api private
+        def extended(system)
+          system.setting :autoloader, reader: true
+
+          system.config.autoloader = loader
+          system.config.component_dirs.loader = Dry::System::Loader::Autoloading
+          system.config.component_dirs.add_to_load_path = false
+
+          system.after(:configure, &method(:setup_autoloader))
+
+          super
+        end
+
+        private
+
+        def setup_autoloader(system)
+          configure_loader(system.autoloader, system)
+
+          push_component_dirs_to_loader(system, system.autoloader)
+
+          system.autoloader.setup if run_setup
+
+          system.after(:finalize) { system.autoloader.eager_load } if eager_load?(system)
+
+          system
+        end
+
+        # Build a zeitwerk loader with the configured component directories
+        #
+        # @return [Zeitwerk::Loader]
+        def configure_loader(loader, system)
+          loader.tag = system.config.name || system.name unless loader.tag
+          loader.inflector = CompatInflector.new(system.config)
+          loader.logger = method(:puts) if debug
+        end
+
+        # Add component dirs to the zeitwerk loader
+        #
+        # @return [Zeitwerk::Loader]
+        def push_component_dirs_to_loader(system, loader)
+          system.config.component_dirs.each do |dir|
+            dir.namespaces.each do |ns|
+              loader.push_dir(
+                system.root.join(dir.path, ns.path.to_s),
+                namespace: module_for_namespace(ns, system.config.inflector)
+              )
+            end
+          end
+
+          loader
+        end
+
+        def module_for_namespace(namespace, inflector)
+          return Object unless namespace.const
+
+          begin
+            inflector.constantize(inflector.camelize(namespace.const))
+          rescue NameError
+            namespace.const.split(PATH_SEPARATOR).reduce(Object) { |parent_mod, mod_path|
+              get_or_define_module(parent_mod, inflector.camelize(mod_path))
+            }
+          end
+        end
+
+        def get_or_define_module(parent_mod, name)
+          parent_mod.const_get(name)
+        rescue NameError
+          parent_mod.const_set(name, Module.new)
+        end
+
+        def eager_load?(system)
+          return eager_load unless eager_load.nil?
+
+          system.config.respond_to?(:env) && system.config.env == :production
+        end
+      end
+    end
+  end
+end

data/lib/dry/system/plugins.rb

@@ -1,64 +1,8 @@
 # frozen_string_literal: true
 
-require "dry/system/constants"
-
 module Dry
   module System
     module Plugins
-      # @api private
-      class Plugin
-        attr_reader :name
-
-        attr_reader :mod
-
-        attr_reader :block
-
-        # @api private
-        def initialize(name, mod, &block)
-          @name = name
-          @mod = mod
-          @block = block
-        end
-
-        # @api private
-        def apply_to(system, options)
-          system.extend(stateful? ? mod.new(options) : mod)
-          system.instance_eval(&block) if block
-          system
-        end
-
-        # @api private
-        def load_dependencies(dependencies = mod_dependencies, gem = nil)
-          Array(dependencies).each do |dependency|
-            if dependency.is_a?(Array) || dependency.is_a?(Hash)
-              dependency.each { |value| load_dependencies(*Array(value).reverse) }
-            elsif !Plugins.loaded_dependencies.include?(dependency.to_s)
-              load_dependency(dependency, gem)
-            end
-          end
-        end
-
-        # @api private
-        def load_dependency(dependency, gem)
-          Kernel.require dependency
-          Plugins.loaded_dependencies << dependency.to_s
-        rescue LoadError => e
-          raise PluginDependencyMissing.new(name, e.message, gem)
-        end
-
-        # @api private
-        def stateful?
-          mod < Module
-        end
-
-        # @api private
-        def mod_dependencies
-          return EMPTY_ARRAY unless mod.respond_to?(:dependencies)
-
-          mod.dependencies.is_a?(Array) ? mod.dependencies : [mod.dependencies]
-        end
-      end
-
       # Register a plugin
       #
       # @param [Symbol] name The name of a plugin
@@ -84,21 +28,19 @@ module Dry
       # Enables a plugin if not already enabled.
       # Raises error if plugin cannot be found in the plugin registry.
       #
-      # Plugin identifier
-      #
-      # @param [Symbol] name The plugin identifier
+      # @param [Symbol] name The plugin name
       # @param [Hash] options Plugin options
       #
       # @return [self]
       #
       # @api public
-      def use(name, options = {})
+      def use(name, **options)
         return self if enabled_plugins.include?(name)
 
-        raise PluginNotFoundError, name unless (plugin = Plugins.registry[name])
+        raise PluginNotFoundError, name unless (plugin = Dry::System::Plugins.registry[name])
 
         plugin.load_dependencies
-        plugin.apply_to(self, options)
+        plugin.apply_to(self, **options)
 
         enabled_plugins << name
 
@@ -116,23 +58,13 @@ module Dry
         @enabled_plugins ||= []
       end
 
-      require "dry/system/plugins/bootsnap"
       register(:bootsnap, Plugins::Bootsnap)
-
-      require "dry/system/plugins/logging"
       register(:logging, Plugins::Logging)
-
-      require "dry/system/plugins/env"
       register(:env, Plugins::Env)
-
-      require "dry/system/plugins/notifications"
       register(:notifications, Plugins::Notifications)
-
-      require "dry/system/plugins/monitoring"
       register(:monitoring, Plugins::Monitoring)
-
-      require "dry/system/plugins/dependency_graph"
       register(:dependency_graph, Plugins::DependencyGraph)
+      register(:zeitwerk, Plugins::Zeitwerk)
     end
   end
 end