gorillib 0.4.1pre → 0.4.2pre

data/spec/gorillib/builder_spec.rb

@@ -1,27 +1,13 @@
 require 'spec_helper'
+require 'support/model_test_helpers'
+require 'gorillib/hash/compact'
 
 # libs under test
 require 'gorillib/builder'
-require 'gorillib/builder/field'
 require 'gorillib/collection/model_collection'
 
-# testing helpers
-require 'gorillib/hash/compact'
-require 'model_test_helpers'
-
 describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
 
-  let(:smurf_class) do
-    class Gorillib::Test::Smurf
-      include Gorillib::Builder
-      magic :smurfiness, Integer
-      magic :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') }
-
   #
   # IT BEHAVES LIKE A MODEL
   # (maybe you wouldn't notice if it was just one little line)
@@ -67,6 +53,14 @@ describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
       wildcat.receive!({}){|c| expect_7 = 7 ; expect_obj = c }
       expect_7.should    == 7 ; expect_obj.should  == wildcat
     end
+    it 'with a block, returns its return value' do
+      val = mock_val
+      wildcat.receive!{      val }.should == val
+      wildcat.receive!{|obj| val }.should == val
+    end
+    it 'with no block, returns nil' do
+      wildcat.receive!.should be_nil
+    end
   end
 
   context ".magic" do
@@ -129,14 +123,16 @@ describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
       wildcat.should     respond_to(:doors)
       wildcat.should_not respond_to(:doors=)
     end
+
+
   end
 
   context 'collections' do
     subject{ garage }
-    let(:sample_val){ Gorillib::ModelCollection.receive([wildcat], :name, car_class) }
+    let(:sample_val){ Gorillib::ModelCollection.receive([wildcat], key_method: :name, item_type: car_class) }
     let(:raw_val   ){ [ wildcat.attributes ] }
     it_behaves_like "a model field", :cars
-    it("#read_attribute is an empty collection if never set"){ subject.read_attribute(:cars).should == Gorillib::ModelCollection.new }
+    it("#read_attribute is an empty collection if never set"){ subject.read_attribute(:cars).should == Gorillib::ModelCollection.new(key_method: :to_key) }
 
     it 'a collection holds named objects' do
       garage.cars.should be_empty
@@ -157,13 +153,13 @@ describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
 
       # examine the whole collection
       garage.cars.keys.should == [:cadzilla, :wildcat, :ford_39]
-      garage.cars.should == Gorillib::ModelCollection.receive([cadzilla, wildcat, ford_39], :name, car_class)
+      garage.cars.should == Gorillib::ModelCollection.receive([cadzilla, wildcat, ford_39], key_method: :name, item_type: car_class)
     end
 
     it 'lazily autovivifies collection items' do
       garage.cars.should be_empty
       garage.car(:chimera).should be_a(car_class)
-      garage.cars.should == Gorillib::ModelCollection.receive([{:name => :chimera}], :name, car_class)
+      garage.cars.should == Gorillib::ModelCollection.receive([{:name => :chimera}], key_method: :name, item_type: car_class)
     end
 
     context 'collection getset method' do

data/spec/gorillib/collection_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 #
 require 'gorillib/model'
 require 'gorillib/collection/model_collection'
-require 'gorillib/collection/list_collection'
-require 'model_test_helpers'
+require 'support/model_test_helpers'
 
 shared_context :collection_spec do
   # a collection with the internal :clxn mocked out, and a method 'innards' to
@@ -15,17 +14,17 @@ shared_context :collection_spec do
   end
 end
 
-shared_examples_for 'a collection' do
+shared_examples_for 'a collection' do |options={}|
   subject{ string_collection }
 
   context '.receive' do
     it 'makes a new collection, has it #receive! the cargo, returns it' do
       mock_collection = mock('collection')
       mock_cargo      = mock('cargo')
-      mock_args       = [mock, mock]
-      described_class.should_receive(:new).with(*mock_args).and_return(mock_collection)
+      mock_args       = {key_method: mock, item_type: mock}
+      described_class.should_receive(:new).with(mock_args).and_return(mock_collection)
       mock_collection.should_receive(:receive!).with(mock_cargo)
-      described_class.receive(mock_cargo, *mock_args).should == mock_collection
+      described_class.receive(mock_cargo, mock_args).should == mock_collection
     end
   end
 
@@ -61,16 +60,19 @@ shared_examples_for 'a collection' do
     end
   end
 
