dry-system 0.15.0 → 0.19.1

data/lib/dry/system/component.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require 'concurrent/map'
+require "concurrent/map"
 
-require 'dry-equalizer'
-require 'dry/inflector'
-require 'dry/system/loader'
-require 'dry/system/errors'
-require 'dry/system/constants'
+require "dry/core/equalizer"
+require "dry/inflector"
+require "dry/system/loader"
+require "dry/system/errors"
+require "dry/system/constants"
+require_relative "identifier"
 
 module Dry
   module System
@@ -14,157 +15,118 @@ module Dry
     # They expose an API to query this information and use a configurable
     # loader object to initialize class instances.
     #
-    # Components are created automatically through auto-registration and can be
-    # accessed through `Container.auto_register!` which yields them.
-    #
     # @api public
     class Component
-      include Dry::Equalizer(:identifier, :path)
+      include Dry::Equalizer(:identifier, :file_path, :options)
 
       DEFAULT_OPTIONS = {
         separator: DEFAULT_SEPARATOR,
-        namespace: nil,
-        inflector: Dry::Inflector.new
+        inflector: Dry::Inflector.new,
+        loader: Loader
       }.freeze
 
       # @!attribute [r] identifier
       #   @return [String] component's unique identifier
       attr_reader :identifier
 
-      # @!attribute [r] path
-      #   @return [String] component's relative path
-      attr_reader :path
-
-      # @!attribute [r] file
-      #   @return [String] component's file name
-      attr_reader :file
+      # @!attribute [r] file_path
+      #   @return [String, nil] full path to the component's file, if found
+      attr_reader :file_path
 
       # @!attribute [r] options
       #   @return [Hash] component's options
       attr_reader :options
 
-      # @!attribute [r] loader
-      #   @return [Object#call] component's loader object
-      attr_reader :loader
-
       # @api private
