dry-system 0.18.1 → 1.0.1

data/lib/dry/system/container.rb

@@ -2,24 +2,10 @@
 
 require "pathname"
 
-require "dry-auto_inject"
-require "dry-configurable"
-require "dry-container"
+require "dry/configurable"
+require "dry/auto_inject"
 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"
-
 module Dry
   module System
     # Abstract container class to inherit from
@@ -46,7 +32,7 @@ module Dry
     #
     # Every container needs to be configured with following settings:
     #
-    # * `:name` - a unique container identifier
+    # * `:name` - a unique container name
     # * `:root` - a system root directory (defaults to `pwd`)
     #
     # @example
@@ -61,219 +47,234 @@ 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
     class Container
-      extend Dry::Configurable
-      extend Dry::Container::Mixin
+      extend Dry::Core::Container::Mixin
       extend Dry::System::Plugins
 
       setting :name
-      setting :default_namespace
-      setting(:root, Pathname.pwd.freeze) { |path| Pathname(path) }
-      setting :system_dir, "system"
-      setting :bootable_dirs, ["system/boot"]
-      setting :registrations_dir, "container"
-      setting :auto_register, []
-      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
-      setting :importer, Dry::System::Importer
-      setting(:components, {}, reader: true, &:dup)
+      setting :root, default: Pathname.pwd.freeze, constructor: ->(path) { Pathname(path) }
+      setting :provider_dirs, default: ["system/providers"]
+      setting :registrations_dir, default: "system/registrations"
+      setting :component_dirs, default: Config::ComponentDirs.new, cloneable: true
+      setting :exports, reader: true
+      setting :inflector, default: Dry::Inflector.new
+      setting :auto_registrar, default: Dry::System::AutoRegistrar
+      setting :manifest_registrar, default: Dry::System::ManifestRegistrar
+      setting :provider_registrar, default: Dry::System::ProviderRegistrar
+      setting :importer, default: Dry::System::Importer
+
+      # Expect "." as key namespace separator. This is not intended to be user-configurable.
+      config.namespace_separator = KEY_SEPARATOR
 
       class << self
-        def strategies(value = nil)
-          if value
-            @strategies = value
-          else
-            @strategies ||= Dry::AutoInject::Strategies
-          end
-        end
-
-        extend Dry::Core::Deprecations["Dry::System::Container"]
-
-        # Define a new configuration setting
+        # @!method config
+        #   Returns the configuration for the container
         #
-        # @see https://dry-rb.org/gems/dry-configurable
+        #   @example
+        #     container.config.root = "/path/to/app"
+        #     container.config.root # => #<Pathname:/path/to/app>
         #
-        # @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
+        #   @return [Dry::Configurable::Config]
+        #
+        #   @api public
 
-        # Configures the container
+        # Yields a configuration object for the container, which you can use to modify the
+        # configuration, then runs the after-`configured` hooks and finalizes (freezes)
+        # the {config}.
+        #
+        # Does not finalize the config when given `finalize_config: false`
         #
         # @example
         #   class MyApp < Dry::System::Container
         #     configure do |config|
         #       config.root = Pathname("/path/to/app")
         #       config.name = :my_app
-        #       config.auto_register = %w(lib/apis lib/core)
         #     end
         #   end
         #
+        # @param finalize_config [Boolean]
+        #
         # @return [self]
         #
+        # @see after
+        #
         # @api public
-        def configure(&block)
-          hooks[:before_configure].each { |hook| instance_eval(&hook) }
+        def configure(finalize_config: true, &block)
           super(&block)
-          load_paths!(config.system_dir)
+          configured!(finalize_config: finalize_config)
+        end
+
+        # Marks the container as configured, runs the after-`configured` hooks, then
+        # finalizes (freezes) the {config}.
+        #
+        # This method is useful to call if you're modifying the container's {config}
+        # directly, rather than via the config object yielded when calling {configure}.
+        #
+        # Does not finalize the config if given `finalize_config: false`.
+        #
+        # @param finalize_config [Boolean]
+        #
+        # @return [self]
+        #
+        # @see after
+        #
+        # @api public
+        def configured!(finalize_config: true)
+          return self if configured?
+
           hooks[:after_configure].each { |hook| instance_eval(&hook) }
