gorillib 0.4.1pre → 0.4.2pre

data/spec/gorillib/model/serialization_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'model_test_helpers'
+require 'support/model_test_helpers'
 
 require 'multi_json'
 #
@@ -7,7 +7,7 @@ require 'gorillib/model'
 require 'gorillib/builder'
 require 'gorillib/model/serialization'
 
-describe Gorillib::Model, :model_spec => true do
+describe Gorillib::Model, :model_spec, :builder_spec do
   subject do
     garage.cars << wildcat
     garage.cars << ford_39

data/spec/gorillib/model_spec.rb

@@ -1,20 +1,9 @@
 require 'spec_helper'
-require 'model_test_helpers'
+require 'support/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') }
-
+describe Gorillib::Model, :model_spec do
   let(:simple_model) do
     class Gorillib::Test::SimpleModel
       include Gorillib::Model
@@ -53,8 +42,8 @@ describe Gorillib::Model, :model_spec => true do
       obj.attributes.should == { :my_field => 'accepted as-is', :str_field => 'bob', :sym_field=>:converted_to_sym }
     end
     it 'handles nested structures' do
-      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, }
+      deep_obj = nested_model.receive(:str_field => 'deep, man', :smurf => papa_smurf.attributes)
+      deep_obj.attributes.should == { :str_field => 'deep, man', :smurf => papa_smurf, :sym_field=>nil, :my_field => nil, }
     end
   end
 
@@ -81,9 +70,9 @@ describe Gorillib::Model, :model_spec => true do
       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, mock_val)
-      (example_inst.receive_my_field(mock_val)).should == example_inst
+    it "supplies #receive_foo, which does write_attribute(:foo) and returns the new value " do
+      example_inst.should_receive(:write_attribute).with(:my_field, mock_val).and_return('okey doke!')
+      (example_inst.receive_my_field(mock_val)).should == 'okey doke!'
     end
     it "sets visibility of reader with :reader => ()" do
       described_class.field :test_field, Integer, :reader => :private, :writer => false
@@ -171,6 +160,9 @@ describe Gorillib::Model, :model_spec => true do
       example_inst.should_receive(:write_attribute).with(:str_field, 'yo')
       example_inst.receive! 'my_field'=>7, :str_field=>'yo'
     end
+    it "returns nil with no block given" do
+      example_inst.receive!('my_field'=>7, :str_field=>'yo').should be_nil
+    end
   end
 
   context '#== -- two models are equal if' do
@@ -229,6 +221,15 @@ describe Gorillib::Model, :model_spec => true do
     end
   end
 
+  context '.inspect' do
+    it('is pretty'){ smurf_class.inspect.should == 'Gorillib::Test::Smurf[name,smurfiness,weapon]' }
+    it('is pretty even if class is anonymous'){ Class.new(smurf_class).inspect.should == 'anon[name,smurfiness,weapon]' }
+  end
+  context '.inspect_compact' do
+    it('is just the class name'){ smurf_class.inspect_compact.should == "Gorillib::Test::Smurf" }
+    it('is detailed if class is anonymous'){ Class.new(smurf_class).inspect_compact.should == "anon[name,smurfiness,weapon]" }
+  end
+
   describe Gorillib::Model::NamedSchema do
     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= ]}

data/spec/gorillib/pathname_spec.rb

@@ -58,17 +58,17 @@ describe Pathname do
     end
   end
 
-  context '.relative_path_to' do
+  context '.relpath_to' do
     subject{ described_class }
 
     it 'collapses "//" double slashes and useless ".." dots, but does not use the filesystem' do
-      subject.relative_path_to('/', '../..', :access, '//have', 'a//pepsi').should == Pathname.new('/would/you/like/to/have/a/pepsi')
+      subject.relpath_to('/', '../..', :access, '//have', 'a//pepsi').should == Pathname.new('/would/you/like/to/have/a/pepsi')
     end
 
     it 'does not expand relative paths' do
       FileUtils.cd '/' do
         subject.register_path(:hello,  'doctor')
-        subject.relative_path_to(:hello, :hello, :hello).should == Pathname.new('doctor/doctor/doctor')
+        subject.relpath_to(:hello, :hello, :hello).should == Pathname.new('doctor/doctor/doctor')
       end
     end
   end
@@ -76,7 +76,7 @@ describe Pathname do
   context 'registering paths' do
     subject { described_class }
     def expand_pathseg(*args) ; subject.send(:expand_pathseg, *args) ;  end
-    
+
     context '.register_path' do
       it 'stores a path so expand_pathseg can get it later' do
         subject.register_path(:probe, ['skeletal', 'girth'])
@@ -92,10 +92,10 @@ describe Pathname do
         expand_pathseg(:glg_20).should == ['milbarge', 'fitz-hume']
       end
     end
-    
+
     context '.register_paths' do
       let(:paths) { { :foo => ['foo'], :bar => [:foo, 'bar'] } }
-      
+
       it 'registers multiple paths' do
         subject.should_receive(:register_path).exactly(paths.size).times
         subject.register_paths(paths)