-      def self.new(*args, &block)
-        cache.fetch_or_store([*args, block].hash) do
-          name, options = args
-          options = DEFAULT_OPTIONS.merge(options || EMPTY_HASH)
-
-          ns, sep, inflector = options.values_at(:namespace, :separator, :inflector)
-          identifier = extract_identifier(name, ns, sep)
-
-          path = name.to_s.gsub(sep, PATH_SEPARATOR)
-          loader = options.fetch(:loader, Loader).new(path, inflector)
-
-          super(identifier, path, options.merge(loader: loader))
-        end
-      end
-
-      # @api private
-      def self.extract_identifier(name, ns, sep)
-        name_s = name.to_s
-        identifier = ns ? remove_namespace_from_name(name_s, ns) : name_s
-
-        identifier.scan(WORD_REGEX).join(sep)
-      end
-
-      # @api private
-      def self.remove_namespace_from_name(name, ns)
-        match_value = name.match(/^(?<remove_namespace>#{ns})(?<separator>\W)(?<identifier>.*)/)
-
-        match_value ? match_value[:identifier] : name
+      def self.new(identifier, options = EMPTY_HASH)
+        options = DEFAULT_OPTIONS.merge(options)
+
+        namespace = options.delete(:namespace)
+        separator = options.delete(:separator)
+
+        identifier =
+          if identifier.is_a?(Identifier)
+            identifier
+          else
+            Identifier.new(
+              identifier,
+              namespace: namespace,
+              separator: separator
+            )
+          end
+
+        super(identifier, **options)
       end
 
       # @api private
-      def self.cache
-        @cache ||= Concurrent::Map.new
-      end
-
-      # @api private
-      def initialize(identifier, path, options)
+      def initialize(identifier, file_path: nil, **options)
         @identifier = identifier
-        @path = path
+        @file_path = file_path
         @options = options
-        @file = "#{path}#{RB_EXT}"
-        @loader = options.fetch(:loader)
-        freeze
       end
 
-      # Returns components instance
-      #
-      # @example
-      #   class MyApp < Dry::System::Container
-      #     configure do |config|
-      #       config.name = :my_app
-      #       config.root = Pathname('/my/app')
-      #     end
-      #
-      #     auto_register!('lib/clients') do |component|
-      #       # some custom initialization logic, ie:
-      #       constant = component.loader.constant
-      #       constant.create
-      #     end
-      #   end
+      # Returns the component's instance
       #
       # @return [Object] component's class instance
-      #
       # @api public
       def instance(*args)
-        loader.call(*args)
+        loader.call(self, *args)
       end
       ruby2_keywords(:instance) if respond_to?(:ruby2_keywords, true)
 
       # @api private
-      def boot?
+      def bootable?
         false
       end
 
-      # @api private
-      def file_exists?(paths)
-        paths.any? { |path| path.join(file).exist? }
+      def key
+        identifier.to_s
       end
 
-      # @api private
-      def prepend(name)
-        self.class.new(
-          [name, identifier].join(separator), options.merge(loader: loader.class)
-        )
+      def path
+        identifier.path
+      end
+
+      def root_key
+        identifier.root_key
       end
 
+      # Returns true if the component has a corresponding file
+      #
+      # @return [Boolean]
       # @api private
-      def namespaced(namespace)
-        self.class.new(
-          path, options.merge(loader: loader.class, namespace: namespace)
-        )
+      def file_exists?
+        !!file_path
       end
 
       # @api private
-      def separator
-        options[:separator]
+      def loader
+        options[:loader]
       end
 
       # @api private
-      def namespace
-        options[:namespace]
+      def inflector
+        options[:inflector]
       end
 
       # @api private
       def auto_register?
-        !!options.fetch(:auto_register) { true }
+        callable_option?(options[:auto_register])
       end
 
       # @api private
-      def root_key
-        namespaces.first
+      def memoize?
+        callable_option?(options[:memoize])
       end
 
       private
 
-      def namespaces
-        identifier.split(separator).map(&:to_sym)
+      def callable_option?(value)
+        if value.respond_to?(:call)
+          !!value.call(self)
+        else
+          !!value
+        end
       end
     end
   end

data/lib/dry/system/component_dir.rb

@@ -0,0 +1,128 @@
+require "pathname"
+require_relative "constants"
+require_relative "identifier"
+require_relative "magic_comments_parser"
+
+module Dry
+  module System
+    # A configured component directory within the container's root. Provides access to the
+    # component directory's configuration, as well as methods for locating component files
+    # within the directory
+    #
+    # @see Dry::System::Config::ComponentDir
+    # @api private
+    class ComponentDir
+      # @!attribute [r] config
+      #   @return [Dry::System::Config::ComponentDir] the component directory configuration
+      #   @api private
+      attr_reader :config
+
+      # @!attribute [r] container
+      #   @return [Dry::System::Container] the container managing the component directory
+      #   @api private
+      attr_reader :container
+
+      # @api private
+      def initialize(config:, container:)
+        @config = config
+        @container = container
+      end
+
+      # Returns a component for a given identifier if a matching component file could be
+      # found within the component dir
+      #
+      # This will search within the component dir's configured default_namespace first,
+      # then fall back to searching for a non-namespaced file
+      #
+      # @param identifier [String] the identifier string
+      # @return [Dry::System::Component, nil] the component, if found
+      #
+      # @api private
+      def component_for_identifier(identifier)
+        identifier = Identifier.new(
+          identifier,
+          namespace: default_namespace,
+          separator: container.config.namespace_separator
+        )
+
+        if (file_path = find_component_file(identifier.path))
+          return build_component(identifier, file_path)
+        end
+
+        identifier = identifier.with(namespace: nil)
+        if (file_path = find_component_file(identifier.path))
+          build_component(identifier, file_path)
+        end
+      end
+
+      # Returns a component for a full path to a Ruby source file within the component dir
+      #
+      # @param path [String] the full path to the file
+      # @return [Dry::System::Component] the component
+      #
+      # @api private
+      def component_for_path(path)
+        separator = container.config.namespace_separator
+
+        key = Pathname(path).relative_path_from(full_path).to_s
+          .sub(RB_EXT, EMPTY_STRING)
+          .scan(WORD_REGEX)
+          .join(separator)
+
+        identifier = Identifier.new(key, separator: separator)
+
+        if identifier.start_with?(default_namespace)
+          identifier = identifier.dequalified(default_namespace, namespace: default_namespace)
+        end
+
+        build_component(identifier, path)
+      end
+
+      # Returns the full path of the component directory
+      #
+      # @return [Pathname]
+      # @api private
+      def full_path
+        container.root.join(path)
+      end
+
+      # @api private
+      def component_options
+        {
+          auto_register: auto_register,
+          loader: loader,
+          memoize: memoize
+        }
+      end
+
+      private
+
+      def build_component(identifier, file_path)
+        options = {
+          inflector: container.config.inflector,
+          **component_options,
+          **MagicCommentsParser.(file_path)
+        }
+
+        Component.new(identifier, file_path: file_path, **options)
+      end
+
+      def find_component_file(component_path)
+        component_file = full_path.join("#{component_path}#{RB_EXT}")
+        component_file if component_file.exist?
+      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

data/lib/dry/system/components.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/system'
+require "dry/system"
 
 Dry::System.register_provider(
   :system,
-  boot_path: Pathname(__dir__).join('system_components').realpath
+  boot_path: Pathname(__dir__).join("system_components").realpath
 )

data/lib/dry/system/components/bootable.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'dry/system/lifecycle'
-require 'dry/system/settings'
-require 'dry/system/components/config'
-require 'dry/system/constants'
+require "dry/system/lifecycle"
+require "dry/system/settings"
+require "dry/system/components/config"
+require "dry/system/constants"
 
 module Dry
   module System
@@ -70,7 +70,7 @@ module Dry
           @config = nil
           @config_block = nil
           @identifier = identifier
-          @triggers = { before: TRIGGER_MAP.dup, after: TRIGGER_MAP.dup }
+          @triggers = {before: TRIGGER_MAP.dup, after: TRIGGER_MAP.dup}
           @options = block ? options.merge(block: block) : options
           @namespace = options[:namespace]
           finalize = options[:finalize] || DEFAULT_FINALIZE
@@ -229,38 +229,10 @@ module Dry
         # @return [TrueClass]
         #
         # @api private
-        def boot?
+        def bootable?
           true
         end
 
-        # Return path to component's boot file
-        #
-        # @return [String]
-        #
-        # @api private
-        def boot_file
-          container_boot_files
-            .detect { |path| Pathname(path).basename(RB_EXT).to_s == identifier.to_s }
-        end
-
-        # Return path to boot dir
-        #
-        # @return [String]
-        #
-        # @api private
-        def boot_path
-          container.boot_path
-        end
-
-        # Return all boot files defined under container's boot path
-        #
-        # @return [String]
-        #
-        # @api private
-        def container_boot_files
-          ::Dir[container.boot_path.join("**/#{RB_GLOB}")].sort
-        end
-
         private
 
         # Return lifecycle object used for this component

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

@@ -21,8 +21,8 @@ module Dry
         private
 
         def method_missing(meth, value = nil)
-          if meth.to_s.end_with?('=')
-            @settings[meth.to_s.gsub('=', '').to_sym] = value
+          if meth.to_s.end_with?("=")
+            @settings[meth.to_s.gsub("=", "").to_sym] = value
           elsif @settings.key?(meth)
             @settings[meth]
           else

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

@@ -0,0 +1,202 @@
+require "dry/configurable"
+require "dry/system/loader"
+
+module Dry
+  module System
+    module Config
+      class ComponentDir
+        include Dry::Configurable
+
+        # @!group Settings
+
+        # @!method auto_register=(policy)
+        #
+        #   Sets the auto-registration policy for the component dir.
+        #
+        #   This may be a simple boolean to enable or disable auto-registration for all
+        #   components, or a proc accepting a `Dry::Sytem::Component` and returning a
+        #   boolean to configure auto-registration on a per-component basis
+        #
+        #   Defaults to `true`.
+        #
+        #   @param policy [Boolean, Proc]
+        #   @return [Boolean, Proc]
+        #
+        #   @example
+        #     dir.auto_register = false
+        #
+        #   @example
+        #     dir.auto_register = proc do |component|
+        #       !component.start_with?("entities")
+        #     end
+        #
+        #   @see auto_register
+        #   @see Component
+        #
+        # @!method auto_register
+        #
+        #   Returns the configured auto-registration policy.
+        #
+        #   @return [Boolean, Proc] the configured policy
+        #
+        #   @see auto_register=
+        setting :auto_register, true
+
+        # @!method add_to_load_path=(policy)
+        #
+        #   Sets whether the dir should be added to the `$LOAD_PATH` after the container
+        #   is configured.
+        #
+        #   Defaults to `true`. This may need to be set to `false` when using a class
+        #   autoloading system.
+        #
+        #   @param policy [Boolean]
+        #   @return [Boolean]
+        #
+        #   @see add_to_load_path
+        #   @see Container.configure
+        #
+        # @!method add_to_load_path
+        #
+        #   Returns the configured value.
+        #
+        #   @return [Boolean]
+        #
+        #   @see add_to_load_path=
+        setting :add_to_load_path, true
+
+        # @!method default_namespace=(leading_namespace)
+        #
+        #   Sets the leading namespace segments to be stripped when registering components
+        #   from the dir in the container.
+        #
+        #   This is useful to configure when the dir contains components in a module
+        #   namespace that you don't want repeated in their identifiers.
+        #
+        #   Defaults to `nil`.
+        #
+        #   @param leading_namespace [String, nil]
+        #   @return [String, nil]
+        #
+        #   @example
+        #     dir.default_namespace = "my_app"
+        #
+        #   @example
+        #     dir.default_namespace = "my_app.admin"
+        #
+        #   @see default_namespace
+        #
+        # @!method default_namespace
+        #
+        #   Returns the configured value.
+        #
+        #   @return [String, nil]
+        #
+        #   @see default_namespace=
+        setting :default_namespace
+
+        # @!method loader=(loader)
+        #
+        #   Sets the loader to use when registering coponents from the dir in the container.
+        #
+        #   Defaults to `Dry::System::Loader`.
+        #
+        #   When using a class autoloader, consider using `Dry::System::Loader::Autoloading`
+        #
+        #   @param loader [#call] the loader
+        #   @return [#call] the configured loader
+        #
+        #   @see loader
+        #   @see Loader
+        #   @see Loader::Autoloading
+        #
+        # @!method loader
+        #
+        #   Returns the configured loader.
+        #
+        #   @return [#call]
+        #
+        #   @see loader=
+        setting :loader, Dry::System::Loader
+
+        # @!method memoize=(policy)
+        #
+        #   Sets whether to memoize components from the dir when registered in the
+        #   container.
+        #
+        #   This may be a simple boolean to enable or disable memoization for all
+        #   components, or a proc accepting a `Dry::Sytem::Component` and returning a
+        #   boolean to configure memoization on a per-component basis
+        #
+        #   Defaults to `false`.
+        #
+        #   @param policy [Boolean, Proc]
+        #   @return [Boolean, Proc] the configured memoization policy
+        #
+        #   @example
+        #     dir.memoize = true
+        #
+        #   @example
+        #     dir.memoize = proc do |component|
+        #       !component.start_with?("providers")
+        #     end
+        #
+        #   @see memoize
+        #   @see Component
+        #
+        # @!method memoize
+        #
+        #   Returns the configured memoization policy.
+        #
+        #   @return [Boolean, Proc] the configured memoization policy
+        #
+        #   @see memoize=
+        setting :memoize, false
+
+        # @!endgroup
+
+        # Returns the component dir path, relative to the configured container root
+        #
+        # @return [String] the path
+        attr_reader :path
+
+        # @api private
+        def initialize(path)
+          super()
+          @path = path
+          yield self if block_given?
+        end
+
+        # @api private
+        def auto_register?
+          !!config.auto_register
+        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 from `ComponentDirs` should be applied
+        # as additional defaults.
+        #
+        # @api private
+        def configured?(key)
+          config._settings[key].input_defined?
+        end
+
+        private
+
+        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