invokr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0174897be54196672b5fc187801b8afb7b950a5
+  data.tar.gz: 4b3b4c3656ffb373aab0cfdd56060689dbb7a40b
+SHA512:
+  metadata.gz: 0f5edb40a999afc101c009ce040a82170c3356ffe25b79150e590dc7b6813ac84db2d9be765ac74764c8f0102cd57cc00a02ae1376fa776dd6e593b1865a106e
+  data.tar.gz: 4c8001a382bb203d173ef4558f690678987c9ad9d5113f7e0dbad775e0e24748b291e057ac7f2abbb29f47cc9f9ca99d7a2c68dfd3fce05f658c5dac401d2cc6

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+tags

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 ntl
+
+MIT License
+
+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,69 @@
+# Invokr
+
+Invoke methods with a consistent Hash interface. Useful for metaprogramming.
+
+## Basic Usage
+
+Let's say you've got a method you want to call:
+
+```ruby
+class BankAccount
+  def add_transaction(amount, account_id:, description: '')
+    # adds transaction
+  end
+end
+```
+
+You can invoke this method through the class interface with pure ruby. But sometimes you've got a Hash containing the parameters. This is where Invokr comes in:
+
+```ruby
+bank_account = BankAccount.new
+params = JSON.parse http_request.response_body
+Invokr.invoke method: :add_transaction, on: bank_account, with: params
+```
+
+Behind the scenes, Invokr figured out how to translate that `Hash` into a method signature compatible with `BankAccount#add_transaction`.
+
+## Querying 
+
+Want to investigate the arguments of a method?
+
+```ruby
+meth = Invokr.query_method bank_account.method(:add_transaction)
+```
+
+This will return an object that you can use to inspect the optional/required dependencies of a method:
+
+```ruby
+meth.required_dependencies
+=> [:amount, :account_id]
+meth.optional_dependencies
+=> [:description]
+```
+
+## Limitations
+
+Currently, more than one optional positional argument isn't supported. Consider:
+
+```ruby
+def my_method arg1 = 'foo', arg2 = 'bar'
+end
+```
+
+Without knowing how to parse the source code for `#my_method`, Invokr couldn't know what the default values are. And even if I brought in e.g. [ruby_parser](https://github.com/seattlerb/ruby_parser), I'd have to support lazy evaluation, for when you supply a method or constant as the default. This complexity is completely unneccessary when using keyword arguments, so I suggest using that approach for multiple defaults.
+
+## Pre-keyword argument hash defaults
+
+Before ruby 2.x introduced keyword arguments, it was common to end your method signature with a default hash, e.g. `def my_method args = {}`. Invoker supports this by building a Hash out of all the unused arguments you passed in, and passing *that* into the optional argument.
+
+## Dependency injection
+
+One of the use cases for Invokr is building abstract factories. In this case, you want to inspect the method signature of `Object#initialize`, but actually pass `.new` to the class to have it allocate memory and invoke the initializer for you. Since this is a weird case, there's some support to make building a dependency injector much easier, just make sure you explictily `require "invokr/dependency_injection"` and then check out `test/dependency_injection_example_test.rb` for how it is used. Basically, your factory object just needs to implement a method called `resolve` that takes in the name of a dependency that maps to a parameter on the `#initialize` method for the class you're trying to build out.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/invokr/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+desc "Update ctags"
+task :ctags do
+  `ctags -R --languages=Ruby --totals -f tags`
+end
+
+desc "Test against all ruby versions"
+task :rbenv_suite do
+  %w(2.1.2 2.0.0-p481 1.9.3-p545).each do |ruby_ver|
+    child_pid = fork do
+      ruby_path = File.join ENV['RBENV_ROOT'], 'shims/ruby'
+      cmd = "#{ruby_path} bin/test_runner ; echo"
+      puts "Testing #{ruby_ver}"
+      env = { 'RBENV_VERSION' => ruby_ver }
+      exec env, cmd
+    end
+    Process.wait2 child_pid
+  end
+end
+
+task :default => :rbenv_suite

data/bin/rake

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+load "bin/test_runner" and exit 0 if ARGV.empty?
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rake', 'rake')

