gorillib 0.1.1 → 0.1.2

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/gorillib.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gorillib}
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Infochimps"]
-  s.date = %q{2011-06-07}
+  s.date = %q{2011-06-24}
   s.description = %q{Gorillib: infochimps lightweight subset of ruby convenience methods}
   s.email = %q{coders@infochimps.org}
   s.extra_rdoc_files = [

data/lib/gorillib/object/try.rb

@@ -1,10 +1,57 @@
+unless Object.method_defined?(:try)
 class Object
+  # Invokes the method identified by the symbol +method+, passing it any arguments
+  # and/or the block specified, just like the regular Ruby <tt>Object#send</tt> does.
+  #
+  # *Unlike* that method however, a +NoMethodError+ exception will *not* be raised
+  # and +nil+ will be returned instead, if the receiving object is a +nil+ object or NilClass.
+  #
+  # If try is called without a method to call, it will yield any given block with the object.
+  #
+  # ==== Examples
+  #
+  # Without +try+
+  #   @person && @person.name
+  # or
   #   @person ? @person.name : nil
-  # vs
+  #
+  # With +try+
   #   @person.try(:name)
-  def try(method)
-    send method if respond_to? method
+  #
+  # +try+ also accepts arguments and/or a block, for the method it is trying
+  #   Person.try(:find, 1)
+  #   @people.try(:collect) {|p| p.name}
+  #
+  # Without a method argument try will yield to the block unless the receiver is nil.
+  #   @person.try { |p| "#{p.first_name} #{p.last_name}" }
+  #--
+  # +try+ behaves like +Object#send+, unless called on +NilClass+.
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    elsif !a.empty? && !respond_to?(a.first)
+      nil
+    else
+      __send__(*a, &b)
+    end
   end
-
 end
 
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes specially helpful when navigating through associations that may return +nil+.
+  #
+  # === Examples
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && !@person.children.blank? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*args)
+    nil
+  end
+end
+end

data/lib/gorillib/receiver/acts_as_hash.rb

@@ -1,3 +1,5 @@
+require 'gorillib/hashlike'
+
 module Receiver
   #
   # Makes a Receiver thingie behave mostly like a hash.
@@ -30,113 +32,135 @@ module Receiver
   #
   module ActsAsHash
 
-    # Hashlike#[]
-    #
-    # Element Reference -- Retrieves the value stored for +key+.
-    #
-    # In a normal hash, a default value can be set; none is provided here.
-    #
-    # Delegates to self.send(key)
-    #
-    # @example
-    #     hsh = { :a => 100, :b => 200 }
-    #     hsh[:a] # => 100
-    #     hsh[:c] # => nil
-    #
-    # @param  key [Object] key to retrieve
-    # @return [Object] the value stored for key, nil if missing
-    #
-    def [](key)
-      key = convert_key(key)
-      self.send(key)
-    end
+    module InstanceMethods
 
-    # Hashlike#[]=
-    # Hashlike#store
-    #
-    # Element Assignment -- Associates the value given by +val+ with the key
-    # given by +key+.
-    #
-    # key should not have its value changed while it is in use as a key. In a
-    # normal hash, a String passed as a key will be duplicated and frozen. No such
-    # guarantee is provided here
-    #
-    # Delegates to self.send("key=", val)
-    #
-    # @example
-    #     hsh = { :a => 100, :b => 200 }
-    #     hsh[:a] = 9
-    #     hsh[:c] = 4
-    #     hsh    # => { :a => 9, :b => 200, :c => 4 }
-    #
-    #     hsh[key] = val                         -> val
-    #     hsh.store(key, val)                    -> val
-    #
-    # @param  key [Object] key to associate
-    # @param  val [Object] value to associate it with
-    # @return [Object]
-    #
-    def []=(key, val)
-      key = convert_key(key)
-      self.send("#{key}=", val)
-    end
+      # Hashlike#[]
+      #
+      # Element Reference -- Retrieves the value stored for +key+.
+      #
+      # In a normal hash, a default value can be set; none is provided here.
+      #
+      # Delegates to self.send(key)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh[:a] # => 100
+      #     hsh[:c] # => nil
+      #
+      # @param  key [Object] key to retrieve
+      # @return [Object] the value stored for key, nil if missing
+      #
+      def [](key)
+        key = convert_key(key)
+        self.send(key)
+      end
 
