casting 0.7.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c87234df3ca2237a6d2e9d0d6de0f4beb8808cae
-  data.tar.gz: 114ccf9e9984a2323288b66982465ef7068a4dd0
+SHA256:
+  metadata.gz: a7d5101d4c7109e86710609589a9f7dcd4d9d5452e7a452fa29349297325d9a7
+  data.tar.gz: 5854e95575b52af1b6d912a5aa3dc18101faa109d9bea387dba59b6bd50b9df7
 SHA512:
-  metadata.gz: cc11494446dad4f1b1cd367d9fbd485ad78cf961884348344d076ff9456e1e8235af7be0d8547c1db84c0f953d79428da99d1a649702aa61d7b397d00b776fb9
-  data.tar.gz: e3d49bea1aaa35a9c08220cd3c07407fcf34657cdd02934ea2f9bd37adb999e3130e37690eebd21b44c884e5a542381b135f207eaaffe3919583877bee70fee4
+  metadata.gz: 1b394e9b29860bc90654751bc36296ddf5d67598bddf7a3bcec570d507a31ed62674ddce23cfa25a7a6f8d202664c131fec735f3bd4de2074940f88f3860a9f3
+  data.tar.gz: 3e02eb89ad5894b7866569e21aa2efb00e5d00ce9a1d74d1d0865bf7b67303e9a3ddf82333044411a4f1f4f54ff3e0296b42cddaffba1c978609c8f335db2ce7

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012-2014 Jim Gay
+Copyright (c) 2012-2022 Jim Gay
 
 MIT License
 

data/README.md

@@ -1,6 +1,5 @@
 # Casting
 
