dry-system 0.15.0 → 0.19.1

data/lib/dry/system/config/component_dirs.rb

@@ -0,0 +1,184 @@
+require "concurrent/map"
+require "dry/configurable"
+require "dry/system/constants"
+require "dry/system/errors"
+require_relative "component_dir"
+
+module Dry
+  module System
+    module Config
+      class ComponentDirs
+        include Dry::Configurable
+
+        # Settings from ComponentDir are configured here as defaults for all added dirs
+        ComponentDir._settings.each do |setting|
+          _settings << setting.dup
+        end
+
+        # @!group Settings
+
+        # @!method auto_register=(value)
+        #
+        #   Sets a default `auto_register` for all added component dirs
+        #
+        #   @see ComponentDir.auto_register
+        #   @see auto_register
+        #
+        # @!method auto_register
+        #
+        #   Returns the configured default `auto_register`
+        #
+        #   @see auto_register=
+
+        # @!method add_to_load_path=(value)
+        #
+        #   Sets a default `add_to_load_path` value for all added component dirs
+        #
+        #   @see ComponentDir.add_to_load_path
+        #   @see add_to_load_path
+        #
+        # @!method add_to_load_path
+        #
+        #   Returns the configured default `add_to_load_path`
+        #
+        #   @see add_to_load_path=
+
+        # @!method default_namespace=(value)
+        #
+        #   Sets a default `default_namespace` value for all added component dirs
+        #
+        #   @see ComponentDir.default_namespace
+        #   @see default_namespace
+        #
+        # @!method default_namespace
+        #
+        #   Returns the configured default `default_namespace`
+        #
+        #   @see default_namespace=
+
+        # @!method loader=(value)
+        #
+        #   Sets a default `loader` value for all added component dirs
+        #
+        #   @see ComponentDir.loader
+        #   @see loader
+        #
+        # @!method loader
+        #
+        #   Returns the configured default `loader`
+        #
+        #   @see loader=
+
+        # @!method memoize=(value)
+        #
+        #   Sets a default `memoize` value for all added component dirs
+        #
+        #   @see ComponentDir.memoize
+        #   @see memoize
+        #
+        # @!method memoize
+        #
+        #   Returns the configured default `memoize`
+        #
+        #   @see memoize=
+
+        # @!endgroup
+
+        # @api private
+        def initialize
+          @dirs = Concurrent::Map.new
+        end
+
+        # @api private
+        def initialize_copy(source)
+          super
+          @dirs = source.dirs.dup
+        end
+
+        # Adds and configures a component dir
+        #
+        # @param path [String] the path for the component dir, relative to the configured
+        #   container root
+        #
+        # @yieldparam dir [ComponentDir] the component dir to configure
+        #
+        # @return [ComponentDir] the added component dir
+        #
+        # @example
+        #   component_dirs.add "lib" do |dir|
+        #     dir.default_namespace = "my_app"
+        #   end
+        #
+        # @see ComponentDir
+        def add(path)
+          raise ComponentDirAlreadyAddedError, path if dirs.key?(path)
+
+          dirs[path] = ComponentDir.new(path).tap do |dir|
+            apply_defaults_to_dir(dir)
+            yield dir if block_given?
+          end
+        end
+
+        # Returns the added component dirs, with default settings applied
+        #
+        # @return [Hash<String, ComponentDir>] the component dirs as a hash, keyed by path
+        def dirs
+          @dirs.each { |_, dir| apply_defaults_to_dir(dir) }
+        end
+
+        # Returns the added component dirs, with default settings applied
+        #
+        # @return [Array<ComponentDir>]
+        def to_a
+          dirs.values
+        end
+
+        # Calls the given block once for each added component dir, passing the dir as an
+        # argument.
+        #
+        # @yieldparam dir [ComponentDir] the yielded component dir
+        def each(&block)
+          to_a.each(&block)
+        end
+
+        private
+
+        # Apply default settings to a component dir. This is run every time the dirs are
+        # accessed to ensure defaults are applied regardless of when new component dirs
+        # are added. This method must be idempotent.
+        #
+        # @return [void]
+        def apply_defaults_to_dir(dir)
+          dir.config.values.each do |key, _value|
+            if configured?(key) && !dir.configured?(key)
+              dir.public_send(:"#{key}=", public_send(key))
+            end
+          end
+        end
+
+        # Returns true if a setting has been explicitly configured and is not returning
+        # just a default value.
+        #
+        # This is used to determine which settings should be applied to added component
+        # dirs as additional defaults.
+        #
+        # @api private
+        def configured?(key)
+          config._settings[key].input_defined?
+        end
+
+        def method_missing(name, *args, &block)
+          if config.respond_to?(name)
+            config.public_send(name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, include_all = false)
+          config.respond_to?(name) || super
+        end
+      end
+    end
+  end
+end

