gorillib 0.4.0pre → 0.4.1pre

data/spec/gorillib/model/record/factories_spec.rb

@@ -22,18 +22,24 @@ describe '', :model_spec => true do
         ff = Gorillib::Factory( ->(obj){ "bob says #{obj}" } )
         ff.receive(3).should == "bob says 3"
       end
-      it 'uses a factory directly' do
+      it 'returns anything that responds to #receive directly' do
+        ff = Object.new ; ff.define_singleton_method(:receive){}
+        Gorillib::Factory(ff).should equal(ff)
+      end
+      it 'returns a factory directly' do
         ff = Gorillib::Factory::SymbolFactory.new
-        Gorillib::Factory(ff).should == ff
-        Gorillib::Factory(Gorillib::Factory::SymbolFactory).should == Gorillib::Factory::SymbolFactory
+        Gorillib::Factory(ff).should equal(ff)
+      end
+      it 'does not look up factory **classes**' do
+        ->{ Gorillib::Factory(Gorillib::Factory::SymbolFactory) }.should raise_error(ArgumentError, /Don\'t know which factory makes/)
       end
       it 'looks up factories by typename' do
-        Gorillib::Factory(:symbol   ).should == Gorillib::Factory::SymbolFactory
-        Gorillib::Factory(:identical).should == Gorillib::Factory::IdenticalFactory
+        Gorillib::Factory(:symbol   ).should be_a(Gorillib::Factory::SymbolFactory)
+        Gorillib::Factory(:identical).should == (::Whatever)
       end
       it 'looks up factories by class' do
-        Gorillib::Factory(Symbol).should == Gorillib::Factory::SymbolFactory
-        Gorillib::Factory(String).should == Gorillib::Factory::StringFactory
+        Gorillib::Factory(Symbol).should be_a(Gorillib::Factory::SymbolFactory)
+        Gorillib::Factory(String).should be_a(Gorillib::Factory::StringFactory)
       end
       it 'calls Gorillib::Factory.receive' do
         x = mock
@@ -86,9 +92,10 @@ describe '', :model_spec => true do
   shared_examples_for :it_is_registered_as do |*keys|
     it "the factory for #{keys}" do
       keys.each do |key|
-        Gorillib::Factory(key).should == described_class
+        Gorillib::Factory(key).should be_a(described_class)
       end
-      Gorillib::Factory.send(:factories).to_hash.select{|key,val| val == described_class }.keys.should == keys
+      its_factory = Gorillib::Factory(keys.first)
+      Gorillib::Factory.send(:factories).to_hash.select{|key,val| val.equal?(its_factory) }.keys.should == keys
     end
   end
 
@@ -177,12 +184,19 @@ describe '', :model_spec => true do
     its(:typename){ should == :boolean }
   end
 
-  describe Gorillib::Factory::IdenticalFactory do
+  describe ::Whatever do
     it_behaves_like :it_considers_native,   true, false, nil, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
-    it_behaves_like :it_is_registered_as, :identical, :whatever
+    it "it is itself the factory for :identical and :whatever" do
+      keys = [Whatever, :identical, :whatever]
+      keys.each do |key|
+        Gorillib::Factory(key).should equal(described_class)
+      end
+      its_factory = ::Whatever
+      Gorillib::Factory.send(:factories).to_hash.select{|key,val| val.equal?(its_factory) }.keys.should == keys
+    end
   end
-  describe ::Whatever do
-    it{ described_class.should equal(Gorillib::Factory::IdenticalFactory) }
+  describe Gorillib::Factory::IdenticalFactory do
+    it{ described_class.should equal(Whatever) }
   end
 
   describe Gorillib::Factory::ModuleFactory do

data/spec/gorillib/model/serialization_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 require 'model_test_helpers'
 
-require 'json'
-
 require 'multi_json'
 #
 require 'gorillib/model'
@@ -17,13 +15,13 @@ describe Gorillib::Model, :model_spec => true do
   end
   let :wired_garage_hash do
     { :cars => [
-        {:name=>:wildcat, :make_model=>"Buick Wildcat",    :year=>1968, :doors=>2, :engine=>{:name=>" engine", :carburetor=>:stock, :volume=>455, :cylinders=>8, :owner=>nil}},
-        {:name=>:ford_39, :make_model=>"Ford Tudor Sedan", :year=>1939, :doors=>2, :engine=>nil}, ] }
+        {:name=>:wildcat, :make_model=>"Buick Wildcat",    :year=>1968, :doors=>2, :engine=>{:name=>" engine", :carburetor=>:stock, :volume=>455, :cylinders=>8, :owner=>nil, :_type => "gorillib.test.engine"}, :_type => "gorillib.test.car"},
+        {:name=>:ford_39, :make_model=>"Ford Tudor Sedan", :year=>1939, :doors=>2, :engine=>nil, :_type => "gorillib.test.car"}, ], :_type => "gorillib.test.garage" }
   end
 
   describe 'to_json' do
     it 'recursively serializes' do
