casting 0.5.0 → 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 475b68274fd553b6f0f42332623d2d13e3668198
+  data.tar.gz: ce58705b237fed2f09d4ea34d45315745c662e8a
+SHA512:
+  metadata.gz: dd71a1d2f4ef744f27c885b8f3b5a71a4c06585b51fa4344010da8334864ce626a66a738716873051990ae0ecc1d0bee8de121ceb81f5bbdfa73755a6a70e501
+  data.tar.gz: 48703d09ddf47127c7f8b3bc2d36059bcf9ab6988ed6c360607fae501229000c4e72a26df490d4f69f9e23e48c8a2fa0e2bfc6c1d57e7fbd4e88bd5b8e6d5ac9

data/lib/casting.rb

@@ -1,190 +1,30 @@
-require 'redcard'
+require 'casting/client'
 
 module Casting
 
+  class InvalidClientError < StandardError; end
+
   def self.delegating(assignments)
     assignments.each do |object, mod|
-      object.send(:instance_variable_set, :@__previous_delegate__, object.instance_variable_get(:@__current_delegate__))
-      object.send(:instance_variable_set, :@__current_delegate__, mod)
+      cast_object(object, mod)
     end
     yield
   ensure
     assignments.each do |object, mod|
-      object.send(:instance_variable_set, :@__current_delegate__, object.instance_variable_get(:@__previous_delegate__))
-      object.send(:remove_instance_variable, :@__previous_delegate__)
+      uncast_object(object)
     end
   end
 
-  class MissingAttendant < StandardError
-    def message
-      "You must set your attendant object using `to'."
-    end
-  end
+  def self.cast_object(object, mod)
+    raise InvalidClientError.new unless object.respond_to?(:cast_as)
 
-  class InvalidAttendant < StandardError
+    object.cast_as(mod)
   end
 
-  module Client
-
-    def self.included(base)
-      def base.delegate_missing_methods
-        self.send(:include, ::Casting::MissingMethodClient)
-      end
-
-      unless base.instance_methods.include?('delegate')
-        base.class_eval{ alias_method :delegate, :cast }
-      end
-    end
-
-    def self.extended(base)
-      unless base.respond_to?('delegate')
-        base.singleton_class.class_eval{ alias_method :delegate, :cast }
-      end
-    end
+  def self.uncast_object(object)
+    return unless object.respond_to?(:uncast)
 
-    def delegation(delegated_method_name)
-      Casting::Delegation.new(delegated_method_name, self)
-    end
-
-    def cast(delegated_method_name, attendant, *args)
-      delegation(delegated_method_name).to(attendant).with(*args).call
-    end
-
-    def delegate_missing_methods
-      self.extend ::Casting::MissingMethodClient
-    end
+    object.uncast
   end
 
-  module MissingMethodClient
-    def method_missing(meth, *args, &block)
-      if delegate_has_method?(meth)
-        delegate(meth, @__current_delegate__, *args, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(meth, *)
-      delegate_has_method?(meth) || super
-    end
-
-    private
-
-    def delegate_has_method?(meth)
-      return false unless @__current_delegate__
-
-      if Module === @__current_delegate__
-        @__current_delegate__.instance_methods
-      else
-        @__current_delegate__.methods
-      end.include?(meth)
-    end
-  end
-
-  class PreparedDelegation
-
-    attr_reader :client
-    attr_reader :delegated_method_name, :attendant, :arguments
-    private :delegated_method_name, :attendant, :arguments
-
-    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 = method_carrier(object_or_module)
-      begin
-        check_valid_type
-      rescue TypeError => e
-        raise unless RedCard.check '2.0'
-        @attendant = method_module || raise
-      end
-      self
-    end
-
-    def with(*args)
-      @arguments = args
-      self
-    end
-
-    def call(*args)
-      @arguments = args unless args.empty?
-      raise MissingAttendant.new unless attendant
-
-      if arguments
-        delegated_method.bind(client).call(*arguments)
-      else
-        delegated_method.bind(client).call
-      end
-    end
-
-    private
-
-    def check_valid_type
-      begin
-        !client.nil? && delegated_method.bind(client)
-      rescue TypeError => e
-        raise TypeError.new("`to' argument must be a module or an instance of #{client.class}")
-      end
-    end
-
-    def method_carrier(object_or_module)
-      if Module === object_or_module
-        if RedCard.check '2.0'
-          object_or_module
-        else
-          client.clone.extend(object_or_module)
-        end
-      else
-        object_or_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).unbind
-      end
-    rescue NameError => e
-      raise InvalidAttendant.new(e.message)
-    end
-
-  end
-
-  class Delegation
-
-    attr_reader :prepared_delegation
-    private :prepared_delegation
-
-    def initialize(delegated_method_name, client)
-      @prepared_delegation = PreparedDelegation.new(:delegated_method_name => delegated_method_name, :client => client)
-    end
-
-    def client
-      prepared_delegation.client
-    end
-
-    def to(object_or_module)
-      prepared_delegation.to(object_or_module)
-      self
-    end
-
-    def with(*args)
-      prepared_delegation.with(*args)
-      self
-    end
-
-    def call(*args)
-      prepared_delegation.call(*args)
-    end
-
-  end
 end

