casting 1.0.1 → 1.0.2

data/test/missing_method_client_test.rb

@@ -1,203 +0,0 @@
-require 'test_helper'
-
-module One
-  def similar
-    "from One"
-  end
-end
-
-module Two
-  def similar
-    "from Two"
-  end
-end
-
-describe Casting::MissingMethodClient, '#cast_as' do
-  let(:client){
-    test_person.extend(Casting::Client, Casting::MissingMethodClient)
-  }
-
-  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
-    # avoid using another client
-    client = test_person
-    client.extend(TestPerson::Greeter)
-    attendant = client.clone
-    client.extend(Casting::Client, Casting::MissingMethodClient)
-
-    client.singleton_class.send(:undef_method, :greet)
-    client.cast_as(attendant)
-    assert_equal 'hello', client.greet
-  end
-
-  it "raises an error when given the client object" do
-    assert_raises(Casting::InvalidAttendant){
-      client.cast_as(client)
-    }
-  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
-  
-  it "delegates methods to the last module added containing the method" do
-    jim = test_person.extend(Casting::Client, Casting::MissingMethodClient)
-    
-    assert_equal "from Two", jim.cast_as(One, Two).similar
-  end
-end
-
-describe Casting::MissingMethodClient, '#uncast' do
-  let(:client){
-    test_person.extend(Casting::Client, Casting::MissingMethodClient)
-  }
-
-  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
-
-  it "removes the specified number of delegates" do
-    jim = test_person.extend(Casting::Client, Casting::MissingMethodClient)
-    jim.cast_as(TestPerson::Greeter, TestPerson::Verbose)
-
-    assert_includes(jim.delegated_methods(true), :psst)
-    assert_includes(jim.delegated_methods(true), :verbose)
-
-    jim.uncast(2)
-
-    refute_includes(jim.delegated_methods(true), :psst)
-    refute_includes(jim.delegated_methods(true), :verbose)
-  end
-end
-
-describe Casting::MissingMethodClient, '#delegated_methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "returns all instance methods including private from the object's delegates" do
-    assert_includes(client.delegated_methods(true), :psst)
-  end
-
-  it "returns all public instance methods from the object and it's delegates" do
-    refute_includes(client.delegated_methods(false), :psst)
-  end
-
-  it "returns all protected instance methods from the object and it's delegates" do
-    assert_includes(client.delegated_methods(true), :hey)
-  end
-end
-
-describe Casting::MissingMethodClient, '#delegated_public_methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "returns all public methods from the object's delegates" do
-    assert_includes(client.delegated_public_methods, :greet)
-  end
-
-  it "excludes all private  methods from the object's delegates" do
-    refute_includes(client.delegated_public_methods, :psst)
-  end
-
-  it "excludes all protected methods from the object's delegates" do
-    refute_includes(client.delegated_public_methods, :hey)
-  end
-
-  it "includes methods from superclasses" do
-    client.cast_as(Nested)
-    assert_includes(client.delegated_public_methods(true), :nested_deep)
-  end
-
-  it "excludes methods from superclasses" do
-    client.cast_as(Nested)
-    refute_includes(client.delegated_public_methods(false), :nested_deep)
-  end
-end
-
-describe Casting::MissingMethodClient, '#delegated_protected_methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "excludes all public methods from the object's delegates" do
-    refute_includes(client.delegated_protected_methods, :greet)
-  end
-
-  it "excludes all private  methods from the object's delegates" do
-    refute_includes(client.delegated_protected_methods, :psst)
-  end
-
-  it "includes all protected methods from the object's delegates" do
-    assert_includes(client.delegated_protected_methods, :hey)
-  end
-
-  it "includes methods from superclasses" do
-    client.cast_as(Nested)
-    assert_includes(client.delegated_protected_methods(true), :protected_nested_deep)
-  end
-
-  it "excludes methods from superclasses" do
-    client.cast_as(Nested)
-    refute_includes(client.delegated_protected_methods(false), :protected_nested_deep)
-  end
-end
-
-describe Casting::MissingMethodClient, '#delegated_private_methods' do
-  let(:client){
-    object = test_person.extend(Casting::Client, Casting::MissingMethodClient)
-    object.cast_as(TestPerson::Greeter)
-    object
-  }
-
-  it "excludes all public methods from the object's delegates" do
-    refute_includes(client.delegated_private_methods, :greet)
-  end
-
-  it "includes all private  methods from the object's delegates" do
-    assert_includes(client.delegated_private_methods, :psst)
-  end
-
-  it "excludes all protected methods from the object's delegates" do
-    refute_includes(client.delegated_private_methods, :hey)
-  end
-
-  it "includes methods from superclasses" do
-    client.cast_as(Nested)
-    assert_includes(client.delegated_private_methods(true), :private_nested_deep)
-  end
-
-  it "excludes methods from superclasses" do
-    client.cast_as(Nested)
-    refute_includes(client.delegated_private_methods(false), :private_nested_deep)
-  end
-end