data/lib/dry/system/constants.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'dry/core/constants'
+require "dry/core/constants"
 
 module Dry
   module System
     include Dry::Core::Constants
 
-    RB_EXT = '.rb'
-    RB_GLOB = '*.rb'
-    PATH_SEPARATOR = '/'
-    DEFAULT_SEPARATOR = '.'
+    RB_EXT = ".rb"
+    RB_GLOB = "*.rb"
+    PATH_SEPARATOR = "/"
+    DEFAULT_SEPARATOR = "."
     WORD_REGEX = /\w+/.freeze
   end
 end

data/lib/dry/system/container.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
-require 'dry-auto_inject'
-require 'dry-configurable'
-require 'dry-container'
-require 'dry/inflector'
-
-require 'dry/core/deprecations'
-
-require 'dry/system'
-require 'dry/system/errors'
-require 'dry/system/loader'
-require 'dry/system/booter'
-require 'dry/system/auto_registrar'
-require 'dry/system/manual_registrar'
-require 'dry/system/importer'
-require 'dry/system/component'
-require 'dry/system/constants'
-require 'dry/system/plugins'
+require "pathname"
+
+require "dry-auto_inject"
+require "dry-configurable"
+require "dry-container"
+require "dry/inflector"
+
+require "dry/core/deprecations"
+
+require "dry/system"
+require "dry/system/errors"
+require "dry/system/booter"
+require "dry/system/auto_registrar"
+require "dry/system/manual_registrar"
+require "dry/system/importer"
+require "dry/system/component"
+require "dry/system/constants"
+require "dry/system/plugins"
+
+require_relative "component_dir"
+require_relative "config/component_dirs"
 
 module Dry
   module System
@@ -48,8 +50,6 @@ module Dry
     #
     # * `:name` - a unique container identifier
     # * `:root` - a system root directory (defaults to `pwd`)
-    # * `:system_dir` - directory name relative to root, where bootable components
-    #                 can be defined in `boot` dir this defaults to `system`
     #
     # @example
     #   class MyApp < Dry::System::Container
@@ -63,7 +63,7 @@ module Dry
     #     end
     #
     #     # this will configure $LOAD_PATH to include your `lib` dir
-    #     load_paths!('lib')
+    #     add_dirs_to_load_paths!('lib')
     #   end
     #
     # @api public
@@ -73,13 +73,12 @@ module Dry
       extend Dry::System::Plugins
 
       setting :name
-      setting :default_namespace
       setting(:root, Pathname.pwd.freeze) { |path| Pathname(path) }
-      setting :system_dir, 'system'
-      setting :registrations_dir, 'container'
-      setting :auto_register, []
+      setting :system_dir, "system"
+      setting :bootable_dirs, ["system/boot"]
+      setting :registrations_dir, "container"
+      setting :component_dirs, Config::ComponentDirs.new, cloneable: true
       setting :inflector, Dry::Inflector.new
-      setting :loader, Dry::System::Loader
       setting :booter, Dry::System::Booter
       setting :auto_registrar, Dry::System::AutoRegistrar
       setting :manual_registrar, Dry::System::ManualRegistrar
@@ -95,7 +94,19 @@ module Dry
           end
         end
 
-        extend Dry::Core::Deprecations['Dry::System::Container']
+        extend Dry::Core::Deprecations["Dry::System::Container"]
+
+        # Define a new configuration setting
+        #
+        # @see https://dry-rb.org/gems/dry-configurable
+        #
+        # @api public
+        def setting(name, *args, &block)
+          super(name, *args, &block)
+          # TODO: dry-configurable needs a public API for this
+          config._settings << _settings[name]
+          self
+        end
 
         # Configures the container
         #
@@ -114,7 +125,6 @@ module Dry
         def configure(&block)
           hooks[:before_configure].each { |hook| instance_eval(&hook) }
           super(&block)
-          load_paths!(config.system_dir)
           hooks[:after_configure].each { |hook| instance_eval(&hook) }
           self
         end
@@ -158,9 +168,10 @@ module Dry
 
         # Registers finalization function for a bootable component
         #
-        # By convention, boot files for components should be placed in
-        # `%{system_dir}/boot` and they will be loaded on demand when components
-        # are loaded in isolation, or during finalization process.
+        # By convention, boot files for components should be placed in a
+        # `bootable_dirs` entry and they will be loaded on demand when
+        # components are loaded in isolation, or during the finalization
+        # process.
         #
         # @example
         #   # system/container.rb