data/lib/casting/client.rb

@@ -0,0 +1,41 @@
+require 'casting/delegation'
+require 'casting/missing_method_client'
+
+module Casting
+  module Client
+
+    def self.included(base)
+      def base.delegate_missing_methods
+        self.send(:include, ::Casting::MissingMethodClient)
+      end
+
+      unless base.instance_methods.include?('delegate')
+        add_delegate_method_to(base)
+      end
+    end
+
+    def self.extended(base)
+      unless base.respond_to?('delegate')
+        add_delegate_method_to(base.singleton_class)
+      end
+    end
+
+    def delegation(delegated_method_name)
+      Casting::Delegation.new(delegated_method_name, self)
+    end
+
+    def cast(delegated_method_name, attendant, *args)
+      delegation(delegated_method_name).to(attendant).with(*args).call
+    end
+
+    def delegate_missing_methods
+      self.extend ::Casting::MissingMethodClient
+    end
+
+    private
+
+    def self.add_delegate_method_to(base)
+      base.class_eval{ alias_method :delegate, :cast }
+    end
+  end
+end

data/lib/casting/delegation.rb

@@ -0,0 +1,32 @@
+require 'casting/prepared_delegation'
+
+module Casting
+  class Delegation
+
+    attr_reader :prepared_delegation
+    private :prepared_delegation
+
+    def initialize(delegated_method_name, client)
+      @prepared_delegation = PreparedDelegation.new(:delegated_method_name => delegated_method_name, :client => client)
+    end
+
+    def client
+      prepared_delegation.client
+    end
+
+    def to(object_or_module)
+      prepared_delegation.to(object_or_module)
+      self
+    end
+
+    def with(*args)
+      prepared_delegation.with(*args)
+      self
+    end
+
+    def call(*args)
+      prepared_delegation.call(*args)
+    end
+
+  end
+end

data/lib/casting/missing_method_client.rb

@@ -0,0 +1,42 @@
+module Casting
+  module MissingMethodClient
+
+    def cast_as(attendant)
+      __delegates__.unshift(attendant)
+      self
+    end
+
+    def uncast
+      __delegates__.shift
+      self
+    end
+
+    def method_missing(meth, *args, &block)
+      if !!method_delegate(meth)
+        delegate(meth, method_delegate(meth), *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, *)
+      !!method_delegate(meth) || super
+    end
+
+    private
+
+    def __delegates__
+      @__delegates__ ||= []
+    end
+
+    def method_delegate(meth)
+      __delegates__.find{|attendant|
+        if Module === attendant
+          attendant.instance_methods
+        else
+          attendant.methods
+        end.include?(meth)
+      }
+    end
+  end
+end

data/lib/casting/prepared_delegation.rb

