dry-system 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed86f20c6700f29644fe61cc3bd215f50b93177963eb67076523cbf295f18051
-  data.tar.gz: b7ec3d205804cc17033450f7585c809f6a9942ea89fea906799cb02c94e2b64b
+  metadata.gz: 1c0977524fa33277150e8611a851c557461c14357e1a5d9c1f1929c283f3c9b3
+  data.tar.gz: 12de5eaa25ede9f5f959cd77e2af8f1d3b4b287aaebea1554c2915433743c290
 SHA512:
-  metadata.gz: b422ce21011d20c5fedd6eab5cae91c0f03e7ee42d2f7e279b915fbba6826477bfa3393933f4e56417a6f284a2782f56ec184843cae8364a69e1073199d70c05
-  data.tar.gz: f2ded5f38dd0fffc72f6262f0c844b430e26f5b411ffd576284c02ec379bbd4b0638c83cae4070d283891f99376b1a6c5700fe453ba938ae4ef17e26cdbf47c5
+  metadata.gz: 6976cb749c98ed536c5fb3e6ca67674aee2707b40cd5d196b6b82472edadfa10877bebac77631b0ebcc5fabe008514ed60e7d9be17ccd1343e8967836f319a11
+  data.tar.gz: fd894f982bf214dac3ccfa0de1d4fd7f95beeea1f91234cd2868dfab4687b76ea831c153b429d8ba9bd9f04bcb46dd2815f87a7829e6b347b2d8992cf0ebd478

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 <!--- DO NOT EDIT THIS FILE - IT'S AUTOMATICALLY GENERATED VIA DEVTOOLS --->
 
