casting 1.0.0 → 1.0.2

data/test/casting_test.rb

@@ -1,89 +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
-
-  it 'delegates missing methods for the objects inside the block' do
-    client = BlockTestPerson.new('Jim')
-    verbose_client = BlockTestPerson.new('Amy')
-
-    assert_raises(NoMethodError){
-      client.greet
-    }
-    Casting.delegating(client => TestPerson::Greeter, verbose_client => TestPerson::Verbose) do
-      assert_equal 'hello', client.greet
-      assert_equal 'this,that', verbose_client.verbose('this','that')
-    end
-    assert_raises(NoMethodError){
-      client.greet
-    }
-  end
-
-  it 'delegates missing methods on altered objects inside the block' do
-    client = test_person.extend(Casting::Client)
-    client.delegate_missing_methods
-
-    assert_raises(NoMethodError){
-      client.greet
-    }
-    Casting.delegating(client => TestPerson::Greeter) do
-      assert_equal 'hello', client.greet
-    end
-    assert_raises(NoMethodError){
-      client.greet
-    }
-  end
-
-  it 'responds to added methods inside the block' do
-    client = test_person.extend(Casting::Client)
-    client.delegate_missing_methods
-
-    assert !client.respond_to?(:greet)
-
-    Casting.delegating(client => TestPerson::Greeter) do
-      assert client.respond_to?(:greet)
-    end
-
-    assert !client.respond_to?(:greet)
-  end
-
-  it 'raises an error if the given object is not an object that delegates missing methods' do
-    client = test_person.extend(Casting::Client)
-
-    assert_raises(Casting::InvalidClientError){
-      Casting.delegating(client => TestPerson::Greeter){ }
-    }
-  end
-
-  it 'allows for nested delegating' do
-    client = test_person.extend(Casting::Client)
-    client.delegate_missing_methods
-
-    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
-    assert !client.respond_to?(:greet)
-  end
-end

data/test/class_refinement_test.rb

@@ -1,119 +0,0 @@
-require 'test_helper'
-
-ClassDelegatingPerson = Struct.new(:name)
-ClassDelegatingPerson.send(:include, Casting::Client)
-ClassDelegatingPerson.delegate_missing_methods :class
-
-InstanceDelegatingPerson = Struct.new(:name)
-InstanceDelegatingPerson.send(:include, Casting::Client)
-InstanceDelegatingPerson.delegate_missing_methods :instance
-
-ClassThenInstanceDelegatingPerson = Struct.new(:name)
-ClassThenInstanceDelegatingPerson.send(:include, Casting::Client)
-ClassThenInstanceDelegatingPerson.delegate_missing_methods :class, :instance
-
-InstanceThenClassDelegatingPerson = Struct.new(:name)
-InstanceThenClassDelegatingPerson.send(:include, Casting::Client)
-InstanceThenClassDelegatingPerson.delegate_missing_methods :instance, :class
-
-module ClassGreeter
-  def greet
-    'hello from the class delegate'
-  end
-
-  def class_greeting
-    'Hi!'
-  end
-end
-
-module InstanceGreeter
-  def greet
-    'hello from the instance delegate'
-  end
-
-  def instance_greeting
-    'hi!'
-  end
-end
-
-describe Casting, '.delegating' do
-  it 'delegates methods for all instances to a class delegate inside a block' do
-    jim = ClassDelegatingPerson.new('Jim')
-    amy = ClassDelegatingPerson.new('Amy')
-
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-    Casting.delegating(ClassDelegatingPerson => TestPerson::Greeter) do
-      assert_equal 'hello', jim.greet
-      assert_equal 'hello', amy.greet
-    end
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-  end
-
-  it 'delegates methods for given instances to an instance delegate inside a block' do
-    jim = InstanceDelegatingPerson.new('Jim')
-    amy = InstanceDelegatingPerson.new('Amy')
-
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-    Casting.delegating(jim => TestPerson::Greeter) do
-      assert_equal 'hello', jim.greet
-      assert_raises(NoMethodError){ amy.greet }
-    end
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-  end
-
-  it 'delegates first to class delegates, then to instance delegates inside a block' do
-    jim = ClassThenInstanceDelegatingPerson.new('Jim')
-    amy = ClassThenInstanceDelegatingPerson.new('Amy')
-
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-    Casting.delegating(ClassThenInstanceDelegatingPerson => ClassGreeter, jim => InstanceGreeter) do
-      assert_equal 'hello from the class delegate', jim.greet
-      assert_equal 'hi!', jim.instance_greeting
-      assert_equal 'hello from the class delegate', amy.greet
-      assert(NoMethodError){ amy.instance_greeting }
-    end
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-  end
-
-  it 'delegates first to instance delegates, then to class delegates inside a block' do
-    jim = InstanceThenClassDelegatingPerson.new('Jim')
-    amy = InstanceThenClassDelegatingPerson.new('Amy')
-
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-    Casting.delegating(InstanceThenClassDelegatingPerson => ClassGreeter, jim => InstanceGreeter) do
-      assert_equal 'hello from the instance delegate', jim.greet
-      assert_equal 'hi!', jim.instance_greeting
-      assert_equal 'hello from the class delegate', amy.greet
-      assert(NoMethodError){ amy.instance_greeting }
-    end
-    assert_raises(NoMethodError){
-      jim.greet
-    }
-  end
-
-  it 'sets instances to respond_to? class delegate methods' do
-    jim = ClassDelegatingPerson.new('Jim')
-
-    refute jim.respond_to?(:greet)
-
-    Casting.delegating(ClassDelegatingPerson => ClassGreeter) do
-      assert jim.respond_to?(:greet)
-    end
-
-    refute jim.respond_to?(:greet)
-  end
-end