+
+          _configurable_finalize! if finalize_config
+
+          @__configured__ = true
+
           self
         end
 
+        # Finalizes the config for this container
+        #
+        # @api private
+        alias_method :_configurable_finalize!, :finalize!
+
+        def configured?
+          @__configured__.equal?(true)
+        end
+
         # Registers another container for import
         #
         # @example
         #   # system/container.rb
+        #   require "dry/system/container"
+        #   require "logger"
+        #
         #   class Core < Dry::System::Container
-        #     configure do |config|
-        #       config.root = Pathname("/path/to/app")
-        #       config.auto_register = %w(lib/apis lib/core)
-        #     end
+        #     register("logger", Logger.new($stdout))
         #   end
         #
         #   # apps/my_app/system/container.rb
         #   require 'system/container'
         #
         #   class MyApp < Dry::System::Container
-        #     configure do |config|
-        #       config.root = Pathname("/path/to/app")
-        #       config.auto_register = %w(lib/apis lib/core)
-        #     end
-        #
-        #     import core: Core
+        #     import(from: Core, as: :core)
         #   end
         #
-        # @param other [Hash, Dry::Container::Namespace]
+        #   MyApp.import(keys: ["logger"], from: Core, as: :core2)
+        #
+        #   MyApp["core.logger"].info("Test")
+        #   MyApp["core2.logger"].info("Test2")
+        #
+        # @param keys [Array<String>] Keys for the components to import
+        # @param from [Class] The container to import from
+        # @param as [Symbol] Namespace to use for the components of the imported container
+        #
+        # @raise [Dry::System::ContainerAlreadyFinalizedError] if the container has already
+        #  been finalized
         #
         # @api public
-        def import(other)
-          case other
-          when Hash then importer.register(other)
-          when Dry::Container::Namespace then super
-          else
-            raise ArgumentError, <<-STR
-              +other+ must be a hash of names and systems, or a Dry::Container namespace
-            STR
-          end
+        def import(from:, as:, keys: nil)
+          raise Dry::System::ContainerAlreadyFinalizedError if finalized?
+
+          importer.register(container: from, namespace: as, keys: keys)
+
+          self
         end
 
-        # Registers finalization function for a bootable component
+        # rubocop:disable Layout/LineLength
+
+        # @overload register_provider(name, namespace: nil, from: nil, source: nil, if: true, &block)
+        #   Registers a provider and its lifecycle hooks
         #
-        # 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.
+        #   By convention, you should place a file for each provider in one of the
+        #   configured `provider_dirs`, and they will be loaded on demand when components
+        #   are loaded in isolation, or during container finalization.
         #
-        # @example
-        #   # system/container.rb
-        #   class MyApp < Dry::System::Container
-        #     configure do |config|
-        #       config.root = Pathname("/path/to/app")
-        #       config.name = :core
-        #       config.auto_register = %w(lib/apis lib/core)
+        #   @example
+        #     # system/container.rb
+        #     class MyApp < Dry::System::Container
+        #       configure do |config|
+        #         config.root = Pathname("/path/to/app")
+        #       end
         #     end
         #
-        #   # system/boot/db.rb
-        #   #
-        #   # Simple component registration
-        #   MyApp.boot(:db) do |container|
-        #     require 'db'
+        #     # system/providers/db.rb
+        #     #
+        #     # Simple provider registration
+        #     MyApp.register_provider(:db) do
+        #       start do
+        #         require "db"
+        #         register("db", DB.new)
+        #       end
+        #     end
         #
