dry-auto_inject 1.0.1 → 1.2.0

data/lib/dry/auto_inject/strategies/args.rb

@@ -9,12 +9,14 @@ module Dry
 
         def define_new
           class_mod.class_exec(container, dependency_map) do |container, dependency_map|
+            deps_with_indices = dependency_map.to_h.values.map.with_index
+
             define_method :new do |*args|
-              deps = dependency_map.to_h.values.map.with_index { |identifier, i|
+              deps = deps_with_indices.map do |identifier, i|
                 args[i] || container[identifier]
-              }
+              end
 
-              super(*deps, *args[deps.size..])
+              super(*deps, *args.drop(deps.size))
             end
           end
         end
@@ -46,11 +48,12 @@ module Dry
         end
 
         def define_initialize_with_splat(super_parameters)
-          super_pass = if super_parameters.splat?
-                         "*args"
-                       else
-                         "*args.take(#{super_parameters.length})"
-                       end
+          super_pass =
+            if super_parameters.splat?
+              "*args"
+            else
+              "*args.take(#{super_parameters.length})"
+            end
 
           assignments = dependency_map.names.map.with_index do |name, idx|
             "@#{name} = args[#{idx}]"

data/lib/dry/auto_inject/strategies/hash.rb

@@ -9,12 +9,14 @@ module Dry
 
         def define_new
           class_mod.class_exec(container, dependency_map) do |container, dependency_map|
+            deps_map = dependency_map.to_h
+
             define_method :new do |options = {}|
-              deps = dependency_map.to_h.each_with_object({}) { |(name, identifier), obj|
-                obj[name] = options[name] || container[identifier]
-              }.merge(options)
+              deps = deps_map.transform_values do |identifier|
+                options[identifier] || container[identifier]
+              end
 
-              super(deps)
+              super({**deps, **options})
             end
           end
         end
@@ -24,7 +26,7 @@ module Dry
           super_pass = super_params.empty? ? "" : "options"
           assignments = dependency_map.names.map do |name|
             <<~RUBY