-      MultiJson.load(wildcat.to_json).should == {"name"=>"wildcat","make_model"=>"Buick Wildcat","year"=>1968,"doors"=>2,"engine"=>{"name"=>" engine","carburetor"=>"stock","volume"=>455,"cylinders"=>8,"owner"=>nil}}
+      MultiJson.load(wildcat.to_json).should == {"name"=>"wildcat","make_model"=>"Buick Wildcat","year"=>1968,"doors"=>2,"engine"=>{"name"=>" engine","carburetor"=>"stock","volume"=>455,"cylinders"=>8,"owner"=>nil,"_type"=>"gorillib.test.engine"},"_type"=>"gorillib.test.car"}
     end
     it 'recursively serializes' do
       subject.to_json.should == MultiJson.dump(wired_garage_hash)

data/spec/gorillib/model_spec.rb

@@ -4,14 +4,19 @@ require 'model_test_helpers'
 require 'gorillib/model'
 
 describe Gorillib::Model, :model_spec => true do
+  let(:smurf_class) do
+    class Gorillib::Test::Smurf
+      include Gorillib::Model
+      field :smurfiness, Integer
+      field :weapon,     Symbol
+    end
+    Gorillib::Test::Smurf
+  end
+  let(:poppa_smurf  ){ smurf_class.receive(:name => 'Poppa Smurf',   :smurfiness => 9,  :weapon => 'staff') }
+  let(:smurfette    ){ smurf_class.receive(:name => 'Smurfette',     :smurfiness => 11, :weapon => 'charm') }
 
-  let(:simple_model){ class Gorillib::Test::TestClass ; include Gorillib::Model ; field :my_field, Whatever ; self ; end }
-  let(:anon_class){    Class.new{ include Gorillib::Model ; field :my_field, :whatever } }
-  let(:example_inst){ subject.receive(:my_field => 69) }
-  let(:example_val){ mock('example val') }
-
-  let(:complex_class) do
-    class Gorillib::Test::ComplexModel
+  let(:simple_model) do
+    class Gorillib::Test::SimpleModel
       include Gorillib::Model
       field :my_field,  :whatever
       field :str_field, String
@@ -19,66 +24,78 @@ describe Gorillib::Model, :model_spec => true do
       self
     end
   end
-  let(:complex_subclass){ Gorillib::Test::TestSubclass = Class.new(complex_class){ field :zyzzyva, Integer; field :acme, Integer } }
+  let(:subclassed_model) do
+    class Gorillib::Test::SubclassedModel < simple_model ; field :zyzzyva, Integer; field :acme, Integer ; end
+    Gorillib::Test::SubclassedModel
+  end
+  let(:nested_model) do
+    smurf_class = self.smurf_class
+    Gorillib::Test::NestedModel = Class.new(simple_model){ field :smurf, smurf_class }
+    Gorillib::Test::NestedModel
+  end
 
-  subject{ complex_class }
+  let(:described_class){ simple_model }
+  let(:example_inst){    described_class.receive(:my_field => 69) }
+
+  #
+  # IT BEHAVES LIKE A MODEL
+  # (maybe you wouldn't notice if it was just one little line)
+  #
+  it_behaves_like 'a model'
+
+  # --------------------------------------------------------------------------
 
   context 'examples' do
-    let(:nested_class){ Class.new(complex_class){ field :another_model, self } }
     it 'type-converts values' do