+## 0.21.0 2021-11-01
+
+
+### Added
+
+- Added **component dir namespaces** as a way to specify multiple, ordered, independent namespace rules within a given component dir. This replaces and expands upon the namespace support we previously provided via the singular `default_namespace` component dir setting (@timriley in #181)
+
+### Changed
+
+- `default_namespace` setting on component dirs has been deprecated. Add a component dir namespace instead, e.g. instead of:
+
+  ```ruby
+  # Inside Dry::System::Container.configure
+  config.component_dirs.add "lib" do |dir|
+    dir.default_namespace = "admin"
+  end
+  ```
+
+  Add this:
+
+  ```ruby
+  config.component_dirs.add "lib" do |dir|
+    dir.namespaces.add "admin", key: nil
+  end
+  ```
+
+  (@timriley in #181)
+- `Dry::System::Component#path` has been removed and replaced by `Component#require_path` and `Component#const_path` (@timriley in #181)
+- Unused `Dry::System::FileNotFoundError` and `Dry::System::InvalidComponentIdentifierTypeError` errors have been removed (@timriley in #194)
+
+[Compare v0.20.0...v0.21.0](https://github.com/dry-rb/dry-system/compare/v0.20.0...v0.21.0)
+
 ## 0.20.0 2021-09-12
 
 

data/README.md

@@ -23,7 +23,7 @@
 This library officially supports the following Ruby versions:
 
 * MRI `>= 2.6.0`
-* ~~jruby~~ `>= 9.3` (we are waiting for [2.6 support](https://github.com/jruby/jruby/issues/6161))
+* jruby `>= 9.3`
 
 ## License
 

data/lib/dry/system/auto_registrar.rb

@@ -29,7 +29,7 @@ module Dry
 
       # @api private
       def call(component_dir)
-        components(component_dir).each do |component|
+        component_dir.each_component do |component|
           next unless register_component?(component)
 
           container.register(component.key, memoize: component.memoize?) { component.instance }
@@ -38,18 +38,6 @@ module Dry
 
       private
 
-      def components(component_dir)
-        files(component_dir.full_path).map { |file_path|
-          component_dir.component_for_path(file_path)
-        }
-      end
-
-      def files(dir)
-        raise ComponentDirNotFoundError, dir unless Dir.exist?(dir)
-
-        Dir["#{dir}/**/#{RB_GLOB}"].sort
-      end
-
       def register_component?(component)
         !container.registered?(component.key) && component.auto_register?
       end

data/lib/dry/system/booter/component_registry.rb

@@ -21,13 +21,13 @@ module Dry
         end
 
         def exists?(name)
-          components.any? { |component| component.identifier == name }
+          components.any? { |component| component.name == name }
         end
 
         def [](name)
-          component = components.detect { |component| component.identifier == name }
+          component = components.detect { |c| c.name == name }
 
-          component || raise(InvalidComponentIdentifierError, name)
+          component || raise(InvalidComponentNameError, name)
         end
       end
     end

data/lib/dry/system/booter.rb

@@ -179,15 +179,15 @@ module Dry
       end
 
       def load_component(path)
-        identifier = Pathname(path).basename(RB_EXT).to_s.to_sym
+        name = Pathname(path).basename(RB_EXT).to_s.to_sym
 
-        Kernel.require path unless components.exists?(identifier)
+        Kernel.require path unless components.exists?(name)
 
         self
       end
 
-      def require_boot_file(identifier)
-        boot_file = find_boot_file(identifier)
+      def require_boot_file(name)
+        boot_file = find_boot_file(name)
 
         Kernel.require boot_file if boot_file
       end

data/lib/dry/system/component.rb

@@ -17,7 +17,7 @@ module Dry
     #
     # @api public
     class Component
-      include Dry::Equalizer(:identifier, :file_path, :options)
+      include Dry::Equalizer(:identifier, :namespace, :options)
 
       DEFAULT_OPTIONS = {
         separator: DEFAULT_SEPARATOR,
@@ -26,43 +26,34 @@ module Dry
       }.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
@@ -74,39 +65,95 @@ module Dry
       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(identifier.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 +168,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,40 +31,101 @@ 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)
+        namespaces.each do |namespace|
+          identifier = Identifier.new(key, separator: container.config.namespace_separator)
+
+          next unless identifier.start_with?(namespace.key)
+
+          if (file_path = find_component_file(identifier, namespace))
+            return build_component(identifier, namespace, file_path)
+          end
+        end
+
+        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
+
+      private
+
+      def namespaces
+        config.namespaces.to_a.map { |namespace| normalize_namespace(namespace) }
+      end
 
-        identifier = identifier.with(namespace: nil)
-        if (file_path = find_component_file(identifier.path))
-          build_component(identifier, file_path)
+      # Returns an array of "normalized" namespaces, safe for loading components
+      #
+      # This works around the issue of a namespace being added for a nested path but
+      # _without_ specifying a key namespace. In this case, the key namespace will defaut
+      # to match the path, meaning it will contain path separators instead of the
+      # container's configured `namespace_separator` (due to `Config::Namespaces` not
+      # being able to know the configured `namespace_separator`), so we need to replace
+      # the path separators with the proper `namespace_separator` here (where we _do_ know
+      # what it is).
+      def normalize_namespace(namespace)
+        if namespace.path&.include?(PATH_SEPARATOR) && namespace.default_key?
+          namespace = namespace.class.new(
+            path: namespace.path,
+            key: namespace.key.gsub(PATH_SEPARATOR, container.config.namespace_separator),
+            const: namespace.const
+          )
         end
+
+        namespace
+      end
+
+      def each_file
+        return enum_for(:each_file) unless block_given?
+
+        raise ComponentDirNotFoundError, full_path unless Dir.exist?(full_path)
+
+        namespaces.each do |namespace|
+          files(namespace).each do |file|
+            yield file, namespace
+          end
+        end
+      end
+
+      def files(namespace)
+        if namespace.path?
+          Dir[File.join(full_path, namespace.path, "**", RB_GLOB)].sort
+        else
+          non_root_paths = 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]
+      def full_path
+        container.root.join(path)
       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)
+      def component_for_path(path, namespace)
         separator = container.config.namespace_separator
 
         key = Pathname(path).relative_path_from(full_path).to_s
@@ -70,46 +134,49 @@ module Dry
           .join(separator)
 
         identifier = Identifier.new(key, separator: separator)
+          .namespaced(
+            from: namespace.path&.gsub(PATH_SEPARATOR, separator),
+            to: namespace.key
+          )
+
+        build_component(identifier, namespace, path)
+      end
 
-        if identifier.start_with?(default_namespace)
-          identifier = identifier.dequalified(default_namespace, namespace: default_namespace)
+      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
 
-        build_component(identifier, path)
-      end
+        file_name = "#{identifier.key_with_separator(PATH_SEPARATOR)}#{RB_EXT}"
 
-      # Returns the full path of the component directory
-      #
-      # @return [Pathname]
-      # @api private
-      def full_path
-        container.root.join(path)
-      end
+        component_file =
+          if namespace.path?
+            full_path.join(namespace.path, file_name)
+          else
+            full_path.join(file_name)
+          end
 
-      # @api private
-      def component_options
-        {
-          auto_register: auto_register,
-          loader: loader,
-          memoize: memoize
-        }
+        component_file if component_file.exist?
       end
 
-      private
-
-      def build_component(identifier, file_path)
+      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,
+          memoize: memoize
+        }
       end
 
       def method_missing(name, *args, &block)

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

@@ -47,9 +47,9 @@ module Dry
       class Bootable
         DEFAULT_FINALIZE = proc {}
 
-        # @!attribute [r] identifier
-        #   @return [Symbol] component's unique identifier
-        attr_reader :identifier
+        # @!attribute [r] key
+        #   @return [Symbol] component's unique name
+        attr_reader :name
 
         # @!attribute [r] options
         #   @return [Hash] component's options
@@ -66,10 +66,10 @@ module Dry
         TRIGGER_MAP = Hash.new { |h, k| h[k] = [] }.freeze
 
         # @api private
-        def initialize(identifier, options = {}, &block)
+        def initialize(name, options = {}, &block)
           @config = nil
           @config_block = nil
-          @identifier = identifier
+          @name = name
           @triggers = {before: TRIGGER_MAP.dup, after: TRIGGER_MAP.dup}
           @options = block ? options.merge(block: block) : options
           @namespace = options[:namespace]
@@ -149,7 +149,7 @@ module Dry
           if block
             @settings_block = block
           elsif @settings_block
-            @settings = Settings::DSL.new(identifier, &@settings_block).call
+            @settings = Settings::DSL.new(&@settings_block).call
           else
             @settings
           end
@@ -211,8 +211,8 @@ module Dry
         # @return [Dry::Struct]
         #
         # @api private
-        def new(identifier, new_options = EMPTY_HASH)
-          self.class.new(identifier, options.merge(new_options))
+        def new(name, new_options = EMPTY_HASH)
+          self.class.new(name, options.merge(new_options))
         end
 
         # Return a new instance with updated options
@@ -221,16 +221,7 @@ module Dry
         #
         # @api private
         def with(new_options)
-          self.class.new(identifier, options.merge(new_options))
-        end
-
-        # Return true
-        #
-        # @return [TrueClass]
-        #
-        # @api private
-        def bootable?
-          true
+          self.class.new(name, options.merge(new_options))
         end
 
         private
@@ -256,7 +247,7 @@ module Dry
           when String, Symbol
             container.namespace(namespace) { |c| return c }
           when true
-            container.namespace(identifier) { |c| return c }
+            container.namespace(name) { |c| return c }
           when nil
             container
           else