data/bin/test_runner

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+module Invokr
+  module Runner
+    extend self
+
+    def run!
+      root = File.expand_path '../..', __FILE__
+
+      load File.join(root, 'test/test_helper.rb')
+
+      Dir[File.join(root, 'test/**/*_test.rb')].each do |test_file|
+        load test_file
+      end
+    end
+  end
+end
+
+Invokr::Runner.run!

data/invokr.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'invokr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "invokr"
+  spec.version       = Invokr::VERSION
+  spec.authors       = %w(ntl)
+  spec.email         = %w(nathanladd+github@gmail.com)
+  spec.summary       = %q{Invoke methods with a consistent Hash interface.}
+  spec.description   = %q{Invoke methods with a consistent Hash interface. Useful for metaprogramming.}
+  spec.homepage      = "https://github.com/ntl/invokr"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = []
+  spec.test_files    = spec.files.grep %r{test/}
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "rake"
+end

data/lib/invokr.rb

@@ -0,0 +1,57 @@
+module Invokr
+  extend self
+
+  def invoke args = {}
+    method_name, obj, hsh_args = require_arguments! args, :method, :on, :with
+    method = obj.method method_name
+    invocation = Builder.build method, hsh_args, args[:block]
+    invocation.invoke! obj
+  end
+
+  def query_method method
+    Method.new method
+  end
+
+  Method = Struct.new :method do
+    def dependencies
+      map_identifiers parameters
+    end
+
+    def optional_dependencies
+      map_identifiers select_parameters_by_type [:opt, :key]
+    end
+
+    def required_dependencies
+      map_identifiers select_parameters_by_type [:req, :keyreq]
+    end
+
+    def parameters
+      method.parameters
+    end
+
+    private
+
+    def select_parameters_by_type types
+      parameters.select do |type, _| types.include? type end
+    end
+
+    def map_identifiers parameters
+      parameters.map do |_, identifier| identifier end
+    end
+  end
+
+  private
+
+  def require_arguments! hsh, *args
+    found_args, missing_args = args.partition do |arg|
+      hsh.has_key? arg
+    end
+    raise InputError.new missing_args unless missing_args.empty?
+    found_args.map { |arg| hsh.fetch arg }
+  end
+end
+
+require_relative 'invokr/builder'
+require_relative 'invokr/errors'
+require_relative 'invokr/invocation'
+require_relative 'invokr/version'

data/lib/invokr/builder.rb

@@ -0,0 +1,116 @@
+module Invokr
+  class Builder
+    def self.build *args
+      builder = new *args
+      builder.build
+    end
+
+    attr :argument_names, :injector, :method, :missing_args, :unused_args
+
+    def initialize method, injector, implicit_block
+      @argument_names = method.parameters.map &:last
+      @injector = injector
+      @method = method
+      @opt_arg_name = nil
+
+      @block_arg = nil
+      @implicit_block = implicit_block
+      @keyword_args = {}
+      @positional_args = []
+      @missing_args = []
+
+      set_unused_args
+    end
+
+    def build
+      handle_args!
+      check_for_unused_args!
+      check_for_missing_args!
+      build_invocation
+    end
+
+    def build_invocation
+      @block_arg = @implicit_block if @implicit_block
+      Invocation.new method.name, @positional_args, @keyword_args, @block_arg
+    end
+
+    def handle_args!
+      method.parameters.each do |type, identifier|
+        send "handle_#{type}_arg", identifier
+      end
+    end
+
+    def handle_req_arg identifier
+      arg = injector.fetch identifier do missing_argument! identifier end
+      @positional_args << arg
+    end
+
+    def handle_opt_arg identifier
+      optional_arg_error! identifier if hit_opt_arg?
+      @opt_arg_name = identifier
+      arg = injector.fetch identifier do
+        build_hash_from_extra_args or return
+      end
+      @positional_args << arg
+    end
+
+    def handle_keyreq_arg identifier
+      arg = injector.fetch identifier do missing_argument! identifier end
+      @keyword_args[identifier] = arg
+    end
+
+    def handle_key_arg identifier
+      return unless injector.has_key? identifier
+      @keyword_args[identifier] = injector[identifier]
+    end
+
+    def handle_block_arg identifier
+      if injector.has_key? identifier and @implicit_block
+        unused_args << identifier and return
+      end
+      @block_arg = injector.fetch identifier do
+        @implicit_block or missing_argument! identifier
+      end
+    end
+
+    def hit_opt_arg?
+      @opt_arg_name ? true : false
+    end
+
+    def set_unused_args
+      @unused_args = injector.keys.flat_map do |hsh_arg|
+        argument_names.include?(hsh_arg) ? [] : [hsh_arg]
+      end
+    end
+
+    def build_hash_from_extra_args
+      return nil if unused_args.empty?
+      hsh = {}
+      unused_args.each do |arg| hsh[arg] = injector.fetch arg end
+      unused_args.clear
+      hsh
+    end
+
+    def check_for_unused_args!
+      return if unused_args.empty?
+      raise ExtraArgumentsError.new self, unused_args
+    end
+
+    def check_for_missing_args!
+      return if missing_args.empty?
+      raise MissingArgumentsError.new self, missing_args
+    end
+
+    def optional_arg_error! identifier
+      raise OptionalPositionalArgumentError.new(
+        method.name,
+        @opt_arg_name,
+        identifier,
+      )
+    end
+
+    def missing_argument! identifier
+      missing_args << identifier
+    end
+  end
+end

