dry-auto_inject 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59c074194d93b68ca4f6f5556cb2e50b6b613bb4
-  data.tar.gz: 2441a44b97fba6eceecbe97404f75e52367020eb
+  metadata.gz: 5c8a5ebc379dd91da33ab5b74b37b8b5233ce496
+  data.tar.gz: 530f763d2a088affcfba27591b4b414b0005b1e5
 SHA512:
-  metadata.gz: 7696fa4ae133db3ee5d2e80bbdd9b293eaf9aa5ab4dab1993ef35280ab82262bbfb3778cba933b722043de629919826f27dcc1c39b4db1d610d5d57fd9f7e707
-  data.tar.gz: 9d896a2cffcf233531d32b02f9c3d91288db46659236b53538993969427974bda1222cd90cb124de2b5249c5d235330b4c15a2337327bc4f0a47c2d2f5f1fe06
+  metadata.gz: fb55775c7a465d2f796e56421c6098abef986ea5c177b18851e4ba2cce6111bbdf8dad8fd873d52072e674901e7fcaeac23a304cae5cd6198e0581f7c5d32c6a
+  data.tar.gz: 0c9c3d0012f2978420fa74fd536eed7c77cdf0d579d85a28afb05d79399f02d31e770b31718679babe16befc8c1a3de22df0635bda5ef495f2475b12c69e0378

data/.travis.yml

@@ -8,8 +8,7 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
-  - rbx-2
-  - jruby
+  - rbx
   - ruby-head
   - jruby-head
 env:
@@ -17,6 +16,7 @@ env:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
 matrix:
   allow_failures:
+    - rvm: rbx
     - rvm: ruby-head
     - rvm: jruby-head
 notifications:

data/CHANGELOG.md

@@ -1,3 +1,89 @@
+# v.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::AutoInect(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::AutoInect(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))
+
 # v0.2.0 2016-02-09
 
 ### Added

data/Gemfile

@@ -5,8 +5,5 @@ gemspec
 
 group :tools do
   gem 'byebug', platforms: :mri
-  gem 'rubocop'
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'guard-rubocop'
+  gem 'pry'
 end

data/README.md