-        #     container.register(:db, DB.new)
-        #   end
+        #     # system/providers/db.rb
+        #     #
+        #     # Provider registration with lifecycle triggers
+        #     MyApp.register_provider(:db) do |container|
+        #       init do
+        #         require "db"
+        #         DB.configure(ENV["DB_URL"])
+        #         container.register("db", DB.new)
+        #       end
         #
-        #   # system/boot/db.rb
-        #   #
-        #   # Component registration with lifecycle triggers
-        #   MyApp.boot(:db) do |container|
-        #     init do
-        #       require 'db'
-        #       DB.configure(ENV['DB_URL'])
-        #       container.register(:db, DB.new)
-        #     end
+        #       start do
+        #         container["db"].establish_connection
+        #       end
         #
-        #     start do
-        #       db.establish_connection
+        #       stop do
+        #         container["db"].close_connection
+        #       end
         #     end
         #
-        #     stop do
-        #       db.close_connection
-        #     end
-        #   end
+        #     # system/providers/db.rb
+        #     #
+        #     # Provider registration which uses another provider
+        #     MyApp.register_provider(:db) do |container|
+        #       start do
+        #         use :logger
         #
-        #   # system/boot/db.rb
-        #   #
-        #   # Component registration which uses another bootable component
-        #   MyApp.boot(:db) do |container|
-        #     use :logger
-        #
-        #     start do
-        #       require 'db'
-        #       DB.configure(ENV['DB_URL'], logger: logger)
-        #       container.register(:db, DB.new)
+        #         require "db"
+        #         DB.configure(ENV['DB_URL'], logger: logger)
+        #         container.register("db", DB.new)
+        #       end
         #     end
-        #   end
         #
-        #   # system/boot/db.rb
-        #   #
-        #   # Component registration under a namespace. This will register the
-        #   # db object under `persistence.db` key
-        #   MyApp.namespace(:persistence) do |persistence|
-        #     require 'db'
-        #     DB.configure(ENV['DB_URL'], logger: logger)
-        #     persistence.register(:db, DB.new)
-        #   end
+        #     # system/providers/db.rb
+        #     #
+        #     # Provider registration under a namespace. This will register the
+        #     # db object with the "persistence.db" key
+        #     MyApp.register_provider(:persistence, namespace: "db") do
+        #       start do
+        #         require "db"
+        #         DB.configure(ENV["DB_URL"])
+        #         register("db", DB.new)
+        #       end
+        #     end
         #
-        # @param name [Symbol] a unique identifier for a bootable component
+        #   @param name [Symbol] a unique name for the provider
+        #   @param namespace [String, nil] the key namespace to use for any registrations
+        #     made during the provider's lifecycle
+        #   @param from [Symbol, nil] the group for the external provider source (with the
+        #     provider source name inferred from `name` or passsed explicitly as
+        #     `source:`)
+        #   @param source [Symbol, nil] the name of the external provider source to use
+        #     (if different from the value provided as `name`)
+        #   @param if [Boolean] a boolean to determine whether to register the provider
         #
-        # @see Lifecycle
+        #   @see Provider
+        #   @see Provider::Source
         #
-        # @return [self]
+        #   @return [self]
         #
-        # @api public
-        def boot(name, **opts, &block)
-          if components.key?(name)
-            raise DuplicatedComponentKeyError, <<-STR
-              Bootable component #{name.inspect} was already registered
-            STR
-          end
-
-          component =
-            if opts[:from]
-              boot_external(name, **opts, &block)
-            else
-              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)
-          System.providers[from].component(
-            identifier, key: key, namespace: namespace, finalize: block, container: self
-          )
+        #   @api public
+        def register_provider(...)
+          providers.register_provider(...)
         end
 
-        # @api private
-        def boot_local(identifier, namespace: nil, &block)
-          Components::Bootable.new(
-            identifier, container: self, namespace: namespace, &block
-          )
-        end
+        # rubocop:enable Layout/LineLength
 
         # Return if a container was finalized
         #
