casting 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0cca3576453e1acf20799cd80afe5a2e9e4c39cc
-  data.tar.gz: f892e78276d01554fa159d893507c61fcb4dcf37
+SHA256:
+  metadata.gz: a7d5101d4c7109e86710609589a9f7dcd4d9d5452e7a452fa29349297325d9a7
+  data.tar.gz: 5854e95575b52af1b6d912a5aa3dc18101faa109d9bea387dba59b6bd50b9df7
 SHA512:
-  metadata.gz: 68f289b4009fd5330f856fda1ce71f190ab8317fbf0aa343b9b4244afc6bcdb613be34457c3b98ceb120b620e889511b285099d1006cd6f679be874a6a0a1251
-  data.tar.gz: 75e7c54b13bad49081fd15597adc4891f3ebfdb5c66b423b0278ecbfd8a3dd48ff22ab1fcc6a2b40b7dae19a29d5e31d1a5a3b1a0986f9250c67e2c3c52c3950
+  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,8 +1,7 @@
 # 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)
-[![Coverage Status](https://coveralls.io/repos/saturnflyer/casting/badge.png)](https://coveralls.io/r/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)
 
 ## Add behavior to your objects without using extend
@@ -18,7 +17,7 @@ Here's a quick example that you might try in a Rails project:
 # implement a module that contains information for the request response
 # and apply it to an object in your system.
 def show
-  respond_with user.cast_as(UserRepresenter)
+  @user = user.cast_as(UserRepresenter)
 end
 ```
 
@@ -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:
 
@@ -293,22 +304,14 @@ Person.instance_method(:hello) #=> #<UnboundMethod: Person#hello>
 But if you attempt to use that `UnboundMethod` on an object that is not a `Person` you'll get
 an error about a type mismatch.
 
-Casting will bind an unbound method to a client object and execute the method as though it is
+Casting will bind an UnboundMethod method to a client object and execute the method as though it is
 defined on the client object. Any reference to `self` from the method block will refer to the
 client object.
 
-This behavior is different in Ruby 1.9 vs. 2.x.
-
-According to [http://rubyspec.org](http://rubyspec.org) the behavior in MRI in 1.9 that allows this to happen is incorrect. In MRI (and JRuby) 1.9 you may unbind methods from an object that has been extended with a module, and bind them to another object of the same type that has *not* been extended with that module.
-
-Casting uses this as a way to trick the interpreter into using the method where we want it and avoid forever extending the object of concern.
-
-This changed in Ruby 2.0 and does not work. What does work (and is so much better) in 2.0 is that you may take any method from a module and apply it to any object. This means that Casting doesn't have to perform any tricks to temporarily apply behavior to an object.
-
-For example, this fails in 1.9, but works in 2.0:
+Rather than define methods on classes, you may take any method from a module and apply it to any object regardless of its class.
 
 ```ruby
-GreetingModule.instance_method(:hello_world).bind(actor).call
+GreetingModule.instance_method(:hello).bind(actor).call
 ```
 
 Casting provides a convenience for doing this.
@@ -350,12 +353,6 @@ If you are using Bundler, add this line to your application's Gemfile:
 gem 'casting'
 ```
 
-If you're using Ruby 1.9, be sure to use a version lower than 0.7
-
-```ruby
-gem 'casting', '~> 0.6.9'
-```
-
 And then execute:
 
     $ bundle

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

@@ -0,0 +1,136 @@
+# This is an experimental implementation of allowing contextual use of behaviors.
+#
+# This relies on versions of Ruby supporting refinements.
+#
+# You *must* include the following module and use it for refinements, and
+# you *must* set the current context for the thread:
+#
+#  class SomeContext
+#    using Casting::Context
+#    extend Casting::Context
+#
+#    initialize(:some, :thing)
+#    # doing that defines your constructor but would cause it too look for
+#    # modules named Some and Thing
+#    module Some; end
+#    module Thing; end
+#
+#    # if you want different module names (why would you?) then you'd need
+#    # to do all this:
+#    def initialize(some, thing)
+#      assign [some, SomeRole], [thing, OtherRole]
+#      Thread.current[:context] = self
+#    end
+#    attr_reader :some, :thing, :assignments
+#
+#    module SomeRole; end
+#    module OtherRole; end
+#  end
+#
+module Casting
+  module Context
+
+    def self.extended(base)
+      base.send(:include, InstanceMethods)
+    end
+
+    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(',')})
+          @assignments = []
+          #{setup_args.map do |name|
+            ["assign(",name,", '",name,"')"].join
+          end.join("\n")}
+          __custom_initialize
+          Thread.current[:context] = self
+        end
+        attr_reader :assignments
+      >
+      mod.class_eval string, __FILE__, line
+      const_set('Initializer', mod)
+      include mod
+    end
+
+    module InstanceMethods
+      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)
+        self.assignments << [object, self.role_for(role_name)]
+      end
+
+      def contains?(obj)
+        assignments.map(&:first).include?(obj)
+      end
+
+      # Execute the behavior from the role on the specifed object
+      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|
+          pair.first == object
+        }.map(&:last)
+      end
+
+      # Get the behavior module for the named role.
+      # This role constant for special_person is SpecialPerson.
+      def role_for(name)
+        role_name = name.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase }
+        self.class.const_get(role_name)
+      rescue NameError
+        Module.new
+      end
+    end
+
+    refine Object do
+      def context
+        Thread.current[:context]
+      end
+
+      def context=(obj)
+        Thread.current[:context] = obj
+      end
+
+      # Get the object playing a particular role
+      def role(role_name)
+        context.send(role_name)
+      end
+
+      # Execute the named method on the object plaing the name role
+      def tell(role_name, method_name, ...)
+        if context == self || context.contains?(self)
+          context.dispatch(role(role_name), method_name, ...)
+        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,13 +47,15 @@ module Casting
     private
 
     def __delegates__
