gorillib 0.0.8 → 0.1.0

data/spec/metaprogramming/aliasing_spec.rb

@@ -43,6 +43,9 @@ describe 'metaprogramming' do
   end
 
   describe 'alias_method_chain' do
+
+    it 'does not have an effect if already provided by another library.'
+
     it 'creates a with_ and without_ method that chain' do
       @instance.should respond_to(:bar)
       feature_aliases = [:bar_with_baz, :bar_without_baz]

data/spec/metaprogramming/cattr_accessor_spec.rb

@@ -12,6 +12,8 @@ describe 'metaprogramming' do
       @object = @class.new
     end
 
+    it 'does not have an effect if already provided by another library.'
+
     it 'uses mattr default' do
       @class.foo.should be_nil
       @object.foo.should be_nil

data/spec/metaprogramming/class_attribute_spec.rb

@@ -8,6 +8,8 @@ describe 'metaprogramming' do
       @sub = Class.new(@klass)
     end
 
+    it 'does not have an effect if already provided by another lib.'
+
     it 'defaults to nil' do
       @klass.setting.should be_nil
       @sub.setting.should be_nil

data/spec/metaprogramming/delegation_spec.rb

@@ -69,6 +69,8 @@ describe 'metaprogramming' do
       @david = Someone.new("David", Somewhere.new("Paulina", "Chicago"))
     end
 
+    it 'does not have an effect if already provided by another library.'
+
     it 'delegates to methods' do
       @david.street.should == "Paulina"
       @david.city.should == "Chicago"

data/spec/metaprogramming/mattr_accessor_spec.rb

@@ -14,6 +14,8 @@ describe Module do
       @object = @class.new
     end
 
+    it 'does not have an effect if already provided by another library.'
+
     it 'uses mattr default' do
       @module.foo.should be_nil
       @object.foo.should be_nil

data/spec/metaprogramming/singleton_class_spec.rb

@@ -6,4 +6,7 @@ describe 'Singleton Class' do
     o = Object.new
     class << o; self end.should == o.singleton_class
   end
+
+  it 'does not have an effect if already provided by another library.'
+
 end

data/spec/receiver/acts_as_hash_spec.rb

