dry-system 0.19.2 → 0.23.0

data/lib/dry/system/component.rb

@@ -17,52 +17,42 @@ module Dry
     #
     # @api public
     class Component
-      include Dry::Equalizer(:identifier, :file_path, :options)
+      include Dry::Equalizer(:identifier, :namespace, :options)
 
       DEFAULT_OPTIONS = {
-        separator: DEFAULT_SEPARATOR,
         inflector: Dry::Inflector.new,
         loader: Loader
       }.freeze
 
       # @!attribute [r] identifier
-      #   @return [String] component's unique identifier
+      #   @return [String] the component's unique identifier
       attr_reader :identifier
 
-      # @!attribute [r] file_path
-      #   @return [String, nil] full path to the component's file, if found
-      attr_reader :file_path
+      # @!attribute [r] namespace
+      #   @return [Dry::System::Config::Namespace] the component's namespace
+      attr_reader :namespace
 
       # @!attribute [r] options
-      #   @return [Hash] component's options
+      #   @return [Hash] the component's options
       attr_reader :options
 
       # @api private
-      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)
+      def initialize(identifier, namespace:, **options)
+        @identifier = identifier
+        @namespace = namespace
+        @options = DEFAULT_OPTIONS.merge(options)
       end
 
+      # Returns true, indicating that the component is directly loadable from the files
+      # managed by the container
+      #
+      # This is the inverse of {IndirectComponent#loadable?}
+      #
+      # @return [TrueClass]
+      #
       # @api private
-      def initialize(identifier, file_path: nil, **options)
-        @identifier = identifier
-        @file_path = file_path
-        @options = options
+      def loadable?
+        true
       end
 
       # Returns the component's instance
@@ -70,43 +60,99 @@ module Dry
       # @return [Object] component's class instance
       # @api public
       def instance(*args)
-        loader.call(self, *args)
+        options[:instance]&.call(self, *args) || loader.call(self, *args)
       end
       ruby2_keywords(:instance) if respond_to?(:ruby2_keywords, true)
 
-      # @api private
-      def bootable?
-        false
-      end
-
+      # Returns the component's unique key
+      #
+      # @return [String] the key
+      #
+      # @see Identifier#key
+      #
+      # @api public
       def key
-        identifier.to_s
-      end
-
-      def path
-        identifier.path
+        identifier.key
       end
 
+      # Returns the root namespace segment of the component's key, as a symbol
+      #
+      # @see Identifier#root_key
+      #
+      # @return [Symbol] the root key
+      #
+      # @api public
       def root_key
         identifier.root_key
       end
 
-      # Returns true if the component has a corresponding file
+      # Returns a path-delimited representation of the compnent, appropriate for passing
+      # to `Kernel#require` to require its source file
       #
-      # @return [Boolean]
-      # @api private
-      def file_exists?
-        !!file_path
+      # The path takes into account the rules of the namespace used to load the component.
+      #
+      # @example Component from a root namespace
+      #   component.key # => "articles.create"
+      #   component.require_path # => "articles/create"
+      #
+      # @example Component from an "admin/" path namespace (with `key: nil`)
+      #   component.key # => "articles.create"
+      #   component.require_path # => "admin/articles/create"
+      #
+      # @see Config::Namespaces#add
+      # @see Config::Namespace
+      #
+      # @return [String] the require path
+      #
+      # @api public
+      def require_path
+        if namespace.path
+          "#{namespace.path}#{PATH_SEPARATOR}#{path_in_namespace}"
+        else
+          path_in_namespace
+        end
+      end
+
+      # Returns an "underscored", path-delimited representation of the component,
+      # appropriate for passing to the inflector for constantizing
+      #
+      # The const path takes into account the rules of the namespace used to load the
+      # component.
+      #
+      # @example Component from a namespace with `const: nil`
+      #   component.key # => "articles.create_article"
+      #   component.const_path # => "articles/create_article"
+      #   component.inflector.constantize(component.const_path) # => Articles::CreateArticle
+      #
+      # @example Component from a namespace with `const: "admin"`
+      #   component.key # => "articles.create_article"
+      #   component.const_path # => "admin/articles/create_article"
+      #   component.inflector.constantize(component.const_path) # => Admin::Articles::CreateArticle
+      #
+      # @see Config::Namespaces#add
+      # @see Config::Namespace
+      #
+      # @return [String] the const path
+      #
+      # @api public
+      def const_path
+        namespace_const_path = namespace.const&.gsub(KEY_SEPARATOR, PATH_SEPARATOR)
+
+        if namespace_const_path
+          "#{namespace_const_path}#{PATH_SEPARATOR}#{path_in_namespace}"
+        else
+          path_in_namespace
+        end
       end
 
       # @api private
       def loader
-        options[:loader]
+        options.fetch(:loader)
       end
 
       # @api private
       def inflector
-        options[:inflector]
+        options.fetch(:inflector)
       end
 
       # @api private
@@ -121,6 +167,17 @@ module Dry
 
       private
 