-    # Hashlike#delete
-    #
-    # Deletes and returns the value from +hsh+ whose key is equal to +key+. If the
-    # optional code block is given and the key is not found, pass in the key and
-    # return the result of +block+.
-    #
-    # In a normal hash, a default value can be set; none is provided here.
-    #
-    # @example
-    #     hsh = { :a => 100, :b => 200 }
-    #     hsh.delete(:a)                            # => 100
-    #     hsh.delete(:z)                            # => nil
-    #     hsh.delete(:z){|el| "#{el} not found" }   # => "z not found"
-    #
-    # @overload hsh.delete(key)                  -> val
-    #   @param  key [Object] key to remove
-    #   @return [Object, Nil] the removed object, nil if missing
-    #
-    # @overload hsh.delete(key){|key| block }    -> val
-    #   @param  key [Object] key to remove
-    #   @yield  [Object] called (with key) if key is missing
-    #   @yieldparam key
-    #   @return [Object, Nil] the removed object, or if missing, the return value
-    #     of the block
-    #
-    def delete(key, &block)
-      key = convert_key(key)
-      if has_key?(key)
-        val = self[key]
-        self.send(:remove_instance_variable, "@#{key}")
-        val
-      elsif block_given?
-        block.call(key)
-      else
-        nil
+      # Hashlike#[]=
+      # Hashlike#store
+      #
+      # Element Assignment -- Associates the value given by +val+ with the key
+      # given by +key+.
+      #
+      # key should not have its value changed while it is in use as a key. In a
+      # normal hash, a String passed as a key will be duplicated and frozen. No such
+      # guarantee is provided here
+      #
+      # Delegates to self.send("key=", val)
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh[:a] = 9
+      #     hsh[:c] = 4
+      #     hsh    # => { :a => 9, :b => 200, :c => 4 }
+      #
+      #     hsh[key] = val                         -> val
+      #     hsh.store(key, val)                    -> val
+      #
+      # @param  key [Object] key to associate
+      # @param  val [Object] value to associate it with
+      # @return [Object]
+      #
+      def []=(key, val)
+        key = convert_key(key)
+        self.send("#{key}=", val)
       end
-    end
 
-    # Hashlike#keys
-    #
-    # Returns a new array populated with the keys from this hashlike.
-    #
-    # @see Hashlike#values.
-    #
-    # @example
-    #     hsh = { :a => 100, :b => 200, :c => 300, :d => 400 }
-    #     hsh.keys   # => [:a, :b, :c, :d]
-    #
-    # @return [Array] list of keys
-    #
-    def keys
-      members & instance_variables.map{|s| convert_key(s[1..-1]) }
-    end
+      # Hashlike#delete
+      #
+      # Deletes and returns the value from +hsh+ whose key is equal to +key+. If the
+      # optional code block is given and the key is not found, pass in the key and
+      # return the result of +block+.
+      #
+      # In a normal hash, a default value can be set; none is provided here.
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200 }
+      #     hsh.delete(:a)                            # => 100
+      #     hsh.delete(:z)                            # => nil
+      #     hsh.delete(:z){|el| "#{el} not found" }   # => "z not found"
+      #
+      # @overload hsh.delete(key)                  -> val
+      #   @param  key [Object] key to remove
+      #   @return [Object, Nil] the removed object, nil if missing
+      #
+      # @overload hsh.delete(key){|key| block }    -> val
+      #   @param  key [Object] key to remove
+      #   @yield  [Object] called (with key) if key is missing
+      #   @yieldparam key
+      #   @return [Object, Nil] the removed object, or if missing, the return value
+      #     of the block
+      #
+      def delete(key, &block)
+        key = convert_key(key)
+        if has_key?(key)
+          val = self[key]
+          self.send(:remove_instance_variable, "@#{key}")
+          val
+        elsif block_given?
+          block.call(key)
+        else
+          nil
+        end
+      end
+
+      # Hashlike#keys
+      #
+      # Returns a new array populated with the keys from this hashlike.
+      #
+      # @see Hashlike#values.
+      #
+      # @example
+      #     hsh = { :a => 100, :b => 200, :c => 300, :d => 400 }
+      #     hsh.keys   # => [:a, :b, :c, :d]
+      #
+      # @return [Array] list of keys
+      #
+      def keys
+        members & instance_variables.map{|s| convert_key(s[1..-1]) }
+      end
+
+      def members
+        self.class.members
+      end
+
+      #
+      # Returns a hash with each key set to its associated value.
+      #
+      # @example
+      #    my_hshlike = MyHashlike.new
+      #    my_hshlike[:a] = 100; my_hshlike[:b] = 200
+      #    my_hshlike.to_hash # => { :a => 100, :b => 200 }
+      #
+      # @return [Hash] a new Hash instance, with each key set to its associated value.
+      #
+      def to_hash
+        {}.tap do |hsh|
+          each_pair do |key, val|
+            hsh[key] = val.respond_to?(:to_hash) ? val.to_hash : val
+          end
+        end
+      end
 