@@ -0,0 +1,286 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/receiver'
+require 'gorillib/metaprogramming/class_attribute'
+require 'gorillib/hashlike'
+require 'gorillib/receiver/acts_as_hash'
+require GORILLIB_ROOT_DIR('spec/support/hashlike_helper')
+require GORILLIB_ROOT_DIR('spec/support/hashlike_via_delegation')
+require GORILLIB_ROOT_DIR('spec/hashlike/hashlike_behavior_spec')
+
+class SimpleReceiver
+  include Receiver
+  include Receiver::ActsAsHash
+  include Gorillib::Hashlike
+  #
+  rcvr_accessor :a,         Integer
+  rcvr_accessor :b,         Integer
+  rcvr_accessor :c,         Integer
+  # rcvr_reader   :b,         Integer
+  # rcvr_writer   :c,         Integer
+  rcvr_accessor :nil_val,   NilClass
+  rcvr_accessor :false_val, Boolean
+  rcvr_accessor :new_key,   String
+end
+
+describe Receiver do
+
+  before do
+    @hshlike                 = SimpleReceiver.new.merge(HashlikeHelper::HASH_TO_TEST_HL_V_A.dup)
+    @empty_hshlike           = SimpleReceiver.new
+    @hshlike_with_array_vals = SimpleReceiver.new.merge(HashlikeHelper::BASE_HSH_WITH_ARRAY_VALS.dup)
+    #
+    @hshlike_subklass        = Class.new(SimpleReceiver)
+    @hshlike_subklass_inst   = @hshlike_subklass.new.merge(HashlikeHelper::BASE_HSH.dup)
+  end
+
+
+  # ===========================================================================
+  #
+  # Fundamental behavior
+
+  describe '#[] and #[]= and #store' do
+    it_should_behave_like :hashlike_store_and_retrieve
+    it_should_behave_like :references_string_and_symbol_keys_equivalently
+    it 'reject unknown keys' do
+      lambda{ @hshlike[:fnord] = 69   }.should raise_error NoMethodError, /undefined method `fnord=' for/
+      lambda{ @hshlike[:fnord]        }.should raise_error NoMethodError, /undefined method `fnord' for/
+      @hshlike.delete(:fnord).should be_nil
+    end
+    it 'accepts defined but unset keys' do
+      @hshlike[:new_key].should be_nil
+      @hshlike[:new_key] = 69
+      @hshlike[:new_key].should == 69
+    end
+    it 'does not allow nil, Object, or other non-stringy keys' do
+      lambda{ @hshlike[300] = :i_haz_num }.should raise_error(ArgumentError, "Keys for SimpleReceiver must be symbols, strings or respond to #to_sym")
+      lambda{ @hshlike[nil] = :i_haz_nil }.should raise_error(ArgumentError, "Keys for SimpleReceiver must be symbols, strings or respond to #to_sym")
+      obj = Object.new
+      lambda{ @hshlike[obj] = :i_haz_obj }.should raise_error(ArgumentError, "Keys for SimpleReceiver must be symbols, strings or respond to #to_sym")
+      def obj.to_sym() :c ; end
+      @hshlike[obj] = :i_haz_obj
+      @hshlike[obj].should == :i_haz_obj
+    end
+
+    it 'd' do
+      @hshlike_subklass.rcvr_writer :write_only_attr,  String
+      @hshlike_subklass.rcvr_reader :read_only_attr,   String
+      @hshlike_subklass.rcvr        :internal_attr,    String
+      @hshlike_subklass.class_eval{ attr_accessor :not_a_receiver }
+      raise 'finish me'
+    end
+
+    it 'has ' do
+      @hshlike_subklass.class_eval{ attr_accessor :not_a_receiver }
+      raise 'finish me'
+    end
+  end
+
+  describe '#delete' do
+    it_should_behave_like :hashlike_delete
+  end
+
+  describe '#keys' do
+    it_should_behave_like :hashlike_keys
+  end
+
+  # ===========================================================================
+  #
+  # Iteration
+
+  describe '#each_pair' do
+    describe 'with block' do
+      it_should_behave_like :each_pair_on_stringlike_keys, :each_pair
+    end
+    it_should_behave_like :with_no_block_returns_enumerator, :each_pair
+  end
+
+  describe '#each' do
+    describe 'with block' do
+      it_should_behave_like :each_pair_on_stringlike_keys, :each
+    end
+    it_should_behave_like :with_no_block_returns_enumerator, :each
+  end
+
+  describe '#each_key' do
+    describe 'with block' do
+      it_should_behave_like :each_key_on_stringlike_keys
+    end
+    it_should_behave_like :with_no_block_returns_enumerator, :each_key
+  end
+
+  describe '#each_value' do
+    describe 'with block' do
+      it_should_behave_like :each_value_on_stringlike_keys
+    end
+    it_should_behave_like :with_no_block_returns_enumerator, :each_value
+  end
+
+  # ===========================================================================
+  #
+  # Retrieval and Membership
+
+  describe '#values' do
+    it_should_behave_like :hashlike_values
+  end
+
+  describe '#values_at' do
+    it_should_behave_like :hashlike_values_at_or_of, :values_at
+  end
+
+  describe '#values_of' do
+    it_should_behave_like :hashlike_values_at_or_of, :values_of
+  end
+
+  describe '#length' do
+    it_should_behave_like :hashlike_length, :length
+  end
+
+  describe '#size' do
+    it_should_behave_like :hashlike_length, :size
+  end
+
+  describe '#has_key?' do
+    it_should_behave_like :hashlike_has_key?, :has_key?
+    it_should_behave_like :hashlike_has_key_string_and_symbol_equivalent, :has_key?
+  end
+
+  describe '#include?' do
+    it_should_behave_like :hashlike_has_key?, :include?
+    it_should_behave_like :hashlike_has_key_string_and_symbol_equivalent, :include?
+  end
+
+  describe '#key?' do
+    it_should_behave_like :hashlike_has_key?, :key?
+    it_should_behave_like :hashlike_has_key_string_and_symbol_equivalent, :key?
+  end
+
+  describe '#member?' do
+    it_should_behave_like :hashlike_has_key?, :member?
+    it_should_behave_like :hashlike_has_key_string_and_symbol_equivalent, :member?
+  end
+
+  describe '#has_value?' do
+    it_should_behave_like :hashlike_has_value?, :has_value?
+  end
+
+  describe '#value?' do
+    it_should_behave_like :hashlike_has_value?, :value?
+  end
+
+  describe '#fetch' do
+    it_should_behave_like :hashlike_fetch
+  end
+
+  describe '#key' do
+    it_should_behave_like :hashlike_key
+  end
+
+  describe '#assoc' do
+    it_should_behave_like :hashlike_assoc
+  end
+
+  describe '#rassoc' do
+    it_should_behave_like :hashlike_rassoc
+  end
+
+  describe '#empty?' do
+    it_should_behave_like :hashlike_empty?
+  end
+
+  # ===========================================================================
+  #
+  # Update, merge!, merge
+
+  describe 'update' do
+    it_should_behave_like :merging_method, :update
+    it_should_behave_like :merging_method_with_normal_keys, :update
+    it_should_behave_like :merging_method_inplace, :update
+  end
+
+  describe '#merge!' do
+    it_should_behave_like :merging_method, :merge!
+    it_should_behave_like :merging_method_with_normal_keys, :merge!
+    it_should_behave_like :merging_method_inplace, :merge!
+  end
+
+  describe '#merge' do
+    it_should_behave_like :merging_method, :merge
+    it_should_behave_like :merging_method_with_normal_keys, :merge
+    it_should_behave_like :merging_method_returning_new, :merge
+  end
+
+  # ===========================================================================
+  #
+  # Filters
+
+  describe '#reject!' do
+    it_should_behave_like :hashlike_filter,  :reject!
+    it_should_behave_like :rejection_filter, :reject!
+    it_should_behave_like :filter_modifies_self_returns_nil_if_unchanged, :reject!, false
+  end
+
+  describe '#select!' do
+    it_should_behave_like :hashlike_filter,  :select!
+    it_should_behave_like :selection_filter, :select!
+    it_should_behave_like :filter_modifies_self_returns_nil_if_unchanged, :select!, true
+  end
+
+  describe '#delete_if' do
+    it_should_behave_like :hashlike_filter,  :delete_if
+    it_should_behave_like :rejection_filter, :delete_if
+    it_should_behave_like :filter_modifies_self_returns_self, :delete_if, false
+  end
+
+  describe '#keep_if' do
+    it_should_behave_like :hashlike_filter,  :keep_if
+    it_should_behave_like :selection_filter, :keep_if
+    it_should_behave_like :filter_modifies_self_returns_self, :keep_if, true
+  end
+
+  describe '#reject' do
+    it_should_behave_like :hashlike_filter,  :select
+    it_should_behave_like :selection_filter, :select
+    it_should_behave_like :filter_does_not_modify_self_returns_same_class, :reject, false
+  end
+
+  describe '#select' do
+    it_should_behave_like :hashlike_filter,  :select
+    it_should_behave_like :selection_filter, :select
+    it_should_behave_like :filter_does_not_modify_self_returns_same_class, :select, true
+  end
+
+  describe '#clear' do
+    it_should_behave_like :hashlike_clear
+  end
+
+  # ===========================================================================
+  #
+  # Conversion
+
+  describe '#to_hash' do
+    it_should_behave_like :hashlike_to_hash
+  end
+
+  describe '#invert' do
+    it_should_behave_like :hashlike_invert
+  end
+
+  describe '#flatten' do
+    it_should_behave_like :hashlike_flatten
+  end
+
+  # ===========================================================================
+  #
+  # Sanity check
+
+  it 'built test objects correctly' do
+    @hshlike_subklass      .should     <  @hshlike.class
+    @hshlike_subklass      .should_not == @hshlike.class
+    @hshlike_subklass_inst .should     be_a(SimpleReceiver)
+    @hshlike_subklass_inst .should     be_a(@hshlike_subklass)
+    @hshlike_subklass_inst .should_not be_an_instance_of(SimpleReceiver)
+    @hshlike               .should_not be_a(@hshlike_subklass)
+    @hshlike               .should     be_an_instance_of(SimpleReceiver)
+  end
+
+end