@@ -1,10 +1,18 @@
-# Dry::AutoInject <a href="https://gitter.im/dryrb/chat" target="_blank">![Join the chat at https://gitter.im/dryrb/chat](https://badges.gitter.im/Join%20Chat.svg)</a>
-
-<a href="https://rubygems.org/gems/dry-auto_inject" target="_blank">![Gem Version](https://badge.fury.io/rb/dry-auto_inject.svg)</a>
-<a href="https://travis-ci.org/dryrb/dry-auto_inject" target="_blank">![Build Status](https://travis-ci.org/dryrb/dry-auto_inject.svg?branch=master)</a>
-<a href="https://gemnasium.com/dryrb/dry-auto_inject" target="_blank">![Dependency Status](https://gemnasium.com/dryrb/dry-auto_inject.svg)</a>
-<a href="https://codeclimate.com/github/dryrb/dry-auto_inject" target="_blank">![Code Climate](https://codeclimate.com/github/dryrb/dry-auto_inject/badges/gpa.svg)</a>
-<a href="http://inch-ci.org/github/dryrb/dry-auto_inject" target="_blank">![Documentation Status](http://inch-ci.org/github/dryrb/dry-auto_inject.svg?branch=master&style=flat)</a>
+[gitter]: https://gitter.im/dry-rb/chat
+[gem]: https://rubygems.org/gems/dry-auto_inject
+[travis]: https://travis-ci.org/dry-rb/dry-auto_inject
+[gemnasium]: https://gemnasium.com/dry-rb/dry-auto_inject
+[code_climate]: https://codeclimate.com/github/dry-rb/dry-auto_inject
+[inch]: http://inch-ci.org/github/dry-rb/dry-auto_inject
+
+# dry-auto_inject [![Join the Gitter chat](https://badges.gitter.im/Join%20Chat.svg)][gitter]
+
+[![Gem Version](https://img.shields.io/gem/v/dry-auto_inject.svg)][gem]
+[![Build Status](https://img.shields.io/travis/dry-rb/dry-auto_inject.svg)][travis]
+[![Dependency Status](https://img.shields.io/gemnasium/dry-rb/dry-auto_inject.svg)][gemnasium]
+[![Code Climate](https://img.shields.io/codeclimate/github/dry-rb/dry-auto_inject.svg)][code_climate]
+[![API Documentation Coverage](http://inch-ci.org/github/dry-rb/dry-auto_inject.svg)][inch]
+![No monkey-patches](https://img.shields.io/badge/monkey--patches-0-brightgreen.svg)
 
 A simple extensions which allows you to automatically inject dependencies to your
 object constructors from a configured container.
@@ -73,5 +81,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/dryrb/dry-auto_inject.
+Bug reports and pull requests are welcome on GitHub at https://github.com/dry-rb/dry-auto_inject.
 

data/bin/console

@@ -1,14 +1,10 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'dry/pipeline'
+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.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start
+require 'pry'
+Pry.start

data/dry-auto_inject.gemspec

@@ -17,6 +17,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '>= 2.0.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'

data/lib/dry/auto_inject.rb

@@ -1,4 +1,4 @@
-require 'dry/auto_inject/version'
+require 'dry/auto_inject/builder'
 
 module Dry
   # Configure an auto-injection module
@@ -38,151 +38,15 @@ module Dry
   # @return [Proc] calling the returned proc builds an auto-injection module
   #
   # @api public
-  def self.AutoInject(container)
-    Injection.new(container)
+  def self.AutoInject(container, options = {})
+    AutoInject::Builder.new(container, options)
   end
 
-  class Injection
-    attr_reader :container, :options
-
-    # @api private
-    def initialize(container, options = {})
-      @container = container
-      @options = options
-    end
-
-    # @api public
-    def hash
-      self.class.new(container, options.merge(type: :hash))
-    end
-
-    # @api public
-    def [](*names)
-      AutoInject.new(names, container, options)
-    end
-  end
-
-  # @api private
-  class AutoInject < Module
-    attr_reader :names
-
-    attr_reader :container
-
-    attr_reader :instance_mod
-
-    attr_reader :ivars
-
-    attr_reader :options
-
-    attr_reader :type
-
-    # @api private
-    def initialize(names, container, options = {})
-      @names = names
-      @container = container
-      @options = options
-      @type = options.fetch(:type, :args)
-      @ivars = names.map(&:to_s).map { |s| s.split('.').last }.map(&:to_sym)
-      @instance_mod = Module.new
-      define_constructor
-    end
-
-    # @api private
-    def included(klass)
-      define_readers
-      define_new_method(klass)
-      define_container(klass)
-
-      klass.send(:include, instance_mod)
-
-      super
-    end
-
-    private
-
-    # @api private
-    def define_container(klass)
-      klass.instance_variable_set('@container', container)
-
-      klass.class_eval do
-        def self.container
-          if superclass.respond_to?(:container)
-            superclass.container
-          else
-            @container
-          end
-        end
-      end
-    end
-
-    # @api private
-    def define_new_method(klass)
-      case type
-      when :args then define_new_method_with_args(klass)
-      when :hash then define_new_method_with_hash(klass)
-      end
-    end
-
-    # @api private
-    def define_new_method_with_args(klass)
-      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.new(*args)
-          names = [#{names.map(&:inspect).join(', ')}]
-          deps = names.map.with_index { |_, i| args[i] || container[names[i]] }
-          super(*deps)
-        end
-      RUBY
-    end
-
-    # @api private
-    def define_new_method_with_hash(klass)
-      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.new(options = {})
-          names = [#{names.map(&:inspect).join(', ')}]
-          deps = names.each_with_object({}) { |k, r|
-            r[k.to_s.split('.').last.to_sym] = options[k] || container[k]
-          }.merge(options)
-          super(deps)
-        end
-      RUBY
-    end
-
-    # @api private
-    def define_constructor
-      case type
-      when :args then define_constructor_with_args
-      when :hash then define_constructor_with_hash
-      end
-    end
-
-    # @api private
-    def define_constructor_with_args
-      instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def initialize(*args)
-          super()
-          #{ivars.map.with_index { |name, i| "@#{name} = args[#{i}]" }.join("\n")}
-        end
-      RUBY
-      self
-    end
-
-    # @api private
-    def define_constructor_with_hash
-      instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def initialize(options)
-          super()
-          #{ivars.map { |name| "@#{name} = options[:#{name}]" }.join("\n")}
-        end
-      RUBY
-      self
-    end
-
+  module AutoInject
     # @api private
-    def define_readers
-      instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        attr_reader #{ivars.map { |name| ":#{name}" }.join(', ')}
-      RUBY
-      self
+    def self.super_method(klass, method)
+      method = klass.instance_method(method)
+      method unless method.owner.equal?(klass)
     end
   end
 end

data/lib/dry/auto_inject/builder.rb

@@ -0,0 +1,31 @@
+require 'dry/auto_inject/strategies'
+require 'dry/auto_inject/injector'
+
+module Dry
+  module AutoInject
+    class Builder
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :strategies
+
+      def initialize(container, options = {})
+        @container = container
+        @strategies = options.fetch(:strategies) { Strategies }
+
+        strategies.keys.each do |strategy_name|
+          define_singleton_method(strategy_name) do
+            strategy = strategies[strategy_name]
+            Injector.new(container, strategy)
+          end
+        end
+      end
+
+      # @api public
+      def [](*dependency_names)
+        default[*dependency_names]
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/dependency_map.rb

@@ -0,0 +1,44 @@
+module Dry
+  module AutoInject
+    DuplicateDependencyError = Class.new(StandardError)
+
+    class DependencyMap
+      def initialize(*dependencies)
+        @map = {}
+
+        dependencies = dependencies.dup
+        aliases = dependencies.last.is_a?(Hash) ? dependencies.pop : {}
+
+        dependencies.each do |identifier|
+          name = identifier.to_s.split(".").last
+          add_dependency(name, identifier)
+        end
+
+        aliases.each do |name, identifier|
+          add_dependency(name, identifier)
+        end
+      end
+
+      def inspect
+        @map.inspect
+      end
+
+      def names
+        @map.keys
+      end
+
+      def to_h
+        @map.dup.to_h
+      end
+      alias_method :to_hash, :to_h
+
+      private
+
+      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,23 @@
+require 'dry/auto_inject/strategies'
+
+module Dry
+  module AutoInject
+    class Injector
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :strategy
+
+      # @api private
+      def initialize(container, strategy)
+        @container = container
+        @strategy = strategy
+      end
+
+      def [](*dependency_names)
+        strategy.new(container, *dependency_names)
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/strategies.rb

@@ -0,0 +1,19 @@
+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,71 @@
+require 'dry/auto_inject/strategies/constructor'
+
+module Dry
+  module AutoInject
+    class Strategies
+      # @api private
+      class Args < Constructor
+        private
+
+        def define_new(klass)
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.new(*args)
+              names = #{dependency_map.inspect}
+              deps = names.values.map.with_index { |identifier, i| args[i] || container[identifier] }
+              super(*deps, *args[deps.size..-1])
+            end
+          RUBY
+        end
+
+        def define_initialize(klass)
+          super_method = find_super(klass, :initialize)
+
+          if super_method.nil? || super_method.parameters.empty?
+            define_initialize_with_params
+          else
+            define_initialize_with_splat(super_method)
+          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})
+              super()
+              #{dependency_map.names.map { |name| "@#{name} = #{name}" }.join("\n")}
+            end
+          RUBY
+        end
+
+        def define_initialize_with_splat(super_method)
+          super_params = if super_method.parameters.any? { |type, _| type == :rest }
+            '*args'
+          else
+            "*args[0..#{super_method.parameters.length - 1}]"
+          end
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(*args)
+              super(#{super_params})
+              #{dependency_map.names.map.with_index { |name, i| "@#{name} = args[#{i}]" }.join("\n")}
+            end
+          RUBY
+        end
+
+        def find_super(klass, method_name)
+          super_method = Dry::AutoInject.super_method(klass, method_name)
+
+          # Look upwards past `def foo(*)` methods until we get an explicit list of parameters
+          while super_method && super_method.parameters == [[:rest]]
+            super_method = Dry::AutoInject.super_method(super_method.owner, :initialize)
+          end
+
+          super_method
+        end
+      end
+
+      register :args, Args
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'dry/auto_inject/dependency_map'
+
+module Dry
+  module AutoInject
+    class Strategies
+      class Constructor < Module
+        ClassMethods = Class.new(Module) do
+          def initialize(container)
+            super()
+            define_method(:container) { container }
+          end
+        end
+
+        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(container)
+        end
+
+        # @api private
+        def included(klass)
+          define_readers
+
+          define_new(klass)
+          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(klass)
+          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,38 @@
+require 'dry/auto_inject/strategies/constructor'
+
+module Dry
+  module AutoInject
+    class Strategies
+      # @api private
+      class Hash < Constructor
+        private
+
+        def define_new(_klass)
+          class_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def new(options = {})
+              names = #{dependency_map.inspect}
+              deps = names.each_with_object({}) { |(name, identifier), obj|
+                obj[name] = options[name] || container[identifier]
+              }.merge(options)
+              super(deps)
+            end
+          RUBY
+        end
+
+        def define_initialize(klass)
+          super_method = Dry::AutoInject.super_method(klass, :initialize)
+          super_params = super_method.nil? || super_method.parameters.empty? ? '' : 'options'
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(options)
+              super(#{super_params})
+              #{dependency_map.names.map { |name| "@#{name} = options[:#{name}]" }.join("\n")}
+            end
+          RUBY
+        end
+      end
+
+      register :hash, Hash
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'dry/auto_inject/strategies/constructor'
+
+module Dry
+  module AutoInject
+    class Strategies
+      # @api private
+      class Kwargs < Constructor
+        private
+
+        def define_new(_klass)
+          class_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def new(**args)
+              names = #{dependency_map.inspect}
+              deps = names.each_with_object({}) { |(name, identifier), obj|
+                obj[name] = args[name] || container[identifier]
+              }.merge(args)
+              super(**deps)
+            end
+          RUBY
+        end
+
+        def define_initialize(klass)
+          super_method = Dry::AutoInject.super_method(klass, :initialize)
+
+          if super_method.nil? || super_method.parameters.empty?
+            define_initialize_with_keywords
+          else
+            define_initialize_with_splat(super_method)
+          end
+
+          self
+        end
+
+        def define_initialize_with_keywords
+          initialize_params = dependency_map.names.map { |name| "#{name}: nil" }.join(', ')
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(#{initialize_params})
+              super()
+              #{dependency_map.names.map { |name| "@#{name} = #{name}" }.join("\n")}
+            end
+          RUBY
+          self
+        end
+
+        def define_initialize_with_splat(super_method)
+          super_kwarg_names = super_method.parameters.select { |type, _| [:key, :keyreq].include?(type) }.map(&:last)
+          super_params = super_kwarg_names.map { |name| "#{name}: args[:#{name}]" }.join(', ')
+
+          # Pass through any non-dependency args if the super method accepts `**args`
+          if super_method.parameters.any? { |type, _| type == :keyrest }
+            super_params += ', **args'
+          end
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(**args)
+              super(#{super_params})
+              #{dependency_map.names.map { |name| "@#{name} = args[:#{name}]" }.join("\n")}
+            end
+          RUBY
+          self
+        end
+      end
+
+      register_default :kwargs, Kwargs
+    end
+  end
+end

data/lib/dry/auto_inject/version.rb

@@ -1,5 +1,5 @@
 module Dry
-  class AutoInject < Module
-    VERSION = '0.2.0'.freeze
+  module AutoInject
+    VERSION = '0.3.0'.freeze
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dry-auto_inject
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-09 00:00:00.000000000 Z
+date: 2016-06-01 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
@@ -73,6 +87,14 @@ files:
 - 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/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/dryrb/dry-auto_inject
@@ -86,7 +108,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -94,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Container-agnostic automatic constructor injection