-      obj = complex_class.receive({
+      obj = simple_model.receive({
           :my_field => 'accepted as-is', :str_field => :bob, :sym_field => 'converted_to_sym'
         })
       obj.attributes.should == { :my_field => 'accepted as-is', :str_field => 'bob', :sym_field=>:converted_to_sym }
     end
     it 'handles nested structures' do
-      obj      = nested_class.receive({ :my_field => 69 })
-      obj.attributes.should == { :my_field => 69, :str_field => nil, :sym_field=>nil, :another_model => nil }
-      deep_obj = nested_class.receive(:my_field => 111, :str_field => 'deep, man',
-        :another_model => { :my_field => 69, :another_model => nil })
-      deep_obj.attributes.should == { :my_field => 111, :str_field => 'deep, man', :sym_field=>nil, :another_model => obj }
+      deep_obj = nested_model.receive(:str_field => 'deep, man', :smurf => poppa_smurf.attributes)
+      deep_obj.attributes.should == { :str_field => 'deep, man', :smurf => poppa_smurf, :sym_field=>nil, :my_field => nil, }
     end
   end
 
   context ".field" do
-    subject{ simple_model }
     it "describes an attribute" do
-      example_inst.attributes.should == { :my_field => 69 }
+      example_inst.compact_attributes.should == { :my_field => 69 }
       example_inst.write_attribute(:my_field, 3).should == 3
-      example_inst.attributes.should == { :my_field => 3 }
+      example_inst.compact_attributes.should == { :my_field => 3 }
       example_inst.read_attribute(:my_field).should == 3
     end
     it 'inherits fields from its parent class, even if they are added later' do
-      complex_class.field_names.should    == [:my_field, :str_field, :sym_field]
-      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
-      complex_class.field :banksy, String
-      complex_class.field_names.should    == [:my_field, :str_field, :sym_field, :banksy ]
-      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
+      simple_model.field_names.should    == [:my_field, :str_field, :sym_field]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
+      simple_model.field :banksy, String
+      simple_model.field_names.should    == [:my_field, :str_field, :sym_field, :banksy ]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
     end
 
     it "supplies a reader method #foo to call read_attribute(:foo)" do
-      example_inst.should_receive(:read_attribute).with(:my_field).and_return(example_val)
-      example_inst.my_field.should == example_val
+      example_inst.should_receive(:read_attribute).with(:my_field).and_return(mock_val)
+      example_inst.my_field.should == mock_val
     end
     it "supplies a writer method #foo= to call write_attribute(:foo)" do
-      example_inst.should_receive(:write_attribute).with(:my_field, example_val)
-      (example_inst.my_field = example_val).should == example_val
+      example_inst.should_receive(:write_attribute).with(:my_field, mock_val)
+      (example_inst.my_field = mock_val).should == mock_val
     end
     it "supplies a receiver method #receive_foo to call write_attribute(:foo) and return self" do
-      example_inst.should_receive(:write_attribute).with(:my_field, example_val)
-      (example_inst.receive_my_field(example_val)).should == example_inst
+      example_inst.should_receive(:write_attribute).with(:my_field, mock_val)
+      (example_inst.receive_my_field(mock_val)).should == example_inst
     end
     it "sets visibility of reader with :reader => ()" do
-      subject.field :test_field, Integer, :reader => :private, :writer => false
-      subject.public_instance_methods.should_not  include(:test_field)
-      subject.private_instance_methods.should     include(:test_field)
-      subject.public_instance_methods.should_not  include(:test_field=)
-      subject.private_instance_methods.should_not include(:test_field=)
+      described_class.field :test_field, Integer, :reader => :private, :writer => false
+      described_class.public_instance_methods.should_not  include(:test_field)
+      described_class.private_instance_methods.should     include(:test_field)
+      described_class.public_instance_methods.should_not  include(:test_field=)
+      described_class.private_instance_methods.should_not include(:test_field=)
     end
   end
 
   context '.field' do
-    subject{           complex_class.new }
+    subject{ described_class.new }
     let(:sample_val){  'bob' }
     let(:raw_val){     :bob  }
     it_behaves_like 'a model field', :str_field
@@ -86,7 +103,7 @@ describe Gorillib::Model, :model_spec => true do
 
   context '#attributes' do
     it "maps field names to attribute values" do
-      example_inst = subject.receive({:my_field=>7, :str_field=>'yo', :sym_field=>:sup})
+      example_inst = simple_model.receive({:my_field=>7, :str_field=>'yo', :sym_field=>:sup})
       example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>:sup}
     end
     it "includes all field names, set and unset" do
@@ -101,8 +118,8 @@ describe Gorillib::Model, :model_spec => true do
       example_inst.attributes.should == {:my_field=>'int', :str_field=>'str', :sym_field=>'sym'}
     end
     it "is an empty hash if there are no fields" do
-      subject = Class.new{ include Gorillib::Model }
-      subject.new.attributes.should == {}
+      model_with_no_fields = Class.new{ include Gorillib::Model }
+      model_with_no_fields.new.attributes.should == {}
     end
   end
 
@@ -116,9 +133,6 @@ describe Gorillib::Model, :model_spec => true do
       example_inst.unset_attribute(:my_field ).should == 69
       example_inst.unset_attribute(:str_field).should == nil
     end
-    it "raises an error if the field does not exist" do
-      ->{ example_inst.unset_attribute(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
-    end
   end
 
   context '#update_attributes' do
@@ -160,8 +174,8 @@ describe Gorillib::Model, :model_spec => true do
   end
 
   context '#== -- two models are equal if' do
-    let(:subklass){ Class.new(subject) }
-    let(:obj_2){ subject.receive(:my_field => 69) }
+    let(:subklass){ Class.new(described_class) }
+    let(:obj_2){ described_class.receive(:my_field => 69) }
     let(:obj_3){ subklass.receive(:my_field => 69) }
 
     it 'they have the same class' do
@@ -172,7 +186,7 @@ describe Gorillib::Model, :model_spec => true do
     end
     it 'and the same attributes' do
       example_inst.attributes.should == obj_2.attributes
-      example_inst.should     == obj_2
+      example_inst.should            == obj_2
       obj_2.my_field = 100
       example_inst.should_not == obj_2
     end
@@ -180,80 +194,48 @@ describe Gorillib::Model, :model_spec => true do
 
   context ".fields" do
     it 'is a hash of Gorillib::Model::Field objects' do
-      subject.fields.keys.should  == [:my_field, :str_field, :sym_field]
-      subject.fields.values.each{|f| f.should be_a(Gorillib::Model::Field) }
-      subject.fields.values.map(&:name).should == [:my_field, :str_field, :sym_field]
+      described_class.fields.keys.should  == [:my_field, :str_field, :sym_field]
+      described_class.fields.values.each{|f| f.should be_a(Gorillib::Model::Field) }
+      described_class.fields.values.map(&:name).should == [:my_field, :str_field, :sym_field]
     end
   end
 
   context '.has_field?' do
     it 'is true if the field exists' do
-      complex_class.has_field?(  :my_field).should be_true
-      complex_subclass.has_field?(:my_field).should be_true
-      complex_subclass.has_field?(:zyzzyva ).should be_true
+      simple_model.has_field?(  :my_field).should be_true
+      subclassed_model.has_field?(:my_field).should be_true
+      subclassed_model.has_field?(:zyzzyva ).should be_true
     end
     it 'is false if it does not exist' do
-      complex_class.has_field?(  :zyzzyva).should be_false
-      complex_class.has_field?(  :fnord  ).should be_false
-      complex_subclass.has_field?(:fnord  ).should be_false
+      simple_model.has_field?(  :zyzzyva).should be_false
+      simple_model.has_field?(  :fnord  ).should be_false
+      subclassed_model.has_field?(:fnord  ).should be_false
     end
   end
 
   context '.field_names' do
     it 'lists fields in order by class, then in order added' do
-      subject.field_names.should   == [:my_field, :str_field, :sym_field]
-      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
-      subject.field :banksy, String
-      subject.field_names.should   == [:my_field, :str_field, :sym_field, :banksy ]
-      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
+      described_class.field_names.should   == [:my_field, :str_field, :sym_field]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
+      described_class.field :banksy, String
+      described_class.field_names.should   == [:my_field, :str_field, :sym_field, :banksy ]
+      subclassed_model.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
     end
   end
 
   context '.typename' do
     it 'has a typename that matches its underscored class name' do
-      subject.typename.should == 'gorillib.test.complex_model'
-    end
-  end
-
-  context '.receive' do
-    it 'creates a new instance' do
-      obj = example_inst
-      subject.should_receive(:new).with().and_return(obj)
-      result = subject.receive(:my_field => 12)
-      result.should equal(obj)
-      result.my_field.should == 12
-    end
-    it 'calls receive! to set the attributes, and returns the object' do
-      obj = example_inst
-      subject.should_receive(:new).with().and_return(obj)
-      obj.should_receive(:receive!).with(:my_field => 12)
-      subject.receive(:my_field => 12).should equal(obj)
-    end
-
-    it 'uses the given type if the _type attribute is a factory' do
-      obj = complex_class.receive(:my_field => 12, :acme => 3, :_type => complex_subclass)
-      obj.should be_a(complex_subclass)
-    end
-
-    it 'complains if the given type is not right' do
-      mock_factory = mock ; mock_factory.stub(:receive! => {}, :receive => mock, :new => mock_factory)
-      mock_factory.should_receive(:<=).and_return(false)
-      complex_class.should_receive(:warn).with(/doesn't match type/)
-      complex_class.receive(:my_field => 12, :acme => 3, :_type => mock_factory)
-    end
-
-    it 'uses the given type if the _type attribute is a typename' do
-      complex_subclass.typename.should == 'gorillib.test.test_subclass'
-      obj = complex_class.receive(:my_field => 12, :acme => 3, :_type => 'gorillib.test.test_subclass')
-      obj.should be_a(complex_subclass)
+      described_class.typename.should == 'gorillib.test.simple_model'
     end
   end
 
   describe Gorillib::Model::NamedSchema do
-    subject{ simple_model }
     context ".meta_module" do
+      let(:basic_field_names){ [ :my_field, :my_field=, :receive_my_field, :receive_str_field, :receive_sym_field, :str_field, :str_field=, :sym_field, :sym_field= ]}
+      let(:anon_class){    Class.new{ include Gorillib::Model ; field :my_field, :whatever } }
+
       it "is named for the class (if the class is named)" do
-        subject.send(:meta_module).should == Meta::Gorillib::Test::TestClassType
+        described_class.send(:meta_module).should == Meta::Gorillib::Test::SimpleModelType
       end
       it "is anonymous if the class is anonymous" do
         anon_class.name.should be_nil
@@ -261,19 +243,19 @@ describe Gorillib::Model, :model_spec => true do
         anon_class.send(:meta_module).name.should be_nil
       end
       it "carries the field-specfic accessor and receive methods" do
-        subject.send(:meta_module).public_instance_methods.sort.should    == [:my_field, :my_field=, :receive_my_field]
-        anon_class.send(:meta_module).public_instance_methods.sort.should == [:my_field, :my_field=, :receive_my_field]
+        described_class.send(:meta_module).public_instance_methods.sort.should == basic_field_names
+        anon_class.send(:meta_module).public_instance_methods.sort.should      == [:my_field, :my_field=, :receive_my_field]
       end
       it "is injected right after the Gorillib::Model module" do
-        subject.ancestors.first(4).should == [subject, Meta::Gorillib::Test::TestClassType, Gorillib::Model, Object]
-        subject.should < Meta::Gorillib::Test::TestClassType
+        described_class.ancestors.first(4).should == [described_class, Meta::Gorillib::Test::SimpleModelType, Gorillib::Model, Object]
+        described_class.should < Meta::Gorillib::Test::SimpleModelType
       end
       it "retrieves an existing named module if one exists" do
         Gorillib::Test.should_not be_const_defined(:TestClass)
-        module Meta::Gorillib::Test::TestClassType ; def kilroy_was_here() '23 skidoo' ; end ; end
-        subject.send(:meta_module).public_instance_methods.sort.should == [:kilroy_was_here, :my_field, :my_field=, :receive_my_field]
-        Gorillib::Test.should be_const_defined(:TestClass)
-        subject.send(:meta_module).should == Meta::Gorillib::Test::TestClassType
+        module Meta::Gorillib::Test::SimpleModelType ; def kilroy_was_here() '23 skidoo' ; end ; end
+        described_class.send(:meta_module).public_instance_methods.sort.should == (basic_field_names + [:kilroy_was_here]).sort
+        Gorillib::Test.should be_const_defined(:SimpleModel)
+        described_class.send(:meta_module).should == Meta::Gorillib::Test::SimpleModelType
       end
     end
   end

data/spec/spec_helper.rb

@@ -12,8 +12,9 @@ $LOAD_PATH.unshift(GORILLIB_ROOT_DIR('lib'))
 $LOAD_PATH.unshift(GORILLIB_ROOT_DIR('spec/support'))
 require 'gorillib_test_helpers'
 Dir[GORILLIB_ROOT_DIR('spec/support/matchers/*.rb')].each {|f| require f}
-Dir[GORILLIB_ROOT_DIR('spec/support/shared_examples/*.rb')].each {|f| require f}
 
 RSpec.configure do |config|
   include Gorillib::TestHelpers
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
 end

data/spec/support/gorillib_test_helpers.rb

@@ -1,6 +1,83 @@
 require 'gorillib/utils/capture_output'
 require 'gorillib/utils/nuke_constants'
 
+shared_examples_for 'a model' do
+
+  context 'initialize' do
+    it "has no required args" do
+      obj = smurf_class.new
+      obj.compact_attributes.should == {}
+    end
+    it "takes the last hashlike arg as the attributes" do
+      obj = smurf_class.new :smurfiness => 3, :weapon => :smurfchucks
+      obj.compact_attributes.should == { :smurfiness => 3, :weapon => :smurfchucks }
+    end
+    it "takes all preceding args as positional, clobbering values set in attrs" do
+      obj = smurf_class.new 7,   :smurfing_stars
+      obj.compact_attributes.should == { :smurfiness => 7, :weapon => :smurfing_stars }
+      obj = smurf_class.new 7,   :smurfing_stars, :smurfiness => 3, :weapon => :smurfchucks
+      obj.compact_attributes.should == { :smurfiness => 7, :weapon => :smurfing_stars }
+    end
+    it "does nothing special with a nil positional arg -- it clobbers anything there setting the attribute to nil" do
+      obj = smurf_class.new nil, :smurfiness => 3
+      obj.compact_attributes.should == { :smurfiness => nil }
+    end
+    it "raises an error if too many positional args are given" do
+      ->{ smurf_class.new 7, :smurfing_stars, :azrael }.should raise_error(ArgumentError, /wrong number of arguments.*3.*0\.\.2/)
+    end
+    it "always takes the last hash arg as the attrs -- even if it is in the positional slot of a hash field" do
+      smurf_class.field :hashie, Hash
+      obj = smurf_class.new({:smurfiness => 3, :weapon => :smurfchucks})
+      obj.compact_attributes.should == { :smurfiness => 3, :weapon => :smurfchucks }
+      obj = smurf_class.new(3, :smurfchucks, { :weapon => :bastard_smurf })
+      obj.compact_attributes.should == { :smurfiness => 3, :weapon => :smurfchucks }
+      obj = smurf_class.new(3, :smurfchucks, {:this => :that}, { :weapon => :bastard_smurf })
+      obj.compact_attributes.should == { :smurfiness => 3, :weapon => :smurfchucks, :hashie => {:this => :that} }
+    end
+  end
+
+  context 'receive' do
+    let(:my_attrs){ { :smurfiness => 900, :weapon => :wood_smurfer } }
+    let(:subklass){ class ::Gorillib::Test::SubSmurf < smurf_class ; end ; ::Gorillib::Test::SubSmurf }
+
+    it "returns nil if given a single nil arg" do
+      smurf_class.receive(nil).should == nil
+    end
+    it "returns the object if given a single object of the model class" do
+      smurf_class.receive(poppa_smurf).should equal(poppa_smurf)
+    end
+    it "raises an error if the attributes are not hashlike" do
+      ->{ smurf_class.receive('DURRRR') }.should raise_error(ArgumentError, /attributes .* like a hash: "DURRRR"/)
+    end
+    context "with hashlike args," do
+      before{ Gorillib::Factory.send(:factories).reject!{|th, type| th.to_s =~ /gorillib\.test/ }}
+
+      it "instantiates the object, passing it the attrs and block" do
+        my_attrs = { :smurfiness => 900, :weapon => :wood_smurfer }
+        smurf_class.should_receive(:new).with(my_attrs)
+        smurf_class.receive(my_attrs)
+      end
+      it "retrieves the right factory if :_type is present" do
+        my_attrs = self.my_attrs.merge(:_type => 'gorillib.test.smurf')
+        smurf_class.should_receive(:new).with(my_attrs)
+        smurf_class.receive(my_attrs)
+      end
+      it "retrieves the right factory if :_type is present" do
+        my_attrs = self.my_attrs.merge(:_type => 'gorillib.test.sub_smurf')
+        subklass.should_receive(:new).with(my_attrs)
+        smurf_class.receive(my_attrs)
+      end
+      it 'complains if the given type is not right' do
+        mock_factory = mock ; mock_factory.stub(:receive! => {}, :receive => mock, :new => mock_factory)
+        mock_factory.should_receive(:<=).and_return(false)
+        smurf_class.should_receive(:warn).with(/factory .* is not a type of Gorillib::Test::Smurf/)
+        smurf_class.receive(:my_field => 12, :acme => 3, :_type => mock_factory)
+      end
+    end
+  end
+end
+
+
 shared_examples_for "a model field" do |field_name|
   it('gives the model a field'){ subject.class.should have_field(field_name) }
 
@@ -10,12 +87,11 @@ shared_examples_for "a model field" do |field_name|
       subject.read_attribute(field_name).should == sample_val
     end
     it "if unset, calls #read_unset_attribute" do
-      mock_val = mock
       subject.should_receive(:read_unset_attribute).with(field_name).and_return(mock_val)
       subject.read_attribute(field_name).should == mock_val
     end
-    it "raises an error if the field does not exist" do
-      ->{ subject.read_attribute(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    it "does **not** raise an error if the field does not exist (require 'model/lint' if you want it to)" do
+      ->{ subject.read_attribute(:fnord) }.should_not raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
     end
   end
 
@@ -27,8 +103,8 @@ shared_examples_for "a model field" do |field_name|
     it('returns the new value') do
       subject.write_attribute(field_name, sample_val).should == sample_val
     end
-    it "raises an error if the field does not exist" do
-      ->{ subject.write_attribute(:fnord, 8) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    it "does **not** raise an error if the field does not exist (require 'model/lint' if you want it to)" do
+      ->{ subject.write_attribute(:fnord, 8) }.should_not raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
     end
   end
 
@@ -44,8 +120,8 @@ shared_examples_for "a model field" do |field_name|
     it('is false if never written') do
       subject.attribute_set?(field_name).should be_false
     end
-    it "raises an error if the field does not exist" do
-      ->{ subject.attribute_set?(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    it "does **not** raise an error if the field does not exist (require 'model/lint' if you want it to)" do
+      ->{ subject.attribute_set?(:fnord) }.should_not raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
     end
   end
 

data/spec/support/model_test_helpers.rb

@@ -4,34 +4,15 @@ module Meta ; module Gorillib ; module Test ; end ; end ; end
 shared_context 'model', :model_spec => true do
   after(:each){ Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
 
-  let(:smurf_klass) do
-    class Gorillib::Test::Smurf
-      include Gorillib::Model
-
-      field :smurfiness, Integer
-      field :weapon,     Symbol
-    end
-    Gorillib::Test::Smurf
-  end
-
-  let(:smurfette_klass) do
-    class Gorillib::Test::Smurfette < smurf_klass
-      field :blondness, Boolean
-    end
-    Gorillib::Test::Smurfette
-  end
-
-  let(:poppa_smurf  ){ smurf_klass.receive(:name => 'Poppa Smurf',   :smurfiness => 9, :weapon => 'staff') }
-  let(:smurfette    ){ smurf_klass.receive(:name => 'Smurfette',     :smurfiness => 11, :weapon => 'charm') }
-  let(:generic_smurf){ smurf_klass.receive(:name => 'Generic Smurf', :smurfiness => 2, :weapon => 'fists') }
+  let(:mock_val){ mock('mock value') }
 
   let(:engine_class) do
     class Gorillib::Test::Engine
       include Gorillib::Builder
-      field    :name,         Symbol, :default => ->{ "#{owner? ? owner.name : ''} engine"}
-      field    :carburetor,   Symbol, :default => :stock
-      field    :volume,       Integer, :doc => 'displacement volume, in in^3'
-      field    :cylinders,    Integer
+      magic    :name,         Symbol, :default => ->{ "#{owner? ? owner.name : ''} engine"}
+      magic    :carburetor,   Symbol, :default => :stock
+      magic    :volume,       Integer, :doc => 'displacement volume, in in^3'
+      magic    :cylinders,    Integer
       member   :owner,        Whatever
       self
     end
@@ -42,10 +23,10 @@ shared_context 'model', :model_spec => true do
     engine_class
     class Gorillib::Test::Car
       include Gorillib::Builder
-      field    :name,          Symbol
-      field    :make_model,    String
-      field    :year,          Integer
-      field    :doors,         Integer
+      magic    :name,          Symbol
+      magic    :make_model,    String
+      magic    :year,          Integer
+      magic    :doors,         Integer
       member   :engine,        Gorillib::Test::Engine
       self
     end