-              unless !options.key?(:#{name}) && instance_variable_defined?(:'@#{name}')
+              if options.key?(:#{name}) || !instance_variable_defined?(:'@#{name}')
                 @#{name} = options[:#{name}]
               end
             RUBY
@@ -33,7 +35,7 @@ module Dry
 
           instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def initialize(options) # def initialize(options)
-                                    #   unless !options.key?(:dep) && instance_variable_defined?(:@dep)
+                                    #   if options.key?(:dep) || !instance_variable_defined?(:@dep)
               #{body}               #     @dep = options[:dep]
                                     #   end
               super(#{super_pass})  #   super(options)

data/lib/dry/auto_inject/strategies/kwargs.rb

@@ -23,8 +23,10 @@ module Dry
 
         def define_initialize(klass)
           super_parameters = MethodParameters.of(klass, :initialize).each do |ps|
-            # Look upwards past `def foo(*)` and `def foo(...)` methods
-            # until we get an explicit list of parameters
+            # Look upwards past methods that only forward arguments, stopping at the
+            # first instance of explicit parameters. So `foo(**kwargs)` is
+            # skipped, but `foo(bar:, **kwargs)` is not. `foo(...)` is used by ROM as
+            # a delegation pattern, so it is not skipped.
             break ps unless ps.pass_through?
           end
 
@@ -37,15 +39,18 @@ module Dry
           self
         end
 
+        # rubocop:disable Lint/UnderscorePrefixedVariableName
         def define_initialize_with_keywords(super_parameters)
           assign_dependencies = method(:assign_dependencies)
           slice_kwargs = method(:slice_kwargs)
 
           instance_mod.class_exec do
-            define_method :initialize do |**kwargs, &block|
-              assign_dependencies.(kwargs, self)
+            # The choice of `__auto_inject_kwargs__` here is intentional, and used
+            # by MethodParameters#pass_through? to detect an injected initialize.
+            define_method :initialize do |**__auto_inject_kwargs__, &block|
+              assign_dependencies.(__auto_inject_kwargs__, self)
 
-              super_kwargs = slice_kwargs.(kwargs, super_parameters)
+              super_kwargs = slice_kwargs.(__auto_inject_kwargs__, super_parameters)
 
               if super_kwargs.any?
                 super(**super_kwargs, &block)
@@ -61,13 +66,13 @@ module Dry
           slice_kwargs = method(:slice_kwargs)
 
           instance_mod.class_exec do
-            define_method :initialize do |*args, **kwargs, &block|
-              assign_dependencies.(kwargs, self)
+            define_method :initialize do |*args, **__auto_inject_kwargs__, &block|
+              assign_dependencies.(__auto_inject_kwargs__, self)
 
               if super_parameters.splat?
-                super(*args, **kwargs, &block)
+                super(*args, **__auto_inject_kwargs__, &block)
               else
-                super_kwargs = slice_kwargs.(kwargs, super_parameters)
+                super_kwargs = slice_kwargs.(__auto_inject_kwargs__, super_parameters)
 
                 if super_kwargs.any?
                   super(*args, **super_kwargs, &block)
@@ -78,6 +83,7 @@ module Dry
             end
           end
         end
+        # rubocop:enable Lint/UnderscorePrefixedVariableName
 
         def assign_dependencies(kwargs, destination)
           dependency_map.names.each do |name|

data/lib/dry/auto_inject/strategies.rb

@@ -11,9 +11,9 @@ module Dry
         register :default, strategy
       end
 
-      register :args, proc { Args }
+      register :args, proc { Strategies::Args }
       register :hash, proc { Strategies::Hash }
-      register_default :kwargs, proc { Kwargs }
+      register_default :kwargs, proc { Strategies::Kwargs }
     end
   end
 end

data/lib/dry/auto_inject/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module AutoInject
-    VERSION = "1.0.1"
+    VERSION = "1.2.0"
   end
 end

data/lib/dry/auto_inject.rb

@@ -6,14 +6,15 @@ require "dry/core"
 module Dry
   module AutoInject
     def self.loader
-      @loader ||= Zeitwerk::Loader.new.tap do |loader|
-        root = File.expand_path("..", __dir__)
+      @loader ||= ::Zeitwerk::Loader.new.tap do |loader|
+        root = ::File.expand_path("..", __dir__)
         loader.tag = "dry-auto_inject"
-        loader.inflector = Zeitwerk::GemInflector.new("#{root}/dry-auto_inject.rb")
+        loader.inflector = ::Zeitwerk::GemInflector.new("#{root}/dry-auto_inject.rb")
         loader.push_dir(root)
         loader.ignore(
           "#{root}/dry-auto_inject.rb",
-          "#{root}/dry/auto_inject/version.rb"
+          "#{root}/dry/auto_inject/version.rb",
+          "#{root}/rubocop"
         )
       end
     end

data/lib/dry-auto_inject.rb

@@ -1,3 +1,9 @@
 # frozen_string_literal: true
 
 require "dry/auto_inject"
+
+module RuboCop
+  module DryAutoInject
+    autoload :Plugin, "rubocop/dry_auto_inject/plugin"
+  end
+end

data/lib/rubocop/cop/dry_auto_inject/dependency_order.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "mixin"
+
+module RuboCop
+  module Cop
+    module DryAutoInject
+      # Enforces a configurable order for dry-auto_inject `Import[...]` deps.
+      #
+      # Non-aliased deps are emitted first, then aliased deps. Within each
+      # section, deps are grouped by matching the configured `Order` patterns
+      # and sorted alphabetically inside a group. Each pattern can be:
+      #
+      #   - `'*'`              — catch-all (at most one; implicitly appended)
+      #   - `'prefix.*'`       — prefix wildcard (matches `prefix` and `prefix.*`)
+      #   - `'/regex/flags'`   — regex matched against the dep path
+      #   - otherwise          — exact path match
+      #
+      # If `Order` is empty or omits `'*'`, a catch-all `'*'` group is appended
+      # implicitly so unmatched deps still have a home.
+      #
+      # Specific patterns take priority over the `*` catch-all regardless of
+      # their position in `Order`.
+      #
+      # @example Order: ['web.*', '*', 'core.*']
+      #   # bad
+      #   include Import[
+      #     'core.db',
+      #     'web.router',
+      #   ]
+      #
+      #   # good
+      #   include Import[
+      #     'web.router',
+      #     'core.db',
+      #   ]
+      #
+      # @example Order: ['/\A[^.]+\z/', '*']  — group dotless deps first
+      #   include Import[
+      #     'logger',
+      #     'core.db',
+      #   ]
+      class DependencyOrder < Base
+        extend AutoCorrector
+        include Mixin
+
+        MSG = "Dependencies are not in the configured order."
+
+        def initialize(config = nil, options = nil)
+          super
+          @parsed_order = build_parsed_order
+        end
+
+        def on_send(node)
+          return unless injector_call?(node)
+
+          deps = parse_injector_deps(node)
+          return if deps.nil?
+
+          order = parsed_order
+          current = deps[:non_aliased] + deps[:aliased]
+          sorted = [deps[:non_aliased], deps[:aliased]].flat_map { |group|
+            group_and_sort(group, order) { |d| d[:path] }
+          }
+
+          return if current == sorted
+
+          add_offense(node, message: MSG) do |corrector|
+            replace_injector_content(corrector, node, sorted)
+          end
+        end
+
+        private
+
+        attr_reader :parsed_order
+
+        def build_parsed_order
+          raw = Array(cop_config["Order"]).dup
+
+          if raw.count("*") > 1
+            raise "#{self.class.badge}: `Order` may contain at most one '*' entry " \
+                  "(got #{raw.inspect})"
+          end
+
+          raw << "*" unless raw.include?("*")
+          raw.each { |pat| validate_regex_pattern!(pat) if pat.start_with?("/") }
+          raw
+        end
+
+        def validate_regex_pattern!(pat)
+          return if parse_regex_entry(pat)
+
+          raise "#{self.class.badge}: invalid regex in `Order` entry #{pat.inspect}"
+        end
+
+        def group_and_sort(deps, order, &)
+          groups = ::Hash.new { |h, k| h[k] = [] }
+
+          # Specific patterns take priority over the `*` catch-all regardless
+          # of their position in `Order`.
+          specific_patterns = order.reject { |p| p == "*" }
+
+          deps.each do |d|
+            pat = specific_patterns.find { |p| match_pattern?(d[:path], p) } || "*"
+            groups[pat] << d
+          end
+
+          order.flat_map { |p| groups[p].sort_by(&) }
+        end
+
+        def match_pattern?(path, pattern)
+          return true if pattern == "*"
+
+          if pattern.start_with?("/")
+            parse_regex_entry(pattern)&.match?(path)
+          elsif pattern.end_with?(".*")
+            prefix = pattern[...-2]
+            path == prefix || path.start_with?("#{prefix}.")
+          else
+            path == pattern
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dry_auto_inject/mixin.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "dry/core"
+
+module RuboCop
+  module Cop
+    module DryAutoInject
+      # Shared helpers for cops that inspect `Import[...]`-style calls produced
+      # by dry-auto_inject.
+      module Mixin
+        include ::Dry::Core::Constants
+
+        private
+
+        def injector_call?(node)
+          return false unless node.send_type?
+          return false unless node.method?(:[])
+
+          receiver = node.receiver
+          return false unless receiver&.const_type?
+
+          match_injector_module?(receiver)
+        end
+
+        def match_injector_module?(const_node)
+          full = const_fullname(const_node)
+          clean = full.sub(/\A::/, "")
+
+          Array(cop_config["InjectorModules"]).any? do |entry|
+            match_injector_entry?(entry.to_s, full, clean)
+          end
+        end
+
+        # Entry formats:
+        #   - `/pattern/flags`    — regex literal, matched against `clean`
+        #   - `*::Name`           — last segment match with any prefix (incl. empty)
+        #   - otherwise           — exact match on the full or leading-`::`-stripped path
+        def match_injector_entry?(entry, full, clean)
+          if entry.start_with?("/")
+            regex = parse_regex_entry(entry)
+            return false unless regex
+
+            regex.match?(clean)
+          elsif entry.start_with?("*::")
+            suffix = entry[3..]
+            clean == suffix || clean.end_with?("::#{suffix}")
+          else
+            entry == full || entry == clean
+          end
+        end
+
+        # Returns a Regexp for a `/pattern/flags` literal, or nil if the
+        # string is not a regex literal or the pattern is invalid.
+        def parse_regex_entry(str)
+          m = str.match(%r{\A/(.*)/([imx]*)\z}m)
+          return nil unless m
+
+          opts = 0
+          opts |= ::Regexp::IGNORECASE if m[2].include?("i")
+          opts |= ::Regexp::MULTILINE if m[2].include?("m")
+          opts |= ::Regexp::EXTENDED if m[2].include?("x")
+          ::Regexp.new(m[1], opts)
+        rescue ::RegexpError
+          nil
+        end
+
+        def const_fullname(const_node)
+          parts = []
+          current = const_node
+
+          while current
+            if current.const_type?
+              parts.unshift(current.children[1].to_s)
+              current = current.children[0]
+            elsif current.cbase_type?
+              parts.unshift("")
+              current = nil
+            else
+              return ""
+            end
+          end
+
+          parts.join("::")
+        end
+
+        # Parses the arguments of an `Import[...]` call into a structured form.
+        # Returns nil if any argument is not a plain string or symbol-keyed/string-valued pair.
+        def parse_injector_deps(node)
+          args = node.arguments
+          return nil if args.empty?
+
+          hash_arg = args.last if args.last.hash_type?
+          string_nodes = hash_arg ? args[...-1] : args
+
+          non_aliased = parse_non_aliased_deps(string_nodes)
+          aliased = parse_aliased_deps(hash_arg)
+          return nil if non_aliased.nil? || aliased.nil?
+
+          {non_aliased:, aliased:}
+        end
+
+        def parse_non_aliased_deps(nodes)
+          return nil unless nodes.all?(&:str_type?)
+
+          nodes.map { |arg| {node: arg, alias: nil, path: arg.value} }
+        end
+
+        def parse_aliased_deps(hash_arg)
+          return EMPTY_ARRAY unless hash_arg
+          return nil unless hash_arg.pairs.all? { |p| p.key.sym_type? && p.value.str_type? }
+
+          hash_arg.pairs.map { |p| {node: p, alias: p.key.value.to_s, path: p.value.value} }
+        end
+
+        def format_dep(dep)
+          node = dep[:node]
+          if dep[:alias]
+            "#{dep[:alias]}: #{node.value.source}"
+          else
+            node.source
+          end
+        end
+
+        def line_indent_col(node)
+          line = node.source_range.source_line
+          line.index(/\S/) || node.source_range.column
+        end
+
+        def item_indent_spaces(node)
+          args = node.arguments
+
+          if args.any? && args.first.source_range.line > node.source_range.line
+            indent(args.first.source_range.column)
+          else
+            indent(line_indent_col(node) + 2)
+          end
+        end
+
+        def indent(width)
+          " " * width
+        end
+
+        def render_deps(node, deps)
+          if node.multiline?
+            inner_indent = item_indent_spaces(node)
+            close_indent = indent(line_indent_col(node))
+            lines = deps.map { |d| "#{inner_indent}#{format_dep(d)}," }
+            "\n#{lines.join("\n")}\n#{close_indent}"
+          else
+            deps.map { |d| format_dep(d) }.join(", ")
+          end
+        end
+
+        def replace_injector_content(corrector, node, deps)
+          selector = node.loc.selector
+          return unless selector&.source&.start_with?("[")
+
+          corrector.replace(selector.adjust(begin_pos: 1, end_pos: -1), render_deps(node, deps))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dry_auto_inject/redundant_alias.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "mixin"
+
+module RuboCop
+  module Cop
+    module DryAutoInject
+      # Flags dry-auto_inject imports whose hash key matches the last segment
+      # of the path, since dry-auto_inject already derives the dependency name
+      # from that segment.
+      #
+      # @example
+      #   # bad
+      #   include Import[foo: 'some.path.foo']
+      #
+      #   # good
+      #   include Import['some.path.foo']
+      class RedundantAlias < Base
+        extend AutoCorrector
+        include Mixin
+
+        MSG =
+          "Redundant alias `%<alias_name>s:` — dependency key is derived from " \
+          "the last segment of `'%<path>s'`."
+
+        def on_send(node)
+          return unless injector_call?(node)
+
+          deps = parse_injector_deps(node)
+          return if deps.nil?
+
+          redundant = deps[:aliased].select { |d| d[:alias] == d[:path].split(".").last }
+          return if redundant.empty?
+
+          canonical = promote_redundant_aliases(deps)
+
+          redundant.each_with_index do |dep, i|
+            add_offense(
+              dep[:node],
+              message: format(MSG, alias_name: dep[:alias], path: dep[:path])
+            ) do |corrector|
+              next unless i.zero?
+
+              replace_injector_content(corrector, node, canonical)
+            end
+          end
+        end
+
+        private
+
+        def promote_redundant_aliases(deps)
+          non_aliased = deps[:non_aliased].dup
+          aliased = []
+
+          deps[:aliased].each do |d|
+            if d[:alias] == d[:path].split(".").last
+              non_aliased << {node: d[:node].value, alias: nil, path: d[:path]}
+            else
+              aliased << d
+            end
+          end
+
+          non_aliased + aliased
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/dry-auto_inject.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "dry_auto_inject"

data/lib/rubocop/dry_auto_inject/plugin.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+
+require "dry/auto_inject/version"
+
+module RuboCop
+  module DryAutoInject
+    class Plugin < ::LintRoller::Plugin
+      def about
+        ::LintRoller::About.new(
+          name: "dry-auto_inject",
+          version: ::Dry::AutoInject::VERSION,
+          homepage: "https://hanakai.org/learn/dry/dry-auto_inject",
+          description: "RuboCop cops for enforcing dry-auto_inject conventions."
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = ::Pathname.new(__dir__).join("../../..")
+
+        ::LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: project_root.join("config", "default.yml")
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/dry_auto_inject.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "dry_auto_inject/plugin"
+require_relative "cop/dry_auto_inject/dependency_order"
+require_relative "cop/dry_auto_inject/redundant_alias"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dry-auto_inject
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
-- Piotr Solnica
-autorequire: 
-bindir: bin
+- Hanakai team
+bindir: exe
 cert_chain: []
-date: 2023-02-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-core
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -82,14 +81,18 @@ dependencies:
         version: '0'
 description: Container-agnostic automatic constructor injection
 email:
-- piotr.solnica@gmail.com
+- info@hanakai.org
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE
+- README.md
 files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- config/default.yml
 - dry-auto_inject.gemspec
 - lib/dry-auto_inject.rb
 - lib/dry/auto_inject.rb
@@ -103,15 +106,21 @@ files:
 - lib/dry/auto_inject/strategies/hash.rb
 - lib/dry/auto_inject/strategies/kwargs.rb
 - lib/dry/auto_inject/version.rb
+- lib/rubocop/cop/dry_auto_inject/dependency_order.rb
+- lib/rubocop/cop/dry_auto_inject/mixin.rb
+- lib/rubocop/cop/dry_auto_inject/redundant_alias.rb
+- lib/rubocop/dry-auto_inject.rb
+- lib/rubocop/dry_auto_inject.rb
+- lib/rubocop/dry_auto_inject/plugin.rb
 homepage: https://dry-rb.org/gems/dry-auto_inject
 licenses:
 - MIT
 metadata:
-  allowed_push_host: https://rubygems.org
   changelog_uri: https://github.com/dry-rb/dry-auto_inject/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/dry-rb/dry-auto_inject
   bug_tracker_uri: https://github.com/dry-rb/dry-auto_inject/issues
-post_install_message: 
+  funding_uri: https://github.com/sponsors/hanami
+  default_lint_roller_plugin: RuboCop::DryAutoInject::Plugin
 rdoc_options: []
 require_paths:
 - lib
@@ -119,15 +128,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Container-agnostic automatic constructor injection
 test_files: []