-[![Build Status](https://travis-ci.org/saturnflyer/casting.png?branch=master)](https://travis-ci.org/saturnflyer/casting)
 [![Code Climate](https://codeclimate.com/github/saturnflyer/casting.png)](https://codeclimate.com/github/saturnflyer/casting)
 [![Test Coverage](https://codeclimate.com/github/saturnflyer/casting/badges/coverage.svg)](https://codeclimate.com/github/saturnflyer/casting/coverage)
 [![Gem Version](https://badge.fury.io/rb/casting.png)](http://badge.fury.io/rb/casting)
@@ -72,6 +71,12 @@ You may also delegate methods without an explicit attendant instance, but provid
 a module containing the behavior you need to use:
 
 ```ruby
+module GreetingModule
+  def hello_world
+    "hello world"
+  end
+end
+
 actor.delegate(:hello_world, GreetingModule)
 # or
 actor.delegation(:hello_world).to(GreetingModule).call
@@ -98,6 +103,12 @@ Casting also provides an option to temporarily apply behaviors to an object.
 Once your class or object is a `Casting::Client` you may send the `delegate_missing_methods` message to it and your object will use `method_missing` to delegate methods to a stored attendant.
 
 ```ruby
+class Actor
+  include Casting::Client
+  delegate_missing_methods
+end
+actor = Actor.new
+
 actor.hello_world #=> NoMethodError
 
 Casting.delegating(actor => GreetingModule) do
@@ -109,7 +120,7 @@ actor.hello_world #=> NoMethodError
 
 The use of `method_missing` is opt-in. If you don't want that mucking up your method calls, just don't tell it to `delegate_missing_methods`.
 
-Before the block is run in `Casting.delegating`, a collection of delegate objects is set on the object to the provided attendant. Then the block yields, and an `ensure` block cleans up the stored attendant.
+Before the block is run in `Casting.delegating`, a collection of delegate objects is set in the current Thread for the provided attendant. Then the block yields, and an `ensure` block cleans up the stored attendant.
 
 This allows you to nest your `delegating` blocks as well:
 

data/lib/casting/client.rb

@@ -22,12 +22,12 @@ module Casting
     end
 
     def delegation(delegated_method_name)
-      Casting::Delegation.new(delegated_method_name, self)
+      Casting::Delegation.prepare(delegated_method_name, self)
     end
 
-    def cast(delegated_method_name, attendant, *args, &block)
+    def cast(delegated_method_name, attendant, ...)
       validate_attendant(attendant)
-      delegation(delegated_method_name).to(attendant).with(*args, &block).call
+      delegation(delegated_method_name).to(attendant).call(...)
     end
 
     def delegate_missing_methods(*which)
@@ -63,4 +63,4 @@ module Casting
       base.send(:extend, ::Casting::MissingMethodClientClass)
     end
   end
-end
+end

data/lib/casting/context.rb

@@ -7,7 +7,7 @@
 #
 #  class SomeContext
 #    using Casting::Context
-#    include Casting::Context
+#    extend Casting::Context
 #
 #    initialize(:some, :thing)
 #    # doing that defines your constructor but would cause it too look for
@@ -18,7 +18,6 @@
 #    # if you want different module names (why would you?) then you'd need
 #    # to do all this:
 #    def initialize(some, thing)
-#      @assignments = []
 #      assign [some, SomeRole], [thing, OtherRole]
 #      Thread.current[:context] = self
 #    end
@@ -28,9 +27,6 @@
 #    module OtherRole; end
 #  end
 #
-# In order to use this the objects sent into the context contstructor *must*
-# `include Casting::Client` so that the `cast` method is available to them
-#
 module Casting
   module Context
 
@@ -38,10 +34,16 @@ module Casting
       base.send(:include, InstanceMethods)
     end
 
-    def initialize(*setup_args)
+    def initialize(*setup_args, &block)
       attr_reader(*setup_args)
       private(*setup_args)
 
+      if block
+        define_method(:__custom_initialize, &block)
+      else
+        define_method(:__custom_initialize) do; end
+      end
+
       mod = Module.new
       line = __LINE__; string = %<
         def initialize(#{setup_args.map{|name| "#{name}:" }.join(',')})
@@ -49,6 +51,7 @@ module Casting
           #{setup_args.map do |name|
             ["assign(",name,", '",name,"')"].join
           end.join("\n")}
+          __custom_initialize
           Thread.current[:context] = self
         end
         attr_reader :assignments
@@ -62,7 +65,11 @@ module Casting
       def context
         self
       end
-  
+
+      def assignments
+        @assignments ||= []
+      end
+
       # Keep track of objects and their behaviors
       def assign(object, role_name)
         instance_variable_set("@#{role_name}", object)
@@ -74,15 +81,19 @@ module Casting
       end
 
       # Execute the behavior from the role on the specifed object
-      def dispatch(object, method_name, *args, &block)
-        object.cast(method_name, context.role_implementing(object, method_name), *args, &block)
+      def dispatch(object, method_name, ...)
+        if object.respond_to?(:cast)
+          object.cast(method_name, context.role_implementing(object, method_name), ...)
+        else
+          Casting::Delegation.prepare(method_name, object).to(role_implementing(object, method_name)).with(...).call
+        end
       end
-    
+
       # Find the first assigned role which implements a response for the given method name
       def role_implementing(object, method_name)
         assigned_roles(object).find{|role| role.method_defined?(method_name) } || raise(NoMethodError, "unknown method '#{method_name}' expected for #{object}")
       end
-    
+
       # Get the roles for the given object
       def assigned_roles(object)
         assignments.select{|pair|
@@ -96,7 +107,7 @@ module Casting
         role_name = name.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase }
         self.class.const_get(role_name)
       rescue NameError
-        Module
+        Module.new
       end
     end
 
@@ -115,11 +126,11 @@ module Casting
       end
 
       # Execute the named method on the object plaing the name role
-      def tell(role_name, method_name, *args, &block)
+      def tell(role_name, method_name, ...)
         if context == self || context.contains?(self)
-          context.dispatch(role(role_name), method_name, *args, &block)
+          context.dispatch(role(role_name), method_name, ...)
         end
       end
     end
   end
-end
+end

data/lib/casting/delegation.rb

@@ -1,32 +1,104 @@
-require 'casting/prepared_delegation'
-
 module Casting
-  class Delegation
 
-    attr_reader :prepared_delegation
-    private :prepared_delegation
+  class MissingAttendant < StandardError
+    def message
+      "You must set your attendant object using `to'."
+    end
+  end
+
+  class InvalidAttendant < StandardError; end
 
-    def initialize(delegated_method_name, client)
-      @prepared_delegation = PreparedDelegation.new(delegated_method_name: delegated_method_name, client: client)
+  class Delegation
+
+    def self.prepare(delegated_method_name, client, &block)
+      new(delegated_method_name: delegated_method_name, client: client, &block)
     end
 
-    def client
-      prepared_delegation.client
+    attr_accessor :client, :delegated_method_name, :attendant, :arguments, :block
+    private :block
+
+    def initialize(**settings, &block)
+      @delegated_method_name = settings[:delegated_method_name]
+      @client = settings[:client]
+      @attendant = settings[:attendant]
+      @arguments = settings[:arguments]
+      @keyword_arguments = settings[:keyword_arguments]
+      @block = block
     end
 
     def to(object_or_module)
-      prepared_delegation.to(object_or_module)
+      @attendant = object_or_module
+      begin
+        bound_method
+      rescue TypeError
+        @attendant = method_module || raise
+      end
       self
     end
 
-    def with(*args, &block)
-      prepared_delegation.with(*args, &block)
+    def with(*args, **kwargs, &block)
+      @arguments = args
+      @keyword_arguments = kwargs
+      @block = block
       self
     end
 
-    def call(*args)
-      prepared_delegation.call(*args)
+    def call(*args, **kwargs, &block)
+      raise MissingAttendant.new unless attendant
+
+      call_args = if args && !args.empty?
+        args
+      elsif @arguments && !@arguments.empty?
+        @arguments
+      end
+      call_kwargs = if kwargs && !kwargs.empty?
+        kwargs
+      elsif @keyword_arguments && !@keyword_arguments.empty?
+        @keyword_arguments
+      end
+
+      call_block = block || @block
+      if call_args
+        if call_kwargs
+          bound_method.call(*call_args, **call_kwargs, &call_block)
+        else
+          bound_method.call(*call_args, &call_block)
+        end
+      else
+        if call_kwargs
+          bound_method.call(**call_kwargs, &call_block)
+        else
+          bound_method.call(&call_block)
+        end
+      end
+    end
+
+    private
+
+    def bound_method
+      begin
+        delegated_method.bind(client)
+      rescue TypeError
+        raise TypeError.new("`to' argument must be a module or an object with #{delegated_method_name} defined in a module")
+      end
+    end
+
+    def method_module
+      mod = delegated_method.owner
+      unless mod.is_a?(Class)
+        mod
+      end
+    end
+
+    def delegated_method
+      if Module === attendant
+        attendant.instance_method(delegated_method_name)
+      else
+        attendant.method(delegated_method_name).owner.instance_method(delegated_method_name)
+      end
+    rescue NameError => e
+      raise InvalidAttendant.new(e.message)
     end
 
   end
-end
+end

data/lib/casting/missing_method_client.rb

@@ -47,18 +47,15 @@ module Casting
     private
 
     def __delegates__
-      return @__delegates__ if defined?(@__delegates__)
-      if frozen?
-        []
-      else
-        @__delegates__ = []
-      end
+      Thread.current[:instance_delegates] ||= {}
+      Thread.current[:instance_delegates][object_id] ||= []
+      Thread.current[:instance_delegates][object_id]
     end
 
-    def method_missing(meth, *args, &block)
+    def method_missing(meth, ...)
       attendant = method_delegate(meth)
       if !!attendant
-        delegate(meth, attendant, *args, &block)
+        cast(meth, attendant, ...)
       else
         super
       end
@@ -105,4 +102,4 @@ module Casting
       end
     end
   end
-end
+end

data/lib/casting/missing_method_client_class.rb

@@ -15,7 +15,7 @@ module Casting
       def method_missing(meth, *args, &block)
         attendant = method_class_delegate(meth)
         if !!attendant
-          delegate(meth, attendant, *args, &block)
+          cast(meth, attendant, *args, &block)
         else
           super
         end

data/lib/casting/null.rb

@@ -1,17 +1,17 @@
 module Casting
   module Null
-    def self.instance_method(_)
+    def self.instance_method(*_)
       Empty.instance_method(:null)
     end
-    def self.method_defined?(_)
+    def self.method_defined?(*_)
       true
     end
   end
   module Blank
-    def self.instance_method(_)
+    def self.instance_method(*_)
       Empty.instance_method(:blank)
     end
-    def self.method_defined?(_)
+    def self.method_defined?(*_)
       true
     end
   end

data/lib/casting/super_delegate.rb

@@ -28,17 +28,12 @@ module Casting
     # some_object.cast_as(Greeter, FormalGreeter)
     # some_object.greet #=> 'Hello, how do you do?'
     #
-    def super_delegate(*args, &block)
-      method_name = name_of_calling_method(caller)
-      owner = args.first || method_delegate(method_name)
-      
-      super_delegate_method = unbound_method_from_next_delegate(method_name, owner)
+    def super_delegate(mod = :none, *args, **kwargs, &block)
+      method_name = name_of_calling_method(caller_locations)
+      owner = (mod unless mod == :none) || method_delegate(method_name)
 
-      if super_delegate_method.arity == 0
-        super_delegate_method.bind(self).call
-      else
-        super_delegate_method.bind(self).call(*args, &block)
-      end
+      super_delegate_method = unbound_method_from_next_delegate(method_name, owner)
+      super_delegate_method.bind(self).call(*args, **kwargs, &block)
     rescue NameError
       raise NoMethodError.new("super_delegate: no delegate method `#{method_name}' for #{self.inspect} from #{owner}")
     end
@@ -49,20 +44,31 @@ module Casting
     
     def method_delegate_skipping(meth, skipped)
       skipped_index = __delegates__.index(skipped)
-      __delegates__.find{|attendant|
-        attendant_methods(attendant).include?(meth) &&
-        skipped_index < __delegates__.index(attendant)
+      __delegates__[(skipped_index + 1)..__delegates__.length].find{|attendant|
+        attendant_methods(attendant).include?(meth)
       }
     end
-    
-    def name_of_calling_method(call_stack)
+
+    def calling_location(call_stack)
       call_stack.reject{|line| 
-        line.to_s =~ casting_library_matcher 
-      }.first.split('`').last.sub("'","").to_sym
+        line.to_s.match? Regexp.union(casting_library_matcher, gem_home_matcher, debugging_matcher)
+      }.first
+    end
+
+    def name_of_calling_method(call_stack)
+      calling_location(call_stack).label.to_sym
     end
     
     def casting_library_matcher
       Regexp.new(Dir.pwd.to_s + '/lib')
     end
+
+    def gem_home_matcher
+      Regexp.new(ENV['GEM_HOME'])
+    end
+
+    def debugging_matcher
+      Regexp.new('internal:trace_point')
+    end
   end
-end
+end

data/lib/casting/version.rb

@@ -1,3 +1,3 @@
 module Casting
-  VERSION = '0.7.2'
-end
+  VERSION = '1.0.0'
+end

data/lib/casting.rb

@@ -1,6 +1,9 @@
+require 'casting/version'
 require 'casting/client'
+require 'casting/enum'
 require 'casting/super_delegate'
 require 'casting/null'
+require 'casting/context'
 
 module Casting
 

data/test/casting_test.rb

@@ -1,6 +1,25 @@
 require 'test_helper'
 
 describe Casting, '.delegating' do
+  it 'delegates missing methods to object delegates' do
+    client = test_person
+    client.extend(Casting::Client)
+    client.delegate_missing_methods
+
+    attendant = test_person
+    attendant.extend(TestPerson::Greeter)
+
+    assert_raises(NoMethodError){
+      client.greet
+    }
+    Casting.delegating(client => attendant) do
+      assert_equal 'hello', client.greet
+    end
+    assert_raises(NoMethodError){
+      client.greet
+    }
+  end
+
   it 'delegates missing methods for the objects inside the block' do
     client = BlockTestPerson.new('Jim')
     verbose_client = BlockTestPerson.new('Amy')

data/test/client_test.rb

@@ -78,4 +78,4 @@ describe Casting::Client do
       client.delegate('hello', attendant)
     }
   end
-end
+end

data/test/context_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class TestContext
+  using Casting::Context
+  extend Casting::Context
+
+  initialize :admin, :user
+
+  def approve
+    tell :admin, :say, 'I approve'
+  end
+
+  def approve_with_keyword
+    tell :admin, :keyword_say, what: 'I approve'
+  end
+
+  def user_approve
+    tell :user, :approve
+  end
+
+  module Admin
+    def say(what)
+      what
+    end
+
+    def keyword_say(what:)
+      what
+    end
+  end
+
+  module User
+    def approve
+      'Yay!'
+    end
+  end
+end
+
+class MissingModuleContext
+  using Casting::Context
+  extend Casting::Context
+
+  initialize :admin, :user
+
+  def run
+    tell :admin, :go
+  end
+end
+
+describe Casting::Context do
+  it 'applies module methods to Casting::Client objects' do
+    admin = casting_person
+    user = casting_person
+
+    context = TestContext.new admin: admin, user: user
+
+    expect(context.approve).must_equal ('I approve')
+    expect(context.approve_with_keyword).must_equal ('I approve')
+    expect(context.user_approve).must_equal ('Yay!')
+  end
+
+  it 'applies module methods to any object' do
+    admin = Object.new
+    user = 1
+
+    context = TestContext.new admin: admin, user: user
+
+    expect(context.approve).must_equal ('I approve')
+    expect(context.user_approve).must_equal ('Yay!')
+  end
+
+  it 'handles missing modules and raises missing method error' do
+    admin = TestPerson.new
+    user = TestPerson.new
+
+    context = MissingModuleContext.new admin: admin, user: user
+
+    err = expect{ context.run }.must_raise(NoMethodError)
+    expect(err.message).must_match(/unknown method 'go'/)
+  end
+end

data/test/delegation_test.rb

@@ -3,11 +3,11 @@ require 'test_helper'
 describe Casting::Delegation do
 
   it 'initializes with method name and object' do
-    assert Casting::Delegation.new('some_method', Object.new)
+    assert Casting::Delegation.prepare('some_method', Object.new)
   end
 
   it 'raises an error when calling without an attendant object' do
-    delegation = Casting::Delegation.new('some_method', Object.new)
+    delegation = Casting::Delegation.prepare('some_method', Object.new)
       begin
         delegation.call
       rescue StandardError => e
@@ -17,7 +17,14 @@ describe Casting::Delegation do
   end
 
   it 'raises an error when setting an invalid attendant type' do
-    delegation = Casting::Delegation.new('some_method', TestPerson.new)
+    delegation = Casting::Delegation.prepare('some_method', TestPerson.new)
+    assert_raises(Casting::InvalidAttendant){
+      delegation.to(Unrelated.new)
+    }
+  end
+
+  it 'raises an error when setting a class as the attendant' do
+    delegation = Casting::Delegation.prepare('some_method', TestPerson)
     assert_raises(Casting::InvalidAttendant){
       delegation.to(Unrelated.new)
     }
@@ -27,20 +34,36 @@ describe Casting::Delegation do
     attendant = test_person
     client = SubTestPerson.new
 
-    delegation = Casting::Delegation.new('name', client)
+    delegation = Casting::Delegation.prepare('name', client)
     assert delegation.to(attendant)
   end
 
   it 'delegates when given a module' do
     client = test_person
-    delegation = Casting::Delegation.new('greet', client).to(TestPerson::Greeter)
+    delegation = Casting::Delegation.prepare('greet', client).to(TestPerson::Greeter)
     assert_equal 'hello', delegation.call
   end
 
   it 'does not delegate when given a class' do
     client = test_person
+    err = expect{
+      Casting::Delegation.prepare('class_defined', client).to(Unrelated)
+    }.must_raise(TypeError)
+    expect(err.message).must_match(/ argument must be a module or an object with/)
+  end
+
+  it 'finds the module defining a method and uses it to delegate' do
+    client = test_person
+    attendant = Unrelated.new
+    delegation = Casting::Delegation.prepare('unrelated', client).to(attendant)
+    assert_equal attendant.unrelated, delegation.call
+  end
+
+  it 'does not delegate to methods defined in classes' do
+    client = test_person
+    attendant = Unrelated.new
     assert_raises(TypeError){
-      Casting::Delegation.new('class_defined', client).to(Unrelated)
+      Casting::Delegation.prepare('class_defined', client).to(attendant)
     }
   end
 
@@ -48,17 +71,128 @@ describe Casting::Delegation do
     client = test_person
     attendant = TestPerson::Verbose
 
-    delegation = Casting::Delegation.new('verbose', client).to(attendant)
+    delegation = Casting::Delegation.prepare('verbose', client).to(attendant)
 
     assert_equal 'hello,goodbye', delegation.with('hello', 'goodbye').call
   end
 
+  it 'assigns keyword arguments to the delegated method using with' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_keywords', client).to(attendant)
+
+    assert_equal 'hello,goodbye', delegation.with(key: 'hello', word: 'goodbye').call
+  end
+
+  it 'assigns regular and keyword arguments to the delegated method using with' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_multi_args', client).to(attendant)
+
+    assert_equal('hello,goodbye,keys,words,block!', delegation.with('hello', 'goodbye', key: 'keys', word: 'words') do
+      "block!"
+    end.call)
+  end
+
+  it 'handles flexible arguments to the delegated method using with' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_flex', client).to(attendant)
+
+    assert_equal('hello,key:keys,word:words,block!', delegation.with('hello', key: 'keys', word: 'words') do
+      "block!"
+    end.call)
+  end
+
   it 'prefers `call` arguments over `with`' do
     client = test_person
     attendant = TestPerson::Verbose
 
-    delegation = Casting::Delegation.new('verbose', client).to(attendant)
+    delegation = Casting::Delegation.prepare('verbose', client).to(attendant)
 
     assert_equal 'call,args', delegation.with('hello', 'goodbye').call('call','args')
   end
-end
+
+  it 'prefers "call" keyword arguments over "with"' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_keywords', client).to(attendant)
+
+    assert_equal 'call,args', delegation.with(key: 'hello', word: 'goodbye').call(key: 'call', word: 'args')
+  end
+
+  it 'prefers "call" regular and keyword arguments over "with"' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_multi_args', client).to(attendant)
+
+    assert_equal 'hello,goodbye,call,args', delegation.with('this', 'that', key: 'something', word: 'else').call('hello', 'goodbye', key: 'call', word: 'args')
+  end
+
+  it 'prefers "call" block arguments over "with"' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_multi_args', client).to(attendant)
+
+    prepared = delegation.with('this', 'that', key: 'something', word: 'else') { "prepared block!" }
+
+    assert_equal('this,that,something,else,call block!', prepared.call{ "call block!" })
+  end
+
+  it 'prefers "call" keyword arguments and block over "with"' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_flex', client).to(attendant)
+
+    prepared = delegation.with(key: 'something', word: 'else') { "prepared block!" }
+
+    assert_equal('key:call_key,word:call_word,call block!', prepared.call(key: 'call_key', word: 'call_word'){ "call block!" })
+  end
+
+  it 'prefers "call" and block over "with"' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.prepare('verbose_flex', client).to(attendant)
+
+    prepared = delegation.with { "prepared block!" }
+
+    assert_equal('call block!', prepared.call { "call block!" })
+  end
+
+  it 'calls a method defined on another object of the same type' do
+    client = test_person
+    attendant = test_person
+    attendant.extend(TestPerson::Greeter)
+    delegation = Casting::Delegation.prepare('greet', client).to(attendant)
+    assert_equal 'hello', delegation.call
+  end
+
+  it 'passes arguments to a delegated method' do
+    client = test_person
+    attendant = test_person
+    attendant.extend(TestPerson::Verbose)
+    delegation = Casting::Delegation.prepare('verbose', client).to(attendant).with('arg1','arg2')
+    assert_equal 'arg1,arg2', delegation.call
+  end
+
+  it 'delegates when given a module' do
+    client = test_person
+    delegation = Casting::Delegation.prepare('greet', client).to(TestPerson::Greeter)
+    assert_equal 'hello', delegation.call
+  end
+
+  it 'does not delegate when given a class' do
+    client = test_person
+    assert_raises(TypeError){
+      Casting::Delegation.prepare('class_defined', client).to(Unrelated)
+    }
+  end
+end

data/test/null_module_test.rb

@@ -21,6 +21,17 @@ describe Casting::Blank do
 end
 
 describe "making null objects" do
+  it "answers to missing methods" do
+    client = TestPerson.new
+    client.extend(Casting::Client)
+    client.delegate_missing_methods
+    attendant = Casting::Null
+
+    assert_respond_to client.cast_as(attendant), 'xyz'
+  end
+end
+
+describe "making blank objects" do
   it "answers to missing methods" do
     client = TestPerson.new
     client.extend(Casting::Client)

data/test/super_test.rb

@@ -4,19 +4,40 @@ module AnyWay
   def which_way
     "any way"
   end
+  def way_with_args(one, two, &block)
+    [one, two, block&.call].compact.inspect
+  end
+  def way_with_keyword_args(one:, two:, &block)
+    [one, two, block&.call].compact.inspect
+  end
 end
 
 module ThisWay
   include Casting::SuperDelegate
   def which_way
-    "this way or #{super_delegate(ThisWay)}"
+    "this way or #{super_delegate}"
+  end
+  def way_with_args(one, two, &block)
+    [one, two, block&.call].compact.inspect
+  end
+  def way_with_keyword_args(one:, two:, &block)
+    [one, two, block&.call].compact.inspect
+  end
+  def no_super
+    super_delegate
   end
 end
 
 module ThatWay
   include Casting::SuperDelegate
   def which_way
-    "#{ super_delegate } and that way!"
+    "#{ super_delegate(ThatWay) } and that way!"
+  end
+  def way_with_args(one, two, &block)
+    super_delegate(one, two, block&.call).compact
+  end
+  def way_with_keyword_args(one:, two:, &block)
+    [one, two, block&.call].compact.inspect
   end
 end
 
@@ -24,8 +45,36 @@ describe Casting, 'modules using delegate_super' do
   it 'call the method from the next delegate with the same arguments' do
     client = TestPerson.new.extend(Casting::Client)
     client.delegate_missing_methods
-    client.cast_as(AnyWay, ThisWay, ThatWay)
+    client.cast_as(AnyWay, ThatWay, ThisWay)
 
     assert_equal 'this way or any way and that way!', client.which_way
   end
-end
+
+  it 'passes arguments' do
+    client = TestPerson.new.extend(Casting::Client)
+    client.delegate_missing_methods
+    client.cast_as(ThatWay, ThisWay)
+
+    assert_equal %{["first", "second", "block"]}, client.way_with_args('first', 'second'){ 'block' }
+  end
+
+  it 'passes keyword arguments' do
+    client = TestPerson.new.extend(Casting::Client)
+    client.delegate_missing_methods
+    client.cast_as(ThatWay, ThisWay)
+
+    assert_equal %{["first", "second", "block"]}, client.way_with_keyword_args(one: 'first', two: 'second'){ 'block' }
+  end
+
+  it 'raises an error when method is not defined' do
+    client = TestPerson.new.extend(Casting::Client)
+    client.delegate_missing_methods
+    client.cast_as(ThisWay)
+
+    err = expect{
+      client.no_super
+    }.must_raise(NoMethodError)
+
+    expect(err.message).must_match(/super_delegate: no delegate method \`no_super' for \#<TestPerson:\dx[a-z0-9]*> from ThisWay/)
+  end
+end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
-
+require "simplecov"
+SimpleCov.start do
+  add_filter 'test'
+end
 require 'minitest/autorun'
 require 'casting'
 
@@ -31,9 +32,25 @@ class TestPerson
     def verbose(arg1, arg2)
       [arg1, arg2].join(',')
     end
+
+    def verbose_keywords(key:, word:)
+      [key, word].join(',')
+    end
+
+    def verbose_multi_args(arg1, arg2, key:, word:, &block)
+      [arg1, arg2, key, word, block&.call].compact.join(',')
+    end
+
+    def verbose_flex(*args, **kwargs, &block)
+      [args, kwargs.map{|k,v| "#{k}:#{v}"}, block&.call].flatten.compact.join(',')
+    end
   end
 end
 
+class TestGreeter
+  include TestPerson::Greeter
+end
+
 class SubTestPerson < TestPerson
   def sub_method
     'sub'
@@ -74,3 +91,7 @@ end
 def test_person
   TestPerson.new
 end
+
+def casting_person
+  test_person.extend(Casting::Client)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: casting
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Jim Gay
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2022-07-17 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Casting assists in method delegation which preserves the binding of 'self' to the object receiving a message.
@@ -31,14 +31,12 @@ files:
 - lib/casting/missing_method_client.rb
 - lib/casting/missing_method_client_class.rb
 - lib/casting/null.rb
-- lib/casting/prepared_delegation.rb
 - lib/casting/super_delegate.rb
 - lib/casting/version.rb
-- test/casting_19_test.rb
-- test/casting_20_test.rb
 - test/casting_test.rb
 - test/class_refinement_test.rb
 - test/client_test.rb
+- test/context_test.rb
 - test/delegation_test.rb
 - test/method_consolidator_test.rb
 - test/missing_method_client_test.rb
@@ -50,7 +48,7 @@ homepage: http://github.com/saturnflyer/casting
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -58,25 +56,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.6
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Proper method delegation.
 test_files:
 - test/test_helper.rb
-- test/casting_19_test.rb
-- test/casting_20_test.rb
 - test/casting_test.rb
 - test/class_refinement_test.rb
 - test/client_test.rb
+- test/context_test.rb
 - test/delegation_test.rb
 - test/method_consolidator_test.rb
 - test/missing_method_client_test.rb

data/lib/casting/prepared_delegation.rb

@@ -1,79 +0,0 @@
-module Casting
-
-  class MissingAttendant < StandardError
-    def message
-      "You must set your attendant object using `to'."
-    end
-  end
-
-  class InvalidAttendant < StandardError; end
-
-  class PreparedDelegation
-
-    attr_accessor :client, :delegated_method_name, :attendant, :arguments, :block
-    private :block
-
-    def initialize(**settings, &block)
-      @delegated_method_name = settings[:delegated_method_name]
-      @client = settings[:client]
-      @attendant = settings[:attendant]
-      @arguments = settings[:arguments]
-      @block = block
-    end
-
-    def to(object_or_module)
-      @attendant = object_or_module
-      begin
-        check_valid_type
-      rescue TypeError
-        @attendant = method_module || raise
-      end
-      self
-    end
-
-    def with(*args, &block)
-      @arguments = args
-      @block = block
-      self
-    end
-
-    def call(*args)
-      @arguments = args unless args.empty?
-      raise MissingAttendant.new unless attendant
-
-      if arguments
-        delegated_method.bind(client).call(*arguments, &block)
-      else
-        delegated_method.bind(client).call
-      end
-    end
-
-    private
-
-    def check_valid_type
-      begin
-        !client.nil? && delegated_method.bind(client)
-      rescue TypeError
-        raise TypeError.new("`to' argument must be a module or an object with #{delegated_method_name} defined in a module")
-      end
-    end
-
-    def method_module
-      mod = delegated_method.owner
-      unless mod.is_a?(Class)
-        mod
-      end
-    end
-
-    def delegated_method
-      if Module === attendant
-        attendant.instance_method(delegated_method_name)
-      else
-        attendant.method(delegated_method_name).owner.instance_method(delegated_method_name)
-      end
-    rescue NameError => e
-      raise InvalidAttendant.new(e.message)
-    end
-
-  end
-end

data/test/casting_19_test.rb

@@ -1,54 +0,0 @@
-require 'test_helper'
-
-describe Casting, '.delegating' do
-  it 'delegates missing methods to object delegates' do
-    client = test_person
-    client.extend(Casting::Client)
-    client.delegate_missing_methods
-
-    attendant = test_person
-    attendant.extend(TestPerson::Greeter)
-
-    assert_raises(NoMethodError){
-      client.greet
-    }
-    Casting.delegating(client => attendant) do
-      assert_equal 'hello', client.greet
-    end
-    assert_raises(NoMethodError){
-      client.greet
-    }
-  end
-end
-
-describe Casting::Delegation do
-
-  it 'calls a method defined on another object of the same type' do
-    client = test_person
-    attendant = test_person
-    attendant.extend(TestPerson::Greeter)
-    delegation = Casting::Delegation.new('greet', client).to(attendant)
-    assert_equal 'hello', delegation.call
-  end
-
-  it 'passes arguments to a delegated method' do
-    client = test_person
-    attendant = test_person
-    attendant.extend(TestPerson::Verbose)
-    delegation = Casting::Delegation.new('verbose', client).to(attendant).with('arg1','arg2')
-    assert_equal 'arg1,arg2', delegation.call
-  end
-
-  it 'delegates when given a module' do
-    client = test_person
-    delegation = Casting::Delegation.new('greet', client).to(TestPerson::Greeter)
-    assert_equal 'hello', delegation.call
-  end
-
-  it 'does not delegate when given a class' do
-    client = test_person
-    assert_raises(TypeError){
-      Casting::Delegation.new('class_defined', client).to(Unrelated)
-    }
-  end
-end

data/test/casting_20_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-describe Casting::Delegation do
-
-  it 'finds the module defining a method and uses it to delegate' do
-    client = test_person
-    attendant = Unrelated.new
-    delegation = Casting::Delegation.new('unrelated', client).to(attendant)
-    assert_equal attendant.unrelated, delegation.call
-  end
-
-  it 'does not delegate to methods defined in classes' do
-    client = test_person
-    attendant = Unrelated.new
-    assert_raises(TypeError){
-      Casting::Delegation.new('class_defined', client).to(attendant)
-    }
-  end
-end