@@ -0,0 +1,90 @@
+require 'redcard'
+
+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
+    private :delegated_method_name, :attendant, :arguments
+
+    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 = method_carrier(object_or_module)
+      begin
+        check_valid_type
+      rescue TypeError => e
+        raise unless RedCard.check '2.0'
+        @attendant = method_module || raise
+      end
+      self
+    end
+
+    def with(*args)
+      @arguments = args
+      self
+    end
+
+    def call(*args)
+      @arguments = args unless args.empty?
+      raise MissingAttendant.new unless attendant
+
+      if arguments
+        delegated_method.bind(client).call(*arguments)
+      else
+        delegated_method.bind(client).call
+      end
+    end
+
+    private
+
+    def check_valid_type
+      begin
+        !client.nil? && delegated_method.bind(client)
+      rescue TypeError => e
+        raise TypeError.new("`to' argument must be a module or an instance of #{client.class}")
+      end
+    end
+
+    def method_carrier(object_or_module)
+      if Module === object_or_module
+        if RedCard.check '2.0'
+          object_or_module
+        else
+          client.clone.extend(object_or_module)
+        end
+      else
+        object_or_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).unbind
+      end
+    rescue NameError => e
+      raise InvalidAttendant.new(e.message)
+    end
+
+  end
+end

data/lib/casting/version.rb

@@ -1,3 +1,3 @@
 module Casting
-  VERSION = '0.5.0'
+  VERSION = '0.5.2'
 end

data/test/casting_19_test.rb

@@ -26,15 +26,6 @@ end
 
 describe Casting::Delegation do
 
-  # it 'errors with a method defined on another object not of the same module type' do
-  #   client = test_person
-  #   attendant = test_person
-  #   attendant.extend(TestPerson::Greeter)
-  #   assert_raises(TypeError){
-  #     Casting::Delegation.new('greet', client).to(attendant)
-  #   }
-  # end
-
   it 'calls a method defined on another object of the same type' do
     client = test_person
     attendant = test_person

data/test/casting_test.rb

@@ -6,7 +6,7 @@ BlockTestPerson.send(:include, Casting::Client)
 BlockTestPerson.delegate_missing_methods
 
 describe Casting, '.delegating' do
-  it 'delegates missing methods for the objects inisde the block' do
+  it 'delegates missing methods for the objects inside the block' do
     client = BlockTestPerson.new('Jim')
     verbose_client = BlockTestPerson.new('Amy')
 
@@ -49,105 +49,27 @@ describe Casting, '.delegating' do
 
     assert !client.respond_to?(:greet)
   end
-end
 