@@ -109,6 +109,6 @@ describe Pathname do
         subject.unregister_path(:foo)
         expect{ expand_pathseg(:foo)}.to raise_error(ArgumentError, /expand path reference.*foo/)
       end
-    end    
+    end
   end
 end

data/spec/gorillib/string/truncate_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require GORILLIB_ROOT_DIR('spec/support/kcode_test_helper')
 require 'gorillib/string/truncate'
 
 describe String, :string_spec => true do
@@ -19,18 +18,9 @@ describe String, :string_spec => true do
       "Hello Big World!".truncate(15, :omission => "[...]", :separator => ' ') .should  == "Hello Big[...]"
     end
 
-    if RUBY_VERSION < '1.9.0'
-      it 'works with unicode when kcode=none' do
-        Gorillib::KcodeTestHelper.with_kcode('none') do
-          "\354\225\210\353\205\225\355\225\230\354\204\270\354\232\224".truncate(10).
-            should == "\354\225\210\353\205\225\355..."
-        end
-      end
-    else # ruby 1.9
-      it 'works with unicode' do
-        "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding('UTF-8').truncate(10).
-          should == "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding('UTF-8')
-      end
+    it 'works with unicode' do
+      "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding('UTF-8').truncate(10).
+        should == "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding('UTF-8')
     end
   end
 

data/spec/gorillib/type/extended_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
-
-require 'gorillib/type/extended'
+require 'support/factory_test_helpers'
 require 'gorillib/object/blank'
+#
+require 'gorillib/type/extended'
 
 describe ::Long do
   it "is_a?(Integer)" do ::Long.should < ::Integer ; end
@@ -15,6 +16,53 @@ describe ::Binary do
   it "is_a?(String)" do ::Binary.should < ::String ; end
 end
 
+describe 'factory', :factory_spec 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) }

data/spec/gorillib/utils/capture_output_spec.rb

@@ -59,7 +59,7 @@ describe Gorillib::TestHelpers, :simple_spec => true do
     end
 
     it 'raises an error if no block is given' do
-      lambda{ Gorillib::TestHelpers.capture_output }.should raise_error(LocalJumpError, "no block given (yield)")
+      lambda{ Gorillib::TestHelpers.capture_output }.should raise_error(LocalJumpError, /no block given/)
     end
 
   end

data/spec/spec_helper.rb

@@ -1,20 +1,23 @@
-require 'rubygems' unless defined?(Gem)
-require 'rspec'
+require 'bundler/setup' ; Bundler.require(:default, :development, :test)
+require 'rspec/autorun'
+
+if ENV['GORILLIB_COV']
+  require 'simplecov'
+  SimpleCov.start
+end
 
 GORILLIB_ROOT_DIR = File.expand_path(File.join(File.dirname(__FILE__),'..'))
 def GORILLIB_ROOT_DIR *paths
   File.join(::GORILLIB_ROOT_DIR, *paths)
 end
 
-ENV['QUIET_RSPEC'] = 'please'
-
 $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}
