dry-system 0.22.0 → 0.23.0

data/lib/dry/system/errors.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require "dry/core/deprecations"
+
 module Dry
   module System
+    extend Dry::Core::Deprecations["dry-system"]
+
     # Error raised when a component dir is added to configuration more than once
     #
     # @api public
@@ -11,8 +15,19 @@ module Dry
       end
     end
 
+    # Error raised when a configured component directory could not be found
+    #
+    # @api public
+    ComponentDirNotFoundError = Class.new(StandardError) do
+      def initialize(dir)
+        super("Component dir '#{dir}' not found")
+      end
+    end
+
     # Error raised when a namespace for a component dir is added to configuration more
     # than once
+    #
+    # @api public
     NamespaceAlreadyAddedError = Class.new(StandardError) do
       def initialize(path)
         path_label = path ? "path #{path.inspect}" : "root path"
@@ -21,45 +36,40 @@ module Dry
       end
     end
 
-    # Error raised when booter file do not match with register component
-    #
-    # @api public
-    ComponentFileMismatchError = Class.new(StandardError) do
-      def initialize(component)
-        super(<<-STR)
-          Bootable component '#{component.name}' not found
-        STR
-      end
-    end
-
-    # Error raised when resolved component couldn't be loaded
+    # Error raised when attempting to register provider using a name that has already been
+    # registered
     #
     # @api public
-    InvalidComponentError = Class.new(ArgumentError) do
-      def initialize(name, reason = nil)
-        super(
-          "Tried to create an invalid #{name.inspect} component - #{reason}"
-        )
+    ProviderAlreadyRegisteredError = Class.new(ArgumentError) do
+      def initialize(provider_name)
+        super("Provider #{provider_name.inspect} has already been registered")
       end
     end
+    DuplicatedComponentKeyError = ProviderAlreadyRegisteredError
+    deprecate_constant :DuplicatedComponentKeyError
 
-    # Error raised when component's name is not valid
+    # Error raised when a named provider could not be found
     #
     # @api public
-    InvalidComponentNameError = Class.new(ArgumentError) do
+    ProviderNotFoundError = Class.new(ArgumentError) do
       def initialize(name)
-        super(
-          "component +#{name}+ is invalid or boot file is missing"
-        )
+        super("Provider #{name.inspect} not found")
       end
     end
+    InvalidComponentError = ProviderNotFoundError
+    deprecate_constant :InvalidComponentError
 
-    # Error raised when trying to stop a component that hasn't started yet
+    # Error raised when a named provider source could not be found
     #
     # @api public
-    ComponentNotStartedError = Class.new(StandardError) do
-      def initialize(component_name)
-        super("component +#{component_name}+ has not been started")
+    ProviderSourceNotFoundError = Class.new(StandardError) do
+      def initialize(name:, group:, keys:)
+        msg = "Provider source not found: #{name.inspect}, group: #{group.inspect}"
+
+        key_list = keys.map { |key| "- #{key[:name].inspect}, group: #{key[:group].inspect}" }
+        msg += "Available provider sources:\n\n#{key_list}"
+
+        super(msg)
       end
     end
 
@@ -72,43 +82,53 @@ module Dry
       end
     end
 
-    # Error raised when a configured component directory could not be found
+    # Exception raise when a plugin dependency failed to load
     #
     # @api public
-    ComponentDirNotFoundError = Class.new(StandardError) do
-      def initialize(dir)
-        super("Component dir '#{dir}' not found")
+    PluginDependencyMissing = Class.new(StandardError) do
+      # @api private
+      def initialize(plugin, message, gem = nil)
+        details = gem ? "#{message} - add #{gem} to your Gemfile" : message
+        super("dry-system plugin #{plugin.inspect} failed to load its dependencies: #{details}")
       end
     end
 
-    DuplicatedComponentKeyError = Class.new(ArgumentError)
-
-    InvalidSettingsError = Class.new(ArgumentError) do
+    # Exception raised when auto-registerable component is not loadable
+    #
+    # @api public
+    ComponentNotLoadableError = Class.new(NameError) do
       # @api private