@@ -243,30 +254,24 @@ module Dry
               boot_local(name, **opts, &block)
             end
 
+          booter.register_component component
+
           components[name] = component
         end
         deprecate :finalize, :boot
 
         # @api private
         def boot_external(identifier, from:, key: nil, namespace: nil, &block)
-          component = System.providers[from].component(
+          System.providers[from].component(
             identifier, key: key, namespace: namespace, finalize: block, container: self
           )
-
-          booter.register_component(component)
-
-          component
         end
 
         # @api private
         def boot_local(identifier, namespace: nil, &block)
-          component = Components::Bootable.new(
+          Components::Bootable.new(
             identifier, container: self, namespace: namespace, &block
           )
-
-          booter.register_component(component)
-
-          component
         end
 
         # Return if a container was finalized
@@ -378,7 +383,7 @@ module Dry
           self
         end
 
-        # Sets load paths relative to the container's root dir
+        # Adds the directories (relative to the container's root) to the Ruby load path
         #
         # @example
         #   class MyApp < Dry::System::Container
@@ -386,7 +391,7 @@ module Dry
         #       # ...
         #     end
         #
-        #     load_paths!('lib')
+        #     add_to_load_path!('lib')
         #   end
         #
         # @param [Array<String>] dirs
@@ -394,12 +399,9 @@ module Dry
         # @return [self]
         #
         # @api public
-        def load_paths!(*dirs)
-          dirs.map(&root.method(:join)).each do |path|
-            next if load_paths.include?(path)
-
-            load_paths << path
-            $LOAD_PATH.unshift(path.to_s)
+        def add_to_load_path!(*dirs)
+          dirs.reverse.map(&root.method(:join)).each do |path|
+            $LOAD_PATH.prepend(path.to_s) unless $LOAD_PATH.include?(path.to_s)
           end
           self
         end
@@ -410,47 +412,6 @@ module Dry
           self
         end
 
-        # Auto-registers components from the provided directory
-        #
-        # Typically you want to configure auto_register directories, and it will
-        # work automatically. Use this method in cases where you want to have an
-        # explicit way where some components are auto-registered, or if you want
-        # to exclude some components from being auto-registered
-        #
-        # @example
-        #   class MyApp < Dry::System::Container
-        #     configure do |config|
-        #       # ...
-        #     end
-        #
-        #     # with a dir
-        #     auto_register!('lib/core')
-        #
-        #     # with a dir and a custom registration block
-        #     auto_register!('lib/core') do |config|
-        #       config.instance do |component|
-        #         # custom way of initializing a component
-        #       end
-        #
-        #       config.exclude do |component|
-        #         # return true to exclude component from auto-registration
-        #       end
-        #     end
-        #   end
-        #
-        # @param [String] dir The dir name relative to the root dir
-        #
-        # @yield AutoRegistrar::Configuration
-        # @see AutoRegistrar::Configuration
-        #
-        # @return [self]
-        #
-        # @api public
-        def auto_register!(dir, &block)
-          auto_registrar.(dir, &block)
-          self
-        end
-
         # Builds injector for this container
         #
         # An injector is a useful mixin which injects dependencies into
@@ -476,7 +437,7 @@ module Dry
         # @param options [Hash] injector options
         #
         # @api public
-        def injector(options = { strategies: strategies })
+        def injector(options = {strategies: strategies})
           Dry::AutoInject(self, options)
         end
 
@@ -494,7 +455,7 @@ module Dry
         # @api public
         def require_from_root(*paths)
           paths.flat_map { |path|
-            path.to_s.include?('*') ? ::Dir[root.join(path)].sort : root.join(path)
+            path.to_s.include?("*") ? ::Dir[root.join(path)].sort : root.join(path)
           }.each { |path|
             Kernel.require path.to_s
           }
@@ -519,8 +480,8 @@ module Dry
         end
 
         # @api public
-        def resolve(key, &block)
-          load_component(key, &block) unless finalized?
+        def resolve(key)
+          load_component(key) unless finalized?
 
           super
         end
@@ -551,18 +512,26 @@ module Dry
         end
 
         # @api private
-        def load_paths
-          @load_paths ||= []
+        def component_dirs
+          config.component_dirs.to_a.map { |dir| ComponentDir.new(config: dir, container: self) }
         end
 
         # @api private
         def booter
-          @booter ||= config.booter.new(boot_path)
+          @booter ||= config.booter.new(boot_paths)
         end
 
         # @api private
-        def boot_path
-          root.join("#{config.system_dir}/boot")
+        def boot_paths
+          config.bootable_dirs.map { |dir|
+            dir = Pathname(dir)
+
+            if dir.relative?
+              root.join(dir)
+            else
+              dir
+            end
+          }
         end
 
         # @api private
@@ -580,67 +549,6 @@ module Dry
           @importer ||= config.importer.new(self)
         end
 
-        # @api private
-        def component(identifier, **options)
-          if (component = booter.components.detect { |c| c.identifier == identifier })
-            component
-          else
-            Component.new(
-              identifier,
-              loader: config.loader,
-              namespace: config.default_namespace,
-              separator: config.namespace_separator,
-              inflector: config.inflector,
-              **options
-            )
-          end
-        end
-
-        # @api private
-        def require_component(component)
-          return if registered?(component.identifier)
-
-          raise FileNotFoundError, component unless component.file_exists?(load_paths)
-
-          require_path(component.path)
-
-          yield
-        end
-
-        # Allows subclasses to use a different strategy for required files.
-        #
-        # E.g. apps that use `ActiveSupport::Dependencies::Loadable#require_dependency`
-        # will override this method to allow container managed dependencies to be reloaded
-        # for non-finalized containers.
-        #
-        # @api private
-        def require_path(path)
-          require path
-        end
-
-        # @api private
-        def load_component(key, &block)
-          return self if registered?(key)
-
-          component(key).tap do |component|
-            if component.boot?
-              booter.start(component)
-            else
-              root_key = component.root_key
-
-              if (bootable_dep = component(root_key)).boot?
-                booter.start(bootable_dep)
-              elsif importer.key?(root_key)
-                load_imported_component(component.namespaced(root_key))
-              end
-
-              load_local_component(component, &block) unless registered?(key)
-            end
-          end
-
-          self
-        end
-
         # @api private
         def after(event, &block)
           hooks[:"after_#{event}"] << block
@@ -657,46 +565,87 @@ module Dry
 
         # @api private
         def inherited(klass)
-          new_hooks = Container.hooks.dup
-
           hooks.each do |event, blocks|
-            new_hooks[event].concat(blocks)
-            new_hooks[event].concat(klass.hooks[event])
+            klass.hooks[event].concat blocks.dup
           end
 
-          klass.instance_variable_set(:@hooks, new_hooks)
           klass.instance_variable_set(:@__finalized__, false)
+
           super
         end
 
-        private
+        protected
 
         # @api private
-        def load_local_component(component, default_namespace_fallback = false, &block)
-          if booter.bootable?(component) || component.file_exists?(load_paths)
-            booter.boot_dependency(component) unless finalized?
+        def load_component(key)
+          return self if registered?(key)
 
-            require_component(component) do
-              register(component.identifier) { component.instance }
-            end
-          elsif !default_namespace_fallback
-            load_local_component(component.prepend(config.default_namespace), true, &block)
+          component = component(key)
+
+          if component.bootable?
+            booter.start(component)
+            return self
+          end
+
+          booter.boot_dependency(component)
+          return self if registered?(key)
+
+          if component.file_exists?
+            load_local_component(component)
           elsif manual_registrar.file_exists?(component)
             manual_registrar.(component)
-          elsif block_given?
-            yield
-          else
-            raise ComponentLoadError, component
+          elsif importer.key?(component.identifier.root_key)
+            load_imported_component(component.identifier)
           end
+
+          self
         end
 
-        # @api private
-        def load_imported_component(component)
-          container = importer[component.namespace]
-          container.load_component(component.identifier)
-          importer.(component.namespace, container)
+        private
+
+        def load_local_component(component)
+          if component.auto_register?
+            register(component.identifier, memoize: component.memoize?) { component.instance }
+          end
+        end
+
+        def load_imported_component(identifier)
+          import_namespace = identifier.root_key
+
+          container = importer[import_namespace]
+
+          container.load_component(identifier.dequalified(import_namespace).key)
+
+          importer.(import_namespace, container)
+        end
+
+        def component(identifier)
+          if (bootable_component = booter.find_component(identifier))
+            return bootable_component
+          end
+
+          # Find the first matching component from within the configured component dirs.
+          # If no matching component is found, return a plain component instance with no
+          # associated file path. This fallback is important because the component may
+          # still be loadable via the manual registrar or an imported container.
+          component_dirs.detect { |dir|
+            if (component = dir.component_for_identifier(identifier))
+              break component
+            end
+          } || Component.new(identifier)
         end
       end
+
+      # Default hooks
+      after :configure do
+        # Add appropriately configured component dirs to the load path
+        #
+        # Do this in a single pass to preserve ordering (i.e. earliest dirs win)
+        paths = config.component_dirs.to_a.each_with_object([]) { |dir, arr|
+          arr << dir.path if dir.add_to_load_path
+        }
+        add_to_load_path!(*paths)
+      end
     end
   end
 end