-  # context '#receive (array)', :if => :receives_arrays do
-  #   it 'adopts the contents of an array'  do
-  #     string_collection.receive!(%w[horton hears a who])
-  #     string_collection.values.should == %w[wocket in my pocket horton hears a who]
-  #   end
-  #   it 'does not adopt duplicates' do
-  #     string_collection.receive!(%w[red fish blue fish])
-  #     string_collection.values.should == %w[wocket in my pocket red fish blue]
-  #   end
-  # end
+  unless (options[:receiving_arrays] == :skip)
+    context '#receive (array)', :if => :receives_arrays do
+      it 'adopts the contents of an array'  do
+        string_collection.receive!(%w[horton hears a who])
+        string_collection.values.should == %w[wocket in my pocket horton hears a who]
+      end
+      it 'does not adopt duplicates' do
+        string_collection.receive!(%w[red fish blue fish])
+        string_collection.values.should == %w[wocket in my pocket red fish blue]
+      end
+    end
+  end
+
   context '#receive (hash)' do
     it 'adopts the values of a hash' do
       string_collection.receive!({horton: "horton", hears: "hears", a: "a", who: "who" })
@@ -96,6 +98,7 @@ shared_examples_for 'a keyed collection' do
   end
 
   context '#fetch' do
+    ABSENT_KEY_ERROR_RE =  /(key not found: 69|index 69 outside)/
     it 'retrieves an object if present' do
       subject[1] = mock_val
       subject.fetch(1).should equal(mock_val)
@@ -106,7 +109,7 @@ shared_examples_for 'a keyed collection' do
       got_here.should == 'yup'
     end
     it 'if absent and no block given: raises an error' do
-      ->{ subject.fetch(69) }.should raise_error IndexError, /(key not found: 69|index 69 outside)/
+      ->{ subject.fetch(69) }.should raise_error IndexError, ABSENT_KEY_ERROR_RE
     end
   end
 
@@ -176,30 +179,123 @@ shared_examples_for 'an auto-keyed collection' do
 end
 
 describe 'collections:', :model_spec, :collection_spec do
+  let(:symbolized_test_items){  {:wocket  => 'wocket', :in  => 'in', :my  => 'my', :pocket  => 'pocket'} }
+  let(:capitalized_test_items){ {'WOCKET' => 'wocket', 'IN' => 'in', 'MY' => 'my', 'POCKET' => 'pocket'} }
+
+  describe Gorillib::Collection do
+    context 'with no key_method (only explicit labels can be stored)' do
+      let(:string_collection){ described_class.receive(symbolized_test_items) }
+      let(:shouty_collection){ described_class.receive(capitalized_test_items) }
+      it_behaves_like 'a collection', :receiving_arrays => :skip
+      it_behaves_like 'a keyed collection'
+    end
 
-  describe Gorillib::ListCollection do
-    let(:string_collection){ described_class.receive(%w[wocket in my pocket]) }
-    it_behaves_like 'a collection'
-    # it_behaves_like 'a keyed collection'
+    context 'with no key_method (only explicit labels can be stored)' do
+      let(:string_collection){ described_class.receive(symbolized_test_items,  key_method: :to_sym) }
+      let(:shouty_collection){ described_class.receive(capitalized_test_items, key_method: :upcase) }
+      it_behaves_like 'a collection', :receiving_arrays => true
+      it_behaves_like 'an auto-keyed collection'
+    end
   end
 
-  describe Gorillib::Collection, :receives_arrays => false do
-    let(:string_collection){ described_class.receive({:wocket  => 'wocket', :in  => 'in', :my  => 'my', :pocket  => 'pocket'}) }
-    let(:shouty_collection){ described_class.receive({'WOCKET' => 'wocket', 'IN' => 'in', 'MY' => 'my', 'POCKET' => 'pocket'}) }
-    it_behaves_like 'a collection', :receives_arrays => false
-    it_behaves_like 'a keyed collection'
+  describe Gorillib::ModelCollection, :model_spec do
+    context do
+      let(:string_collection){ described_class.receive(%w[wocket in my pocket], key_method: :to_sym, item_type: String) }
+      let(:shouty_collection){ described_class.receive(%w[wocket in my pocket], key_method: :upcase, item_type: String) }
+      it_behaves_like 'a collection'
+      it_behaves_like 'a keyed collection'
+      it_behaves_like 'an auto-keyed collection'
+    end
+
+    subject{ smurf_collection }
+    let(:smurf_collection){ described_class.receive([], key_method: :name, item_type: smurf_class) }
+    let(:test_item){  papa_smurf }
+    let(:test_attrs){ test_item.attributes }
+    let(:mock_factory){ mf = mock('factory'); mf.stub!(:native? => true) ; mf }
 
