dry-auto_inject 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04bd4b08425b83733006cac8ef6612068304a720a63f8896e8f0369e1d26b0cc
-  data.tar.gz: 38b6073a686faa24ec5b628e70125ae97ea2c402403c410608acd57506a7482c
+  metadata.gz: 0703f168c7bd86b0b847ff3805d192745b22595a9b0b70bd1880e74d4a189251
+  data.tar.gz: f4fe146fe1721a14cf22a90cb7a5d58f17f55ba97a5e74304368a04c69a26f47
 SHA512:
-  metadata.gz: bd8267844c208234397d5b8a62113bc5bc665daad2c3410d27342489b5894b24b92e6dec1df721028e5967a0f2f7c24465e52bac7b4e469ad0e6e98d65bb0c25
-  data.tar.gz: 64be14b7a6797e064690838ec867c0d2056101387e5a652cf20213ef40f5a86822420f50a42d8f85288bc66af30f710c05b2c8dde4e4ca0952b2d3cd71b0a3d5
+  metadata.gz: ad18bccd197227333852c9cb65116cfff76a3fce5a5dfaef22ad73cdcfbda699f8305602d330af59b2dd3a8fe02c40cf403ac10e23f973db9b1787b2928e824e
+  data.tar.gz: a699bbd6b33883d036fee625782790ea9a43e6687c730a7f62185c47570df021f661e33ea492ab9c72d79584717074b5ebd2bb7c012b27753c127c928ae19983

data/.codeclimate.yml

@@ -1,6 +1,12 @@
-engines:
+# this file is managed by dry-rb/devtools project
+
+version: "2"
+
+exclude_patterns:
+  - "benchmarks/"
+  - "examples/"
+  - "spec/"
+
+plugins:
   rubocop:
     enabled: true