data/lib/invokr/dependency_injection.rb

@@ -0,0 +1,30 @@
+module Invokr
+  module DependencyInjection
+    def self.inject args = {}
+      klass = args.fetch :klass
+      resolver = args.fetch :using
+      injector = Injector.new resolver, klass
+      injector.inject
+    end
+
+    Injector = Struct.new :resolver, :klass do
+      def inject
+        invocation = Builder.build initializer, self, nil
+        invocation.method = :new
+        invocation.invoke! klass
+      end
+
+      def keys
+        initializer.parameters.map { |_, identifier| identifier }
+      end
+
+      def fetch arg, &default
+        resolver.resolve arg, &default
+      end
+
+      def initializer
+        klass.instance_method :initialize
+      end
+    end
+  end
+end

data/lib/invokr/errors.rb

@@ -0,0 +1,63 @@
+module Invokr
+  class InputError < ArgumentError
+    attr :missing_args
+
+    def initialize missing_args
+      @missing_args = missing_args
+      missing_args.map! do |arg| "`#{arg}'" end
+    end
+
+    def message
+      @message ||= build_message
+    end
+
+    def build_message
+      prefix = "cannot invoke; missing required arguments: "
+      prefix << concat_missing_args
+      prefix
+    end
+
+    def concat_missing_args
+      return missing_args.first if missing_args.size == 1
+      last_arg = missing_args.pop
+      "#{missing_args.join ', '} and #{last_arg}"
+    end
+  end
+
+  class BadArgumentsError < ArgumentError
+    attr :builder, :args
+
+    def initialize builder, args
+      @builder = builder
+      @args = args
+    end
+
+    def formatted_args
+      args.map { |arg| "`#{arg}'" }.join ', '
+    end
+  end
+
+  class ExtraArgumentsError < BadArgumentsError
+    def message
+      %(unused argument(s) #{formatted_args} when invoking method `#{builder.method.name}' on #{builder.method.owner.inspect})
+    end
+  end
+
+  class MissingArgumentsError < BadArgumentsError
+    def message
+      %(missing required argument(s) #{formatted_args} when invoking method `#{builder.method.name}' on #{builder.method.owner.inspect})
+    end
+  end
+
+  class OptionalPositionalArgumentError < StandardError
+    attr :message
+
+    def initialize method, arg1, arg2
+      @message = <<-MESSAGE
+method `#{method}' has optional positional argument `#{arg2}', after optional argument `#{arg1}'.
+
+We cannot use this method because there's no way to supply an explicit value for `#{arg2}' without knowing the default value for `#{arg1}'. It's technically possible to overcome this with S-expression analysis, but a much simpler solution would be to use keyword arguments.
+      MESSAGE
+    end
+  end
+end

data/lib/invokr/invocation.rb

@@ -0,0 +1,22 @@
+module Invokr
+  Invocation = Struct.new :method, :positional_args, :keyword_args, :block_arg do
+    def invoke! obj
+      if block_arg?
+        obj.public_send method, *args, &block_arg
+      else
+        obj.public_send method, *args
+      end
+    end
+
+    def block_arg?
+      block_arg ? true : false
+    end
+
+    def args
+      args = positional_args.dup
+      args << keyword_args unless keyword_args.empty?
+      args
+    end
+  end
+
+end

data/lib/invokr/version.rb

@@ -0,0 +1,3 @@
+module Invokr
+  VERSION = "0.0.1"
+end

data/test/block_args_test.rb

@@ -0,0 +1,64 @@
+class BlockArgsTest < Minitest::Test
+  def test_supplying_block_argument_explicitly
+    actual = Invokr.invoke(
+      method: :block_argument,
+      on:     TestMethodBank,
+      with:   { album_block: -> { 'farmhouse' } },
+    )
+
+    assert_equal 'farmhouse', actual
+  end
+
+  def test_supplying_block_argument_implicitly
+    actual = Invokr.invoke(
+      method: :block_argument,
+      on:     TestMethodBank,
+      with:   {},
+      block:  -> { 'farmhouse' },
+    )
+
+    assert_equal 'farmhouse', actual
+  end
+
+  def test_failing_to_supply_block_argument
+    error = assert_raises Invokr::MissingArgumentsError do
+      Invokr.invoke(
+        method: :block_argument,
+        on:     TestMethodBank,
+        with:   {},
+      )
+    end
+
+    assert_equal(
+      "missing required argument(s) `album_block' when invoking method `block_argument' on #<TestMethodBank:0xdeadbeef>",
+      error.message,
+    )
+  end
+
+  def test_supplying_block_argument_implicitly_and_explicitly
+    error = assert_raises Invokr::ExtraArgumentsError do
+      Invokr.invoke(
+        method: :block_argument,
+        on:     TestMethodBank,
+        with:   { album_block: -> { 'farmhouse' } },
+        block:  -> { 'farmhouse' },
+      )
+    end
+
+    assert_equal(
+      "unused argument(s) `album_block' when invoking method `block_argument' on #<TestMethodBank:0xdeadbeef>",
+      error.message,
+    )
+  end
+
+  def test_implicit_block
+    actual = Invokr.invoke(
+      method: :just_yields,
+      on:     TestMethodBank,
+      with:   {},
+      block:  -> { 'farmhouse' },
+    )
+
+    assert_equal 'farmhouse', actual
+  end
+end

data/test/dependency_injection_example_test.rb

@@ -0,0 +1,41 @@
+require 'invokr/dependency_injection'
+
+class DependencyInjectionExampleTest < Minitest::Test
+  def setup
+    @injector = TestInjector.new(
+      :album => 'farmhouse',
+      :guitarist => 'trey',
+      :drummer => 'fishman',
+    )
+  end
+
+  def test_dependency_injection
+    @injector.inject TestObject
+  end
+
+  class TestInjector
+    def initialize hsh
+      @hsh = hsh
+    end
+
+    def inject klass
+      Invokr::DependencyInjection.inject(
+        :klass => klass,
+        :using => self,
+      )
+    end
+
+    def resolve val
+      @hsh.fetch val
+    end
+  end
+
+  class TestObject
+    attr :album, :guitarist
+
+    def initialize album, guitarist
+      @album = album
+      @guitarist = guitarist
+    end
+  end
+end

data/test/invokr_test.rb

@@ -0,0 +1,12 @@
+class InvokrTest < Minitest::Test
+  def test_incorrectly_invoking
+    error = assert_raises Invokr::InputError do
+      Invokr.invoke
+    end
+
+    assert_equal(
+      "cannot invoke; missing required arguments: `method', `on' and `with'",
+      error.message,
+    )
+  end
+end

data/test/keyword_args_test.rb

@@ -0,0 +1,70 @@
+module KeywordArgsTest
+  class OptionalKeywordArgsTest < Minitest::Test
+    def setup
+      skip unless RUBY_VERSION >= '2.0'
+    end
+
+    def test_overriding_optional_keyword_argument
+      actual = Invokr.invoke(
+        method: :optional_keyword_argument,
+        on:     TestMethodBank,
+        with:   { album: 'billy_breathes' },
+      )
+
+      assert_equal 'billy_breathes', actual
+    end
+
+    def test_using_default_optional_keyword_argument
+      actual = Invokr.invoke(
+        method: :optional_keyword_argument,
+        on:     TestMethodBank,
+        with:   {},
+      )
+
+      assert_equal 'pitcher_of_nectar', actual
+    end
+
+    def test_querying_optional_keyword_argument
+      method = Invokr.query_method TestMethodBank.method :optional_keyword_argument
+
+      assert_equal [:album], method.optional_dependencies
+    end
+  end
+
+  class RequiredKeywordArgsTest < Minitest::Test
+    def setup
+      skip unless RUBY_VERSION >= '2.1'
+    end
+
+    def test_supplying_required_keyword_argument
+      actual = Invokr.invoke(
+        method: :required_keyword_argument,
+        on:     TestMethodBank,
+        with:   { album: 'pitcher_of_nectar' },
+      )
+
+      assert_equal 'pitcher_of_nectar', actual
+    end
+
+    def test_failing_to_supply_a_required_keyword_argument
+      error = assert_raises Invokr::MissingArgumentsError do
+        Invokr.invoke(
+          method: :required_keyword_argument,
+          on:     TestMethodBank,
+          with:   {},
+        )
+      end
+
+      assert_equal(
+        "missing required argument(s) `album' when invoking method `required_keyword_argument' on #<TestMethodBank:0xdeadbeef>",
+        error.message,
+      )
+    end
+
+    def test_querying_required_keyword_argument
+      method = Invokr.query_method TestMethodBank.method :required_keyword_argument
+
+      assert_equal [:album], method.required_dependencies
+    end
+  end
+end

data/test/optional_args_test.rb

@@ -0,0 +1,66 @@
+class OptionalArgsTest < Minitest::Test
+  def test_overriding_optional_argument
+    actual = Invokr.invoke(
+      method: :optional_argument,
+      on:     TestMethodBank,
+      with:   { album: 'rift' },
+    )
+
+    assert_equal 'rift', actual
+  end
+
+  def test_default_optional_argument
+    actual = Invokr.invoke(
+      method: :optional_argument,
+      on:     TestMethodBank,
+      with:   {},
+    )
+
+    assert_equal 'junta', actual
+  end
+
+  def test_use_extra_args_as_hash_for_optional_argument
+    hsh = { guitarist: 'trey' }
+
+    actual = Invokr.invoke(
+      method: :optional_argument,
+      on:     TestMethodBank,
+      with:   hsh,
+    )
+
+    assert_equal hsh, actual
+  end
+
+  def test_cant_use_extra_args_as_hash_to_override_optional_argument
+    error = assert_raises Invokr::ExtraArgumentsError do
+      Invokr.invoke(
+        method: :optional_argument,
+        on:     TestMethodBank,
+        with:   { album: 'junta', guitarist: 'trey' },
+      )
+    end
+
+    assert_equal(
+      "unused argument(s) `guitarist' when invoking method `optional_argument' on #<TestMethodBank:0xdeadbeef>",
+      error.message,
+    )
+  end
+
+  def test_argument_after_optional_argument_raises_error
+    error = assert_raises Invokr::OptionalPositionalArgumentError do
+      Invokr.invoke(
+        method: :double_optional_argument,
+        on:     TestMethodBank,
+        with:   {},
+      )
+    end
+
+    expected_error_message = <<-MESSAGE
+method `double_optional_argument' has optional positional argument `album2', after optional argument `album1'.
+
+We cannot use this method because there's no way to supply an explicit value for `album2' without knowing the default value for `album1'. It's technically possible to overcome this with S-expression analysis, but a much simpler solution would be to use keyword arguments.
+    MESSAGE
+
+    assert_equal expected_error_message, error.message
+  end
+end

data/test/query_test.rb

@@ -0,0 +1,18 @@
+class QueryTest < Minitest::Test
+  def setup
+    method = TestMethodBank.method :one_required_one_optional_argument
+    @method = Invokr.query_method method
+  end
+
+  def test_dependencies
+    assert_equal [:album, :guitarist], @method.dependencies
+  end
+
+  def test_optional_dependencies
+    assert_equal [:guitarist], @method.optional_dependencies
+  end
+
+  def test_required_dependencies
+    assert_equal [:album], @method.required_dependencies
+  end
+end

data/test/required_args_test.rb

@@ -0,0 +1,41 @@
+class RequiredArgsTest < Minitest::Test
+  def test_required_argument
+    actual = Invokr.invoke(
+      method: :required_argument,
+      on:     TestMethodBank,
+      with:   { album: 'junta' },
+    )
+
+    assert_equal 'junta', actual
+  end
+
+  def test_failing_to_supply_required_arguments
+    error = assert_raises Invokr::MissingArgumentsError do
+      Invokr.invoke(
+        method: :multiple_required_arguments,
+        on:     TestMethodBank,
+        with:   {},
+      )
+    end
+
+    assert_equal(
+      "missing required argument(s) `album', `guitarist' when invoking method `multiple_required_arguments' on #<TestMethodBank:0xdeadbeef>",
+      error.message,
+    )
+  end
+
+  def test_refuses_to_invoke_if_unused_args_are_passed
+    error = assert_raises Invokr::ExtraArgumentsError do
+      Invokr.invoke(
+        method: :required_argument,
+        on:     TestMethodBank,
+        with:   { album: 'junta', guitarist: 'trey' },
+      )
+    end
+
+    assert_equal(
+      "unused argument(s) `guitarist' when invoking method `required_argument' on #<TestMethodBank:0xdeadbeef>",
+      error.message,
+    )
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,59 @@
+$LOAD_PATH.<< File.expand_path '../../lib', __FILE__
+require 'invokr'
+
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+
+module TestMethodBank
+  extend self
+
+  def required_argument album
+    album
+  end
+
+  def optional_argument album = 'junta'
+    album
+  end
+
+  def double_optional_argument album1 = 'junta', album2 = 'rift'
+  end
+
+  def block_argument &album_block
+    album_block.call
+  end
+
+  def multiple_required_arguments album, guitarist
+    [album, guitarist]
+  end
+
+  def one_required_one_optional_argument album, guitarist = 'trey'
+    [album, guitarist]
+  end
+
+  def just_yields
+    yield
+  end
+
+  def inspect
+    "#<#{name}:0xdeadbeef>"
+  end
+
+  if RUBY_VERSION >= '2.0'
+    module_eval <<-RB, __FILE__, __LINE__
+      def optional_keyword_argument album: 'pitcher_of_nectar'
+        album
+      end
+    RB
+  end
+
+  if RUBY_VERSION >= '2.1'
+    module_eval <<-RB, __FILE__, __LINE__
+      def required_keyword_argument(album:)
+        album
+      end
+    RB
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: invokr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ntl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Invoke methods with a consistent Hash interface. Useful for metaprogramming.
+email:
+- nathanladd+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rake
+- bin/test_runner
+- invokr.gemspec
+- lib/invokr.rb
+- lib/invokr/builder.rb
+- lib/invokr/dependency_injection.rb
+- lib/invokr/errors.rb
+- lib/invokr/invocation.rb
+- lib/invokr/version.rb
+- test/block_args_test.rb
+- test/dependency_injection_example_test.rb
+- test/invokr_test.rb
+- test/keyword_args_test.rb
+- test/optional_args_test.rb
+- test/query_test.rb
+- test/required_args_test.rb
+- test/test_helper.rb
+homepage: https://github.com/ntl/invokr
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: Invoke methods with a consistent Hash interface.
+test_files:
+- test/block_args_test.rb
+- test/dependency_injection_example_test.rb
+- test/invokr_test.rb
+- test/keyword_args_test.rb
+- test/optional_args_test.rb
+- test/query_test.rb
+- test/required_args_test.rb
+- test/test_helper.rb