gorillib-model 0.0.1

data/spec/model/factories_spec.rb

@@ -0,0 +1,323 @@
+require 'spec_helper'
+
+describe '', :model_spec => true, :factory_spec => true do
+
+  describe Gorillib::Factory do
+    describe 'Factory()' do
+      it 'turns a proc into an ApplyProcFactory' do
+        ff = Gorillib::Factory( ->(obj){ "bob says #{obj}" } )
+        ff.receive(3).should == "bob says 3"
+      end
+      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 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 be_a(Gorillib::Factory::SymbolFactory)
+        Gorillib::Factory(:identical).should == (::Whatever)
+      end
+      it 'looks up factories by class' do
+        Gorillib::Factory(Symbol).should be_a(Gorillib::Factory::SymbolFactory)
+        Gorillib::Factory(String).should be_a(Gorillib::Factory::StringFactory)
+      end
+      it 'calls Gorillib::Factory.lookup' do
+        x = double
+        Gorillib::Factory.should_receive(:find).with(x)
+        Gorillib::Factory(x)
+      end
+    end
+  end
+
+  # __________________________________________________________________________
+  #
+  #
+  #
+  describe Gorillib::Factory::StringFactory do
+    it_behaves_like :it_considers_native,   'foo', ''
+    it_behaves_like :it_converts,           :foo => 'foo', 3 => '3', false => "false", [] => "[]"
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_is_registered_as, :string, String
+    its(:typename){ should == :string }
+  end
+
+  describe Gorillib::Factory::SymbolFactory do
+    it_behaves_like :it_considers_native,   :foo, :"symbol :with weird chars"
+    it_behaves_like :it_converts,           'foo' => :foo
+    it_behaves_like :it_considers_blankish, nil, ""
+    it_behaves_like :it_is_a_mismatch_for,  3, false, []
+    it_behaves_like :it_is_registered_as, :symbol, Symbol
+    its(:typename){ should == :symbol }
+  end
+
+  describe Gorillib::Factory::RegexpFactory do
+    it_behaves_like :it_considers_native,   /foo/, //
+    it_behaves_like :it_converts,           'foo' => /foo/,  ".*" => /.*/
+    it_behaves_like :it_considers_blankish, nil, ""
+    it_behaves_like :it_is_a_mismatch_for,  :foo, 3, false, []
+    it_behaves_like :it_is_registered_as, :regexp, Regexp
+    its(:typename){ should == :regexp }
+  end
+
+  describe Gorillib::Factory::IntegerFactory do
+    it_behaves_like :it_considers_native,   1, -1, 123_456_789_123_456_789_123_456_789_123_456_789
+    #
+    it_behaves_like :it_converts,           '1'   => 1,   '0'   => 0,   '1234567'   => 1234567
+    it_behaves_like :it_converts,           '123456789123456789123456789123456789' => 123_456_789_123_456_789_123_456_789_123_456_789
+    it_behaves_like :it_converts,           '1_234_567'  => 1234567
+    it_behaves_like :it_converts,            1.0  => 1,   1.99  => 1,   -0.9 =>  0
+    it_behaves_like :it_converts,            Complex(1,0) => 1, Complex(1.0,0) => 1, Rational(5,2) => 2
+    #
+    it_behaves_like :it_considers_blankish,  nil, ''
+    it_behaves_like :it_is_a_mismatch_for,   Complex(1,0.0), Complex(0,3), :foo, false, []
+    it_behaves_like :it_is_a_mismatch_for,  '8_',          'one',         '3blindmice',        '_8_'
+    it_behaves_like :it_is_a_mismatch_for,   Float::INFINITY, Float::NAN
+    # Does not accept floating-point-ish
+    it_behaves_like :it_is_a_mismatch_for,  '1.0',       '0.0',       '1234567.0'
+    it_behaves_like :it_is_a_mismatch_for,  '1e5',       '1_234_567e-3',         '1_234_567.0', '+11.123E+12'
+    # Handles hex
+    it_behaves_like :it_converts,           '011' =>  9,   '0x10' => 16
+    # Intolerant of cruft, unlike GraciousIntegerFactory
+    it_behaves_like :it_is_a_mismatch_for,  '0L',          '1_234_567L',              '1_234_567e-3f', '1,234,567'
+    #
+    it_behaves_like :it_is_registered_as, :int, :integer, Integer
+    its(:typename){ should == :integer }
+  end
+
+  describe Gorillib::Factory::GraciousIntegerFactory do
+    it_behaves_like :it_considers_native,   1, -1, 123_456_789_123_456_789_123_456_789_123_456_789
+    #
+    it_behaves_like :it_converts,           '1'   => 1,    '0'   => 0,   '1234567'   => 1234567
+    it_behaves_like :it_converts,           '123456789123456789123456789123456789' => 123_456_789_123_456_789_123_456_789_123_456_789
+    it_behaves_like :it_converts,           '1_234_567'  => 1234567
+    it_behaves_like :it_converts,            1.0  => 1,   1.99  => 1,   -0.9 =>  0
+    it_behaves_like :it_converts,            Complex(1,0) => 1, Complex(1.0,0) => 1, Rational(5,2) => 2
+    #
+    it_behaves_like :it_considers_blankish,  nil, ''
+    it_behaves_like :it_is_a_mismatch_for,   Complex(1,0.0), Complex(0,3), :foo, false, []
+    it_behaves_like :it_is_a_mismatch_for,  '8_',          'one',         '3blindmice',        '_8_'
+    it_behaves_like :it_is_a_mismatch_for,   Float::INFINITY, Float::NAN
+    # Handles floating-point well
+    it_behaves_like :it_converts,           '1.0' => 1,    '0.0' => 0,   '1234567.0' => 1234567
+    it_behaves_like :it_converts,           '1e5' => 100000, '1_234_567e-3' => 1234,  '1_234.5e3' => 1_234_500, '+11.123E+12' => 11_123_000_000_000
+    # Silently confuses hex and octal
+    it_behaves_like :it_converts,           '011' =>  9,   '0x10' => 16, '0x1.999999999999ap4' => 25
+    # Tolerates some cruft, unlike IntegerFactory
+    it_behaves_like :it_converts,           '0L'  => 0,    '1_234_567L' => 1234567,    '1234.5e3f' => 1_234_500,    '1234567e-3f' => 1_234
+    it_behaves_like :it_converts,           '1,234,567'  => 1234567, ',,,,1,23,45.67e,-1,' => 1234
+    #
+    it_behaves_like :it_is_registered_as, :gracious_int
+    its(:typename){ should == :integer }
+  end
+
+  describe Gorillib::Factory::FloatFactory do
+    it_behaves_like :it_considers_native,   1.0, 1.234567e6, 123_456_789_123_456_789_123_456_789_123_456_789.0
+    it_behaves_like :it_considers_native,   Float::INFINITY, Float::NAN
+    it_behaves_like :it_converts,           '1'   => 1.0, '0'   => 0.0, '1234567'   => 1234567.0
+    it_behaves_like :it_converts,           '1.0' => 1.0, '0.0' => 0.0, '1234567.0' => 1234567.0
+    it_behaves_like :it_converts,           '123456789123456789123456789123456789' => 123_456_789_123_456_789_123_456_789_123_456_789.0
+    it_behaves_like :it_converts,           '1_234_567'  => 1234567.0
+    it_behaves_like :it_converts,            1    => 1.0
+    it_behaves_like :it_converts,            Complex(1,0) => 1.0, Complex(1.0,0) => 1.0, Rational(5,2) => 2.5
+    it_behaves_like :it_converts,           '1e5' => 1e5,  '1_234_567e-3' => 1234.567, '1_234_567.0' => 1234567.0, '+11.123E+700' => 11.123e700
+    #
+    it_behaves_like :it_considers_blankish,  nil, ''
+    it_behaves_like :it_is_a_mismatch_for,   Complex(1,0.0), Complex(0,3), :foo, false, []
+    #
+    # Different from #to_f
+    it_behaves_like :it_converts,           '011' => 11.0, '0x10' => 16.0, '0x1.999999999999ap4' => 25.6
+    it_behaves_like :it_is_a_mismatch_for,  '0L',          '1_234_567L',              '1_234_567e-3f'
+    it_behaves_like :it_is_a_mismatch_for,  '_8_',          'one',         '3blindmice',        '8_'
+    #
+    it_behaves_like :it_is_registered_as, :float, Float
+    its(:typename){ should == :float }
+  end
+
+  describe Gorillib::Factory::GraciousFloatFactory do
+    it_behaves_like :it_considers_native,   1.0, 1.234567e6, 123_456_789_123_456_789_123_456_789_123_456_789.0
+    it_behaves_like :it_converts,           '1'   => 1.0, '0'   => 0.0, '1234567'   => 1234567.0
+    it_behaves_like :it_converts,           '1.0' => 1.0, '0.0' => 0.0, '1234567.0' => 1234567.0
+    it_behaves_like :it_converts,           '123456789123456789123456789123456789' => 123_456_789_123_456_789_123_456_789_123_456_789.0
+    it_behaves_like :it_converts,           '1_234_567'  => 1234567.0
+    it_behaves_like :it_converts,            1    => 1.0
+    it_behaves_like :it_converts,            Complex(1,0) => 1.0, Complex(1.0,0) => 1.0, Rational(5,2) => 2.5
+    it_behaves_like :it_converts,           '1e5' => 1e5,  '1_234_567e-3' => 1234.567, '1_234_567.0' => 1234567.0, '+11.123E+700' => 11.123e700
+    #
+    it_behaves_like :it_considers_blankish,  nil, ''
+    it_behaves_like :it_is_a_mismatch_for,   Complex(1,0.0), Complex(0,3), :foo, false, []
+    #
+    # Different from stricter FloatFactory or laxer #to_f
+    it_behaves_like :it_converts,           '011' => 11.0, '0x10' => 16.0, '0x1.999999999999ap4' => 25.6
+    it_behaves_like :it_converts,           '0L'  => 0.0,  '1_234_567L' => 1234567.0, '1_234_567e-3f' => 1234.567
+    it_behaves_like :it_is_a_mismatch_for,  '_8_',         'one',         '3blindmice',        '8_'
+    it_behaves_like :it_converts,           '1,234,567e-3' => 1234.567, ',,,,1,23,45.67e,-1,' => 1234.567, '+11.123E+700' => 11.123e700
+    #
+    it_behaves_like :it_is_registered_as, :gracious_float
+    its(:typename){ should == :float }
+  end
+
+  describe Gorillib::Factory::ComplexFactory do
+    cplx0 = Complex(0) ; cplx1 = Complex(1) ; cplx1234500 = Complex(1_234_500,0) ; cplx1234500f = Complex(1_234_500.0,0) ;
+    it_behaves_like :it_considers_native,   Complex(1,3), Complex(1,0)
+    it_behaves_like :it_converts,           '1234.5e3' => cplx1234500f, '1234500' => cplx1234500, '0' => cplx0
+    it_behaves_like :it_converts,           1234.5e3 => cplx1234500f,   1 => cplx1,  -1 => Complex(-1), Rational(3,2) => Complex(Rational(3,2),0)
+    it_behaves_like :it_converts,           [1,0] => Complex(1),       [1,2] => Complex(1,2)
+    it_behaves_like :it_converts,           ['1234.5e3','98.6'] => Complex(1234.5e3, 98.6)
+    it_behaves_like :it_considers_blankish, nil, ''
+    it_behaves_like :it_is_a_mismatch_for,  'one', '3blindmice', '0x10', '1234.5e3f', '1234L', :foo, false, []
+    it_behaves_like :it_is_registered_as, :complex, Complex
+    its(:typename){ should == :complex }
+  end
+
+  describe Gorillib::Factory::RationalFactory do
+    rat_0 = Rational(0) ; rat1 = Rational(1) ; rat3_2 = Rational(3, 2) ;
+    it_behaves_like :it_considers_native,   Rational(1, 3), Rational(1, 7)
+    it_behaves_like :it_converts,           '1.5' => rat3_2, '1' => rat1, '0' => rat_0, '1_234_567' => Rational(1234567), '1_234_567.0' => Rational(1234567)
+    it_behaves_like :it_converts,            1.5  => rat3_2,  1  => rat1,  -1 => Rational(-1), Complex(1.5) => rat3_2
+    it_behaves_like :it_considers_blankish, nil, ''
+    it_behaves_like :it_is_a_mismatch_for,  'one', '3blindmice', '0x10', '1234.5e3f', '1234L', :foo, false, [], Complex(1.5,3)
+    it_behaves_like :it_is_registered_as, :rational, Rational
+    its(:typename){ should == :rational }
+  end
+
+  describe Gorillib::Factory::TimeFactory do
+    fuck_wit_dre_day   = Time.new(1993, 2, 18, 8, 8, 0, '-08:00')  # and Everybody's Celebratin'
+    ice_cubes_good_day = Time.utc(1992, 1, 20, 0, 0, 0)
+    it_behaves_like :it_considers_native,   Time.now.utc, ice_cubes_good_day
+    it_behaves_like :it_converts,           fuck_wit_dre_day => fuck_wit_dre_day.getutc
+    it_behaves_like :it_converts,           '19930218160800' => fuck_wit_dre_day.getutc, '19920120000000Z' => ice_cubes_good_day
+    it_behaves_like :it_converts,           Date.new(1992, 1, 20) => ice_cubes_good_day
+    before('behaves like it_converts "an unparseable time" to nil'){ subject.stub(:warn) }
+    it_behaves_like :it_converts,           "an unparseable time" => nil, :non_native_ok => true
+    it_behaves_like :it_considers_blankish, nil, ''
+    it_behaves_like :it_is_a_mismatch_for,  :foo, false, []
+    it_behaves_like :it_is_registered_as,   :time, Time
+    it('always returns a UTC timezoned time') do
+      subject.convert(fuck_wit_dre_day).utc_offset.should == 0
+      fuck_wit_dre_day.utc_offset.should == (-8 * 3600)
+    end
+    its(:typename){ should == :time }
+  end
+
+  describe Gorillib::Factory::BooleanFactory do
+    it_behaves_like :it_considers_native,   true, false
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_converts,           'false' => false, :false => false
+    it_behaves_like :it_converts,           'true' => true,   :true  => true, '0' => true, 0 => true, [] => true, :foo => true, [] => true, Complex(1.5,3) => true, Object.new => true
+    it_behaves_like :it_is_registered_as, :boolean
+    its(:typename){ should == :boolean }
+  end
+
+  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 '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 Gorillib::Factory::IdenticalFactory do
+    it{ described_class.should equal(Whatever) }
+  end
+
+  describe Gorillib::Factory::ModuleFactory do
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_considers_native,  Module, Module.new, Class, Class.new, Object, String, BasicObject
+    it_behaves_like :it_is_a_mismatch_for, true, false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' },             Complex(1,3), Object.new
+    it_behaves_like :it_is_registered_as, :module, Module
+    its(:typename){ should == :module }
+  end
+
+  describe Gorillib::Factory::ClassFactory do
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_considers_native,  Module, Class, Class.new, Object, String, BasicObject
+    it_behaves_like :it_is_a_mismatch_for, true, false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
+    it_behaves_like :it_is_registered_as, :class, Class
+    its(:typename){ should == :class }
+  end
+
+  describe Gorillib::Factory::NilFactory do
+    it_behaves_like :it_considers_native,  nil
+    it_behaves_like :it_is_a_mismatch_for, true, false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
+    it_behaves_like :it_is_registered_as, :nil, NilClass
+    its(:typename){ should == :nil_class }
+  end
+
+  describe Gorillib::Factory::TrueFactory do
+    it_behaves_like :it_considers_native,  true
+    it_behaves_like :it_is_a_mismatch_for,       false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
+    it_behaves_like :it_is_registered_as, :true, TrueClass
+  end
+
+  describe Gorillib::Factory::FalseFactory do
+    it_behaves_like :it_considers_native,  false
+    it_behaves_like :it_is_a_mismatch_for, true,        3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
+    it_behaves_like :it_is_registered_as, :false, FalseClass
+  end
+
+  describe Gorillib::Factory::RangeFactory do
+    it_behaves_like :it_considers_blankish, nil, []
+    it_behaves_like :it_considers_native,  (1..2), ('a'..'z')
+    it_behaves_like :it_is_a_mismatch_for, true,        3, '', 'a string', :a_symbol, [1,2], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
+    it_behaves_like :it_is_registered_as, :range, Range
+    its(:typename){ should == :range }
+  end
+
+  # __________________________________________________________________________
+
+  describe Gorillib::Factory::HashFactory do
+    let(:collection_123){   { 'a' => 1, :b => 2, 'c' => 3 } }
+    let(:empty_collection){ {} }
+
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_converts, { {} => {}, { "a" => 2 } => { 'a' => 2 }, { :a => 2 } => { :a => 2 }, :non_native_ok => true }
+    it_behaves_like :it_is_a_mismatch_for, [1,2,3]
+    it_behaves_like :an_enumerable_factory
+
+    it 'follows examples' do
+      described_class.new.receive(collection_123).should == { 'a' => 1, :b => 2, 'c' => 3}
+      described_class.new(:keys  => :symbol).receive({'a' => 'x', :b => 'y', 'c' => :z}).should == {:a  => 'x', :b => 'y', :c  => :z}
+      described_class.new(:items => :symbol).receive({'a' => 'x', :b => 'y', 'c' => :z}).should == {'a' => :x,  :b => :y,  'c' => :z}
+      autov_factory = described_class.new(:empty_product => Hash.new{|h,k| h[k] = {} })
+      result = autov_factory.receive({:a => :b})  ; result.should == { :a => :b }
+      result[:flanger][:modacity] = 11            ; result.should == { :a => :b,  :flanger => { :modacity => 11 }}
+      result2 = autov_factory.receive({:x => :y}) ; result2.should == { :x => :y } ; result.should == { :a => :b,  :flanger => { :modacity => 11 }}
+    end
+
+    it "accepts a factory for the keys" do
+      mock_factory = double('factory')
+      mock_factory.should_receive(:receive).with(3).and_return("converted!")
+      factory = described_class.new(:keys => mock_factory)
+      factory.receive( { 3 => 4 } ).should == { 'converted!' => 4 }
+    end
+    it_behaves_like :it_is_registered_as, :hash, Hash
+    its(:typename){ should == :hash }
+  end
+
+  describe Gorillib::Factory::ArrayFactory do
+    let(:collection_123){ [1,2,3] }
+    let(:empty_collection){ [] }
+
+    it 'follows examples' do
+      described_class.new.receive([1,2,3]).should == [1,2,3]
+      described_class.new(:items         => :symbol).receive(['a', 'b', :c]).should == [:a, :b, :c]
+      described_class.new(:empty_product => [1,2,3]).receive([:a,  :b,  :c]).should == [1, 2, 3, :a, :b, :c]
+    end
+
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_converts, { [] => [], {} => [], [1,2,3] => [1,2,3], {:a => :b} => [[:a, :b]], [:a] => [:a], [[]] => [[]], :non_native_ok => true }
+    it_behaves_like :an_enumerable_factory
+    it_behaves_like :it_is_registered_as, :array, Array
+    its(:typename){ should == :array }
+  end
+
+end