-ratings:
-  paths:
-    - lib/**

data/.github/ISSUE_TEMPLATE/----please-don-t-ask-for-support-via-issues.md

@@ -0,0 +1,10 @@
+---
+name: "⚠️  Please don't ask for support via issues"
+about: See CONTRIBUTING.md for more information
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+

data/.github/ISSUE_TEMPLATE/---bug-report.md

@@ -0,0 +1,30 @@
+---
+name: "\U0001F41B Bug report"
+about: See CONTRIBUTING.md for more information
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Before you submit this: WE ONLY ACCEPT BUG REPORTS AND FEATURE REQUESTS**
+
+For more information see `CONTRIBUTING.md`.
+
+**Describe the bug**
+
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+
+Provide detailed steps to reproduce, an executable script would be best.
+
+**Expected behavior**
+
+A clear and concise description of what you expected to happen.
+
+**Your environment**
+
+- Affects my production application: **YES/NO**
+- Ruby version: ...
+- OS: ...

data/.github/ISSUE_TEMPLATE/---feature-request.md

@@ -0,0 +1,18 @@
+---
+name: "\U0001F6E0 Feature request"
+about: See CONTRIBUTING.md for more information
+title: ''
+labels: feature
+assignees: ''
+
+---
+
+Summary of what the feature is supposed to do.
+
+## Examples
+
+Code examples showing how the feature could be used.
+
+## Resources
+
+Additional information, like a link to the discussion forum thread where the feature was discussed etc.

data/.github/workflows/ci.yml

@@ -0,0 +1,76 @@
+# this file is managed by dry-rb/devtools project
+
+name: ci
+
+on:
+  push:
+    paths:
+      - .github/workflows/ci.yml
+      - lib/**
+      - spec/**
+      - Gemfile
+      - "*.gemspec"
+
+jobs:
+  tests-mri:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["2.6.x", "2.5.x", "2.4.x"]
+        include:
+          - ruby: "2.6.x"
+            coverage: "true"
+    steps:
+      - uses: actions/checkout@v1
+      - name: Set up Ruby
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: ${{matrix.ruby}}
+      - name: Download test reporter
+        if: "matrix.coverage == 'true'"
+        run: |
+          mkdir -p tmp/
+          curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./tmp/cc-test-reporter
+          chmod +x ./tmp/cc-test-reporter
+          ./tmp/cc-test-reporter before-build
+      - name: Bundle install
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3 --without tools docs benchmarks
+      - name: Run all tests
+        env:
+          COVERAGE: ${{matrix.coverage}}
+        run: bundle exec rake
+      - name: Send coverage results
+        if: "matrix.coverage == 'true'"
+        env:
+          CC_TEST_REPORTER_ID: ${{secrets.CC_TEST_REPORTER_ID}}
+          GIT_COMMIT_SHA: ${{github.sha}}
+          GIT_BRANCH: ${{github.ref}}
+          GIT_COMMITTED_AT: ${{github.event.head_commit.timestamp}}
+        run: |
+          GIT_BRANCH=`ruby -e "puts ENV['GITHUB_REF'].split('/', 3).last"` \
+          GIT_COMMITTED_AT=`ruby -r time -e "puts Time.iso8601(ENV['GIT_COMMITTED_AT']).to_i"` \
+          ./tmp/cc-test-reporter after-build
+
+  tests-others:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        image: ["jruby:9.2.9", "ruby:2.7"]
+    container:
+      image: ${{matrix.image}}
+    steps:
+      - uses: actions/checkout@v1
+      - name: Install git
+        run: |
+          apt-get update
+          apt-get install -y --no-install-recommends git
+      - name: Bundle install
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3 --without tools docs benchmarks
+      - name: Run all tests
+        run: bundle exec rake

data/.github/workflows/docsite.yml

@@ -0,0 +1,34 @@
+# this file is managed by dry-rb/devtools project
+
+name: docsite
+
+on:
+  push:
+    paths:
+      - docsite/**
+      - .github/workflows/docsite.yml
+    branches:
+      - master
+      - release-**
+    tags:
+
+jobs:
+  update-docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Set up Ruby
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: "2.6.x"
+      - name: Install dependencies
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3 --without benchmarks sql
+      - name: Symlink ossy
+        run: mkdir -p bin && ln -sf "$(bundle show ossy)/bin/ossy" bin/ossy
+      - name: Trigger dry-rb.org deploy
+        env:
+          GITHUB_LOGIN: dry-bot
+          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+        run: bin/ossy github workflow dry-rb/dry-rb.org ci

data/.github/workflows/sync_configs.yml

@@ -0,0 +1,34 @@
+# this file is managed by dry-rb/devtools project
+
+name: sync_configs
+
+on:
+  repository_dispatch:
+
+jobs:
+  sync-configs:
+    runs-on: ubuntu-latest
+    if: github.event.action == 'sync_configs'
+    steps:
+      - uses: actions/checkout@v1
+      - name: Update configuration files from devtools
+        env:
+          GITHUB_LOGIN: dry-bot
+          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+        run: |
+          git clone https://github.com/dry-rb/devtools.git tmp/devtools
+
+          if [ -f ".github/workflows/custom_ci.yml" ]; then
+            rsync -av --exclude '.github/workflows/ci.yml' tmp/devtools/shared/ . ;
+          else
+            rsync -av tmp/devtools/shared/ . ;
+          fi
+
+          git config --local user.email "dry-bot@dry-rb.org"
+          git config --local user.name "dry-bot"
+          git add -A
+          git commit -m "[devtools] config sync" || echo "nothing changed"
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GH_PAT }}

data/.rspec

@@ -1,2 +1,4 @@
 --color
 --require spec_helper
+--order random
+--warnings

data/.rubocop.yml

@@ -1,19 +1,95 @@
-# Generated by `rubocop --auto-gen-config`
-inherit_from: .rubocop_todo.yml
+# this file is managed by dry-rb/devtools project
 
-Metrics/LineLength:
-  Max: 110
+AllCops:
+  TargetRubyVersion: 2.4
 
-Lint/HandleExceptions:
-  Exclude:
-    - rakelib/*.rake
+Style/EachWithObject:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/Alias:
+  Enabled: false
 
 Style/LambdaCall:
-  EnforcedStyle: braces
+  Enabled: false
+
+Style/StabbyLambdaParentheses:
+  Enabled: false
+
+Style/FormatString:
+  Enabled: false
 
 Style/Documentation:
   Enabled: false
 
-Style/FileName:
+Layout/SpaceInLambdaLiteral:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+  EnforcedStyle: indented
+
+Metrics/LineLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Max: 22
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/AbcSize:
+  Max: 20
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: true
+  Max: 10
+
+Lint/BooleanSymbol:
+  Enabled: false
+
+Style/AccessModifierDeclarations:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false
+
+Layout/IndentFirstArrayElement:
+  EnforcedStyle: consistent
+
+Style/ClassAndModuleChildren:
   Exclude:
-    - lib/dry-pipeline.rb
+    - "spec/**/*_spec.rb"
+
+Lint/HandleExceptions:
+  Exclude:
+    - "spec/spec_helper.rb"
+
+Naming/FileName:
+  Exclude:
+    - "lib/dry-*.rb"
+
+Style/SymbolArray:
+  Exclude:
+    - "spec/**/*_spec.rb"
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Naming/MethodName:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/DateTime:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.7.0 / 2019-12-28
+
+### Fixed
+
+- Keyword warnings issued by Ruby 2.7 in certain contexts (flash-gordon)
+
+### Changed
+
+- [BREAKING] Support for 2.3 was dropped
+
+[Compare v0.6.1...v0.7.0](https://github.com/dry-rb/dry-auto_inject/compare/v0.6.1...v0.7.0)
+
 # 0.6.1 / 2019-04-16
 
 ### Fixed
@@ -28,35 +40,35 @@
 
 - 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
+  ```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
 
-    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
+    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)
 
@@ -112,20 +124,20 @@
 
 - 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
+  ```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
+  # 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
-    ```
+  # 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
 
@@ -141,87 +153,89 @@
 
 ### Added
 
-* Support for new `kwargs` and `hash` injection strategies
+- Support for new `kwargs` and `hash` injection strategies
 
-    These strategies can be accessed via methods on the main builder object:
+  These strategies can be accessed via methods on the main builder object:
 
-    ```ruby
-    MyInject = Dry::AutoInject(my_container)
+  ```ruby
+  MyInject = Dry::AutoInject(my_container)
 
-    class MyClass
-      include MyInject.hash["my_dep"]
-    end
-    ```
-* Support for user-provided injection strategies
+  class MyClass
+    include MyInject.hash["my_dep"]
+  end
+  ```
 
-    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:
+- Support for user-provided injection strategies
 
-    ```ruby
-    class CustomStrategy < Module
-      # Your strategy code goes here :)
-    end
+  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:
 
-    # Registering your own strategy (globally)
-    Dry::AutoInject::Strategies.register :custom, CustomStrategy
+  ```ruby
+  class CustomStrategy < Module
+    # Your strategy code goes here :)
+  end
 
-    MyInject = Dry::AutoInject(my_container)
+  # Registering your own strategy (globally)
+  Dry::AutoInject::Strategies.register :custom, CustomStrategy
 
-    class MyClass
-      include MyInject.custom["my_dep"]
-    end
+  MyInject = Dry::AutoInject(my_container)
 
-    # Providing your own container (keeping the existing strategies in place)
-    class MyStrategies < Dry::AutoInject::Strategies
-      register :custom, CustomStrategy
-    end
+  class MyClass
+    include MyInject.custom["my_dep"]
+  end
 
-    MyInject = Dry::AutoInject(my_container, strategies: MyStrategies)
+  # Providing your own container (keeping the existing strategies in place)
+  class MyStrategies < Dry::AutoInject::Strategies
+    register :custom, CustomStrategy
+  end
 
-    class MyClass
-      include MyInject.custom["my_dep"]
-    end
+  MyInject = Dry::AutoInject(my_container, strategies: MyStrategies)
 
-    # Proiding a completely separated container
-    class MyStrategies
-      extend Dry::Container::Mixin
-      register :custom, CustomStrategy
-    end
+  class MyClass
+    include MyInject.custom["my_dep"]
+  end
 
-    MyInject = Dry::AutoInject(my_container, strategies: MyStrategies)
+  # Proiding a completely separated container
+  class MyStrategies
+    extend Dry::Container::Mixin
+    register :custom, CustomStrategy
+  end
 
-    class MyClass
-      include MyInject.custom["my_dep"]
-    end
-    ```
-* User-specified aliases for dependencies
+  MyInject = Dry::AutoInject(my_container, strategies: MyStrategies)
 
-    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:
+  class MyClass
+    include MyInject.custom["my_dep"]
+  end
+  ```
 
-    ```ruby
-    MyInject = Dry::AutoInject(my_container)
+- User-specified aliases for dependencies
 
-    class MyClass
-      include MyInject[my_dep: "some_other.dep"]
+  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:
 
-      # Refer to the dependency as `my_dep` inside the class
-    end
+  ```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)
-    ```
+  # 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:
+  A mix of both regular and aliased dependencies can also be injected:
 
-    ```ruby
-    include MyInject["some_dep", another_dep: "some_other.dep"]
-    ```
+  ```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.
+- 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))
+- `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)
 