+      def path_in_namespace
+        identifier_in_namespace =
+          if namespace.key
+            identifier.namespaced(from: namespace.key, to: nil)
+          else
+            identifier
+          end
+
+        identifier_in_namespace.key_with_separator(PATH_SEPARATOR)
+      end
+
       def callable_option?(value)
         if value.respond_to?(:call)
           !!value.call(self)

data/lib/dry/system/component_dir.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "pathname"
+require "dry/system/constants"
 require_relative "constants"
 require_relative "identifier"
 require_relative "magic_comments_parser"
@@ -28,88 +31,126 @@ module Dry
         @container = container
       end
 
-      # Returns a component for a given identifier if a matching component file could be
-      # found within the component dir
+      # Returns a component for the given key if a matching source file is 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
+      # This searches according to the component dir's configured namespaces, in order of
+      # definition, with the first match returned as the component.
       #
-      # @param identifier [String] the identifier string
+      # @param key [String] the component's key
       # @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)
+      def component_for_key(key)
+        config.namespaces.each do |namespace|
+          identifier = Identifier.new(key)
+
+          next unless identifier.start_with?(namespace.key)
+
+          if (file_path = find_component_file(identifier, namespace))
+            return build_component(identifier, namespace, file_path)
+          end
         end
 
-        identifier = identifier.with(namespace: nil)
-        if (file_path = find_component_file(identifier.path))
-          build_component(identifier, file_path)
+        nil
+      end
+
+      def each_component
+        return enum_for(:each_component) unless block_given?
+
+        each_file do |file_path, namespace|
+          yield component_for_path(file_path, namespace)
         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
+      private
 
-        key = Pathname(path).relative_path_from(full_path).to_s
-          .sub(RB_EXT, EMPTY_STRING)
-          .scan(WORD_REGEX)
-          .join(separator)
+      def each_file
+        return enum_for(:each_file) unless block_given?
 
-        identifier = Identifier.new(key, separator: separator)
+        raise ComponentDirNotFoundError, full_path unless Dir.exist?(full_path)
 
-        if identifier.start_with?(default_namespace)
-          identifier = identifier.dequalified(default_namespace, namespace: default_namespace)
+        config.namespaces.each do |namespace|
+          files(namespace).each do |file|
+            yield file, namespace
+          end
         end
+      end
 
-        build_component(identifier, path)
+      def files(namespace)
+        if namespace.path?
+          Dir[File.join(full_path, namespace.path, "**", RB_GLOB)].sort
+        else
+          non_root_paths = config.namespaces.to_a.reject(&:root?).map(&:path)
+
+          Dir[File.join(full_path, "**", RB_GLOB)].reject { |file_path|
+            Pathname(file_path).relative_path_from(full_path).to_s.start_with?(*non_root_paths)
+          }.sort
+        end
       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
-        }
+      # 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
+      def component_for_path(path, namespace)
+        key = Pathname(path).relative_path_from(full_path).to_s
+          .sub(RB_EXT, EMPTY_STRING)
+          .scan(WORD_REGEX)
+          .join(KEY_SEPARATOR)
+
+        identifier = Identifier.new(key)
+          .namespaced(
+            from: namespace.path&.gsub(PATH_SEPARATOR, KEY_SEPARATOR),
+            to: namespace.key
+          )
+
+        build_component(identifier, namespace, path)
       end
 
-      private
+      def find_component_file(identifier, namespace)
+        # To properly find the file within a namespace with a key, we should strip the key
+        # from beginning of our given identifier
+        if namespace.key
+          identifier = identifier.namespaced(from: namespace.key, to: nil)
+        end
 
-      def build_component(identifier, file_path)
+        file_name = "#{identifier.key_with_separator(PATH_SEPARATOR)}#{RB_EXT}"
+
+        component_file =
+          if namespace.path?
+            full_path.join(namespace.path, file_name)
+          else
+            full_path.join(file_name)
+          end
+
+        component_file if component_file.exist?
+      end
+
+      def build_component(identifier, namespace, file_path)
         options = {
           inflector: container.config.inflector,
           **component_options,
           **MagicCommentsParser.(file_path)
         }
 
-        Component.new(identifier, file_path: file_path, **options)
+        Component.new(identifier, namespace: namespace, **options)
       end
 
-      def find_component_file(component_path)
-        component_file = full_path.join("#{component_path}#{RB_EXT}")
-        component_file if component_file.exist?
+      def component_options
+        {
+          auto_register: auto_register,
+          loader: loader,
+          instance: instance,
+          memoize: memoize
+        }
       end
 
       def method_missing(name, *args, &block)

data/lib/dry/system/components.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
-require "dry/system"
+require "dry/core/deprecations"
 
-Dry::System.register_provider(
-  :system,
-  boot_path: Pathname(__dir__).join("system_components").realpath
+Dry::Core::Deprecations.announce(
+  "require \"dry/system/components\"",
+  "Use `require \"dry/system/provider_sources\"` instead",
+  tag: "dry-system",
+  uplevel: 1
 )
+
+require_relative "provider_sources"