data/test/module_cleanup_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-module Cleaner
-  def self.uncast_object(object)
-    object.send(:remove_instance_variable, :@cleaner_message)
-  end
-  
-  def self.cast_object(object)
-    object.instance_variable_set(:@cleaner_message, "#{object.name} will be cleaned up")
-  end
-  
-  def cleaner_message
-    @cleaner_message
-  end
-end
-
-class CleanupPerson
-  include Casting::Client
-  delegate_missing_methods
-  attr_accessor :name
-end
-
-describe 'modules with setup tasks' do
-  it 'allows modules to setup an object when cast_as' do
-    jim = CleanupPerson.new
-    jim.name = 'Jim'
-    jim.cast_as(Cleaner)
-    assert_equal "Jim will be cleaned up", jim.cleaner_message
-    assert_equal "Jim will be cleaned up", jim.instance_variable_get(:@cleaner_message)
-  end
-end
-
-describe 'modules with cleanup tasks' do
-  it 'allows modules to cleanup their required attributes when uncast' do
-    jim = CleanupPerson.new
-    jim.name = 'Jim'
-    jim.cast_as(Cleaner)
-    assert_equal "Jim will be cleaned up", jim.cleaner_message
-    assert_equal "Jim will be cleaned up", jim.instance_variable_get(:@cleaner_message)
-    jim.uncast
-    refute jim.instance_variable_defined?(:@cleaner_message)
-  end
-end

data/test/null_module_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-describe Casting::Null do
-  it 'will answer to any method with nil' do
-    client = TestPerson.new
-    client.extend(Casting::Client)
-    attendant = Casting::Null
-
-    assert_nil client.delegate('greet', attendant)
-  end
-end
-
-describe Casting::Blank do
-  it 'will answer to any method with an empty string' do
-    client = TestPerson.new
-    client.extend(Casting::Client)
-    attendant = Casting::Blank
-
-    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

@@ -1,80 +0,0 @@
-require 'test_helper'
-
-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}"
-  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(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
-
-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, ThatWay, ThisWay)
-
-    assert_equal 'this way or any way and that way!', client.which_way
-  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,97 +0,0 @@
-require "simplecov"
-SimpleCov.start do
-  add_filter 'test'
-end
-require 'minitest/autorun'
-require 'casting'
-
-BlockTestPerson = Struct.new(:name)
-BlockTestPerson.send(:include, Casting::Client)
-BlockTestPerson.delegate_missing_methods
-
-class TestPerson
-  def name
-    'name from TestPerson'
-  end
-
-  module Greeter
-    def greet
-      'hello'
-    end
-
-    protected
-
-    def hey; end
-
-    private
-
-    def psst; end
-  end
-
-  module Verbose
-    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'
-  end
-end
-
-class Unrelated
-  module More
-    def unrelated
-      'unrelated'
-    end
-  end
-  include More
-
-  def class_defined
-    'oops!'
-  end
-end
-
-module Deep
-  def nested_deep; end
-  protected
-  def protected_nested_deep; end
-  private
-  def private_nested_deep; end
-end
-
-module Nested
-  include Deep
-
-  def nested; end
-  protected
-  def protected_nested; end
-  private
-  def private_nested; end
-end
-
-def test_person
-  TestPerson.new
-end
-
-def casting_person
-  test_person.extend(Casting::Client)
-end