@@ -316,51 +317,55 @@ module Dry
         def finalize!(freeze: true, &block)
           return self if finalized?
 
+          configured!
+
+          hooks[:before_finalize].each { |hook| instance_eval(&hook) }
           yield(self) if block
 
-          importer.finalize!
-          booter.finalize!
-          manual_registrar.finalize!
+          providers.finalize!
           auto_registrar.finalize!
+          manifest_registrar.finalize!
+          importer.finalize!
 
           @__finalized__ = true
 
           self.freeze if freeze
+          hooks[:after_finalize].each { |hook| instance_eval(&hook) }
           self
         end
 
-        # Boots a specific component
+        # Starts a provider
         #
-        # As a result, `init` and `start` lifecycle triggers are called
+        # As a result, the provider's `prepare` and `start` lifecycle triggers are called
         #
         # @example
         #   MyApp.start(:persistence)
         #
-        # @param name [Symbol] the name of a registered bootable component
+        # @param name [Symbol] the name of a registered provider to start
         #
         # @return [self]
         #
         # @api public
         def start(name)
-          booter.start(name)
+          providers.start(name)
           self
         end
 
-        # Boots a specific component but calls only `init` lifecycle trigger
+        # Prepares a provider using its `prepare` lifecycle trigger
         #
-        # This way of booting is useful in places where a heavy dependency is
-        # needed but its started environment is not required
+        # Preparing (as opposed to starting) a provider is useful in places where some
+        # aspects of a heavier dependency are needed, but its fully started environment
         #
         # @example
-        #   MyApp.init(:persistence)
+        #   MyApp.prepare(:persistence)
         #
-        # @param [Symbol] name The name of a registered bootable component
+        # @param name [Symbol] The name of the registered provider to prepare
         #
         # @return [self]
         #
         # @api public
-        def init(name)
-          booter.init(name)
+        def prepare(name)
+          providers.prepare(name)
           self
         end
 
@@ -369,22 +374,23 @@ module Dry
         # @example
         #   MyApp.stop(:persistence)
         #
-        # @param [Symbol] name The name of a registered bootable component
+        # @param name [Symbol] The name of a registered bootable component
         #
         # @return [self]
         #
         # @api public
         def stop(name)
-          booter.stop(name)
+          providers.stop(name)
           self
         end
 
+        # @api public
         def shutdown!
-          booter.shutdown
+          providers.shutdown
           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
@@ -392,68 +398,24 @@ module Dry
         #       # ...
         #     end
         #
-        #     load_paths!('lib')
+        #     add_to_load_path!('lib')
         #   end
         #
-        # @param [Array<String>] dirs
+        # @param dirs [Array<String>]
         #
         # @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
 
         # @api public
         def load_registrations!(name)
-          manual_registrar.(name)
-          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)
+          manifest_registrar.(name)
           self
         end
 
@@ -482,8 +444,8 @@ module Dry
         # @param options [Hash] injector options
         #
         # @api public
-        def injector(options = {strategies: strategies})
-          Dry::AutoInject(self, options)
+        def injector(**options)
+          Dry::AutoInject(self, **options)
         end
 
         # Requires one or more files relative to the container's root
@@ -525,8 +487,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
@@ -535,7 +497,7 @@ module Dry
         #
         # @!method registered?(key)
         #   Whether a +key+ is registered (doesn't trigger loading)
-        #   @param [String,Symbol] key Identifier
+        #   @param key [String,Symbol] The key
         #   @return [Boolean]
         #   @api public
         #
@@ -543,7 +505,7 @@ module Dry
         # Check if identifier is registered.
         # If not, try to load the component
         #
-        # @param [String,Symbol] key Identifier
+        # @param key [String,Symbol] Identifier
         # @return [Boolean]
         #
         # @api public