data/spec/model/lint_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+require 'gorillib/model/lint'
+
+describe Gorillib::Model::Lint, :model_spec => true do
+  subject do
+    klass = Class.new{ include Gorillib::Model ; include Gorillib::Model::Lint ; field :bob, Integer }
+    klass.new
+  end
+
+  context '#read_attribute' do
+    it "raises an error if the field does not exist" do
+      ->{ subject.read_attribute(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    end
+  end
+
+  context '#write_attribute' do
+    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/)
+    end
+  end
+
+  context '#attribute_set?' do
+    it "raises an error if the field does not exist" do
+      ->{ subject.attribute_set?(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    end
+  end
+end

data/spec/model/serialization/csv_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'gorillib/model/serialization'
+
+describe Gorillib::Model::LoadFromCsv, :model_spec => true, :builder_spec => true do
+
+  context ".load_csv" do
+
+    let(:expected_engine) do 
+      {:name=>:Wankel, :carburetor=>:no, :volume=>1, :cylinders=>982, :owner=>"who_am_i"}
+    end
+
+    before :each do
+      engine_class.class_eval { include Gorillib::Model::LoadFromCsv }
+      csv_file = double('csv_file')
+      csv_file.stub(:shift) {}
+      csv_file.stub(:each).and_yield(expected_engine.values)
+      CSV.should_receive(:open).and_yield(csv_file)
+    end
+
+    it "loads from file" do
+      engine_class.load_csv('test').to_wire().first.keep_if{|k,| k != :_type}.should
+        eql(expected_engine)
+     end
+
+     it "loads from file with block" do
+       expect { |b| engine_class.load_csv('test', &b) }.to yield_with_args(engine_class)
+     end
+  end
+end

data/spec/model/serialization/tsv_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+require 'gorillib/model/serialization'
+
+describe Gorillib::Model::LoadFromTsv, :model_spec => true, :builder_spec => true do
+
+  context ".load_tsv" do
+
+    let(:expected_engine) do
+      {:name=>:Wankel, :carburetor=>:no, :volume=>1, :cylinders=>982, :owner=>"who_am_i"}
+    end
+
+    before :each do
+      engine_class.class_eval { include Gorillib::Model::LoadFromTsv }
+      engine_class.should_receive(:_each_raw_line).with(:test, {}).
+        and_yield(expected_engine.values.join("\t"))
+    end
+
+    it "loads from file" do
+      engine_class.load_tsv(:test).to_wire().first.keep_if{|k,| k != :_type}.should
+        eql(expected_engine)
+     end
+
+     it "loads from file with block" do
+       expect { |b| engine_class.load_tsv(:test, &b) }.to yield_with_args(engine_class)
+     end
+  end
+end

data/spec/model/serialization_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+require 'gorillib/model/serialization'
+
+describe Gorillib::Model, :model_spec => true, :builder_spec => true do
+  subject do
+    garage.cars << wildcat
+    garage.cars << ford_39
+    garage
+  end
+  let :wired_garage_hash do
+    { :cars => [
+        {:name=>:wildcat, :make_model=>"Buick Wildcat",    :year=>1968, :doors=>2, :engine=>{:volume=>455, :cylinders=>8, :_type => "gorillib.test.engine"}, :_type => "gorillib.test.car"},
+        {:name=>:ford_39, :make_model=>"Ford Tudor Sedan", :year=>1939, :doors=>2, :_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"=>{"volume"=>455,"cylinders"=>8, "_type"=>"gorillib.test.engine"},"_type"=>"gorillib.test.car"}
+    end
+    it 'recursively serializes' do
+      subject.to_json.should == MultiJson.dump(wired_garage_hash)
+    end
+  end
+
+  describe 'to_wire' do
+    it 'calls to_wire recursively, passing options along' do
+      opts = {:dummy=>'options'}
+      ford_39.should_receive(:to_wire).with(opts)
+      wildcat.engine.should_receive(:to_wire).with(opts)
+      subject.to_wire(opts)
+    end
+
+    it 'returns a nested hash' do
+      subject.to_wire.should == wired_garage_hash
+    end
+    it 'aliases method as_json' do
+      subject.as_json.should == wired_garage_hash
+    end
+  end
+end

data/spec/model/type/extended_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+require 'gorillib/model/type/extended'
+
+describe ::Long do
+  it "is_a?(Integer)" do ::Long.should < ::Integer ; end
+end
+
+describe ::Double do
+  it "is_a?(Float)" do ::Double.should < ::Float ; end
+end
+
+describe ::Binary do
+  it "is_a?(String)" do ::Binary.should < ::String ; end
+end
+
+describe 'factory', :factory_spec => true do
+  describe Gorillib::Factory::DateFactory do
+    fuck_wit_dre_day   = Date.new(1993, 2, 18)  # and Everybody's Celebratin'
+    ice_cubes_good_day = Date.new(1992, 1, 20)
+    it_behaves_like :it_considers_native,   Date.today, fuck_wit_dre_day, ice_cubes_good_day
+    it_behaves_like :it_converts,           '19930218' => fuck_wit_dre_day, '19920120' => ice_cubes_good_day
+    it_behaves_like :it_converts,           Time.utc(1992, 1, 20, 8, 8, 8) => ice_cubes_good_day
+    before('behaves like it_converts "an unparseable date" to nil'){ subject.stub(:warn) }
+    it_behaves_like :it_converts,           "an unparseable date" => nil, :non_native_ok => true
+    it_behaves_like :it_considers_blankish, nil, ""
+    it_behaves_like :it_is_a_mismatch_for,  :foo, false, []
+    it_behaves_like :it_is_registered_as,   :date, Date
+    its(:typename){ should == :date }
+  end
+
+  describe Gorillib::Factory::SetFactory do
+    let(:collection_123){   Set.new([1,2,3]) }
+    let(:empty_collection){ Set.new }
+
+    it 'follows examples' do
+      described_class.new.receive([1,2,3]).should == collection_123
+      described_class.new(:items  => :symbol).receive(['a', 'b', :c]).should == [:a, :b, :c].to_set
+      described_class.new(:empty_product => [1,2,3].to_set).receive([:a,  :b,  :c]).should == [1, 2, 3, :a, :b, :c].to_set
+
+      has_an_empty_array = described_class.new.receive( [[]] )
+      has_an_empty_array.should == Set.new( [[]] )
+      has_an_empty_array.first.should == []
+      has_an_empty_array.size.should  == 1
+    end
+
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_converts, { [] => Set.new, {} => Set.new, [1,2,3] => [1,2,3].to_set, {:a => :b} => Set.new({:a => :b}), [:a] => [:a].to_set, :non_native_ok => true }
+    it_behaves_like :an_enumerable_factory
+    it_behaves_like :it_is_registered_as, :set, Set
+    its(:typename){ should == :set }
+  end
+
+  describe Gorillib::Factory::Boolean10Factory do
+    it_behaves_like :it_considers_native,   true, false
+    it_behaves_like :it_considers_blankish, nil
+    it_behaves_like :it_converts,           "false" => false, :false => false, "0" => false, 0 => false
+    it_behaves_like :it_converts,           "true" => true,   :true  => true,  "1" => true,  [] => true, :foo => true, [] => true, Complex(1.5,3) => true, Object.new => true
+    it_behaves_like :it_is_registered_as, :boolean_10
+    its(:typename){ should == :boolean_10 }
+  end
+end
+
+# describe ::Boolean, :model_spec => true do
+#   let(:true_bool ){ ::Boolean.new(true)  }
+#   let(:false_bool){ ::Boolean.new(false) }
+#
+#   def it_responds_same_as(test_obj, comparable, meth, *meth_args, &block)
+#     test_obj.send(meth, *meth_args, &block).should == comparable.send(meth, *meth_args, &block)
+#   end
+#
+#   def it_responds_with_same_contents(test_obj, comparable, meth, *meth_args, &block)
+#     test_obj.send(meth, *meth_args, &block).sort.should == comparable.send(meth, *meth_args, &block).sort
+#   end
+#
+#   it("has #class ::Boolean" ){ (true_bool.class).should == ::Boolean ; (false_bool.class).should == ::Boolean }
+#
+#   it "#is_a?(Boolean)"           do true_bool.should be_a(::Boolean)             ; false_bool.should be_a(::Boolean) ; end
+#   it "#is_a?(True/False)"        do true_bool.should be_a(::TrueClass)           ; false_bool.should be_a(::FalseClass) ; end
+#   it "#kind_of?(Boolean)"        do true_bool.should be_a_kind_of(::Boolean)     ; false_bool.should be_a_kind_of(::Boolean) ; end
+#   it "#instance_of?(True/False)" do true_bool.should be_instance_of(::TrueClass) ; false_bool.should be_instance_of(::FalseClass) ; end
+#
+#   describe 'mimics true/false' do
+#     [ :!, :to_s, :blank?, :frozen?, :nil?, :present?,
+#     ].each do |meth|
+#       it "##{meth}" do
+#         it_responds_same_as(true_bool,  true,  meth)
+#         it_responds_same_as(false_bool, false, meth)
+#       end
+#     end
+#
+#     [ :private_methods, :protected_methods, :singleton_methods,
+#     ].each do |meth|
+#       it "##{meth}" do
+#         it_responds_with_same_contents(true_bool,  true,  meth)
+#         it_responds_with_same_contents(false_bool, false, meth)
+#       end
+#     end
+#     it "#methods"        do ( true.methods         - true_bool.methods  ).should be_empty ; end
+#     it "#methods"        do ( false.methods        - false_bool.methods ).should be_empty ; end
+#     it "#public_methods" do ( true.public_methods  - true_bool.public_methods  ).should be_empty ; end
+#     it "#public_methods" do ( false.public_methods - false_bool.public_methods ).should be_empty ; end
+#
+#     it ".methods"          do (TrueClass.methods | [:true, :false, :new]).sort.should ==  Boolean.methods.sort ; end
+#
+#     { :!=           => [true, false, nil],
+#       :!~           => [true, false, nil],
+#       :&            => [true, false, nil],
+#       :<=>          => [true, false, nil],
+#       :==           => [true, false, nil],
+#       :===          => [true, false, nil],
+#       :=~           => [true, false, nil],
+#       :^            => [true, false, nil],
+#       :|            => [true, false, nil],
+#       :eql?         => [true, false, nil],
+#       :equal?       => [true, false, nil],
+#       :instance_of? => [::TrueClass, ::FalseClass, ::Object],
+#       :is_a?        => [::TrueClass, ::FalseClass, ::Object],
+#       :kind_of?     => [::TrueClass, ::FalseClass, ::Object],
+#     }.each do |meth, meth_args|
+#       meth_args.each do |meth_arg|
+#         it "##{meth}(#{meth_arg})" do
+#           it_responds_same_as(true_bool,  true,  meth, meth_arg)
+#           it_responds_same_as(false_bool, false, meth, meth_arg)
+#         end
+#       end
+#     end
+#
+#   end
+#
+#   [ :==, :===, :eql?, :equal?, :<=> ].each do |meth|
+#     it "Boolean.true #{meth} itself and true" do
+#       true_bool.send(meth,  true_bool     ).should be_true
+#       true_bool.send(meth,  Boolean.true  ).should be_true
+#       true_bool.send(meth,  true          ).should be_true
+#       true_bool.send(meth,  false_bool    ).should be_false
+#       true_bool.send(meth,  Boolean.false ).should be_false
+#       true_bool.send(meth,  false         ).should be_false
+#       true_bool.send(meth,  0             ).should be_false
+#     end
+#     it "Boolean.false #{meth} itself and false" do
+#       false_bool.send(meth, false_bool    ).should be_true
+#       false_bool.send(meth, Boolean.false ).should be_true
+#       false_bool.send(meth, false         ).should be_true
+#       false_bool.send(meth, true_bool     ).should be_false
+#       false_bool.send(meth, Boolean.true  ).should be_false
+#       false_bool.send(meth, true          ).should be_false
+#       false_bool.send(meth, 0             ).should be_false
+#     end
+#     it "!=" do
+#       (true_bool  != true         ).should be_false ; (true_bool  != false        ).should be_true
+#       (true_bool  != true_bool    ).should be_false ; (true_bool  != false_bool   ).should be_true
+#       (true_bool  != Boolean.true ).should be_false ; (true_bool  != Boolean.false).should be_true
+#       (true_bool  != 0            ).should be_true  ; (true_bool  != "true"       ).should be_true
+#       (false_bool != false        ).should be_false ; (false_bool != true         ).should be_true
+#       (false_bool != false_bool   ).should be_false ; (false_bool != true_bool    ).should be_true
+#       (false_bool != Boolean.false).should be_false ; (false_bool != Boolean.true ).should be_true
+#       (false_bool != 0            ).should be_true  ; (false_bool  != "true"      ).should be_true
+#     end
+#     it "!~" do
+#       (true_bool !~ true        ).should be_true
+#       (true_bool !~ true_bool   ).should be_true
+#       (true_bool !~ Boolean.true).should be_true
+#     end
+#   end
+# end