data/test/client_test.rb

@@ -1,81 +0,0 @@
-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 'executes delegated methods with a block' do
-    client = TestPerson.new
-    client.extend(Casting::Client)
-    mod = Module.new
-    mod.module_eval do
-      def blocky(arg, &block)
-        block.call(arg, self)
-      end
-    end
-
-    output = client.delegate('blocky', mod, 'argument') do |arg, me|
-      %{#{arg} from #{me.name}}
-    end
-
-    assert_equal 'argument from name from TestPerson', output
-  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
-
-  it 'refuses to delegate to itself' do
-    client = TestPerson.new
-    client.extend(Casting::Client)
-
-    assert_raises(Casting::InvalidAttendant){
-      client.delegate('to_s', client)
-    }
-  end
-
-  it 'does not delegate singleton methods' do
-    client = test_person.extend(Casting::Client)
-    client.delegate_missing_methods
-    attendant = test_person
-
-    def attendant.hello
-      'hello'
-    end
-    assert_raises(TypeError){
-      client.delegate('hello', attendant)
-    }
-  end
-end

data/test/context_test.rb

@@ -1,80 +0,0 @@
-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

@@ -1,198 +0,0 @@
-require 'test_helper'
-
-describe Casting::Delegation do
-
-  it 'initializes with method name and object' do
-    assert Casting::Delegation.prepare('some_method', Object.new)
-  end
-
-  it 'raises an error when calling without an attendant object' do
-    delegation = Casting::Delegation.prepare('some_method', Object.new)
-      begin
-        delegation.call
-      rescue StandardError => e
-      end
-    assert_kind_of Casting::MissingAttendant, e
-    assert_equal "You must set your attendant object using `to'.", e.message
-  end
-
-  it 'raises an error when setting an invalid attendant type' do
-    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)
-    }
-  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.prepare('name', client)
-    assert delegation.to(attendant)
-  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
-    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.prepare('class_defined', client).to(attendant)
-    }
-  end
-
-  it 'assigns arguments to the delegated method using with' do
-    client = test_person
-    attendant = TestPerson::Verbose
-
-    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.prepare('verbose', client).to(attendant)
-
-    assert_equal 'call,args', delegation.with('hello', 'goodbye').call('call','args')
-  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/method_consolidator_test.rb

@@ -1,81 +0,0 @@
-require 'test_helper'
-
-describe Casting::MethodConsolidator, '#methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient, Casting::MethodConsolidator)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "returns all instance methods including private from the object and it's delegates" do
-    assert_includes(client.methods(true), :psst)
-  end
-
-  it "returns all public instance methods from the object and it's delegates" do
-    refute_includes(client.methods(false), :psst)
-  end
-
-  it "returns all protected instance methods from the object and it's delegates" do
-    assert_includes(client.methods(true), :hey)
-  end
-end
-
-describe Casting::MethodConsolidator, '#public_methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient, Casting::MethodConsolidator)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "returns all public_methods and those from it's delegates" do
-    assert_includes(client.public_methods, :greet)
-  end
-
-  it "excludes all protected_methods and those from it's delegates" do
-    refute_includes(client.public_methods, :hey)
-  end
-
-  it "excludes all private_methods from the object and it's delegates" do
-    refute_includes(client.public_methods, :psst)
-  end
-end
-
-describe Casting::MethodConsolidator, '#protected_methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient, Casting::MethodConsolidator)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "excludes all public_methods and those from it's delegates" do
-    refute_includes(client.protected_methods, :greet)
-  end
-
-  it "returns all protected_methods and those from it's delegates" do
-    assert_includes(client.protected_methods, :hey)
-  end
-
-  it "excludes all private_methods from the object and it's delegates" do
-    refute_includes(client.protected_methods, :psst)
-  end
-end
-
-describe Casting::MethodConsolidator, '#private_methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient, Casting::MethodConsolidator)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "excludes all public_methods and those from it's delegates" do
-    refute_includes(client.private_methods, :greet)
-  end
-
-  it "excludes all protected_methods and those from it's delegates" do
-    refute_includes(client.private_methods, :hey)
-  end
-
-  it "excludes all private_methods from the object and it's delegates" do
-    assert_includes(client.private_methods, :psst)
-  end
-end