-    # I only want the 'adopts the contents of an array' to run when the
-    # it_behaves_like group says it should be part of the specs.
-    it "needs travis's rspec help on the 'adopts the contents of an array' spec"
+    context '#receive_item' do
+      before do
+        @test_proc = ->{ 'test' };
+        subject.stub(item_type: mock_factory)
+      end
 
+      it 'sends it to item_type for receive, then adds it' do
+        mock_factory.should_receive(:receive).with(mock_val, &@test_proc).and_return(mock_val)
+        subject.should_receive(:add).with(mock_val, nil)
+        subject.receive_item(nil, mock_val, &@test_proc)
+      end
+      it 'accepts an explicit label' do
+        mock_factory.should_receive(:receive).with(mock_val, &@test_proc).and_return(mock_val)
+        subject.should_receive(:add).with(mock_val, 'truffula')
+        subject.receive_item('truffula', mock_val, &@test_proc)
+      end
+    end
+
+    context '#update_or_add' do
+      it "if absent, creates item with given attrs" do
+        test_proc = ->{ 'test' };
+        subject.should_receive(:receive_item).with('truffula', test_attrs.merge(name: 'truffula'), &test_proc).and_return(test_item)
+        #
+        subject.update_or_add('truffula', test_attrs, &test_proc)
+      end
+      it "if there's no key_method, does not it as an attr to create" do
+        subject.send(:remove_instance_variable, '@key_method')
+        subject.should_receive(:receive_item).with('truffula', test_attrs)
+        #
+        subject.update_or_add('truffula', test_attrs)
+      end
+      it "if present, updates item with attrs" do
+        test_proc = ->{ 'test' };
+        hsh       = { :smurfiness => 99 }
+        subject['truffula'] = test_item
+        test_item.should_receive(:receive!).with(hsh, &test_proc)
+        #
+        subject.update_or_add('truffula', hsh, &test_proc)
+      end
+      it "returns item" do
+        updated_item = test_item.dup ; updated_item.name = 'truffula'
+        subject.update_or_add('truffula', test_attrs).should == updated_item
+        subject.update_or_add('truffula', test_item ).should == test_item
+      end
+      it 'FIXME: does not behave right on existing bojects' do
+        updated_item = test_item.dup ; updated_item.name = 'truffula'
+        subject.update_or_add('truffula', test_item ).should == updated_item
+      end
+      it "adds item to collection" do
+        updated_item = test_item.dup ; updated_item.name = 'truffula'
+        subject.update_or_add('truffula', test_attrs)
+        subject['truffula'].should == updated_item
+      end
+    end
   end
 
-  describe Gorillib::ModelCollection do
-    let(:string_collection){ described_class.receive(%w[wocket in my pocket], :to_sym, String) }
-    let(:shouty_collection){ described_class.receive(%w[wocket in my pocket], :upcase, String) }
-    it_behaves_like 'a collection'
-    it_behaves_like 'a keyed collection'
-    it_behaves_like 'an auto-keyed collection'
+
+  describe Gorillib::Model do
+    describe '.collection' do
+      let(:described_class){ smurf_village_class }
+      subject{ described_class.new(name: :smurf_town) }
+      before do
+        smurf_collection_class ; smurf_village_class
+        smurf_class.field :village, smurf_village_class
+      end
+
+      it 'adds an eponymous field' do
+        described_class.should have_field(:smurfs)
+      end
+
+      it 'sets a default that auto-vivifies the collection field' do
+        subject.smurfs.should be_a(Gorillib::ModelCollection)
+        subject.smurfs.belongs_to.should == subject
+      end
+
+      it 'receives' do
+        subject = smurf_village_class.receive({name: :smurf_town,
+          smurfs: [
+            { name: 'whatever_smurf', smurfiness: 20},
+          ]})
+        subject.smurfs['whatever_smurf'].village.should == subject
+      end
+    end
+
   end
 end

data/spec/gorillib/exception/raisers_spec.rb

@@ -9,6 +9,7 @@ describe 'raisers' do
   def should_return_true
     yield.should be_true
   end
+  # different rubies have different error messages ARRGH.
   def capture_error
     message = 'should have raised, did not'
     begin