-    def members
-      self.class.members
     end
 
     module ClassMethods
@@ -153,7 +177,7 @@ module Receiver
       end
     end
 
-  protected
+    protected
 
     def convert_key(key)
       raise ArgumentError, "Keys for #{self.class} must be symbols, strings or respond to #to_sym" unless key.respond_to?(:to_sym)
@@ -161,8 +185,9 @@ module Receiver
     end
 
     def self.included base
-      base.extend ClassMethods
       base.send(:include, Gorillib::Hashlike)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
     end
   end
 end

data/lib/gorillib/receiver.rb

@@ -1,3 +1,7 @@
+require 'gorillib/object/blank'
+require 'gorillib/object/try'
+require 'gorillib/array/extract_options'
+
 # dummy type for receiving True or False
 class Boolean ; end unless defined?(Boolean)
 
@@ -85,19 +89,23 @@ module Receiver
   RECEIVER_BODIES[Array]    = %q{ case when v.nil? then nil when v.blank? then [] else Array(v) end }
   RECEIVER_BODIES[Hash]     = %q{ case when v.nil? then nil when v.blank? then {} else v end }
   RECEIVER_BODIES[Boolean]  = %q{ case when v.nil? then nil when v.to_s.strip.blank? then false else v.to_s.strip != "false" end }
-  RECEIVER_BODIES[NilClass] = %q{ raise ArgumentError, "This field must be nil, but {#{v}} was given" unless (v.nil?) ; nil }
+  RECEIVER_BODIES[NilClass] = %q{ raise ArgumentError, "This field must be nil, but [#{v}] was given" unless (v.nil?) ; nil }
   RECEIVER_BODIES[Object]   = %q{ v } # accept and love the object just as it is
 
   #
   # Give each base class a receive method
   #
   RECEIVER_BODIES.each do |k,b|
-    if k.is_a?(Class)
+    if k.is_a?(Class) && b.is_a?(String)
       k.class_eval <<-STR, __FILE__, __LINE__ + 1
       def self.receive(v)
         #{b}
       end
       STR
+    elsif k.is_a?(Class)
+      k.class_eval do
+        define_singleton_method(:receive, &b)
+      end
     end
   end
 
@@ -187,12 +195,19 @@ public
     def rcvr name, type, info={}
       name = name.to_sym
       type = type_to_klass(type)