@@ -229,7 +243,7 @@
 
 ### Added
 
-* Support for hashes as constructor arguments via `Import.hash` interface (solnic)
+- 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)
 

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.4.0, available at [https://www.contributor-covenant.org/version/1/4/code-of-conduct](https://www.contributor-covenant.org/version/1/4/code-of-conduct)

data/CONTRIBUTING.md

@@ -10,7 +10,7 @@ Report a feature request **only after discussing it first on [discourse.dry-rb.o
 
 ## Reporting questions, support requests, ideas, concerns etc.
 
-**PLEASE DON'T** - use [discourse.dry-rb.org](https://discourse.dry-rb.org) instead.
+**PLEASE DON'T** - use [discourse.dry-rb.org](http://discourse.dry-rb.org) instead.
 
 # Pull Request Guidelines
 
@@ -26,4 +26,4 @@ Other requirements:
 
 # 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).
+If these guidelines aren't helpful, and you're stuck, please post a message on [discourse.dry-rb.org](https://discourse.dry-rb.org) or join [our chat](https://dry-rb.zulipchat.com).

data/Gemfile

@@ -13,4 +13,5 @@ end
 group :tools do
   gem 'byebug', platforms: :mri
   gem 'pry'
+  gem "ossy", git: "https://github.com/solnic/ossy.git", branch: "master"
 end

data/LICENSE

@@ -1,20 +1,20 @@
-Copyright (c) 2015-2016 Piotr Solnica
+The MIT License (MIT)
 
-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:
+Copyright (c) 2015-2019 dry-rb team
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+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 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.
+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

@@ -1,5 +1,5 @@
 [gem]: https://rubygems.org/gems/dry-auto_inject
-[travis]: https://travis-ci.org/dry-rb/dry-auto_inject
+[ci]: https://github.com/dry-rb/dry-auto_inject/actions?query=workflow%3Aci
 [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
@@ -8,7 +8,7 @@
 # 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]
+[![Build Status](https://github.com/dry-rb/dry-auto_inject/workflows/ci/badge.svg)][ci]
 [![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]
@@ -38,13 +38,14 @@ $ bundle
 ```
 
 Or install it yourself as:
+
 ```sh
 $ gem install dry-auto_inject
 ```
 
 ## Links
 
-* [Documentation](http://dry-rb.org/gems/dry-auto_inject/)
+- [Documentation](http://dry-rb.org/gems/dry-auto_inject/)
 
 ## Development
 
@@ -55,4 +56,3 @@ 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/dry-rb/dry-auto_inject.
-

data/docsite/source/basic-usage.html.md

@@ -0,0 +1,104 @@
+---
+title: Basic usage
+layout: gem-single
+name: dry-auto_inject
+---
+
+### Requirements
+
+You need only one thing before you can use dry-auto\_inject: a container to hold your application’s dependencies. These are commonly known as “inversion of control” containers.
+
+A [dry-container](/gems/dry-container) will work well, but the only requirement is that the container responds to the `#[]` interface. For example, `my_container["users_repository"]` should return the “users_repository” object registered with the container.
+
+### Creating an injector
+
+To create an injector, pass the container to `Dry::AutoInject`:
+
+```ruby
+Import = Dry::AutoInject(my_container)
+```
+
+Assign the injector to a constant (or make it globally accessible somehow) so you can refer to it from within your classes.
+
+### Specifying dependencies
+
+To specify the dependencies for a class, mix in the injector and provide the container identifiers for each dependency:
+
+```ruby
+class MyClass
+  include Import["users_repository", "deliver_welcome_email"]
+end
+```
+
+### Using dependencies
+
+Each dependency is available via a reader with a matching name:
+
+```ruby
+class MyClass
+  include Import["users_repository"]
+
+  def call
+    puts users_repository.inspect
+  end
+end
+```
+
+If your container identifiers include delimiters (like `"."`) or other characters that are not allowed within variable or method names, then the final part of the name will be used instead:
+
+```ruby
+class MyClass
+  include Import["repositories.users"]
+
+  def call
+    puts users.inspect
+  end
+end
+```
+
+### Specifying aliases for dependencies
+
+You can specify dependencies as a hash to provide your own names for each one:
+
+```ruby
+class MyClass
+  include Import[users_repo: "repositories.users"]
+
+  def call
+    puts users_repo.inspect
+  end
+end
+```
+
+If you want to provide a mix of inferred names and aliases, provide the aliases last:
+
+```ruby
+class MyClass
+  include Import[
+    "repositories.users",
+    deliver_email: "operations.deliver_welcome_email",
+  ]
+end
+```
+
+### Initializing your object
+
+Initialize your object without any arguments and all the dependencies will be resolved from the the container automatically:
+
+```ruby
+my_obj = MyClass.new
+```
+
+### Passing manual dependencies
+
+To provide an alternative object for a dependency, pass it to the initializer with a keyword argument matching the dependency’s name:
+
+```ruby
+class MyClass
+  include Import["repositories.users"]
+end
+
+my_obj = MyClass.new(users: different_repo)
+```
+
+This technique is useful when testing your class in isolation. You can pass in test doubles to verify your class’ behaviour under various different circumstances.

data/docsite/source/how-does-it-work.html.md

@@ -0,0 +1,45 @@
+---
+title: How does it work?
+layout: gem-single
+name: dry-auto_inject
+---
+
+dry-auto\_inject enables _constructor dependency injection_ for your objects. It achieves this by defining two methods in the module that you include in your class.
+
+First, it defines `.new`, which resolves your dependencies from the container, if you haven't otherwise provided them as explicit arguments. It then passes these dependencies as arguments onto `#initialize`, as per Ruby’s usual behaviour.
+
+It also defines `#initialize`, which receives these dependencies as arguments and then assigns them to instance variables. These variables are made available via `attr_reader`s.
+
+So when you specify dependencies like this:
+
+```ruby
+Import = Dry::AutoInject(MyContainer)
+
+class MyClass
+  include Import["users_repository"]
+end
+```
+
+You’re building something like this (this isn’t a line-for-line copy of what is mixed into your class; it’s intended as a guide only):
+
+```ruby
+class MyClass
+  attr_reader :users_repository
+
+  def self.new(**args)
+    deps = {
+      users_repository: args[:users_repository] || MyContainer["users_repository"]
+    }
+
+    super(**deps)
+  end
+
+  def initialize(users_repository: nil)
+    super()
+
+    @users_repository = users_repository
+  end
+end
+```
+
+Since these methods are defined in the module that you include in your class, you can still override them in your class if you wish to provide custom behavior.

data/docsite/source/index.html.md

@@ -0,0 +1,53 @@
+---
+title: Introduction
+description: Container-agnostic dependency resolution mixin
+layout: gem-single
+order: 4
+type: gem
+name: dry-auto_inject
+sections:
+  - basic-usage
+  - how-does-it-work
+  - injection-strategies
+---
+
+dry-auto\_inject provides low-impact dependency injection and resolution support for your classes.
+
+It’s designed to work with a container that holds your application’s dependencies. It works well with [dry-container](/gems/dry-container), but supports any container that responds to the `#[]` interface.
+
+### Usage example
+
+```ruby
+# Set up a container (using dry-container here)
+class MyContainer
+  extend Dry::Container::Mixin
+
+  register "users_repository" do
+    UsersRepository.new
+  end
+
+  register "operations.create_user" do
+    CreateUser.new
+  end
+end
+
+# Set up your auto-injection mixin
+Import = Dry::AutoInject(MyContainer)
+
+class CreateUser
+  include Import["users_repository"]
+
+  def call(user_attrs)
+    users_repository.create(user_attrs)
+  end
+end
+
+create_user = MyContainer["operations.create_user"]
+create_user.call(name: "Jane")
+```
+
+### Why use dry-auto\_inject?
+
+Splitting your application’s behavior into smaller, more focused units makes for logic that is easier to understand, test, and refactor. Dependency injection is what then allows you to combine these small units to create more sophisticated behavior.
+
+By using a container and dry-auto\_inject, this process becomes easy. You don’t need to worry about building constructors or accessors, and adding extra dependencies is as easy as adding a string to a list.

data/docsite/source/injection-strategies.html.md

@@ -0,0 +1,94 @@
+---
+title: Injection strategies
+layout: gem-single
+name: dry-auto_inject
+---
+
+dry-auto\_inject supports three _injection strategies_, allowing you to design and integrate with different kinds of classes.
+
+These strategies all provide _constructor dependency injection_: dependencies are passed when creating your objects. The strategies differ in how they expect dependencies to be passed to the initializer.
+
+## Choosing a strategy
+
+Choose a strategy when you build the injector:
+
+```ruby
+# Default keyword arguments strategy
+Import = Dry::AutoInject(MyContainer)
+
+# Positional arguments strategy
+Import = Dry::AutoInject(MyContainer).args
+```
+
+Strategies can also be chained from existing injectors, which means you can set up a single injector for your most commonly used strategy, then use a different strategy directly in particular classes if they have differing requirements. For example:
+
+```ruby
+# Set up a standard strategy for your app
+Import = Dry::AutoInject(MyContainer)
+
+class MyClass
+ # Use the standard strategy here
+ include Import["users_repository"]
+end
+
+class SpecialClass
+ # Use a different strategy in this particular class
+ include Import.args["users_repository"]
+end
+```
+
+## Strategies
+
+### Keyword arguments (`kwargs`)
+
+This is the default strategy.
+
+Pass dependencies to the initializer using keyword arguments.
+
+```ruby
+Import = Dry::AutoInject(MyContainer)
+
+class MyClass
+ include Import["users_repository"]
+end
+
+MyClass.new(users_repository: my_repo)
+```
+
+The `#initialize` method has two possible argument signatures:
+
+- If there is no `super` method for `#initialize`, or the `super` method takes no arguments, then the keyword arguments will be explicit, e.g. `#initialize(users_repository: nil)`.
+- If the `super` method for `#initialize` takes its own set of keyword arguments, then the arguments will be a single splat, e.g. `#initialize(**args)`.
+
+### Options hash (`hash`)
+
+Pass the dependencies to the initializer as a single hash.
+
+```ruby
+Import = Dry::AutoInject(MyContainer).hash
+
+class MyClass
+ include Import["users_repository"]
+end
+
+# This can also take `{users_repo: my_repo}`
+MyClass.new(users_repository: my_repo)
+```
+
+The `#initialize` method has an argument signature of `#initialize(options)`, where `options` is expected to be a hash.
+
+### Positional arguments (`args`)
+
+Pass dependencies to the initializer using standard positional arguments.
+
+```ruby
+Import = Dry::AutoInject(MyContainer).args
+
+class MyClass
+ include Import["users_repository"]
+end
+
+MyClass.new(my_repo)
+```
+
+The `#initialize` method has an argument signature with a named positional argument for each dependency, e.g. `#initialize(users_repository)`.

data/dry-auto_inject.gemspec

@@ -19,7 +19,7 @@ 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.3.0'
+  spec.required_ruby_version = '>= 2.4.0'
 
   spec.add_runtime_dependency 'dry-container', '>= 0.3.4'
 

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

@@ -50,7 +50,7 @@ module Dry
               super_kwargs = slice_kwargs.(kwargs, super_parameters)
 
               if super_kwargs.any?
-                super(super_kwargs)
+                super(**super_kwargs)
               else
                 super()
               end
@@ -67,12 +67,12 @@ module Dry
               assign_dependencies.(kwargs, self)
 
               if super_parameters.splat?
-                super(*args, kwargs)
+                super(*args, **kwargs)
               else
                 super_kwargs = slice_kwargs.(kwargs, super_parameters)
 
                 if super_kwargs.any?
-                  super(*args, super_kwargs)
+                  super(*args, **super_kwargs)
                 else
                   super(*args)
                 end

data/lib/dry/auto_inject/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module AutoInject
-    VERSION = '0.6.1'
+    VERSION = '0.7.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-auto_inject
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-15 00:00:00.000000000 Z
+date: 2019-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-container
@@ -74,12 +74,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
+- ".github/ISSUE_TEMPLATE/----please-don-t-ask-for-support-via-issues.md"
+- ".github/ISSUE_TEMPLATE/---bug-report.md"
+- ".github/ISSUE_TEMPLATE/---feature-request.md"
+- ".github/workflows/ci.yml"
+- ".github/workflows/docsite.yml"
+- ".github/workflows/sync_configs.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
 - Gemfile
 - LICENSE
@@ -87,6 +93,10 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- docsite/source/basic-usage.html.md
+- docsite/source/how-does-it-work.html.md
+- docsite/source/index.html.md
+- docsite/source/injection-strategies.html.md
 - dry-auto_inject.gemspec
 - lib/dry-auto_inject.rb
 - lib/dry/auto_inject.rb
@@ -113,14 +123,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Container-agnostic automatic constructor injection

data/.travis.yml

@@ -1,26 +0,0 @@
-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