maglev-injectable 2.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 032be6c3740e077577ece58660af3636a98adb9cc13272ab12e42f3366724dad
+  data.tar.gz: bb6549d739e3e2a5a49fd134436c3874fa4f78e9825d8b795ce9a182cdf28207
+SHA512:
+  metadata.gz: ff4c8dd10329368fe28ad93d552ced0a109ab34234a7e7c375989423da9acfdbef467c3e1bf9bf8af6d93d37aa8446c7ad5c5a8ffc43db162923608378b49e6e
+  data.tar.gz: '0856a305f51edb5df46c84201c19108220c2af77943cd5bd679e6127c0a82f7004ba128f727eb08b307e03e0ce6523dede3aeb1208c6d7ace7e44c021e04abc2'

data/.github/workflows/ruby.yml

@@ -0,0 +1,25 @@
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ 2.5.x, 2.6, 2.7.x ]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby ${{ matrix.ruby }}
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 2.0.1

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+### Unreleased
+
+### 2.1.1 - 2021-03-15
+
+* bug fixes
+  * Address final Ruby 2.7 warnings (#24)
+
+### 2.1.0 - 2021-01-05
+
+* enhancements
+  * Return `method` object instead of monkey patched instance (#17)
+  * Prepare for Ruby 3.0 (#22)
+
+### 2.0.0 - 2020-03-16
+
+* breaking changes
+  * Raises exception if shadowing an existing `#call` method in a dependency (#15)
+
+### 1.0.3 - 2020-03-16
+
+* enhancements
+  * Added GitHub Actions as CI (#9)
+
+* bug fixes
+  * Fixed a bug that wouldn't pass a block if `#call` was aliased (#7)
+
+### 1.0.2 - 2020-03-02
+
+* security
+  * Bump `rake` to 12.3.3 (#11)

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+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, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at dev@rubiconmd.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in injectable.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    maglev-injectable (2.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.3)
+    coderay (1.1.3)
+    diff-lcs (1.4.4)
+    method_source (1.0.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  maglev-injectable!
+  pry-byebug
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.2.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 amrocco
+
+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,360 @@
+# Injectable
+
+[![Maintainability](https://api.codeclimate.com/v1/badges/a45cc5935a5c16b837ed/maintainability)](https://codeclimate.com/github/rubiconmd/injectable/maintainability)![Ruby](https://github.com/rubiconmd/injectable/workflows/Ruby/badge.svg)
+
+`Injectable` is an opinionated and declarative [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection) library for ruby.
+
+It is being used in production (under ruby 2.5.1) in [RubiconMD](https://github.com/rubiconmd) and was extracted from its codebase.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'injectable', '>= 1.0.0'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install injectable
+
+## Motivation
+
+The main motivation of `Injectable` is to ease compliance with [SOLID's](https://en.wikipedia.org/wiki/SOLID)\*, [SRP](https://en.wikipedia.org/wiki/Single_responsibility_principle)\* and [Dependency Inversion principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle) by providing a declarative and very readable [DSL](https://en.wikipedia.org/wiki/Domain-specific_language)\* which avoids lots of bolierplate code and thus encourages good practices.*
+
+*Sorry about the acronyms, but using an [Ubiquitous Language](https://martinfowler.com/bliki/UbiquitousLanguage.html) is important.
+
+### Encapsulate domain logic
+
+Using Ruby on Rails recommended practices as an example, when your application grows enough you usually end up with huge model classes with too many responsibilities.
+
+It's way better (although it requires effort and discipline) to split those models and extract domain logic into [Service Objects](https://martinfowler.com/bliki/AnemicDomainModel.html) ("SOs" from now on). You can do this without `Injectable`, but `Injectable` will make your SOs way more readable and a pleasure not only to write but also to test, while encouraging general good practices.
+
+### Avoiding to hardcode dependencies
+
+If you find occurences of `SomeClass.any_instance.expects(:method)` in your **unit** tests, then you are probably hardcoding dependencies:
+
+```rb
+test "MyClass#call"
+  Collaborator.any_instance.expects(:submit!) # hardcoded dependency
+  MyClass.new.call
+end
+
+class MyClass
+  attr_reader :collaborator
+
+  def initialize
+    @collaborator = Collaborator.new
+  end
+
+  def call
+    collaborator.submit!
+  end
+end
+```
+
+What if you did this instead:
+
+```rb
+test "MyClass#call"
+  collaborator = stub('Collaborator')
+  collaborator.expects(:submit!)
+  MyClass.new(collaborator: collaborator).call
+end
+
+class MyClass
+  attr_reader :collaborator
+
+  def initialize(collaborator: Collaborator.new) # we will just provide a default
+    @collaborator = collaborator
+  end
+
+  def call
+    collaborator.submit!
+  end
+end
+```
+
+The benefits are not only for testing, as now your class is more modular and you can swap collaborators as long as they have the proper interface, in this case they have to `respond_to :submit!`
+
+`Injectable` allows you to write the above code like this:
+
+```rb
+class MyClass
+  include Injectable
+
+  dependency :collaborator
+
+  def call
+    collaborator.submit!
+  end
+end
+```
+
+It might not seem a lot but:
+
+1. Imagine that you have 4 dependencies. That's a lot of boilerplate.
+2. `Injectable` is not only this, it has many more features. Please keep reading.
+
+## Usage example
+
+`Injectable` is a mixin that you have to include in your class and it will provide several macros.
+
+This is a real world example:
+
+```rb
+class PdfGenerator
+  include Injectable
+
+  dependency :wicked_pdf
+
+  argument :html
+  argument :render_footer, default: false
+
+  def call
+    wicked_pdf.pdf_from_string(html, options)
+  end
+
+  private
+
+  def options
+    return {} unless render_footer
+
+    {
+      footer: {
+        left: footer,
+      }
+    }
+  end
+
+  def footer
+    "Copyright ® #{Time.current.year}"
+  end
+end
+
+# And you would use it like this:
+PdfGenerator.call(html: '<some html here>')
+# Overriding the wicked_pdf dependency:
+PdfGenerator.new(wicked_pdf: wicked_pdf_replacement).call(html: '<some html>')
+```
+
+## Premises
+
+In order to understand how (and why) `Injectable` works, you need to know some principles.
+
+### #1 The `#call` method
+
+`Injectable` classes **must define a public `#call` method that takes no arguments**.
+
+This is **the only public method** you will be defining in your `Injectable` classes.
+
+```rb
+# Correct ✅
+def call
+  # do stuff
+end
+
+# Wrong ❗️
+def call(some_argument)
+  # won't work and will raise an exception at runtime
+end
+```
+
+If you want your `#call` method to receive arguments, that's what the `#argument` macro is for. BTW, we call those **runtime arguments**.
+
+Why `#call`?
+
+Because it's a ruby idiom. Many things in ruby are `callable`, like lambdas.
+
+### #2 The `initialize` method
+
+Injectable classes take their **dependencies as keyword arguments** on the `initialize` method. They can also take **configuration arguments** on `initialize`:
+
+```rb
+MyClass.new(some_dep: some_dep_instance, some_config: true).call
+```
+
+`Injectable` instantiates **dependencies that you have declared with the `dependency` macro** for you and passes them to `initialize`, so if you don't want to override those you don't even need to instantiate the class and you can use the provided class method **`#call` shortcut**:
+
+```rb
+Myclass.call # This is calling `initialize` under the hood
+```
+
+If you need to override dependencies or configuration options, just call `new` yourself:
+
+```rb
+Myclass.new(some_dep: Override.new, some_config: false).call
+```
+
+If you do that, **any dependency that you didn't pass will be injected by `Injectable`**.
+Notice that **configuration arguments**, which are declared with `#initialize_with` behave in the exact same way.
+
+### #3 Keyword arguments
+
+Both `#initialize` and `#call` take **keyword arguments**.
+
+### #4 Readers
+
+All `Injectable` macros define reader methods for you, that's why you define `#call` without arguments, because **you access everything you declare via reader methods**.
+
+## The `#dependency` macro
+
+This is the main reason why you want to use this library in the first place.
+
+There are several ways of declaring a `#dependency`:
+
+### Bare dependency name
+
+```rb
+class ReportPdfRenderer
+  include Injectable
+
+  dependency :some_dependency
+end
+```
+
+1. `Injectable` first tries to find the `SomeDependency` constant in `ReportPdfRenderer`namespace.
+2. If it doesn't find it, then tries without namespace (`::SomeDependency`).
+
+Notice that this happens **at runtime**, not when defining your class.
+
+### Explicit, inline class:
+
+```rb
+class MyInjectable
+  include Injectable
+
+  dependency :client, class: Aws::S3::Client
+  dependency :parser, class: VeryLongClassNameForMyParser
+end
+```
+
+Nothing fancy here, you are explicitly telling `Injectable` which class to instantiate for you.
+
+You will want to use this style for example if the class is namespaced somewhere else or if you want a different name other than the class', like for example if it's too long.
+
+Notice that this approach sets the class when ruby interprets the class, **not at runtime**.
+
+### With a block:
+
+```rb
+dependency :complex_client do
+  instance = ThirdPartyLib.new(:foo, bar: 'goo')
+  instance.set_config(:name, 'value')
+  instance
+end
+```
+
+It's important to understand that `Injectable` won't call `#new` on whatever you return from this block.
+
+You probably want to use this when your dependency has a complex setup. We use it a lot when wrapping third party libraries which aren't reused elsewhere.
+
+If you want to wrap a third party library and you need to reuse it, then we recommend that you write a specific `Injectable` class for it, so it adheres to its principles and is easier to use.
+
+### `#dependency` options
+
+#### `:with`
+
+If the dependency takes arguments, you can set them with :with
+
+```rb
+# Arrays will be splatted: WithNormalArguments.new(1, 2, 3)
+dependency :with_normal_arguments, with: [1, 2, 3]
+# Hashes will be passed as-is: WithKeywordArguments.new(foo: 'bar)
+dependency :with_keyword_arguments, with: { foo: 'bar' }
+```
+
+### `:depends_on`
+
+It allows you to share **memoized instances** of dependencies and supports both a single dependency or multiples as an Array:
+
+```rb
+dependency :client # this will be instantiated just once and will be shared
+dependency :reporter, depends_on: :client
+dependency :mailer,   depends_on: %i[client reporter]
+```
+
+Dependencies of dependencies will be passed as keyword arguments using the same name they were declared with. In the example above, `Injectable` will instantiate a `Mailer` class passing `{ client: client, reporter: reporter }` to `#initialize`.
+
+If you have a dependency that is defined with a block which also depends_on other dependencies, you'll receive those as keyword arguments:
+
+```rb
+dependency :my_dependency, depends_on: :client do |client:|
+  MyDependency.new(client)
+end
+```
+
+### `:call`
+
+Sometimes you have a class that doesn't adhere to `Injectable` principles:
+
+```rb
+dependency :renderer
+
+def call
+  renderer.render # this class does not respond to `call`
+end
+```
+
+`:call` is a way of wrapping such dependency so it behaves like an `Injectable`:
+
+```rb
+dependency :renderer, call: :render
+
+def call
+  renderer.call
+end
+```
+
+It's important to understand that **you can mix and match all dependency configurations and options** described above.
+
+## `#initialize_with` macro
+
+This macro is meant for **configuration arguments** passed to `initialize`:
+
+```rb
+initialize_with :debug, default: false
+```
+
+If you don't pass the `:default` option the argument will be required.
+
+## `#argument` macro
+
+`#argument` allows you to define **runtime arguments** passed to `#call`
+
+```rb
+argument :browser, default: 'Unknown'
+```
+
+If you don't pass the `:default` option the argument will be required.
+
+
+## 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/rubiconmd/injectable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Injectable project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).
+
+## Credits
+
+- [RubiconMD](https://github.com/rubiconmd) allowed extracting this gem from its codebase and release it as open source.
+- [Durran Jordan](https://github.com/durran) allowed the usage of the gem name at rubygems.org.
+- [David Marchante](https://github.com/iovis) brainstormed the `initialize`/`call` approach, did all code reviews and provided lots of insightful feedback and suggestions. He also wrote the inline documentation.
+- [Julio Antequera](https://github.com/jantequera), [Jimmi Carney](https://github.com/ayoformayo) and [Anthony Rocco](https://github.com/amrocco) had the patience to use it and report many bugs. Also most of the features in this gem came up when reviewing their usage of it. Anthony also made the effort of extracting the code from RubiconMD's codebase.
+- [Rodrigo Álvarez](https://github.com/Papipo) had the idea for the DSL and actually wrote the library.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "injectable"
+
+# 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(__FILE__)

data/bin/setup

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

data/lib/injectable/class_methods.rb

@@ -0,0 +1,159 @@
+module Injectable
+  module ClassMethods
+    def self.extended(base)
+      base.class_eval do
+        simple_class_attribute :dependencies,
+                               :call_arguments,
+                               :initialize_arguments
+
+        self.dependencies = DependenciesGraph.new(namespace: base)
+        self.initialize_arguments = {}
+        self.call_arguments = {}
+      end
+    end
+
+    def inherited(base)
+      base.class_eval do
+        self.dependencies = dependencies.with_namespace(base)
+        self.initialize_arguments = initialize_arguments.dup
+        self.call_arguments = call_arguments.dup
+      end
+    end
+
+    # Blatantly stolen from rails' ActiveSupport.
+    # This is a simplified version of class_attribute
+    def simple_class_attribute(*attrs)
+      attrs.each do |name|
+        define_singleton_method(name) { nil }
+
+        ivar = "@#{name}"
+
+        define_singleton_method("#{name}=") do |val|
+          singleton_class.class_eval do
+            define_method(name) { val }
+          end
+
+          if singleton_class?
+            class_eval do
+              define_method(name) do
+                if instance_variable_defined? ivar
+                  instance_variable_get ivar
+                else
+                  singleton_class.send name
+                end
+              end
+            end
+          end
+          val
+        end
+      end
+    end
+
+    # Use the service with the params declared with '.argument'
+    # @param args [Hash] parameters needed for the Service
+    # @example MyService.call(foo: 'first_argument', bar: 'second_argument')
+    def call(args = {})
+      new.call(args)
+    end
+
+    # Declare dependencies for the service
+    # @param name [Symbol] the name of the service
+    # @option options [Class] :class The class to use if it's different from +name+
+    # @option options [Symbol, Array<Symbol>] :depends_on if the dependency has more dependencies
+    # @yield explicitly declare the dependency
+    #
+    # @return [Object] the injected dependency
+    #
+    # @example Using the same name as the service object
+    #   dependency :team_query
+    #     # => @team_query = TeamQuery.new
+    #
+    # @example Specifying a different class
+    #   dependency :player_query, class: UserQuery
+    #     # => @player_query = UserQuery.new
+    #
+    # @example With a block
+    #   dependency :active_players do
+    #     ->(players) { players.select(&:active?) }
+    #   end
+    #     # => @active_players = [lambda]
+    #
+    # @example With more dependencies
+    #   dependency :counter
+    #   dependency :team_service
+    #   dependency :player_counter, depends_on: [:counter, :team_service]
+    #     # => @counter = Counter.new
+    #     # => @team_service = TeamService.new
+    #     # => @player_counter = PlayerCounter.new(counter: @counter, team_service: @team_service)
+    #
+    # @example Dependencies that don't accept keyword arguments
+    #   dependency :counter
+    #   dependency :player_counter, depends_on: :counter do |counter:|
+    #     PlayerCounter.new(counter)
+    #   end
+    #     # => @counter = Counter.new
+    #     # => @player_counter = PlayerCounter.new(@counter)
+    def dependency(name, options = {}, &block)
+      options[:block] = block if block_given?
+      options[:depends_on] = Array(options.fetch(:depends_on, []))
+      options[:name] = name
+      dependencies.add(**options)
+      define_method name do
+        return instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
+
+        instance_variable_set "@#{name}", instantiate_dependency(name)
+      end
+    end
+
+    # Declare the arguments for `#call` and initialize the accessors
+    # This helps us clean up the code for memoization:
+    #
+    # ```
+    # private
+    #
+    # def player
+    #   # player_id exists in the context because we added it as an argument
+    #   @player ||= player_query.call(player_id)
+    # end
+    # ```
+    #
+    # Every argument is required unless given an optional default value
+    # @param name Name of the argument
+    # @option options :default The default value of the argument
+    # @example
+    #   argument :player_id
+    #     # => def call(player_id:)
+    #     # =>   @player_id = player_id
+    #     # => end
+    # @example with default arguments
+    #   argument :team_id, default: 1
+    #     # => def call(team_id: 1)
+    #     # =>   @team_id = team_id
+    #     # => end
+    def argument(name, options = {})
+      call_arguments[name] = options
+      attr_accessor name
+    end
+
+    def initialize_with(name, options = {})
+      initialize_arguments[name] = options
+      attr_accessor name
+    end
+
+    # Get the #initialize arguments declared with '.initialize_with' with no default
+    # @private
+    def required_initialize_arguments
+      find_required_arguments initialize_arguments
+    end
+
+    # Get the #call arguments declared with '.argument' with no default
+    # @private
+    def required_call_arguments
+      find_required_arguments call_arguments
+    end
+
+    def find_required_arguments(hash)
+      hash.reject { |_arg, options| options.key?(:default) }.keys
+    end
+  end
+end

data/lib/injectable/dependencies_graph.rb

@@ -0,0 +1,40 @@
+require 'forwardable'
+
+module Injectable
+  # Holds the dependency signatures of the service object
+  class DependenciesGraph
+    attr_reader :graph, :dependency_class
+    attr_accessor :namespace
+    extend Forwardable
+    def_delegators :@graph, :[]
+
+    def initialize(namespace:, dependency_class: ::Injectable::Dependency)
+      @namespace = namespace
+      @graph = {}
+      @dependency_class = dependency_class
+    end
+
+    def names
+      graph.keys
+    end
+
+    def with_namespace(namespace)
+      dup.tap { |dupe| dupe.namespace = namespace }
+    end
+
+    # Adds the signature of a dependency to the graph
+    def add(name:, depends_on:, **kwargs)
+      check_for_missing_dependencies!(depends_on)
+      graph[name] = dependency_class.new(kwargs.merge(name: name, depends_on: depends_on))
+    end
+
+    private
+
+    def check_for_missing_dependencies!(deps)
+      missing = deps.reject { |dep| graph.key?(dep) }
+      return if missing.empty?
+
+      raise Injectable::MissingDependenciesException, "missing dependencies: #{missing.join(', ')}"
+    end
+  end
+end

data/lib/injectable/dependency.rb

@@ -0,0 +1,76 @@
+module Injectable
+  # Initialize a dependency based on the options or the block passed
+  Dependency = Struct.new(:name, :block, :class, :call, :with, :depends_on, keyword_init: true) do
+    def instance(args: [], namespace: nil)
+      positional_args, kwargs = split_args(args)
+
+      wrap_call build_instance(positional_args, kwargs, namespace: namespace)
+    end
+
+    private
+
+    def split_args(args)
+      args = preprocess_args(args)
+
+      return [[], {}] if args.empty?
+
+      kwargs = args.pop
+
+      if kwargs.is_a?(Hash) && kwargs.keys.all? { |key| key.is_a?(Symbol) }
+        [args, kwargs]
+      else
+        [args << kwargs, {}]
+      end
+    end
+
+    def preprocess_args(args)
+      args = with unless with.nil?
+      wrap_args(args)
+    end
+
+    def wrap_args(args)
+      args.is_a?(Array) ? args.clone : [args]
+    end
+
+    def wrap_call(the_instance)
+      return the_instance unless call
+
+      if the_instance.respond_to? :call
+        raise Injectable::MethodAlreadyExistsException
+      end
+
+      the_instance.public_method(call)
+    end
+
+    def build_instance(args, kwargs, namespace:)
+      return build_instance_26(args, kwargs, namespace: namespace) if RUBY_VERSION < '2.7'
+
+      instantiator = block || klass(namespace: namespace).method(:new)
+      if kwargs.empty?
+        # otherwise an empty hash will be added in ruby 2.7, which could be taken as
+        # positional argument instead.
+        instantiator.call(*args)
+      else
+        instantiator.call(*args, **kwargs)
+      end
+    end
+
+    def klass(namespace:)
+      self.class || resolve(namespace: namespace)
+    end
+
+    def resolve(namespace:)
+      (namespace || Object).const_get(camelcased)
+    end
+
+    def camelcased
+      @camelcased ||= name.to_s.split('_').map(&:capitalize).join
+    end
+
+    def build_instance_26(args, kwargs, namespace:)
+      args << kwargs if kwargs.any?
+
+      block.nil? ? klass(namespace: namespace).new(*args) : block.call(*args)
+    end
+  end
+end

data/lib/injectable/instance_methods.rb

@@ -0,0 +1,68 @@
+module Injectable
+  module InstanceMethods
+    # Initialize the service with the dependencies injected
+    def initialize(args = {})
+      check_missing_arguments!(self.class.required_initialize_arguments, args)
+      variables_for!(self.class.initialize_arguments, args)
+      variables_from_dependencies!(args)
+      super()
+    end
+
+    # Entry point of the service.
+    # Arguments for this method should be declared explicitly with '.argument'
+    # and declare this method without arguments
+    def call(args = {})
+      check_call_definition!
+      check_missing_arguments!(self.class.required_call_arguments, args)
+      variables_for!(self.class.call_arguments, args)
+      super()
+    end
+
+    private
+
+    def instantiate_dependency(name)
+      deps = self.class.dependencies
+      deps[name].instance(args: memoized_dependencies_of(name), namespace: deps.namespace)
+    end
+
+    def memoized_dependencies_of(name)
+      return [] if dependencies_of(name).empty?
+
+      dependencies_of(name).each_with_object({}) { |dep, hash| hash[dep] = public_send(dep) }
+    end
+
+    def dependencies_of(name)
+      self.class.dependencies[name].depends_on
+    end
+
+    def check_call_definition!
+      return if (self.class.ancestors - [Injectable::InstanceMethods]).any? do |ancestor|
+        ancestor.instance_methods(false).include?(:call)
+      end
+      raise NoMethodError, "A #call method with zero arity must be defined in #{self.class}"
+    end
+
+    def check_missing_arguments!(expected, args)
+      missing = expected - args.keys
+      return if missing.empty?
+      raise ArgumentError, "missing keywords: #{missing.join(',')}"
+    end
+
+    def variables_for!(subject, args)
+      subject.each do |arg, options|
+        instance_variable_set("@#{arg}", args.fetch(arg) { options[:default] })
+      end
+    end
+
+    def variables_from_dependencies!(args)
+      self.class.dependencies.names.each do |name|
+        next if self.class.initialize_arguments.key?(name)
+        next unless args.key?(name)
+        next instance_variable_set("@#{name}", args[name]) unless args[name].respond_to?(:new)
+        next instance_variable_set("@#{name}", args[name].new) if dependencies_of(name).empty?
+
+        instance_variable_set("@#{name}", args[name].new(memoized_dependencies_of(name)))
+      end
+    end
+  end
+end

data/lib/injectable/method_already_exists_exception.rb

@@ -0,0 +1,4 @@
+module Injectable
+  class MethodAlreadyExistsException < RuntimeError
+  end
+end

data/lib/injectable/missing_dependencies_exception.rb

@@ -0,0 +1,4 @@
+module Injectable
+  class MissingDependenciesException < RuntimeError
+  end
+end

data/lib/injectable/version.rb

@@ -0,0 +1,3 @@
+module Injectable
+  VERSION = '2.1.1'.freeze
+end

data/lib/injectable.rb

@@ -0,0 +1,62 @@
+require 'injectable/version'
+require 'injectable/class_methods'
+require 'injectable/dependencies_graph'
+require 'injectable/dependency'
+require 'injectable/instance_methods'
+require 'injectable/missing_dependencies_exception'
+require 'injectable/method_already_exists_exception'
+
+# Convert your class into an injectable service
+#
+# @example
+#   You would create a service like this:
+#
+#   class AddPlayerToTeamRoster
+#     include Injectable
+#
+#     dependency :team_query
+#     dependency :player_query, class: UserQuery
+#
+#     argument :team_id
+#     argument :player_id
+#
+#     def call
+#       player_must_exist!
+#       team_must_exist!
+#       team_must_accept_players!
+#
+#       team.add_to_roster(player)
+#     end
+#
+#     private
+#
+#     def player
+#       @player ||= player_query.call(player_id)
+#     end
+#
+#     def team
+#       @team ||= team_query.call(team_id)
+#     end
+#
+#     def player_must_exist!
+#       player.present? || raise UserNotFoundException
+#     end
+#
+#     def team_must_exist!
+#       team.present? || raise TeamNotFoundException
+#     end
+#
+#     def team_must_accept_players!
+#       team.accepts_players? || raise TeamFullException
+#     end
+#   end
+#
+#   And use it like this:
+#
+#   AddPlayerToTeamRoster.call(player_id: player.id, team_id: team.id)
+module Injectable
+  def self.included(base)
+    base.extend(Injectable::ClassMethods)
+    base.prepend(Injectable::InstanceMethods)
+  end
+end

data/maglev-injectable.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'injectable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'maglev-injectable'
+  spec.version       = Injectable::VERSION
+  spec.authors       = %w[Papipo iovis jantequera amrocco rewritten]
+  spec.email         = %w[dev@rubiconmd.com]
+
+  spec.summary       = 'A library to help you build nice service objects with dependency injection.'
+  spec.homepage      = 'https://github.com/rubiconmd/injectable'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.5'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: maglev-injectable
+version: !ruby/object:Gem::Version
+  version: 2.1.1
+platform: ruby
+authors:
+- Papipo
+- iovis
+- jantequera
+- amrocco
+- rewritten
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-09-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- dev@rubiconmd.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/injectable.rb
+- lib/injectable/class_methods.rb
+- lib/injectable/dependencies_graph.rb
+- lib/injectable/dependency.rb
+- lib/injectable/instance_methods.rb
+- lib/injectable/method_already_exists_exception.rb
+- lib/injectable/missing_dependencies_exception.rb
+- lib/injectable/version.rb
+- maglev-injectable.gemspec
+homepage: https://github.com/rubiconmd/injectable
+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.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: A library to help you build nice service objects with dependency injection.
+test_files: []