@@ -557,26 +519,13 @@ 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_paths)
-        end
-
-        # @api private
-        def boot_paths
-          config.bootable_dirs.map { |dir|
-            dir = Pathname(dir)
-
-            if dir.relative?
-              root.join(dir)
-            else
-              dir
-            end
-          }
+        def providers
+          @providers ||= config.provider_registrar.new(self)
         end
 
         # @api private
@@ -585,8 +534,8 @@ module Dry
         end
 
         # @api private
-        def manual_registrar
-          @manual_registrar ||= config.manual_registrar.new(self)
+        def manifest_registrar
+          @manifest_registrar ||= config.manifest_registrar.new(self)
         end
 
         # @api private
@@ -594,74 +543,45 @@ 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.
+        # Registers a callback hook to run before container lifecycle events.
         #
-        # 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.
+        # Currently, the only supported event is `:finalized`. This hook is called when
+        # you run `{finalize!}`.
         #
-        # @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.bootable?
-              booter.start(component)
-            else
-              root_key = component.root_key
-
-              if (root_bootable = component(root_key)).bootable?
-                booter.start(root_bootable)
-              elsif importer.key?(root_key)
-                load_imported_component(component.namespaced(root_key))
-              end
-
-              load_local_component(component, &block) unless registered?(key)
-            end
-          end
-
+        # When the given block is called, `self` is the container class, and no block
+        # arguments are given.
+        #
+        # @param event [Symbol] the event name
+        # @param block [Proc] the callback hook to run
+        #
+        # @return [self]
+        #
+        # @api public
+        def before(event, &block)
+          hooks[:"before_#{event}"] << block
           self
         end
 
-        # @api private
+        # Registers a callback hook to run after container lifecycle events.
+        #
+        # The supported events are:
+        #
+        # - `:configured`, called when you run {configure} or {configured!}, or when
+        #   running {finalize!} and neither of the prior two methods have been called.
+        # - `:finalized`, called when you run {finalize!}.
+        #
+        # When the given block is called, `self` is the container class, and no block
+        # arguments are given.
+        #
+        # @param event [Symbol] the event name
+        # @param block [Proc] the callback hook to run
+        #
+        # @return [self]
+        #
+        # @api public
         def after(event, &block)
           hooks[:"after_#{event}"] << block
-        end
-
-        def before(event, &block)
-          hooks[:"before_#{event}"] << block
+          self
         end
 
         # @api private
@@ -671,45 +591,85 @@ 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(:@__configured__, false)
           klass.instance_variable_set(:@__finalized__, false)
+
           super
         end
 
-        private
+        protected
 
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
         # @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)
-          elsif manual_registrar.file_exists?(component)
-            manual_registrar.(component)
-          elsif block_given?
-            yield
-          else
-            raise ComponentLoadError, component
+          if (provider = providers.find_and_load_provider(key))
+            provider.start
+            return self
+          end
+
+          component = find_component(key)
+
+          providers.start_provider_dependency(component)
+          return self if registered?(key)
+
+          if component.loadable?
+            load_local_component(component)
+          elsif manifest_registrar.file_exists?(component)
+            manifest_registrar.(component)
+          elsif importer.namespace?(component.identifier.root_key)
+            load_imported_component(component.identifier, namespace: component.identifier.root_key)
+          elsif importer.namespace?(nil)
+            load_imported_component(component.identifier, namespace: nil)
           end
+
+          self
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
 
-        # @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, namespace:)
+          return unless importer.namespace?(namespace)
+
+          import_key = identifier.namespaced(from: namespace, to: nil).key
+
+          importer.import(namespace, keys: [import_key])
         end
+
+        def find_component(key)
+          # Find the first matching component from within the configured component dirs.
+          # If no matching component is found, return a null component; this fallback is
+          # important because the component may still be loadable via the manifest
+          # registrar or an imported container.
+          component_dirs.detect { |dir|
+            if (component = dir.component_for_key(key))
+              break component
+            end
+          } || IndirectComponent.new(Identifier.new(key))
+        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