-      @__delegates__ ||= []
+      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
@@ -65,6 +67,7 @@ module Casting
 
     def method_delegate(meth)
       __delegates__.find{|attendant|
+        attendant.respond_to?(:method_defined?) && attendant.method_defined?(meth) ||
         attendant_methods(attendant).include?(meth)
       }
     end
@@ -99,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,18 +1,24 @@
 module Casting
   module Null
-    def self.instance_method(name)
+    def self.instance_method(*_)
       Empty.instance_method(:null)
     end
+    def self.method_defined?(*_)
+      true
+    end
   end
   module Blank
-    def self.instance_method(name)
+    def self.instance_method(*_)
       Empty.instance_method(:blank)
     end
+    def self.method_defined?(*_)
+      true
+    end
   end
   module Empty
-    def null(*args, &block); end
-    def blank(*args, &block)
+    def null(*, &_block); end
+    def blank(*, &_block)
       ""
     end
   end 
-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.0'
-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

@@ -18,4 +18,26 @@ describe Casting::Blank do
 
     assert_empty client.delegate('greet', attendant)
   end
+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)
+    client.delegate_missing_methods
+    attendant = Casting::Blank
+
+    assert_respond_to client.cast_as(attendant), 'xyz'
+  end
 end

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,13 +1,7 @@
-require 'simplecov'
+require "simplecov"
 SimpleCov.start do
   add_filter 'test'
 end
-
-require 'coveralls'
-if ENV['COVERALLS']
-  Coveralls.wear!
-end
-
 require 'minitest/autorun'
 require 'casting'
 
@@ -38,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'
@@ -81,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.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Jim Gay
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-06-26 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.
@@ -20,62 +20,59 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
+- Rakefile
 - lib/casting.rb
 - lib/casting/client.rb
+- lib/casting/context.rb
 - lib/casting/delegation.rb
 - lib/casting/method_consolidator.rb
 - 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
-- LICENSE
-- Rakefile
-- README.md
-- 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
-- test/null_module_test.rb
 - test/module_cleanup_test.rb
+- test/null_module_test.rb
 - test/super_test.rb
+- test/test_helper.rb
 homepage: http://github.com/saturnflyer/casting
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 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.0.14
-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,76 +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_reader :client
-    attr_reader :delegated_method_name, :attendant, :arguments, :block
-    private :delegated_method_name, :attendant, :arguments, :block
-
-    def initialize(settings)
-      @delegated_method_name = settings[:delegated_method_name]
-      @client = settings[:client]
-      @attendant = settings[:attendant]
-      @arguments = settings[:arguments]
-    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
-      delegated_method.owner unless delegated_method.owner.is_a?(Class)
-    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