@@ -42,6 +43,11 @@ describe 'raisers' do
         should_raise_my_error(capture_error{ [].fill()   }){ described_class.check_arity!([],  1..3) }
         should_raise_my_error(capture_error{ [].to_s(1)  }){ described_class.check_arity!([1], 0) }
       end
+      it 'appends result of block (if given) to message' do
+        str = "esiar no delave ylno"
+        ->{ described_class.check_arity!([],  1..3){ str.reverse! } }.should raise_error(/only evaled on raise/)
+        str.should == "only evaled on raise"
+      end
     end
 
     context '.arity_at_least!' do
@@ -57,4 +63,37 @@ describe 'raisers' do
       end
     end
   end
+
+  describe TypeMismatchError do
+    context '.mismatched!' do
+      let(:error_message){ /.+ has mismatched type/ }
+      it 'raises an error' do
+        should_raise_my_error{ described_class.mismatched!("string", Integer) }
+        should_raise_my_error{ described_class.mismatched!(Object.new) }
+      end
+    end
+
+    context '.check_type!' do
+      let(:error_message){ /.+ has mismatched type; expected .+/ }
+      it 'raises true if any type matches' do
+        should_return_true{    described_class.check_type!("string", [Integer, String]) }
+      end
+      it 'raises an error if nothing matches' do
+        should_raise_my_error{ described_class.check_type!("string", [Integer, Float]) }
+        should_raise_my_error{ described_class.check_type!("string", [Integer]) }
+        should_raise_my_error{ described_class.check_type!("string", Integer) }
+      end
+      it 'checks is_a? given a class' do
+        should_return_true{    described_class.check_type!("string", [Integer, String]) }
+        should_return_true{    described_class.check_type!(7,        [Integer, String]) }
+        should_raise_my_error{ described_class.check_type!(:symbol,  [Integer, String]) }
+      end
+      it 'checks responds_to? given a symbol' do
+        should_return_true{    described_class.check_type!("string", [:to_str, :to_int]) }
+        should_return_true{    described_class.check_type!(7,        [:to_str, :to_int]) }
+        should_raise_my_error{ described_class.check_type!(:symbol,  [:to_str, :to_int]) }
+      end
+    end
+  end
+
 end

data/spec/gorillib/hash/deep_compact_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'gorillib/hash/deep_compact'
 require 'gorillib/array/deep_compact'
 
-describe Hash, :hashlike_spec => true do
+describe Hash, :hashlike_spec do
   describe 'array/deep_compact and hash/deep_compact' do
     it "should respond to the method deep_compact!" do
       { }.should respond_to :deep_compact!
@@ -13,13 +13,13 @@ describe Hash, :hashlike_spec => true do
     end
 
     it "should return a hash with all blank values removed recursively" do
-      @test_hash = {:e=>["", nil, [], {}, "foo", { :a=> [nil, {}, { :c=> ["","",[]] } ], :b => nil }]}
+      @test_hash = {:e => ["", nil, [], {}, "foo", { :a => [nil, {}, { :c => ["","",[]] } ], :b => nil }]}
       @test_hash.deep_compact!.should == {:e=>["foo"]}
     end
   end
 end
 
-describe Array, :hashlike_spec => true do
+describe Array, :hashlike_spec do
   describe 'array/deep_compact and hash/deep_compact' do
     it "should respond to the method deep_compact!" do
       [ ].should respond_to :deep_compact!

data/spec/gorillib/model/{record/defaults_spec.rb → defaults_spec.rb}

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
-require 'gorillib/model'
+require 'gorillib/metaprogramming/concern'
+require 'gorillib/metaprogramming/class_attribute'
+require 'gorillib/model/named_schema'
+require 'gorillib/model/base'
+require 'gorillib/model/schema_magic'
 require 'gorillib/model/field'
 require 'gorillib/model/defaults'
 

data/spec/gorillib/model/factories_spec.rb

@@ -0,0 +1,335 @@
+require 'spec_helper'
+# require 'support/factory_test_helpers'
+
+require 'gorillib/object/blank'
+require 'gorillib/object/try_dup'
+require 'gorillib/hash/slice'
+require 'gorillib/metaprogramming/class_attribute'
+require 'gorillib/string/inflector'
+
+require 'gorillib/collection'
+require 'gorillib/model/factories'
+
+require 'factory_test_helpers'
+
+describe '', :model_spec, :factory_spec, :only 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 = mock
+        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 = mock('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