dry-system 0.18.1 → 1.0.1

data/README.md

@@ -1,3 +1,4 @@
+<!--- this file is synced from dry-rb/template-gem project -->
 [gem]: https://rubygems.org/gems/dry-system
 [actions]: https://github.com/dry-rb/dry-system/actions
 [codacy]: https://www.codacy.com/gh/dry-rb/dry-system
@@ -10,19 +11,19 @@
 [![CI Status](https://github.com/dry-rb/dry-system/workflows/ci/badge.svg)][actions]
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/3a0e30d0ae2542c7ba047ba5f923c0bb)][codacy]
 [![Codacy Badge](https://api.codacy.com/project/badge/Coverage/3a0e30d0ae2542c7ba047ba5f923c0bb)][codacy]
-[![Inline docs](http://inch-ci.org/github/dry-rb/dry-system.svg?branch=master)][inchpages]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-system.svg?branch=main)][inchpages]
 
 ## Links
 
-* [User documentation](http://dry-rb.org/gems/dry-system)
+* [User documentation](https://dry-rb.org/gems/dry-system)
 * [API documentation](http://rubydoc.info/gems/dry-system)
 
 ## Supported Ruby versions
 
 This library officially supports the following Ruby versions:
 
-* MRI >= `2.4`
-* jruby >= `9.2`
+* MRI `>= 2.7.0`
+* jruby `>= 9.3` (postponed until 2.7 is supported)
 
 ## License
 

data/dry-system.gemspec

@@ -1,41 +1,38 @@
 # frozen_string_literal: true
-# this file is managed by dry-rb/devtools project
 
-lib = File.expand_path('lib', __dir__)
+# this file is synced from dry-rb/template-gem project
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'dry/system/version'
+require "dry/system/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'dry-system'
+  spec.name          = "dry-system"
   spec.authors       = ["Piotr Solnica"]
   spec.email         = ["piotr.solnica@gmail.com"]
-  spec.license       = 'MIT'
+  spec.license       = "MIT"
   spec.version       = Dry::System::VERSION.dup
 
   spec.summary       = "Organize your code into reusable components"
   spec.description   = spec.summary
-  spec.homepage      = 'https://dry-rb.org/gems/dry-system'
+  spec.homepage      = "https://dry-rb.org/gems/dry-system"
   spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-system.gemspec", "lib/**/*"]
-  spec.bindir        = 'bin'
+  spec.bindir        = "bin"
   spec.executables   = []
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
-  spec.metadata['changelog_uri']     = 'https://github.com/dry-rb/dry-system/blob/master/CHANGELOG.md'
-  spec.metadata['source_code_uri']   = 'https://github.com/dry-rb/dry-system'
-  spec.metadata['bug_tracker_uri']   = 'https://github.com/dry-rb/dry-system/issues'
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-system/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/dry-rb/dry-system"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/dry-rb/dry-system/issues"
 
-  spec.required_ruby_version = ">= 2.4.0"
+  spec.required_ruby_version = ">= 2.7.0"
 
   # to update dependencies edit project.yml
-  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_runtime_dependency "dry-auto_inject", ">= 0.4.0"
-  spec.add_runtime_dependency "dry-configurable", "~> 0.11", ">= 0.11.1"
-  spec.add_runtime_dependency "dry-container", "~> 0.7", ">= 0.7.2"
-  spec.add_runtime_dependency "dry-core", "~> 0.3", ">= 0.3.1"
-  spec.add_runtime_dependency "dry-equalizer", "~> 0.2"
-  spec.add_runtime_dependency "dry-inflector", "~> 0.1", ">= 0.1.2"
-  spec.add_runtime_dependency "dry-struct", "~> 1.0"
+  spec.add_runtime_dependency "dry-auto_inject", "~> 1.0", "< 2"
+  spec.add_runtime_dependency "dry-configurable", "~> 1.0", "< 2"
+  spec.add_runtime_dependency "dry-core", "~> 1.0", "< 2"
+  spec.add_runtime_dependency "dry-inflector", "~> 1.0", "< 2"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/lib/dry/system/auto_registrar.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "dry/system/constants"
-require "dry/system/magic_comments_parser"
-require "dry/system/auto_registrar/configuration"
 
 module Dry
   module System
@@ -17,83 +15,30 @@ module Dry
     class AutoRegistrar
       attr_reader :container
 
-      attr_reader :config
-
       def initialize(container)
         @container = container
-        @config = container.config
       end
 
       # @api private
       def finalize!
-        Array(config.auto_register).each { |dir| call(dir) }
-      end
-
-      # @api private
-      def call(dir)
-        registration_config = Configuration.new
-        yield(registration_config) if block_given?
-        components(dir).each do |component|
-          next if !component.auto_register? || registration_config.exclude.(component)
-
-          container.require_component(component) do
-            register(component.identifier, memoize: registration_config.memoize) {
-              registration_config.instance.(component)
-            }
-          end
+        container.component_dirs.each do |component_dir|
+          call(component_dir) if component_dir.auto_register?
         end
       end
 
-      private
-
-      # @api private
-      def components(dir)
-        files(dir)
-          .map { |file_name| [file_name, file_options(file_name)] }
-          .map { |file_name, options| component(relative_path(dir, file_name), **options) }
-          .reject { |component| registered?(component.identifier) }
-      end
-
       # @api private
-      def files(dir)
-        components_dir = File.join(root, dir)
+      def call(component_dir)
+        component_dir.each_component do |component|
+          next unless register_component?(component)
 
-        unless ::Dir.exist?(components_dir)
-          raise ComponentsDirMissing, "Components dir '#{components_dir}' not found"
+          container.register(component.key, memoize: component.memoize?) { component.instance }
         end
-
-        ::Dir["#{components_dir}/**/#{RB_GLOB}"].sort
-      end
-
-      # @api private
-      def relative_path(dir, file_path)
-        dir_root = root.join(dir.to_s.split("/")[0])
-        file_path.to_s.sub("#{dir_root}/", "").sub(RB_EXT, EMPTY_STRING)
       end
 
-      # @api private
-      def file_options(file_name)
-        MagicCommentsParser.(file_name)
-      end
-
-      # @api private
-      def component(path, **options)
-        container.component(path, **options)
-      end
-
-      # @api private
-      def root
-        container.root
-      end
-
-      # @api private
-      def registered?(name)
-        container.registered?(name)
-      end
+      private
 
-      # @api private
-      def register(*args, &block)
-        container.register(*args, &block)
+      def register_component?(component)
+        !container.registered?(component.key) && component.auto_register?
       end
     end
   end

data/lib/dry/system/component.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require "concurrent/map"
-
-require "dry-equalizer"
+require "pathname"
 require "dry/inflector"
-require "dry/system/loader"
 require "dry/system/errors"
 require "dry/system/constants"
 
@@ -14,157 +11,180 @@ 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, :namespace, :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
+      #   @return [String] the component's unique identifier
       attr_reader :identifier
 
-      # @!attribute [r] path
-      #   @return [String] component's relative path
-      attr_reader :path
+      # @!attribute [r] file_path
+      #   @return [Pathname] the component's source file path
+      attr_reader :file_path
 
-      # @!attribute [r] file
-      #   @return [String] component's file name
-      attr_reader :file
+      # @!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
 
-      # @!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
+      def initialize(identifier, file_path:, namespace:, **options)
+        @identifier = identifier
+        @file_path = Pathname(file_path)
+        @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 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)
+      def loadable?
+        true
       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
+      # Returns the component's instance
+      #
+      # @return [Object] component's class instance
+      # @api public
+      def instance(*args)
+        options[:instance]&.call(self, *args) || loader.call(self, *args)
       end
+      ruby2_keywords(:instance) if respond_to?(:ruby2_keywords, true)
 
-      # @api private
-      def self.cache
-        @cache ||= Concurrent::Map.new
+      # Returns the component's unique key
+      #
+      # @return [String] the key
+      #
+      # @see Identifier#key
+      #
+      # @api public
+      def key
+        identifier.key
       end
 
-      # @api private
-      def initialize(identifier, path, options)
-        @identifier = identifier
-        @path = path
-        @options = options
-        @file = "#{path}#{RB_EXT}"
-        @loader = options.fetch(:loader)
-        freeze
+      # 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 components instance
+      # Returns a path-delimited representation of the compnent, appropriate for passing
+      # to `Kernel#require` to require its source file
       #
-      # @example
-      #   class MyApp < Dry::System::Container
-      #     configure do |config|
-      #       config.name = :my_app
-      #       config.root = Pathname('/my/app')
-      #     end
+      # The path takes into account the rules of the namespace used to load the component.
       #
-      #     auto_register!('lib/clients') do |component|
-      #       # some custom initialization logic, ie:
-      #       constant = component.loader.constant
-      #       constant.create
-      #     end
-      #   end
+      # @example Component from a root namespace
+      #   component.key # => "articles.create"
+      #   component.require_path # => "articles/create"
       #
-      # @return [Object] component's class instance
+      # @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 instance(*args)
-        loader.call(*args)
-      end
-      ruby2_keywords(:instance) if respond_to?(:ruby2_keywords, true)
-
-      # @api private
-      def bootable?
-        false
-      end
-
-      # @api private
-      def file_exists?(paths)
-        paths.any? { |path| path.join(file).exist? }
+      def require_path
+        if namespace.path
+          "#{namespace.path}#{PATH_SEPARATOR}#{path_in_namespace}"
+        else
+          path_in_namespace
+        end
       end
 
-      # @api private
-      def prepend(name)
-        self.class.new(
-          [name, identifier].join(separator), options.merge(loader: loader.class)
-        )
-      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)
 
-      # @api private
-      def namespaced(namespace)
-        self.class.new(
-          path, options.merge(loader: loader.class, namespace: namespace)
-        )
+        if namespace_const_path
+          "#{namespace_const_path}#{PATH_SEPARATOR}#{path_in_namespace}"
+        else
+          path_in_namespace
+        end
       end
 
       # @api private
-      def separator
-        options[:separator]
+      def loader
+        options.fetch(:loader)
       end
 
       # @api private
-      def namespace
-        options[:namespace]
+      def inflector
+        options.fetch(: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 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)
+        else
+          !!value
+        end
       end
     end
   end

data/lib/dry/system/component_dir.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/system/constants"
+
+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 the given key if a matching source file is found within
+      # the component dir
+      #
+      # This searches according to the component dir's configured namespaces, in order of
+      # definition, with the first match returned as the component.
+      #
+      # @param key [String] the component's key
+      # @return [Dry::System::Component, nil] the component, if found
+      #
+      # @api private
+      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
+
+        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 each_file
+        return enum_for(:each_file) unless block_given?
+
+        raise ComponentDirNotFoundError, full_path unless Dir.exist?(full_path)
+
+        config.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 = 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]
+      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
+      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
+
+      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
+
+        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,
+          namespace: namespace,
+          file_path: file_path,
+          **options
+        )
+      end
+
+      def component_options
+        {
+          auto_register: auto_register,
+          loader: loader,
+          instance: instance,
+          memoize: memoize
+        }
+      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