dry-auto_inject 0.6.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 04bd4b08425b83733006cac8ef6612068304a720a63f8896e8f0369e1d26b0cc
+  data.tar.gz: 38b6073a686faa24ec5b628e70125ae97ea2c402403c410608acd57506a7482c
+SHA512:
+  metadata.gz: bd8267844c208234397d5b8a62113bc5bc665daad2c3410d27342489b5894b24b92e6dec1df721028e5967a0f2f7c24465e52bac7b4e469ad0e6e98d65bb0c25
+  data.tar.gz: 64be14b7a6797e064690838ec867c0d2056101387e5a652cf20213ef40f5a86822420f50a42d8f85288bc66af30f710c05b2c8dde4e4ca0952b2d3cd71b0a3d5

data/.codeclimate.yml

@@ -0,0 +1,6 @@
+engines:
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+    - lib/**

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/vendor/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,19 @@
+# Generated by `rubocop --auto-gen-config`
+inherit_from: .rubocop_todo.yml
+
+Metrics/LineLength:
+  Max: 110
+
+Lint/HandleExceptions:
+  Exclude:
+    - rakelib/*.rake
+
+Style/LambdaCall:
+  EnforcedStyle: braces
+
+Style/Documentation:
+  Enabled: false
+
+Style/FileName:
+  Exclude:
+    - lib/dry-pipeline.rb

data/.rubocop_todo.yml

@@ -0,0 +1,6 @@
+# This configuration was generated by `rubocop --auto-gen-config`
+# on 2015-08-19 22:11:28 +0100 using RuboCop version 0.32.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.

data/.travis.yml

@@ -0,0 +1,26 @@
+language: ruby
+cache: bundler
+bundler_args: --without tools
+after_success:
+  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
+rvm:
+  - 2.6.2
+  - 2.5.5
+  - 2.4.5
+  - 2.3.8
+  - jruby-9.2.6.0
+  - truffleruby
+matrix:
+  allow_failures:
+    - rvm: truffleruby
+env:
+  global:
+    - COVERAGE=true
+notifications:
+  email: false
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/19098b4253a72c9796db
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false

data/CHANGELOG.md

@@ -0,0 +1,243 @@
+# 0.6.1 / 2019-04-16
+
+### Fixed
+
+- Allow explicit injection of falsey values (timriley in [#58](https://github.com/dry-rb/dry-auto_inject/pull/58))
+
+[Compare v0.6.0...v0.6.1](https://github.com/dry-rb/dry-auto_inject/compare/v0.6.0...v0.6.1)
+
+# 0.6.0 / 2018-11-29
+
+### Changed
+
+- [BREAKING] 0.6.0 supports Ruby 2.3 and above. If you're on 2.3 keep in mind its EOL is scheduled at the end of March, 2019
+
+### Added
+
+- Enhanced support for integrating with existing constructors. The kwargs strategy will now pass dependencies up to the next constructor if it accepts an arbitrary number of arguments with `*args`. Note that this change may break existing code though we think it's unlikely to happen. If something doesn't work for you please report and we'll try to sort it out (flash-gordon + timriley in [#48](https://github.com/dry-rb/dry-auto_inject/pull/48))
+
+### Fixed
+
+- A couple of regressions were fixed along the way, see [#46](https://github.com/dry-rb/dry-auto_inject/issues/46) and [#49](https://github.com/dry-rb/dry-auto_inject/issues/49) (flash-gordon + timriley in [#48](https://github.com/dry-rb/dry-auto_inject/pull/48))
+
+[Compare v0.5.0...v0.6.0](https://github.com/dry-rb/dry-auto_inject/compare/v0.5.0...v0.6.0)
+
+# 0.5.0 / 2018-11-09
+
+### Changed
+
+- Only assign `nil` dependency instance variables from generated `#initialize` if the instance variable has not been previously defined. This improves compatibility with objects initialized in non-conventional ways (see example below) (timriley in [#47](https://github.com/dry-rb/dry-auto_inject/pull/47))
+
+    ```ruby
+    module SomeFramework
+      class Action
+        def self.new(configuration:, **args)
+          # Do some trickery so `#initialize` on subclasses don't need to worry
+          # about handling a configuration kwarg and passing it to super
+          allocate.tap do |obj|
+            obj.instance_variable_set :@configuration, configuration
+            obj.send :initialize, **args
+          end
+        end
+      end
+    end
+
+    module MyApp
+      class Action < SomeFramework::Action
+        # Inject the configuration object, which is passed to
+        # SomeFramework::Action.new but not all the way through to any subsequent
+        # `#initialize` calls
+        include Import[configuration: "web.action.configuration"]
+      end
+
+      class SomeAction < Action
+        # Subclasses of MyApp::Action don't need to concern themselves with
+        # `configuration` dependency
+        include Import["some_repo"]
+      end
+    end
+    ```
+
+[Compare v0.4.6...v0.5.0](https://github.com/dry-rb/dry-auto_inject/compare/v0.4.6...v0.5.0)
+
+# 0.4.6 / 2018-03-27
+
+### Changed
+
+- In injector-generated `#initialize` methods, set dependency instance variables before calling `super` (timriley)
+
+[Compare v0.4.5...v0.4.6](https://github.com/dry-rb/dry-auto_inject/compare/v0.4.5...v0.4.6)
+
+# 0.4.5 / 2018-01-02
+
+### Added
+
+- Improved handling of kwargs being passed to #initialize’s super method (timriley)
+
+[Compare v0.4.4...v0.4.5](https://github.com/dry-rb/dry-auto_inject/compare/v0.4.4...v0.4.5)
+
+# 0.4.4 / 2017-09-14
+
+### Added
+
+- Determine name for dependencies by splitting identifiers on any invalid local variable name characters (e.g. "/", "?", "!"), instead of splitting on dots only (raventid in [#39](https://github.com/dry-rb/dry-auto_inject/pull/39))
+
+# 0.4.3 / 2017-05-27
+
+### Added
+
+- Push sequential arguments along with keywords in the kwargs strategy (hbda + vladra in [#32](https://github.com/dry-rb/dry-auto_inject/pull/32))
+
+[Compare v0.4.2...v0.4.3](https://github.com/dry-rb/dry-auto_inject/compare/v0.4.2...v0.4.3)
+
+# 0.4.2 / 2016-10-10
+
+### Fixed
+
+- Fixed issue where injectors for different containers could not be used on different classes in an inheritance hierarchy (timriley in [#31](https://github.com/dry-rb/dry-auto_inject/pull/31))
+
+[Compare v0.4.1...v0.4.2](https://github.com/dry-rb/dry-auto_inject/compare/v0.4.1...v0.4.2)
+
+# 0.4.1 / 2016-08-14
+
+### Changed
+
+- Loosened version dependency on dry-container (AMHOL)
+
+[Compare v0.4.0...v0.4.1](https://github.com/dry-rb/dry-auto_inject/compare/v0.4.0...v0.4.1)
+
+# 0.4.0 / 2016-07-26
+
+### Added
+
+- Support for strategy chaining, which is helpful in opting for alternatives to an application's normal strategy (timriley in [#25](https://github.com/dry-rb/dry-auto_inject/pull/25))
+
+    ```ruby
+    # Define the application's injector with a non-default
+    MyInject = Dry::AutoInject(MyContainer).hash
+
+    # Opt for a different strategy in a particular class
+    class MyClass
+      include MyInject.args["foo"]
+    end
+
+    # You can chain as long as you want (silly example to demonstrate the flexibility)
+    class OtherClass
+      include MyInject.args.hash.kwargs.args["foo"]
+    end
+    ```
+
+### Changed
+
+- Use a `BasicObject`-based environment for the injector builder API instead of the previous `define_singleton_method`-based approach, which had negative performance characteristics (timriley in [#26](https://github.com/dry-rb/dry-auto_inject/pull/26))
+
+### Fixed
+
+- Fixed issue with kwargs injectors used at multiple points in a class inheritance heirarchy (flash-gordon in [#27](https://github.com/dry-rb/dry-auto_inject/pull/27))
+
+[Compare v0.3.0...v0.4.0](https://github.com/dry-rb/dry-auto_inject/compare/v0.3.0...v0.4.0)
+
+# 0.3.0, 2016-06-02
+
+### Added
+
+* Support for new `kwargs` and `hash` injection strategies
+
+    These strategies can be accessed via methods on the main builder object:
+
+    ```ruby
+    MyInject = Dry::AutoInject(my_container)
+
+    class MyClass
+      include MyInject.hash["my_dep"]
+    end
+    ```
+* Support for user-provided injection strategies
+
+    All injection strategies are now held in their own `Dry::AutoInject::Strategies` container. You can add register your own strategies to this container, or choose to provide a strategies container of your own:
+
+    ```ruby
+    class CustomStrategy < Module
+      # Your strategy code goes here :)
+    end
+
+    # Registering your own strategy (globally)
+    Dry::AutoInject::Strategies.register :custom, CustomStrategy
+
+    MyInject = Dry::AutoInject(my_container)
+
+    class MyClass
+      include MyInject.custom["my_dep"]
+    end
+
+    # Providing your own container (keeping the existing strategies in place)
+    class MyStrategies < Dry::AutoInject::Strategies
+      register :custom, CustomStrategy
+    end
+
+    MyInject = Dry::AutoInject(my_container, strategies: MyStrategies)
+
+    class MyClass
+      include MyInject.custom["my_dep"]
+    end
+
+    # Proiding a completely separated container
+    class MyStrategies
+      extend Dry::Container::Mixin
+      register :custom, CustomStrategy
+    end
+
+    MyInject = Dry::AutoInject(my_container, strategies: MyStrategies)
+
+    class MyClass
+      include MyInject.custom["my_dep"]
+    end
+    ```
+* User-specified aliases for dependencies
+
+    These aliases enable you to specify your own name for dependencies, both for their local readers and their keys in the kwargs- and hash-based initializers. Specify aliases by passing a hash of names:
+
+    ```ruby
+    MyInject = Dry::AutoInject(my_container)
+
+    class MyClass
+      include MyInject[my_dep: "some_other.dep"]
+
+      # Refer to the dependency as `my_dep` inside the class
+    end
+
+    # Pass your own replacements using the `my_dep` initializer key
+    my_obj = MyClass.new(my_dep: something_else)
+    ```
+
+    A mix of both regular and aliased dependencies can also be injected:
+
+    ```ruby
+    include MyInject["some_dep", another_dep: "some_other.dep"]
+    ```
+
+* Inspect the `super` method of the including class’s `#initialize` and send it arguments that will match its own arguments list/arity. This allows auto_inject to be used more easily in existing class inheritance heirarchies.
+
+### Changed
+
+* `kwargs` is the new default injection strategy
+* Rubinius support is not available for the `kwargs` strategy (see [#18](https://github.com/dry-rb/dry-auto_inject/issues/18))
+
+[Compare v0.2.0...v0.3.0](https://github.com/dry-rb/dry-auto_inject/compare/v0.2.0...v0.3.0)
+
+# v0.2.0 2016-02-09
+
+### Added
+
+* Support for hashes as constructor arguments via `Import.hash` interface (solnic)
+
+[Compare v0.1.0...v0.2.0](https://github.com/dry-rb/dry-auto_inject/compare/v0.1.0...v0.2.0)
+
+# v0.1.0 2015-11-12
+
+Changed interface from `Dry::AutoInject.new { container(some_container) }` to
+`Dry::AutoInject(some_container)`.
+
+# v0.0.1 2015-08-20
+
+First public release \o/

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Issue Guidelines
+
+## Reporting bugs
+
+If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
+
+## Reporting feature requests
+
+Report a feature request **only after discussing it first on [discourse.dry-rb.org](https://discourse.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
+
+## Reporting questions, support requests, ideas, concerns etc.
+
+**PLEASE DON'T** - use [discourse.dry-rb.org](https://discourse.dry-rb.org) instead.
+
+# Pull Request Guidelines
+
+A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
+
+Other requirements:
+
+1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
+2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
+3) Add API documentation if it's a new feature
+4) Update API documentation if it changes an existing feature
+5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
+
+# Asking for help
+
+If these guidelines aren't helpful, and you're stuck, please post a message on [discourse.dry-rb.org](https://discourse.dry-rb.org).

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dry-auto_inject.gemspec
+gemspec
+
+group :test do
+  gem "simplecov"
+  gem "codeclimate-test-reporter", require: nil
+end
+
+group :tools do
+  gem 'byebug', platforms: :mri
+  gem 'pry'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015-2016 Piotr Solnica
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+[gem]: https://rubygems.org/gems/dry-auto_inject
+[travis]: https://travis-ci.org/dry-rb/dry-auto_inject
+[codeclimate]: https://codeclimate.com/github/dry-rb/dry-auto_inject
+[coveralls]: https://coveralls.io/r/dry-rb/dry-auto_inject
+[inchpages]: http://inch-ci.org/github/dry-rb/dry-auto_inject
+[chat]: https://dry-rb.zulipchat.com
+
+# dry-auto_inject [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
+
+[![Gem Version](https://badge.fury.io/rb/dry-auto_inject.svg)][gem]
+[![Build Status](https://travis-ci.org/dry-rb/dry-auto_inject.svg?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/dry-rb/dry-auto_inject/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/dry-rb/dry-auto_inject/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-auto_inject.svg?branch=master)][inchpages]
+![No monkey-patches](https://img.shields.io/badge/monkey--patches-0-brightgreen.svg)
+
+A simple extension which allows you to automatically inject dependencies to your
+object constructors from a configured container.
+
+It does 3 things:
+
+- Defines a constructor which accepts dependencies
+- Defines attribute readers for dependencies
+- Injects dependencies automatically to the constructor with overridden `.new`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dry-auto_inject'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+```sh
+$ gem install dry-auto_inject
+```
+
+## Links
+
+* [Documentation](http://dry-rb.org/gems/dry-auto_inject/)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dry-rb/dry-auto_inject.
+

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc 'Run all specs in spec directory'
+RSpec::Core::RakeTask.new(:spec)

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'dry-auto_inject'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dry-auto_inject.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dry/auto_inject/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-auto_inject'
+  spec.version       = Dry::AutoInject::VERSION.dup
+  spec.authors       = ['Piotr Solnica']
+  spec.email         = ['piotr.solnica@gmail.com']
+  spec.license       = 'MIT'
+
+  spec.summary       = 'Container-agnostic automatic constructor injection'
+  spec.homepage      = 'https://github.com/dry-rb/dry-auto_inject'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_runtime_dependency 'dry-container', '>= 0.3.4'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.8'
+end

data/lib/dry-auto_inject.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject'

data/lib/dry/auto_inject.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/builder'
+
+module Dry
+  # Configure an auto-injection module
+  #
+  # @example
+  #    module MyApp
+  #      # set up your container
+  #      container = Dry::Container.new
+  #
+  #      container.register(:data_store, -> { DataStore.new })
+  #      container.register(:user_repository, -> { container[:data_store][:users] })
+  #      container.register(:persist_user, -> { PersistUser.new })
+  #
+  #      # set up your auto-injection function
+  #      AutoInject = Dry::AutoInject(container)
+  #
+  #      # define your injection function
+  #      def self.Inject(*keys)
+  #        AutoInject[*keys]
+  #      end
+  #    end
+  #
+  #    # then simply include it in your class providing which dependencies should be
+  #    # injected automatically from the configured container
+  #    class PersistUser
+  #      include MyApp::Inject(:user_repository)
+  #
+  #      def call(user)
+  #        user_repository << user
+  #      end
+  #    end
+  #
+  #    persist_user = container[:persist_user]
+  #
+  #    persist_user.call(name: 'Jane')
+  #
+  # @return [Proc] calling the returned proc builds an auto-injection module
+  #
+  # @api public
+  def self.AutoInject(container, options = {})
+    AutoInject::Builder.new(container, options)
+  end
+end

data/lib/dry/auto_inject/builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies'
+require 'dry/auto_inject/injector'
+
+module Dry
+  module AutoInject
+    class Builder < BasicObject
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :strategies
+
+      def initialize(container, options = {})
+        @container = container
+        @strategies = options.fetch(:strategies) { Strategies }
+      end
+
+      # @api public
+      def [](*dependency_names)
+        default[*dependency_names]
+      end
+
+      def respond_to?(name, include_private = false)
+        Builder.public_instance_methods.include?(name) || strategies.key?(name)
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        if strategies.key?(name)
+          Injector.new(container, strategies[name], builder: self)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/dependency_map.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Dry
+  module AutoInject
+    DuplicateDependencyError = Class.new(StandardError)
+    DependencyNameInvalid = Class.new(StandardError)
+
+    VALID_NAME = /([a-z_][a-zA-Z_0-9]*)$/
+
+    class DependencyMap
+      def initialize(*dependencies)
+        @map = {}
+
+        dependencies = dependencies.dup
+        aliases = dependencies.last.is_a?(Hash) ? dependencies.pop : {}
+
+        dependencies.each do |identifier|
+          name = name_for(identifier)
+          add_dependency(name, identifier)
+        end
+
+        aliases.each do |name, identifier|
+          add_dependency(name, identifier)
+        end
+      end
+
+      def inspect
+        @map.inspect
+      end
+
+      def names
+        @names ||= @map.keys
+      end
+
+      def to_h
+        @map.dup
+      end
+      alias_method :to_hash, :to_h
+
+      private
+
+      def name_for(identifier)
+        matched = VALID_NAME.match(identifier.to_s)
+        raise DependencyNameInvalid, "name +#{identifier}+ is not a valid Ruby identifier" unless matched
+        matched[0]
+      end
+
+      def add_dependency(name, identifier)
+        name = name.to_sym
+        raise DuplicateDependencyError, "name +#{name}+ is already used" if @map.key?(name)
+        @map[name] = identifier
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/injector.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies'
+
+module Dry
+  module AutoInject
+    class Injector < BasicObject
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :strategy
+
+      # @api private
+      attr_reader :builder
+
+      # @api private
+      def initialize(container, strategy, builder:)
+        @container = container
+        @strategy = strategy
+        @builder = builder
+      end
+
+      def [](*dependency_names)
+        strategy.new(container, *dependency_names)
+      end
+
+      def respond_to?(name, include_private = false)
+        Injector.instance_methods.include?(name) || builder.respond_to?(name)
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        builder.__send__(name)
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/method_parameters.rb

@@ -0,0 +1,92 @@
+require 'set'
+
+module Dry
+  module AutoInject
+    # @api private
+    class MethodParameters
+      PASS_THROUGH = [[:rest]]
+
+      if RUBY_VERSION >= '2.4.4.' && !defined? JRUBY_VERSION
+        def self.of(obj, name)
+          Enumerator.new do |y|
+            begin
+              method = obj.instance_method(name)
+            rescue NameError
+            end
+
+            loop do
+              break if method.nil?
+
+              y << MethodParameters.new(method.parameters)
+              method = method.super_method
+            end
+          end
+        end
+      else
+        # see https://bugs.ruby-lang.org/issues/13973
+        def self.of(obj, name)
+          Enumerator.new do |y|
+            ancestors = obj.ancestors
+
+            loop do
+              klass = ancestors.shift
+              break if klass.nil?
+
+              begin
+                method = klass.instance_method(name)
+
+                next unless method.owner.equal?(klass)
+              rescue NameError
+                next
+              end
+
+              y << MethodParameters.new(method.parameters)
+            end
+          end
+        end
+      end
+
+      attr_reader :parameters
+
+      def initialize(parameters)
+        @parameters = parameters
+      end
+
+      def splat?
+        return @splat if defined? @splat
+        @splat = parameters.any? { |type, _| type == :rest }
+      end
+
+      def sequential_arguments?
+        return @sequential_arguments if defined? @sequential_arguments
+        @sequential_arguments = parameters.any? { |type, _|
+          type == :req || type == :opt
+        }
+      end
+
+      def keyword_names
+        @keyword_names ||= parameters.each_with_object(Set.new) { |(type, name), names|
+          names << name if type == :key || type == :keyreq
+        }
+      end
+
+      def keyword?(name)
+        keyword_names.include?(name)
+      end
+
+      def empty?
+        parameters.empty?
+      end
+
+      def length
+        parameters.length
+      end
+
+      def pass_through?
+        parameters.eql?(PASS_THROUGH)
+      end
+
+      EMPTY = new([])
+    end
+  end
+end

data/lib/dry/auto_inject/strategies.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-container'
+
+module Dry
+  module AutoInject
+    class Strategies
+      extend Dry::Container::Mixin
+
+      # @api public
+      def self.register_default(name, strategy)
+        register name, strategy
+        register :default, strategy
+      end
+    end
+  end
+end
+
+require 'dry/auto_inject/strategies/args'
+require 'dry/auto_inject/strategies/hash'
+require 'dry/auto_inject/strategies/kwargs'

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies/constructor'
+require 'dry/auto_inject/method_parameters'
+
+module Dry
+  module AutoInject
+    class Strategies
+      # @api private
+      class Args < Constructor
+        private
+
+        def define_new
+          class_mod.class_exec(container, dependency_map) do |container, dependency_map|
+            define_method :new do |*args|
+              deps = dependency_map.to_h.values.map.with_index { |identifier, i|
+                args[i] || container[identifier]
+              }
+
+              super(*deps, *args[deps.size..-1])
+            end
+          end
+        end
+
+        def define_initialize(klass)
+          super_parameters = MethodParameters.of(klass, :initialize).each do |ps|
+            # Look upwards past `def foo(*)` methods until we get an explicit list of parameters
+            break ps unless ps.pass_through?
+          end
+
+          if super_parameters.empty?
+            define_initialize_with_params
+          else
+            define_initialize_with_splat(super_parameters)
+          end
+        end
+
+        def define_initialize_with_params
+          initialize_args = dependency_map.names.join(', ')
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(#{initialize_args})
+              #{dependency_map.names.map { |name| "@#{name} = #{name}" }.join("\n")}
+              super()
+            end
+          RUBY
+        end
+
+        def define_initialize_with_splat(super_parameters)
+          super_pass = if super_parameters.splat?
+            '*args'
+          else
+            "*args.take(#{super_parameters.length})"
+          end
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(*args)
+              #{dependency_map.names.map.with_index { |name, i| "@#{name} = args[#{i}]" }.join("\n")}
+              super(#{super_pass})
+            end
+          RUBY
+        end
+      end
+
+      register :args, Args
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/dependency_map'
+
+module Dry
+  module AutoInject
+    class Strategies
+      class Constructor < Module
+        ClassMethods = Class.new(Module)
+        InstanceMethods = Class.new(Module)
+
+        attr_reader :container
+        attr_reader :dependency_map
+        attr_reader :instance_mod
+        attr_reader :class_mod
+
+        def initialize(container, *dependency_names)
+          @container = container
+          @dependency_map = DependencyMap.new(*dependency_names)
+          @instance_mod = InstanceMethods.new
+          @class_mod = ClassMethods.new
+        end
+
+        # @api private
+        def included(klass)
+          define_readers
+
+          define_new
+          define_initialize(klass)
+
+          klass.send(:include, instance_mod)
+          klass.extend(class_mod)
+
+          super
+        end
+
+        private
+
+        def define_readers
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            attr_reader #{dependency_map.names.map { |name| ":#{name}" }.join(', ')}
+          RUBY
+          self
+        end
+
+        def define_new
+          raise NotImplementedError, "must be implemented by a subclass"
+        end
+
+        def define_initialize(klass)
+          raise NotImplementedError, "must be implemented by a subclass"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies/constructor'
+require 'dry/auto_inject/method_parameters'
+
+module Dry
+  module AutoInject
+    class Strategies
+      # @api private
+      class Hash < Constructor
+        private
+
+        def define_new
+          class_mod.class_exec(container, dependency_map) do |container, dependency_map|
+            define_method :new do |options = {}|
+              deps = dependency_map.to_h.each_with_object({}) { |(name, identifier), obj|
+                obj[name] = options[name] || container[identifier]
+              }.merge(options)
+
+              super(deps)
+            end
+          end
+        end
+
+        def define_initialize(klass)
+          super_params = MethodParameters.of(klass, :initialize).first
+          super_pass = super_params.empty? ? '' : 'options'
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(options)
+              #{dependency_map.names.map { |name| "@#{name} = options[:#{name}] unless !options.key?(#{name}) && instance_variable_defined?(:'@#{name}')" }.join("\n")}
+              super(#{super_pass})
+            end
+          RUBY
+        end
+      end
+
+      register :hash, Hash
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies/constructor'
+require 'dry/auto_inject/method_parameters'
+
+module Dry
+  module AutoInject
+    class Strategies
+      # @api private
+      class Kwargs < Constructor
+        private
+
+        def define_new
+          class_mod.class_exec(container, dependency_map) do |container, dependency_map|
+            map = dependency_map.to_h
+
+            define_method :new do |*args, **kwargs|
+              map.each do |name, identifier|
+                kwargs[name] = container[identifier] unless kwargs.key?(name)
+              end
+
+              super(*args, **kwargs)
+            end
+          end
+        end
+
+        def define_initialize(klass)
+          super_parameters = MethodParameters.of(klass, :initialize).each do |ps|
+            # Look upwards past `def foo(*)` methods until we get an explicit list of parameters
+            break ps unless ps.pass_through?
+          end
+
+          if super_parameters.splat? || super_parameters.sequential_arguments?
+            define_initialize_with_splat(super_parameters)
+          else
+            define_initialize_with_keywords(super_parameters)
+          end
+
+          self
+        end
+
+        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|
+              assign_dependencies.(kwargs, self)
+
+              super_kwargs = slice_kwargs.(kwargs, super_parameters)
+
+              if super_kwargs.any?
+                super(super_kwargs)
+              else
+                super()
+              end
+            end
+          end
+        end
+
+        def define_initialize_with_splat(super_parameters)
+          assign_dependencies = method(:assign_dependencies)
+          slice_kwargs = method(:slice_kwargs)
+
+          instance_mod.class_exec do
+            define_method :initialize do |*args, **kwargs|
+              assign_dependencies.(kwargs, self)
+
+              if super_parameters.splat?
+                super(*args, kwargs)
+              else
+                super_kwargs = slice_kwargs.(kwargs, super_parameters)
+
+                if super_kwargs.any?
+                  super(*args, super_kwargs)
+                else
+                  super(*args)
+                end
+              end
+            end
+          end
+        end
+
+        def assign_dependencies(kwargs, destination)
+          dependency_map.names.each do |name|
+            # Assign instance variables, but only if the ivar is not
+            # previously defined (this improves compatibility with objects
+            # initialized in unconventional ways)
+            if kwargs.key?(name) || !destination.instance_variable_defined?(:"@#{name}")
+              destination.instance_variable_set :"@#{name}", kwargs[name]
+            end
+          end
+        end
+
+        def slice_kwargs(kwargs, super_parameters)
+          kwargs.select do |key|
+            !dependency_map.names.include?(key) || super_parameters.keyword?(key)
+          end
+        end
+      end
+
+      register_default :kwargs, Kwargs
+    end
+  end
+end

data/lib/dry/auto_inject/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module AutoInject
+    VERSION = '0.6.1'
+  end
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+begin
+  require 'rubocop/rake_task'
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << '--display-cop-names'
+  end
+
+  namespace :rubocop do
+    desc 'Generate a configuration file acting as a TODO list.'
+    task :auto_gen_config do
+      exec 'bundle exec rubocop --auto-gen-config'
+    end
+  end
+
+rescue LoadError
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: dry-auto_inject
+version: !ruby/object:Gem::Version
+  version: 0.6.1
+platform: ruby
+authors:
+- Piotr Solnica
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+description: 
+email:
+- piotr.solnica@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dry-auto_inject.gemspec
+- lib/dry-auto_inject.rb
+- lib/dry/auto_inject.rb
+- lib/dry/auto_inject/builder.rb
+- lib/dry/auto_inject/dependency_map.rb
+- lib/dry/auto_inject/injector.rb
+- lib/dry/auto_inject/method_parameters.rb
+- lib/dry/auto_inject/strategies.rb
+- lib/dry/auto_inject/strategies/args.rb
+- lib/dry/auto_inject/strategies/constructor.rb
+- lib/dry/auto_inject/strategies/hash.rb
+- lib/dry/auto_inject/strategies/kwargs.rb
+- lib/dry/auto_inject/version.rb
+- rakelib/rubocop.rake
+homepage: https://github.com/dry-rb/dry-auto_inject
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Container-agnostic automatic constructor injection
+test_files: []