data/spec/receiver_spec.rb

@@ -0,0 +1,478 @@
+require File.dirname(__FILE__)+'/spec_helper.rb'
+require 'gorillib/metaprogramming/class_attribute'
+require 'gorillib/object/blank'
+require 'time'
+require 'date'
+require 'gorillib/receiver'
+require 'gorillib/array/extract_options'
+
+class Wide
+  include Receiver
+  rcvr_accessor :my_int, Integer
+end
+
+describe Receiver do
+  before do
+    @klass = Class.new(Wide)
+  end
+
+  it 'tracks an order for the rcvrs' do
+    @klass.rcvr_accessor :a, Integer
+    @klass.rcvr_reader   :b, Integer
+    @klass.rcvr_writer   :c, Integer
+    @klass.rcvr          :d, Integer
+    @klass.receiver_attr_names.should == [:my_int, :a, :b, :c, :d]
+  end
+
+  describe '.receive' do
+    it 'creates a new object and returns it' do
+      obj = @klass.new
+      @klass.should_receive(:new).and_return(obj)
+      ret = @klass.receive({})
+      ret.should equal(obj)
+    end
+
+    it 'invokes receive! on the new object' do
+      obj = @klass.new
+      @klass.should_receive(:new).and_return(obj)
+      obj.should_receive(:receive!).with({})
+      ret = @klass.receive({})
+    end
+
+    it 'passes extra args to the constructor' do
+      obj = @klass.new
+      @klass.should_receive(:new).with(:a, :b).and_return(obj)
+      obj.should_receive(:receive!).with({})
+      ret = @klass.receive(:a, :b, {})
+    end
+
+    it 'accepts an empty arg set (receives an empty hash)' do
+      obj = mock
+      @klass.should_receive(:new).and_return(obj)
+      obj.should_receive(:receive!).with({})
+      @klass.receive(nil)
+    end
+
+    it 'uses the *last* arg as the hsh to receive' do
+      obj = mock
+      hsh_to_receive      = { :a => :b }
+      hsh_for_constructor = { :c => :d }
+      @klass.should_receive(:new).with(hsh_for_constructor).and_return(obj)
+      obj.should_receive(:receive!).with(hsh_to_receive)
+      @klass.receive(hsh_for_constructor, hsh_to_receive)
+    end
+  end
+
+  describe '.receive_tuple' do
+    it 'receives a tuple, assigning to rcvrs in order'
+
+    it 'allows empty tuple'
+
+    it '?breaks? on too-long tuple'
+  end
+
+
+  describe '.receive_foo' do
+    it 'injects a superclass, so I can call super() in receive_foo'
+  end
+
+  describe '.rcvr' do
+
+    it 'creates the receive_{whatever} method' do
+      @klass.rcvr_accessor :a, Integer, :foo => :bar_a
+      obj = @klass.new
+      obj.should respond_to(:receive_a)
+    end
+
+    it 'stores the name, type and extra info into receiver_attrs, and the name (in order) into receiver_attr_names' do
+      @klass.rcvr_accessor :a, Integer, :foo => :bar_a
+      @klass.rcvr_reader   :b, Integer, :foo => :bar_b
+      @klass.rcvr          :c, Integer, :foo => :bar_c
+      @klass.receiver_attr_names.should == [:my_int, :a, :b, :c]
+      @klass.receiver_attrs.should      == {
+        :my_int => {:type => Integer, :name => :my_int},
+        :a => {:type => Integer, :name => :a, :foo => :bar_a},
+        :b => {:type => Integer, :name => :b, :foo => :bar_b},
+        :c => {:type => Integer, :name => :c, :foo => :bar_c},
+      }
+    end
+
+    it 'does not replace the class attributes in-place, so that inheritance works' do
+      old_receiver_attrs = @klass.receiver_attrs
+      old_receiver_attr_names = @klass.receiver_attr_names
+      @klass.rcvr_accessor :a, Integer, :foo => :bar_a
+      old_receiver_attrs.should_not equal(@klass.receiver_attrs)
+      old_receiver_attr_names.should_not equal(@klass.receiver_attr_names)
+    end
+
+    it 'accepts a type alias but uses the aliased class' do
+      @klass.rcvr_accessor :my_symbol, :symbol
+      @klass.rcvr_accessor :my_bytes,  :bytes
+      @klass.receiver_attrs[:my_symbol][:type].should == Symbol
+      @klass.receiver_attrs[:my_bytes ][:type].should == String
+    end
+
+    it 'does not accept an unknown type' do
+      lambda{ @klass.rcvr_accessor :my_symbol, :oxnard }.should raise_error(ArgumentError, "Can\'t handle type oxnard: is it a Class or one of the TYPE_ALIASES?")
+    end
+  end
+
+  describe '.rcvr_accessor, .rcvr_reader, .rcvr_writer' do
+    it 'accepts rcvr, rcvr_accessor, rcvr_reader, rcvr_writer' do
+      @klass.rcvr_accessor :a, Integer
+      @klass.rcvr_reader   :b, Integer
+      @klass.rcvr_writer   :c, Integer
+      @klass.rcvr          :d, Integer
+      obj = @klass.new
+      obj.should     respond_to(:a)
+      obj.should     respond_to(:a=)
+      obj.should     respond_to(:b)
+      obj.should_not respond_to(:b=)
+      obj.should_not respond_to(:c)
+      obj.should     respond_to(:c=)
+      obj.should_not respond_to(:d)
+      obj.should_not respond_to(:d=)
+    end
+
+    it 'delegates to rcvr' do
+      @klass.should_receive(:rcvr).with(:a, Integer, {:foo => :bar}).ordered
+      @klass.should_receive(:rcvr).with(:b, Integer, {:foo => :bar}).ordered
+      @klass.should_receive(:rcvr).with(:c, Integer, {:foo => :bar}).ordered
+      @klass.should_receive(:rcvr).with(:d, Integer, {:foo => :bar}).ordered
+      @klass.rcvr_accessor :a, Integer, :foo => :bar
+      @klass.rcvr_reader   :b, Integer, :foo => :bar
+      @klass.rcvr_writer   :c, Integer, :foo => :bar
+      @klass.rcvr          :d, Integer, :foo => :bar
+    end
+
+    it 'does not modify parent class' do
+      @klass.rcvr_accessor :a, Integer
+      @klass.rcvr          :d, Integer
+      obj = Wide.new
+      obj.should_not respond_to(:a)
+      obj.should_not respond_to(:a=)
+      Wide.receiver_attr_names.should == [:my_int]
+      Wide.receiver_attrs.should      == {:my_int => {:type => Integer, :name => :my_int}}
+    end
+  end
+
+  describe 'default values' do
+    it 'rcvr accepts a default for an attribute' do
+      @klass.rcvr_reader :will_get_a_value, Integer, :default => 12
+      @klass.rcvr_reader :has_a_default, Integer, :default => 5
+      obj = @klass.receive(:my_int => 3, :will_get_a_value => 9)
+      obj.my_int.should == 3
+      obj.has_a_default.should == 5
+      obj.will_get_a_value.should == 9
+    end
+
+    it 'does not use default if value is set-but-nil' do
+      @klass.rcvr_reader :has_a_default, Integer, :default => 5
+      obj = @klass.receive(:my_int => 3, :has_a_default => nil)
+      obj.has_a_default.should be_nil
+    end
+  end
+
+  describe 'required attributes' do
+    it 'rcvr accepts required attributes'
+  end
+
+  describe 'typed collections' do
+    it 'sets a type for an array with :of => Type' do
+      @klass.rcvr_accessor :array_of_symbol, Array, :of => Symbol
+      obj = @klass.receive(:array_of_symbol => [:a, 'b', 'c'])
+      obj.array_of_symbol.should == [:a, :b, :c]
+    end
+
+    it 'accepts nil if value is nil' do
+      @klass.rcvr_accessor :array_of_symbol, Array, :of => Symbol
+      obj = @klass.receive(:array_of_symbol => nil)
+      obj.array_of_symbol.should == nil
+    end
+
+    it 'accepts complex class as :of => Type' do
+      class Foo ; include Receiver ; rcvr_accessor(:foo, Integer) ; end
+      @klass.rcvr_accessor :array_of_obj, Array, :of => Foo
+      obj = @klass.receive( :array_of_obj => [ {:foo => 3}, {:foo => 5} ] )
+      p obj
+      obj.array_of_obj.first.foo.should == 3
+      obj.array_of_obj.last.foo.should == 5
+    end
+
+    it 'sets a type for a hash with :of => Type' do
+      @klass.rcvr_accessor :hash_of_symbol, Hash, :of => Symbol
+      obj = @klass.receive(:hash_of_symbol => { :a => 'val_a', 'b' => :val_b , 'c' => 'val_c' })
+      obj.hash_of_symbol.should == { :a => :val_a, 'b' => :val_b , 'c' => :val_c }
+    end
+  end
+
+  describe '.rcvr_remaining' do
+    it 'creates a dummy receiver for the extra params' do
+      @klass.should_receive(:rcvr_reader).with(:bob, Hash, {:foo => :bar})
+      @klass.rcvr_remaining :bob, :foo => :bar
+    end
+    it 'does not get params that go with defined attrs (even if there is no writer)' do
+      @klass.rcvr_remaining :bob
+      hsh = {:my_int => 3, :foo => :bar, :width => 5}
+      obj = @klass.receive(hsh)
+      obj.bob.should == {:foo => :bar, :width => 5}
+      hsh.should == {:my_int => 3, :foo => :bar, :width => 5}
+    end
+    it 'does not get params whose key starts with "_"' do
+      @klass.rcvr_remaining :bob
+      hsh = {:my_int => 3, :foo => :bar, :width => 5, :_ignored => 9}
+      obj = @klass.receive(hsh)
+      obj.bob.should == {:foo => :bar, :width => 5}
+    end
+    it 'stores them, replacing a previous value' do
+      @klass.rcvr_remaining :bob
+      obj = @klass.new
+      obj.instance_variable_set("@bob", {:foo => 9, :width => 333, :extra => :will_be_gone})
+      obj.receive!({ :my_int => 3, :foo => :bar, :width => 5 })
+      obj.bob.should == {:foo => :bar, :width => 5}
+    end
+  end
+
+  describe '.after_receive, #run_after_receivers' do
+    it 'calls each block in order' do
+      @klass.after_receive{|hsh| hsh.i_am_calling_you_first }
+      @klass.after_receive{|hsh| hsh.i_am_calling_you_second }
+      @klass.after_receive{|hsh| hsh.i_am_calling_you_third }
+      hsh = {:my_int => 3}
+      hsh.should_receive(:i_am_calling_you_first).ordered
+      hsh.should_receive(:i_am_calling_you_second).ordered
+      hsh.should_receive(:i_am_calling_you_third).ordered
+      @klass.receive(hsh)
+    end
+
+    it 'calls the block with the full receive hash' do
+      @klass.after_receive{|hsh| hsh.i_am_calling_you }
+      hsh = {}
+      hsh.should_receive(:i_am_calling_you)
+      @klass.receive(hsh)
+    end
+  end
+
+  describe '#unset' do
+    it 'nukes any existing instance_variable' do
+      obj = @klass.new
+      obj.my_int = 3
+      obj.instance_variable_get('@my_int').should == 3
+      obj.send(:unset!, :my_int)
+      obj.instance_variable_get('@my_int').should be_nil
+      obj.instance_variables.should == []
+    end
+
+    it 'succeeds even if instance_variable never set' do
+      obj = @klass.new
+      obj.send(:unset!, :my_int)
+      obj.instance_variable_get('@my_int').should be_nil
+      obj.instance_variables.should == []
+    end
+
+  end
+
+  describe 'attr_set?' do
+    it 'is set if the corresponding instance_variable exists' do
+      obj = @klass.new
+      obj.attr_set?(:my_int).should == false
+      obj.instance_variable_set('@my_int', 3)
+      obj.attr_set?(:my_int).should == true
+    end
+
+    it 'can be set but nil or false' do
+      @klass.rcvr_accessor :bool_field, Boolean
+      @klass.rcvr_accessor :str_field,  String
+      obj = @klass.new
+      obj.attr_set?(:bool_field).should == false
+      obj.attr_set?(:str_field).should == false
+      obj.instance_variable_set('@bool_field', false)
+      obj.instance_variable_set('@str_field',  nil)
+      obj.attr_set?(:bool_field).should == true
+      obj.attr_set?(:str_field).should == true
+    end
+  end
+
+  describe '#receive!' do
+    before do
+      @obj = @klass.new
+    end
+    it 'accepts things that quack like a hash: have [] and has_key?' do
+      foo = mock
+      def foo.[](*_) 3 end ; def foo.has_key?(*_) true end
+      @obj.receive!(foo)
+      @obj.my_int.should == 3
+    end
+    it 'only accepts things that quack like a hash' do
+      lambda{ @obj.receive!(3) }.should raise_error ArgumentError, "Can't receive (it isn't hashlike): {3}"
+    end
+    it 'lets me call receive! with no args so I can trigger the defaults and after_receive hooks' do
+      @obj.should_receive(:impose_defaults!).with({}).ordered
+      @obj.should_receive(:run_after_receivers).with({}).ordered
+      @obj.receive!
+    end
+
+    it 'receives symbol key' do
+      @obj.receive! :my_int => 4
+      @obj.my_int.should == 4
+    end
+    it 'receives string key' do
+      @obj.receive! :my_int => 5
+      @obj.my_int.should == 5
+    end
+    it 'with symbol and string key in given hash, takes symbol key only' do
+      @obj.receive! :my_int => 7, 'my_int' => 6
+      @obj.my_int.should == 7
+    end
+    it 'only accepts things that are receivers' do
+      @klass.class_eval do attr_accessor :bob ; end
+      @obj.receive! :my_int => 7, :bob => 12
+      @obj.should_not_receive(:bob=)
+      @obj.bob.should be_nil
+    end
+    it 'ignores extra keys' do
+      @obj.receive! :my_int => 7, :bob => 12
+      @obj.instance_variable_get('@bob').should be_nil
+    end
+    it 'delegates to receive_{whatever}' do
+      @obj.should_receive(:receive_my_int).with(7)
+      @obj.receive! :my_int => 7, :bob => 12
+    end
+    it 'imposes defaults and triggers after_receivers after hash has been sucked in' do
+      @obj.should_receive(:receive_my_int).with(7).ordered
+      @obj.should_receive(:impose_defaults!).with(:my_int => 7, :bob => 12).ordered
+      @obj.should_receive(:run_after_receivers).with(:my_int => 7, :bob => 12).ordered
+      @obj.receive! :my_int => 7, :bob => 12
+    end
+    it 'returns self, to allow chaining' do
+      @obj.receive!(:my_int => 7, :bob => 12).should equal(@obj)
+    end
+
+    it 'receives even if there is no setter' do
+      @klass.rcvr_reader :a, Integer
+      @klass.rcvr        :b, Integer
+      obj = @klass.receive :my_int => 3, :a => 5, :b => 7
+      obj.should_not respond_to(:a=)
+      obj.should_not respond_to(:b=)
+      obj.my_int.should == 3
+      obj.a.should == 5
+      obj.instance_variable_get("@b").should == 7
+    end
+  end
+
+  describe "receiving type" do
+    RECEIVABLES = [Symbol, String, Integer, Float, Time, Date, Array, Hash, Boolean, NilClass, Object]
+    ALIASES     = [:symbol, :string, :int, :integer, :long, :time, :date, :float, :double, :hash, :map, :array, :null, :boolean, :bytes]
+    it "has specs for every type" do
+      (Receiver::RECEIVER_BODIES.keys - RECEIVABLES).should be_empty
+    end
+    it "has specs for every alias" do
+      (Receiver::TYPE_ALIASES.keys - ALIASES).should == []
+    end
+    RECEIVABLES.each do |receivable|
+      it "#{receivable} has a receiver_body" do
+        Receiver::RECEIVER_BODIES.should have_key(receivable)
+      end
+    end
+    (RECEIVABLES - [String]).each do |receivable|
+      it "#{receivable} accepts nil as nil" do
+        @klass.rcvr_accessor :nil_field, receivable
+        obj = @klass.receive(:nil_field => nil)
+        obj.nil_field.should be_nil
+      end
+    end
+    [String].each do |receivable|
+      it "#{receivable} accepts nil as empty string" do
+        @klass.rcvr_accessor :nil_field, receivable
+        obj = @klass.receive(:nil_field => nil)
+        obj.nil_field.should == ""
+      end
+    end
+
+    it 'keeps values across a receive!' do
+      @klass.rcvr_accessor :repeated,    Integer
+      @klass.rcvr_accessor :just_second, Integer
+      obj = @klass.receive( :my_int => 1, :repeated => 3)
+      [obj.my_int, obj.repeated, obj.just_second].should == [1, 3, nil]
+      obj.receive!(:repeated => 20, :just_second => 30)
+      [obj.my_int, obj.repeated, obj.just_second].should == [1, 20, 30]
+    end
+
+    # ---------------------------------------------------------------------------
+
+    describe 'core class .receive method' do
+      Symbol.receive('hi').should == :hi
+      Integer.receive(3.4).should == 3
+      Float.receive("4.5").should == 4.5
+      String.receive(4.5).should == "4.5"
+      Time.receive('1985-11-05T04:03:02Z').should == Time.parse('1985-11-05T04:03:02Z')
+      Date.receive('1985-11-05T04:03:02Z').should == Date.parse('1985-11-05')
+      Array.receive('hi').should == ['hi']
+      Hash.receive({:hi => :there}).should == {:hi => :there}
+      Boolean.receive("false").should == false
+      NilClass.receive(nil).should == nil
+      Object.receive(:fnord).should == :fnord
+    end
+
+    # ---------------------------------------------------------------------------
+
+    def self.it_correctly_converts(type, orig, desired)
+      it "for #{type} converts #{orig.inspect} to #{desired.inspect}" do
+        field = "#{type}_field".to_sym
+        @klass.rcvr_accessor field, type
+        obj = @klass.receive( field => orig )
+        obj.send(field).should == desired
+      end
+    end
+
+    describe 'type coercion' do
+      [
+        [Symbol,   'foo', :foo], [Symbol, :foo, :foo], [Symbol, nil, nil],     [Symbol, '', nil],
+        [Integer, '5', 5],       [Integer, 5,   5],    [Integer, nil, nil],    [Integer, '', nil],
+        [Integer, '5', 5],       [Integer, 5,   5],    [Integer, nil, nil],    [Integer, '', nil],
+        [Float,   '5.2', 5.2],   [Float,   5.2, 5.2],  [Float, nil, nil],      [Float, '', nil],
+        [String,  'foo', 'foo'], [String, :foo, 'foo'], [String, nil, ""],     [String, '', ""],
+        [String,  5.2, "5.2"],   [String, [1], "[1]"],  [String, 1, "1"],
+        [Time,  '1985-11-05T04:03:02Z',             Time.parse('1985-11-05T04:03:02Z')],
+        [Time,  '1985-11-05T04:03:02+06:00',        Time.parse('1985-11-04T22:03:02Z')],
+        [Time,  Time.parse('1985-11-05T04:03:02Z'), Time.parse('1985-11-05T04:03:02Z')],
+        [Date,  Time.parse('1985-11-05T04:03:02Z'), Date.parse('1985-11-05')],
+        [Date,  '1985-11-05T04:03:02Z',             Date.parse('1985-11-05')],
+        [Date,  '1985-11-05T04:03:02+06:00',        Date.parse('1985-11-05')],
+        [Time, nil, nil],  [Time, '', nil], [Time, 'blah', nil],
+        [Date, nil, nil],  [Date, '', nil], [Date, 'blah', nil],
+        [Array,  ['this', 'that', 'thother'], ['this', 'that', 'thother'] ],
+        [Array,  ['this,that,thother'],       ['this,that,thother'] ],
+        [Array,   'this,that,thother',        ['this,that,thother'] ],
+        [Array,  'alone', ['alone'] ],
+        [Array,  '',      []        ],
+        [Array,  nil,     nil       ],
+        [Hash,   {:hi => 1}, {:hi => 1}], [Hash,   nil,     nil],    [Hash,   "",      {}], [Hash,   [],      {}], [Hash,   {},      {}],
+        [:boolean, '0', true],   [:boolean, 0, true],  [:boolean, '',  false], [:boolean, [],     true], [:boolean, nil, nil],
+        [:boolean, '1', true],   [:boolean, 1, true],  [:boolean, '5', true],  [:boolean, 'true', true],
+        [NilClass, nil, nil],
+        [Object,  {:foo => [1]}, {:foo => [1]} ], [Object, nil, nil], [Object, 1, 1],
+      ].each do |type, orig, desired|
+        it_correctly_converts type, orig, desired
+      end
+
+      describe 'controversially' do
+        [
+          [Hash,  ['does no type checking'],      ['does no type checking'] ],
+          [Hash,   'does no type checking',        'does no type checking'  ],
+        ].each do |type, orig, desired|
+          it_correctly_converts type, orig, desired
+        end
+      end
+
+      describe 'NilClass' do
+        it 'only accepts nil' do
+          @klass.rcvr_accessor :nil_field, NilClass
+          lambda{ @klass.receive( :nil_field => 'hello' ) }.should raise_error(ArgumentError, "This field must be nil, but {hello} was given")
+        end
+      end
+    end
+
+  end
+end
+