-      def initialize(attributes)
-        message = <<~STR
-          Could not initialize settings. The following settings were invalid:
+      def initialize(component, error,
+                     corrections: DidYouMean::ClassNameChecker.new(error).corrections)
+        full_class_name = [error.receiver, error.name].join("::")
 
-          #{attributes_errors(attributes).join("\n")}
-        STR
-        super(message)
-      end
+        message = [
+          "Component '#{component.key}' is not loadable.",
+          "Looking for #{full_class_name}."
+        ]
 
-      private
+        if corrections.any?
+          case_correction = corrections.find { |correction| correction.casecmp?(full_class_name) }
+          if case_correction
+            acronyms_needed = case_correction.split("::").difference(full_class_name.split("::"))
+            stringified_acronyms_needed = acronyms_needed.map { |acronym|
+              "'#{acronym}'"
+            } .join(", ")
+            message <<
+              <<~ERROR_MESSAGE
 
-      def attributes_errors(attributes)
-        attributes.map { |key, error| "#{key.name}: #{error}" }
-      end
-    end
+                You likely need to add:
 
-    # Exception raise when a plugin dependency failed to load
-    #
-    # @api public
-    PluginDependencyMissing = Class.new(StandardError) do
-      # @api private
-      def initialize(plugin, message, gem = nil)
-        details = gem ? "#{message} - add #{gem} to your Gemfile" : message
-        super("dry-system plugin #{plugin.inspect} failed to load its dependencies: #{details}")
+                    acronym(#{stringified_acronyms_needed})
+
+                to your container's inflector, since we found a #{case_correction} class.
+              ERROR_MESSAGE
+          else
+            message << DidYouMean.formatter.message_for(corrections)
+          end
+        end
+
+        super message.join("\n")
       end
     end
   end

data/lib/dry/system/identifier.rb

@@ -13,20 +13,15 @@ module Dry
     #
     # @api public
     class Identifier
-      include Dry::Equalizer(:key, :separator)
+      include Dry::Equalizer(:key)
 
       # @return [String] the identifier's string key
       # @api public
       attr_reader :key
 
-      # @return [String] the configured namespace separator
-      # @api public
-      attr_reader :separator
-
       # @api private
-      def initialize(key, separator: DEFAULT_SEPARATOR)
+      def initialize(key)
         @key = key.to_s
-        @separator = separator
       end
 
       # @!method to_s
@@ -49,11 +44,9 @@ module Dry
         segments.first.to_sym
       end
 
-      # Returns true if the given leading namespaces are a leading part of the
-      # identifier's key
+      # Returns true if the given leading segments string is a leading part of the {key}.
       #
-      # Also returns true if nil is given (technically, from nothing everything is
-      # wrought)
+      # Also returns true if nil or an empty string is given.
       #
       # @example
       #   identifier.key # => "articles.operations.create"
@@ -63,13 +56,62 @@ module Dry
       #   identifier.start_with?("article") # => false
       #   identifier.start_with?(nil) # => true
       #
-      # @param leading_namespaces [String] the one or more leading namespaces to check
+      # @param leading_segments [String] the one or more leading segments to check
+      # @return [Boolean]
+      # @api public
+      def start_with?(leading_segments)
+        leading_segments.to_s.empty? ||
+          key.start_with?("#{leading_segments}#{KEY_SEPARATOR}") ||
+          key.eql?(leading_segments)
+      end
+
+      # Returns true if the given trailing segments string is the end part of the {key}.
+      #
+      # Also returns true if nil or an empty string is given.
+      #
+      # @example
+      #   identifier.key # => "articles.operations.create"
+      #
+      #   identifier.end_with?("create") # => true
+      #   identifier.end_with?("operations.create") # => true
+      #   identifier.end_with?("ate") # => false, not a whole segment
+      #   identifier.end_with?("nup") # => false, not in key at all
+      #
+      # @param trailing_segments [String] the one or more trailing key segments to check
+      # @return [Boolean]
+      # @api public
+      def end_with?(trailing_segments)
+        trailing_segments.to_s.empty? ||
+          key.end_with?("#{KEY_SEPARATOR}#{trailing_segments}") ||
+          key.eql?(trailing_segments)
+      end
+
+      # Returns true if the given segments string matches whole segments within the {key}.
+      #
+      # @example
+      #   identifier.key # => "articles.operations.create"
+      #
+      #   identifier.include?("operations") # => true
+      #   identifier.include?("articles.operations") # => true
+      #   identifier.include?("operations.create") # => true
+      #
+      #   identifier.include?("article") # => false, not a whole segment
+      #   identifier.include?("update") # => false, not in key at all
+      #
+      # @param segments [String] the one of more key segments to check
       # @return [Boolean]
       # @api public
-      def start_with?(leading_namespaces)
-        leading_namespaces.nil? ||
-          key.start_with?("#{leading_namespaces}#{separator}") ||
-          key.eql?(leading_namespaces)
+      def include?(segments)
+        return false if segments.to_s.empty?
+
+        sep_re = Regexp.escape(KEY_SEPARATOR)
+        key.match?(
+          /
+            (\A|#{sep_re})
+            #{Regexp.escape(segments)}
+            (\Z|#{sep_re})
+          /x
+        )
       end
 
       # Returns the key with its segments separated by the given separator
@@ -108,27 +150,27 @@ module Dry
       def namespaced(from:, to:)
         return self if from == to
 
-        separated_to = "#{to}#{separator}" if to
+        separated_to = "#{to}#{KEY_SEPARATOR}" if to
 
         new_key =
           if from.nil?
             "#{separated_to}#{key}"
           else
             key.sub(
-              /^#{Regexp.escape(from.to_s)}#{Regexp.escape(separator)}/,
+              /^#{Regexp.escape(from.to_s)}#{Regexp.escape(KEY_SEPARATOR)}/,
               separated_to || EMPTY_STRING
             )
           end
 
         return self if new_key == key
 
-        self.class.new(new_key, separator: separator)
+        self.class.new(new_key)
       end
 
       private
 
       def segments
-        @segments ||= key.split(separator)
+        @segments ||= key.split(KEY_SEPARATOR)
       end
     end
   end

data/lib/dry/system/importer.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "dry/container"
+require_relative "constants"
+
 module Dry
   module System
     # Default importer implementation
@@ -11,25 +14,34 @@ module Dry
     #
     # @api private
     class Importer
-      attr_reader :container
+      # @api private
+      class Item
+        attr_reader :namespace, :container, :import_keys
+
+        def initialize(namespace:, container:, import_keys:)
+          @namespace = namespace
+          @container = container
+          @import_keys = import_keys
+        end
+      end
 
-      attr_reader :separator
+      attr_reader :container
 
       attr_reader :registry
 
       # @api private
       def initialize(container)
         @container = container
-        @separator = container.config.namespace_separator
         @registry = {}
       end
 
       # @api private
-      def finalize!
-        registry.each do |name, container|
-          call(name, container.finalize!)
-        end
-        self
+      def register(namespace:, container:, keys: nil)
+        registry[namespace] = Item.new(
+          namespace: namespace,
+          container: container,
+          import_keys: keys
+        )
       end
 
       # @api private
@@ -41,15 +53,74 @@ module Dry
       def key?(name)
         registry.key?(name)
       end
+      alias_method :namespace?, :key?
 
       # @api private
-      def call(ns, other)
-        container.merge(other, namespace: ns)
+      def finalize!
+        registry.each_key { import(_1) }
+        self
       end
 
       # @api private
-      def register(other)
-        registry.update(other)
+      def import(namespace, keys: Undefined)
+        item = self[namespace]
+        keys = Undefined.default(keys, item.import_keys)
+
+        if keys
+          import_keys(item.container, namespace, keys_to_import(keys, item))
+        else
+          import_all(item.container, namespace)
+        end
+
+        self
+      end
+
+      private
+
+      def keys_to_import(keys, item)
+        keys
+          .then { (arr = item.import_keys) ? _1 & arr : _1 }
+          .then { (arr = item.container.exports) ? _1 & arr : _1 }
+      end
+
+      def import_keys(other, namespace, keys)
+        container.merge(build_merge_container(other, keys), namespace: namespace)
+      end
+
+      def import_all(other, namespace)
+        merge_container =
+          if other.exports
+            build_merge_container(other, other.exports)
+          else
+            build_merge_container(other.finalize!, other.keys)
+          end
+
+        container.merge(merge_container, namespace: namespace)
+      end
+
+      def build_merge_container(other, keys)
+        keys.each_with_object(Dry::Container.new) { |key, ic|
+          next unless other.key?(key)
+
+          # Access the other container's items directly so that we can preserve all their
+          # options when we merge them with the target container (e.g. if a component in
+          # the provider container was registered with a block, we want block registration
+          # behavior to be exhibited when later resolving that component from the target
+          # container). TODO: Make this part of dry-system's public API.
+          item = other._container[key]
+
+          # By default, we "protect" components that were themselves imported into the
+          # other container from being implicitly exported; imported components are
+          # considered "private" and must be explicitly included in `exports` to be
+          # exported.
+          next if item.options[:imported] && !other.exports
+
+          if item.callable?
+            ic.register(key, **item.options, imported: true, &item.item)
+          else
+            ic.register(key, item.item, **item.options, imported: true)
+          end
+        }
       end
     end
   end

data/lib/dry/system/indirect_component.rb

@@ -6,7 +6,7 @@ module Dry
   module System
     # An indirect component is a component that cannot be directly from a source file
     # directly managed by the container. It may be component that needs to be loaded
-    # indirectly, either via a manual registration file or an imported container
+    # indirectly, either via a registration manifest file or an imported container
     #
     # Indirect components are an internal abstraction and, unlike ordinary components, are
     # not exposed to users via component dir configuration hooks.

data/lib/dry/system/loader.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "dry/system/errors"
+
 module Dry
   module System
     # Default component loader implementation
@@ -61,7 +63,10 @@ module Dry
         # @api public
         def constant(component)
           inflector = component.inflector
-          inflector.constantize(inflector.camelize(component.const_path))
+          const_name = inflector.camelize(component.const_path)
+          inflector.constantize(const_name)
+        rescue NameError => e
+          raise ComponentNotLoadableError.new(component, e)
         end
 
         private

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
@@ -34,6 +36,7 @@ module Dry
         require(root.join(config.registrations_dir, component.root_key.to_s))
       end
 
+      # @api private
       def file_exists?(component)
         File.exist?(File.join(registrations_dir, "#{component.root_key}#{RB_EXT}"))
       end

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: DEFAULT_OPTIONS }
+          system.setting :bootsnap, default: DEFAULT_OPTIONS
           system.after(:configure, &:setup_bootsnap)
         end
 

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

@@ -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,7 +1,6 @@
 # frozen_string_literal: true
 
-require "dry/system/constants"
-require "dry/system/plugins/dependency_graph/strategies"
+require_relative "dependency_graph/strategies"
 
 module Dry
   module System
@@ -12,36 +11,43 @@ module Dry
         def self.extended(system)
           super
 
-          system.use(:notifications)
+          system.instance_eval do
+            use(:notifications)
 
-          system.before(:configure) do
-            setting :ignored_dependencies, default: []
-          end
-
-          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 injector(**options)
+          super(**options, strategies: DependencyGraph::Strategies)
         end
 
         # @api private
         def register(key, contents = nil, options = {}, &block)
-          super
-          dependency_key = key.to_s
-          unless config.ignored_dependencies.include?(dependency_key)
-            self[:notifications].instrument(
-              :registered_dependency, key: dependency_key, class: self[dependency_key].class
-            )
+          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

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

@@ -8,7 +8,7 @@ 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, default: "log"
@@ -40,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)