-describe Casting::Delegation do
-
-  it 'initializes with method name and object' do
-    assert Casting::Delegation.new('some_method', Object.new)
-  end
-
-  it 'raises an error when calling without an attendant object' do
-    delegation = Casting::Delegation.new('some_method', Object.new)
-    assert_raises(Casting::MissingAttendant){
-      delegation.call
-    }
-  end
-
-  it 'raises an error when setting an invalid attendant type' do
-    delegation = Casting::Delegation.new('some_method', TestPerson.new)
-    assert_raises(Casting::InvalidAttendant){
-      delegation.to(Unrelated.new)
-    }
-  end
-
-  it 'sets an attendant to an object of an ancestor class of the object class' do
-    attendant = test_person
-    client = SubTestPerson.new
-
-    delegation = Casting::Delegation.new('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)
-    assert_equal 'hello', delegation.call
-  end
+  it 'raises an error if the given object is not an object that delegates missing methods' do
+    client = test_person.extend(Casting::Client)
 
-  it 'does not delegate when given a class' do
-    client = test_person
-    assert_raises(TypeError){
-      Casting::Delegation.new('class_defined', client).to(Unrelated)
+    assert_raises(Casting::InvalidClientError){
+      Casting.delegating(client => TestPerson::Greeter){ }
     }
   end
 
-  it 'assigns arguments to the delegated method using with' do
-    client = test_person
-    attendant = TestPerson::Verbose
-
-    delegation = Casting::Delegation.new('verbose', client).to(attendant)
-
-    assert_equal 'hello,goodbye', delegation.with('hello', 'goodbye').call
-  end
-
-  it 'prefers `call` arguments over `with`' do
-    client = test_person
-    attendant = TestPerson::Verbose
-
-    delegation = Casting::Delegation.new('verbose', client).to(attendant)
-
-    assert_equal 'call,args', delegation.with('hello', 'goodbye').call('call','args')
-  end
-end
+  it 'allows for nested delegating' do
+    client = test_person.extend(Casting::Client)
+    client.delegate_missing_methods
 
-describe Casting::Client do
-  it 'will not override an existing `delegate` method' do
-    client = TestPerson.new
-    def client.delegate
-      'existing delegate method'
+    Casting.delegating(client => TestPerson::Greeter) do
+      assert client.respond_to?(:greet)
+      Casting.delegating(client => TestPerson::Verbose) do
+        assert client.respond_to?(:greet)
+        assert client.respond_to?(:verbose)
+      end
+      assert !client.respond_to?(:verbose)
     end
-    client.extend(Casting::Client)
-
-    attendant = TestPerson::Greeter
-
-    assert_equal 'existing delegate method', client.delegate
-
-    assert_equal 'hello', client.cast('greet', attendant)
-  end
-
-  it 'adds a delegate method to call a method on an attendant' do
-    client = TestPerson.new
-    client.extend(Casting::Client)
-    attendant = TestPerson::Greeter
-
-    assert_equal 'hello', client.delegate('greet', attendant)
-  end
-
-  it 'passes additional parameters to the attendant' do
-    client = TestPerson.new
-    client.extend(Casting::Client)
-    attendant = TestPerson::Verbose
-
-    assert_equal 'hello,goodbye', client.delegate('verbose', attendant, 'hello', 'goodbye')
-  end
-
-  it 'passes the object as the client for delegation' do
-    client = Object.new
-    client.extend(Casting::Client)
-
-    delegation = client.delegation('id')
-
-    assert_equal client, delegation.client
+    assert !client.respond_to?(:greet)
   end
 end

data/test/client_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+describe Casting::Client do
+  it 'will not override an existing `delegate` method' do
+    client = TestPerson.new
+    def client.delegate
+      'existing delegate method'
+    end
+    client.extend(Casting::Client)
+
+    attendant = TestPerson::Greeter
+
+    assert_equal 'existing delegate method', client.delegate
+
+    assert_equal 'hello', client.cast('greet', attendant)
+  end
+
+  it 'adds a delegate method to call a method on an attendant' do
+    client = TestPerson.new
+    client.extend(Casting::Client)
+    attendant = TestPerson::Greeter
+
+    assert_equal 'hello', client.delegate('greet', attendant)
+  end
+
+  it 'passes additional parameters to the attendant' do
+    client = TestPerson.new
+    client.extend(Casting::Client)
+    attendant = TestPerson::Verbose
+
+    assert_equal 'hello,goodbye', client.delegate('verbose', attendant, 'hello', 'goodbye')
+  end
+
+  it 'passes the object as the client for delegation' do
+    client = Object.new
+    client.extend(Casting::Client)
+
+    delegation = client.delegation('id')
+
+    assert_equal client, delegation.client
+  end
+end

data/test/delegation_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+describe Casting::Delegation do
+
+  it 'initializes with method name and object' do
+    assert Casting::Delegation.new('some_method', Object.new)
+  end
+
+  it 'raises an error when calling without an attendant object' do
+    delegation = Casting::Delegation.new('some_method', Object.new)
+    assert_raises(Casting::MissingAttendant){
+      delegation.call
+    }
+  end
+
+  it 'raises an error when setting an invalid attendant type' do
+    delegation = Casting::Delegation.new('some_method', TestPerson.new)
+    assert_raises(Casting::InvalidAttendant){
+      delegation.to(Unrelated.new)
+    }
+  end
+
+  it 'sets an attendant to an object of an ancestor class of the object class' do
+    attendant = test_person
+    client = SubTestPerson.new
+
+    delegation = Casting::Delegation.new('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)
+    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
+
+  it 'assigns arguments to the delegated method using with' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.new('verbose', client).to(attendant)
+
+    assert_equal 'hello,goodbye', delegation.with('hello', 'goodbye').call
+  end
+
+  it 'prefers `call` arguments over `with`' do
+    client = test_person
+    attendant = TestPerson::Verbose
+
+    delegation = Casting::Delegation.new('verbose', client).to(attendant)
+
+    assert_equal 'call,args', delegation.with('hello', 'goodbye').call('call','args')
+  end
+end

data/test/missing_method_client_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+require 'casting/client'
+
+describe Casting::MissingMethodClient, '#cast_as' do
+  def client
+    @client ||= test_person.extend(Casting::Client, Casting::MissingMethodClient)
+  end
+
+  it "sets the object's delegate for missing methods" do
+    client.cast_as(TestPerson::Greeter)
+    assert_equal 'hello', client.greet
+  end
+
+  it "delegates to objects of the same type" do
+    client.extend(TestPerson::Greeter)
+    attendant = client.clone
+    client.singleton_class.send(:undef_method, :greet)
+    client.cast_as(attendant)
+    assert_equal 'hello', client.greet
+  end
+
+  it "returns the object for further operation" do
+    jim = test_person.extend(Casting::Client, Casting::MissingMethodClient)
+
+    assert_equal 'hello', jim.cast_as(TestPerson::Greeter).greet
+  end
+end
+
+describe Casting::MissingMethodClient, '#uncast' do
+  def client
+    @client ||= test_person.extend(Casting::Client, Casting::MissingMethodClient)
+  end
+
+  it "removes the last added delegate" do
+    client.cast_as(TestPerson::Greeter)
+    assert_equal 'hello', client.greet
+    client.uncast
+    assert_raises(NoMethodError){ client.greet }
+  end
+
+  it "maintains any previously added delegates" do
+    client.cast_as(TestPerson::Verbose)
+    assert_equal 'one,two', client.verbose('one', 'two')
+    client.uncast
+    assert_raises(NoMethodError){ client.verbose('one', 'two') }
+  end
+
+  it "returns the object for further operation" do
+    jim = test_person.extend(Casting::Client, Casting::MissingMethodClient)
+
+    assert_equal 'name from TestPerson', jim.uncast.name
+  end
+end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: casting
 version: !ruby/object:Gem::Version
-  version: 0.5.0
-  prerelease: 
+  version: 0.5.2
 platform: ruby
 authors:
 - Jim Gay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-26 00:00:00.000000000 Z
+date: 2013-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redcard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,15 +20,14 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.1.0
-description: ! "Casting assists in method delegation which preserves the binding of
-  'self' to the object receiving a message.\n\n    This allows you to define behavior
-  and apply it to an object temporarily without extending the object's super class
-  structure."
+description: |-
+  Casting assists in method delegation which preserves the binding of 'self' to the object receiving a message.
+
+      This allows you to define behavior and apply it to an object temporarily without extending the object's super class structure.
 email:
 - jim@saturnflyer.com
 executables: []
@@ -39,37 +36,46 @@ extra_rdoc_files: []
 files:
 - lib/casting.rb
 - lib/casting/version.rb
+- lib/casting/delegation.rb
+- lib/casting/missing_method_client.rb
+- lib/casting/prepared_delegation.rb
+- lib/casting/client.rb
 - test/test_helper.rb
-- test/casting_test.rb
 - test/casting_19_test.rb
 - test/casting_20_test.rb
+- test/casting_test.rb
+- test/client_test.rb
+- test/delegation_test.rb
+- test/missing_method_client_test.rb
 homepage: http://github.com/saturnflyer/casting
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Proper method delegation.
 test_files:
 - test/test_helper.rb
-- test/casting_test.rb
 - test/casting_19_test.rb
 - test/casting_20_test.rb
-has_rdoc: 
+- test/casting_test.rb
+- test/client_test.rb
+- test/delegation_test.rb
+- test/missing_method_client_test.rb