-      class_eval <<-STR, __FILE__, __LINE__ + 1
+      body = receiver_body_for(type, info)
+      if body.is_a?(String)
+        class_eval(%Q{
         def receive_#{name}(v)
-          v = (#{receiver_body_for(type, info)}) ;
+          self.instance_variable_set("@#{name}", (#{body}))
+        end}, __FILE__, __LINE__ + 1)
+      else
+        define_method("receive_#{name}") do |*args|
+          v = body.call(*args)
           self.instance_variable_set("@#{name}", v)
+          v
         end
-      STR
+      end
       # careful here: don't modify parent's class_attribute in-place
       self.receiver_attrs = self.receiver_attrs.dup
       self.receiver_attr_names += [name] unless receiver_attr_names.include?(name)
@@ -254,6 +269,30 @@ public
       defs
     end
 
+    # returns an in-order traversal of the
+    #
+    def tuple_keys
+      return @tuple_keys if @tuple_keys
+      @tuple_keys = self
+      @tuple_keys = receiver_attrs.map do |attr, info|
+        info[:type].try(:tuple_keys) || attr
+      end.flatten
+    end
+
+    def consume_tuple(tuple)
+      obj = self.new
+      receiver_attrs.each do |attr, info|
+        if info[:type].respond_to?(:consume_tuple)
+          val = info[:type].consume_tuple(tuple)
+        else
+          val = tuple.shift
+        end
+        # obj.send("receive_#{attr}", val)
+        obj.send("#{attr}=", val)
+      end
+      obj
+    end
+
   protected
     def receiver_body_for type, info
       type = type_to_klass(type)
@@ -261,16 +300,15 @@ public
       # they have an :of => SomeType option.
       case
       when info[:of] && (type == Array)
-        %Q{ v.nil? ? nil : v.map{|el| #{info[:of]}.receive(el) } }
+        receiver_type = info[:of]
+        lambda{|v|  v.nil? ? nil : v.map{|el| receiver_type.receive(el) } }
       when info[:of] && (type == Hash)
-        %Q{ v.nil? ? nil : v.inject({}){|h, (el,val)| h[el] = #{info[:of]}.receive(val); h } }
+        receiver_type = info[:of]
+        lambda{|v| v.nil? ? nil : v.inject({}){|h, (el,val)| h[el] = receiver_type.receive(val); h } }
       when Receiver::RECEIVER_BODIES.include?(type)
         Receiver::RECEIVER_BODIES[type]
       when type.is_a?(Class)
-        %Q{v.blank? ? nil : #{type}.receive(v) }
-      # when (type.is_a?(Symbol) && type.to_s =~ /^[A-Z]/)
-      #   # a hack so you can use a class not defined yet
-      #   %Q{v.blank? ? nil : #{type}.receive(v) }
+        lambda{|v| v.blank? ? nil : type.receive(v) }
       else
         raise("Can't receive #{type} #{info}")
       end
@@ -286,6 +324,18 @@ public
     end
   end
 
+  def to_tuple
+    tuple = []
+    self.each_value do |val|
+      if val.respond_to?(:to_tuple)
+        tuple += val.to_tuple
+      else
+        tuple << val
+      end
+    end
+    tuple
+  end
+
   module ClassMethods
     # By default, the hashlike methods iterate over the receiver attributes.
     # If you want to filter our add to the keys list, override this method
@@ -303,13 +353,15 @@ public
   # set up receiver attributes, and bring in methods from the ClassMethods module at class-level
   def self.included base
     base.class_eval do
-      class_attribute :receiver_attrs
-      class_attribute :receiver_attr_names
-      class_attribute :after_receivers
-      self.receiver_attrs      = {} # info about the attr
-      self.receiver_attr_names = [] # ordered set of attr names
-      self.after_receivers     = [] # blocks to execute following receive!
-      extend ClassMethods
+      unless method_defined?(:receiver_attrs)
+        class_attribute :receiver_attrs
+        class_attribute :receiver_attr_names
+        class_attribute :after_receivers
+        self.receiver_attrs      = {} # info about the attr
+        self.receiver_attr_names = [] # ordered set of attr names
+        self.after_receivers     = [] # blocks to execute following receive!
+        extend ClassMethods
+      end
     end
   end
 end

data/spec/object/try_spec.rb

@@ -2,8 +2,8 @@ require File.dirname(__FILE__)+'/../spec_helper'
 require 'gorillib/object/try'
 
 class Foo
-  def i_am_a_method_hooray
-    "i was called!"
+  def i_am_a_method_hooray param='hooray'
+    "i was called! #{param}!"
   end
 end
 
@@ -12,8 +12,9 @@ describe Object do
     it 'returns nil if item does not #respond_to? method' do
       Foo.new.try(:i_am_not_a_method).should be_nil
     end
-    it 'calls the method if the item does #respond_to? it' do
-      Foo.new.try(:i_am_a_method_hooray).should == "i was called!"
+    it 'calls the method (with args) if the item does #respond_to? it' do
+      Foo.new.try(:i_am_a_method_hooray).should == "i was called! hooray!"
+      Foo.new.try(:i_am_a_method_hooray, 'yay').should == "i was called! yay!"
     end
   end
 end

data/spec/receiver/acts_as_hash_spec.rb

@@ -10,13 +10,10 @@ 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
@@ -41,16 +38,19 @@ describe Receiver do
   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")
@@ -61,17 +61,19 @@ describe Receiver do
       @hshlike[obj].should == :i_haz_obj
     end
 
-    it 'd' do
+    it 'defines the right accessor methods' 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'
+      [ :receive_write_only_attr, :write_only_attr=,
+        :receive_read_only_attr,  :read_only_attr,
+        :receive_internal_attr,
+        :not_a_receiver, :not_a_receiver= ].each{ |attr| @hshlike_subklass.should be_method_defined(attr) }
+      [ :write_only_attr,  :read_only_attr=,
+        :internal_attr,  :internal_attr=,
+        :receive_not_a_receiver ].each{ |attr| @hshlike_subklass.should_not be_method_defined(attr) }
+      @hshlike_subklass.receiver_attr_names.should == [:a, :b, :c, :nil_val, :false_val, :new_key, :write_only_attr, :read_only_attr, :internal_attr]
     end
   end
 
@@ -259,6 +261,13 @@ describe Receiver do
 
   describe '#to_hash' do
     it_should_behave_like :hashlike_to_hash
+
+    it 'should recurse' do
+      @hshlike_subklass.rcvr_accessor :k2, SimpleReceiver
+      hsh = HashlikeHelper::HASH_TO_TEST_HL_V_A.merge(:k2 => {:a => 3, :new_key => 'hi' })
+      obj = @hshlike_subklass.receive(hsh)
+      obj.to_hash.should == {:a=>100, :b=>200, :c=>300, :nil_val=>nil, :false_val=>false, :k2=>{:a=>3, :new_key=>"hi"} }
+    end
   end
 
   describe '#invert' do

data/spec/receiver_spec.rb

@@ -11,6 +11,36 @@ class Wide
   rcvr_accessor :my_int, Integer
 end
 
+require 'gorillib/receiver/acts_as_hash'
+class StreetAddress
+  include Receiver
+  include Receiver::ActsAsHash
+  rcvr_accessor :num,      Integer
+  rcvr_accessor :street,   String
+  rcvr_accessor :city,     String
+  rcvr_accessor :state,    String
+  rcvr_accessor :zip_code, Integer
+end
+
+class Vcard
+  include Receiver
+  include Receiver::ActsAsHash
+  rcvr_accessor :name,         String
+  rcvr_accessor :home_address, StreetAddress
+  rcvr_accessor :work_address, StreetAddress
+  rcvr_accessor :phone,        String
+end
+
+class RecursiveReceiver < Wide
+  include Receiver
+  rcvr_accessor :a, Integer
+  rcvr_accessor :b, String
+  rcvr_accessor :wide_rcvr_a, Wide
+  rcvr_accessor :rec_field, RecursiveReceiver
+  rcvr_accessor :wide_rcvr_b, Wide
+  rcvr_accessor :c, String
+end
+
 describe Receiver do
   before do
     @klass = Class.new(Wide)
@@ -63,14 +93,44 @@ describe Receiver do
     end
   end
 
-  describe '.receive_tuple' do
-    it 'receives a tuple, assigning to rcvrs in order'
+  ADDRESS_TUPLE = ['Homer J Simpson', 742, 'Evergreen Terr', 'Springfield', 'AZ', 12345, 100, 'Industrial Way', 'Springfield', 'WY', 98765, '800-BITE-ME']
+  ADDRESS_HASH = {
+        :name => 'Homer J Simpson',
+        :home_address => { :num => 742, :street => 'Evergreen Terr', :city => 'Springfield', :state => 'AZ', :zip_code => 12345 },
+        :work_address => { :num => 100, :street => 'Industrial Way', :city => 'Springfield', :state => 'WY', :zip_code => 98765 },
+    :phone => '800-BITE-ME'}
+
+  describe '.consume_tuple' do
+    it 'receives a tuple, assigning to rcvrs in order' do
+      obj = Vcard.consume_tuple(ADDRESS_TUPLE.dup)
+      obj.to_hash.should == ADDRESS_HASH
+    end
 
     it 'allows empty tuple'
 
     it '?breaks? on too-long tuple'
   end
 
+  describe '#to_tuple' do
+    it 'flattens' do
+      obj = Vcard.receive(ADDRESS_HASH)
+      obj.to_tuple.should == ADDRESS_TUPLE
+    end
+  end
+
+  describe '.tuple_keys' do
+    it 'for a simple receiver, produces attrs in order' do
+      StreetAddress.tuple_keys.should == [:num, :street, :city, :state, :zip_code]
+    end
+
+    it 'for a complex receiver, in-order traverses the tree' do
+      Vcard.tuple_keys.should == [:name, :num, :street, :city, :state, :zip_code, :num, :street, :city, :state, :zip_code, :phone]
+    end
+
+    it 'does not recurse endlessly' do
+      RecursiveReceiver.tuple_keys.should == [:my_int, :a, :b, :my_int, RecursiveReceiver, :my_int, :c]
+    end
+  end
 
   describe '.receive_foo' do
     it 'injects a superclass, so I can call super() in receive_foo'
@@ -194,7 +254,6 @@ describe Receiver 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
@@ -389,6 +448,14 @@ describe Receiver do
       end
     end
 
+    it "lets me use an anonymous class as a received type" do
+      @klass_2 = Class.new(Wide)
+      @klass_2.rcvr_accessor :maw, Integer
+      @klass.rcvr_accessor :k2, @klass_2
+      obj = @klass.receive({ :my_int => 3, :k2 => { :maw => 2 }})
+      obj.k2.maw.should == 2
+    end
+
     it 'keeps values across a receive!' do
       @klass.rcvr_accessor :repeated,    Integer
       @klass.rcvr_accessor :just_second, Integer
@@ -468,7 +535,7 @@ describe Receiver do
       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")
+          lambda{ @klass.receive( :nil_field => 'hello' ) }.should raise_error(ArgumentError, "This field must be nil, but [hello] was given")
         end
       end
     end

data/spec/support/hashlike_helper.rb

@@ -54,7 +54,8 @@ module HashlikeHelper
     :assert_valid_keys,
     :nested_under_indifferent_access,
     :stringify_keys, :stringify_keys!, :symbolize_keys, :symbolize_keys!,
-    :with_indifferent_access, :yaml_initialize
+    :with_indifferent_access, :yaml_initialize,
+    :extractable_options?, :deep_dup, :reverse_merge, :reverse_merge!, :slice, :slice!, :extract!, :deep_merge, :deep_merge!, :deep_compact!, :compact, :compact!, :compact_blank, :compact_blank!
   ]
   FANCY_HASHLIKE_METHODS.each{|meth| OMITTED_METHODS_FROM_HASH << meth }
 

metadata

@@ -2,7 +2,7 @@
 name: gorillib
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Infochimps
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-07 00:00:00 -07:00
+date: 2011-06-24 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -315,7 +315,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2181950979362360273
+      hash: -517886677893709781
       segments: 
       - 0
       version: "0"