+
+require_relative 'support/gorillib_test_helpers'
+Dir[GORILLIB_ROOT_DIR('spec/support/matchers/*.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/factory_test_helpers.rb

@@ -0,0 +1,76 @@
+
+#
+# Shared examples for testing type factories
+#
+
+shared_examples_for :it_converts do |conversion_mapping|
+  non_native_ok = conversion_mapping.delete(:non_native_ok)
+  conversion_mapping.each do |obj, expected_result|
+    it "#{obj.inspect} to #{expected_result.inspect}" do
+      actual_result = subject.receive(obj)
+      actual_result.should  eql(expected_result)
+      subject.native?(  obj).should be_false
+      subject.blankish?(obj).should be_false
+      unless non_native_ok then subject.native?(actual_result).should be_true  ; end
+    end
+  end
+end
+
+shared_examples_for :it_considers_native do |*native_objs|
+  it native_objs.inspect do
+    native_objs.each do |obj|
+      subject.native?(  obj).should be_true
+      actual_result = subject.receive(obj)
+      actual_result.should equal(obj)
+    end
+  end
+end
+
+shared_examples_for :it_considers_blankish do |*blankish_objs|
+  it blankish_objs.inspect do
+    blankish_objs.each do |obj|
+      subject.blankish?(obj).should be_true
+      subject.receive(obj).should be_nil
+    end
+  end
+end
+
+shared_examples_for :it_is_a_mismatch_for do |*mismatched_objs|
+  it mismatched_objs.inspect do
+    mismatched_objs.each do |obj|
+      ->{ subject.receive(obj) }.should raise_error(Gorillib::Factory::FactoryMismatchError)
+    end
+  end
+end
+
+shared_examples_for :it_is_registered_as do |*keys|
+  it "the factory for #{keys}" do
+    keys.each do |key|
+      Gorillib::Factory(key).should be_a(described_class)
+    end
+    its_factory = Gorillib::Factory(keys.first)
+    Gorillib::Factory.send(:factories).to_hash.select{|key,val| val.equal?(its_factory) }.keys.should == keys
+  end
+end
+
+# hand it a collection with entries 1, 2, 3 please
+shared_examples_for :an_enumerable_factory do
+  it "accepts a factory for its items" do
+    mock_factory = mock('factory')
+    mock_factory.should_receive(:receive).with(1)
+    mock_factory.should_receive(:receive).with(2)
+    mock_factory.should_receive(:receive).with(3)
+    factory = described_class.new(:items => mock_factory)
+    factory.receive( collection_123 )
+  end
+  it "can generate an empty collection" do
+    subject.empty_product.should == empty_collection
+  end
+  it "lets you override the empty collection" do
+    ep = mock; ep.should_receive(:try_dup).and_return 'hey'
+    subject = described_class.new(:empty_product => ep)
+    subject.empty_product.should == 'hey'
+    subject = described_class.new(:empty_product => ->{ 'yo' })
+    subject.empty_product.should == 'yo'
+  end
+end

data/spec/support/gorillib_test_helpers.rb

@@ -12,27 +12,39 @@ shared_examples_for 'a model' 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} }
+
+    context 'positional args' do
+      before do
+        smurf_class.fields[:smurfiness].position = 0
+        smurf_class.fields[:weapon    ].position = 1
+      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, :position => 2
+        obj = smurf_class.new({:smurfiness => 3, :weapon => :smurfiken})
+        obj.compact_attributes.should == { :smurfiness => 3, :weapon => :smurfiken }
+        obj = smurf_class.new(3, :smurfiken, { :weapon => :bastard_smurf })
+        obj.compact_attributes.should == { :smurfiness => 3, :weapon => :smurfiken }
+        obj = smurf_class.new(3, :smurfiken, {:this => :that}, { :weapon => :bastard_smurf })
+        obj.compact_attributes.should == { :smurfiness => 3, :weapon => :smurfiken, :hashie => {:this => :that} }
+      end
+      it "skips fields that are not positional args" do
+        smurf_class.fields[:weapon].unset_attribute(:position)
+        smurf_class.field :color, String, :position => 1
+        smurf_class.new(99, 'cerulean').compact_attributes.should == { :smurfiness => 99, :color => 'cerulean' }
+      end
     end
   end
 
@@ -44,7 +56,7 @@ shared_examples_for 'a model' 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)
+      smurf_class.receive(papa_smurf).should equal(papa_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"/)
@@ -126,8 +138,8 @@ shared_examples_for "a model field" do |field_name|
   end
 
   context "#receive_XX" do
-    it('returns the model itself') do
-      subject.send("receive_#{field_name}", raw_val).should == subject
+    it('returns the new attribute') do
+      subject.send("receive_#{field_name}", raw_val).should == sample_val
     end
     it('type-converts the object') do
       subject.send("receive_#{field_name}", raw_val)

data/spec/support/model_test_helpers.rb

@@ -1,11 +1,48 @@
 module Gorillib ;               module Test ;       end ; end
 module Meta ; module Gorillib ; module Test ; end ; end ; end
 
-shared_context 'model', :model_spec => true do
+shared_context 'model', :model_spec do
   after(:each){ Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
 
   let(:mock_val){ mock('mock value') }
 
+  let(:smurf_class) do
+    class Gorillib::Test::Smurf
+      include Gorillib::Model
+      field :name,       String
+      field :smurfiness, Integer
+      field :weapon,     Symbol
+    end
+    Gorillib::Test::Smurf
+  end
+  let(:papa_smurf   ){ smurf_class.receive(:name => 'Papa Smurf', :smurfiness => 9,  :weapon => 'staff') }
+  let(:smurfette    ){ smurf_class.receive(:name => 'Smurfette',  :smurfiness => 11, :weapon => 'charm') }
+
+  let(:smurf_collection_class) do
+    smurf_class
+    class Gorillib::Test::SmurfCollection < Gorillib::ModelCollection
+      include Gorillib::Collection::ItemsBelongTo
+      self.item_type        = Gorillib::Test::Smurf
+      self.parentage_method = :village
+    end
+    Gorillib::Test::SmurfCollection
+  end
+
+  let(:smurf_village_class) do
+    smurf_class ; smurf_collection_class
+    module Gorillib::Test
+      class SmurfVillage
+        include Gorillib::Model
+        field      :name,   Symbol
+        collection :smurfs, SmurfCollection, item_type: Smurf, key_method: :name
+      end
+    end
+    Gorillib::Test::SmurfVillage
+  end
+
+end
+
+shared_context 'builder', :model_spec, :builder_spec do
   let(:engine_class) do
     class Gorillib::Test::Engine
       include Gorillib::Builder
@@ -37,7 +74,7 @@ shared_context 'model', :model_spec => true do
     car_class
     class Gorillib::Test::Garage
       include Gorillib::Builder
-      collection :cars,       Gorillib::Test::Car
+      collection :cars,       Gorillib::Test::Car, key_method: :name
       self
     end
     Gorillib::Test::Garage