gorillib-model 0.0.1

data/spec/core_ext/object.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'try_dup', :simple_spec => true do
+  it "returns a duplicate version on regular objects" do
+    obj = Object.new
+    oth = obj.try_dup
+    obj.should_not === oth
+  end
+
+  it "returns self on Numerics" do
+    obj = 12
+    oth = obj.try_dup
+    obj.should === oth
+  end
+
+  it "returns self on Symbols" do
+    obj = :test
+    oth = obj.try_dup
+    obj.should === oth
+  end
+
+  it "returns self on true" do
+    obj = true
+    oth = obj.try_dup
+    obj.should === oth
+  end
+
+  it "returns self on false" do
+    obj = false
+    oth = obj.try_dup
+    obj.should === oth
+  end
+
+  it "returns self on nil" do
+    obj = nil
+    oth = obj.try_dup
+    obj.should === oth
+  end
+
+  it "returns self on modules" do
+    obj = Module.new
+    oth = obj.try_dup
+    obj.object_id.should == oth.object_id
+  end
+end

data/spec/model/collection_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper'
+
+require 'gorillib/model/collection/model_collection'
+
+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 = double('collection')
+      mock_cargo      = double('cargo')
+      mock_args       = {key_method: double, item_type: double}
+      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
+    end
+  end
+
+  context 'empty collection' do
+    subject{ described_class.new }
+    its(:length){ should == 0 }
+    its(:size  ){ should == 0 }
+    its(:empty?){ should be true }
+    its(:blank?){ should be true }
+    its(:values){ should == [] }
+    its(:to_a  ){ should == [] }
+  end
+  context 'non-empty collection' do
+    subject{ string_collection }
+    its(:length){ should == 4 }
+    its(:size  ){ should == 4 }
+    its(:empty?){ should be false }
+    its(:blank?){ should be false }
+  end
+
+  context '#values returns an array' do
+    its(:values){ should == %w[wocket in my pocket] }
+  end
+  context '#to_a returns same as values' do
+    its(:to_a  ){ should == %w[wocket in my pocket] }
+  end
+
+  context '#each_value' do
+    it 'each value in order' do
+      result = []
+      ret = subject.each_value{|val| result << val.reverse }
+      result.should == %w[tekcow ni ym tekcop]
+    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" })
+      string_collection.values.should == %w[wocket in my pocket horton hears a who]
+    end
+    it 'does not adopt duplicates' do
+      string_collection.receive!({red:  'red',  fish: 'fish'})
+      string_collection.receive!({blue: 'blue', fish: 'fish'})
+      string_collection.values.should == %w[wocket in my pocket red fish blue]
+    end
+  end
+
+end
+
+shared_examples_for 'a keyed collection' do
+  subject{ string_collection }
+
+  context '#[]' do
+    it 'retrieves stored objects' do
+      subject[1] = mock_val
+      subject[1].should equal(mock_val)
+    end
+  end
+
+  context '#fetch' do
+    let(:absent_key_err_re){ /(key not found: 69|index 69 outside)/ }
+    # 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)
+    end
+    it 'if absent and block given: calls block with label, returning its value' do
+      got_here = nil
+      subject.fetch(69){ got_here = 'yup' ; mock_val }.should equal(mock_val)
+      got_here.should == 'yup'
+    end
+    it 'if absent and no block given: raises an error' do
+      ->{ subject.fetch(69) }.should raise_error IndexError, absent_key_err_re# ABSENT_KEY_ERROR_RE
+    end
+  end
+
+  context '#delete' do
+    it 'retrieves an object if present' do
+      subject[1] = mock_val
+      subject.delete(1).should equal(mock_val)
+      subject.values.should_not include(mock_val)
+    end
+    it 'if absent and block given: calls block with label, returning its value' do
+      got_here = nil
+      subject.delete(69){ got_here = 'yup' ; mock_val }.should equal(mock_val)
+      got_here.should == 'yup'
+    end
+    it 'if absent and no block given: returns nil' do
+      subject.delete(69).should be nil
+    end
+  end
+end
+
+shared_examples_for 'an auto-keyed collection' do
+  subject{ string_collection }
+
+  it 'retrieves things by their label' do
+    string_collection[:pocket].should == "pocket"
+    string_collection['pocket'].should == nil
+    shouty_collection['POCKET'].should == "pocket"
+    shouty_collection['pocket'].should == nil
+  end
+
+  it 'gets label from key if none supplied' do
+    string_collection[:marvin].should be nil
+    string_collection << 'marvin'
+    string_collection[:marvin].should == 'marvin'
+    shouty_collection << 'marvin'
+    shouty_collection['MARVIN'].should == 'marvin'
+  end
+
+  context '#receive!' do
+    it 'extracts labels given an array' do
+      subject.receive!(%w[horton hears a who])
+      subject[:horton].should == 'horton'
+    end
+    it 'replaces labels in-place, preserving order' do
+      shouty_collection.receive!(%w[in MY pocKET wocKET])
+      shouty_collection['WOCKET'].should == 'wocKET'
+      shouty_collection.values.should == %w[wocKET in MY pocKET]
+    end
+  end
+
+  context '#<<' do
+    it 'adds element under its natural label, at end' do
+      subject << 'marvin'
+      subject.values.last.should == 'marvin'
+      subject[:marvin].should == 'marvin'
+    end
+    it 'replaces duplicate values' do
+      val = 'wocKET'
+      shouty_collection['WOCKET'].should     == 'wocket'
+      shouty_collection['WOCKET'].should_not equal(val)
+      shouty_collection << val
+      shouty_collection['WOCKET'].should     == 'wocKET'
+      shouty_collection['WOCKET'].should     equal(val)
+    end
+  end
+
+end
+
+describe 'collections:', :model_spec => true, :collection_spec => true 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
+
+    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::ModelCollection, :model_spec => true 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 = double('factory'); mf.stub(:native? => true) ; mf }
+
+    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 "returns item" 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::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/model/defaults_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+module Gorillib::Test       ; end
+module Meta::Gorillib::Test ; end
+
+describe Gorillib::Model, :model_spec => true do
+  after(:each){   Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
+
+  let(:car_class) do
+    class Gorillib::Test::Car
+      include Gorillib::Model
+      field    :name,          Symbol
+      field    :make_model,    String
+      field    :year,          Integer
+      field    :style,         Symbol, :default => :sedan
+      field    :doors,         Integer,
+        :default => ->{ [:coupe, :convertible].include?(style) ? 2 : 4 }
+      self
+    end
+    Gorillib::Test::Car
+  end
+  let(:wildcat) do
+    car_class.receive( :name => :wildcat, :make_model => 'Buick Wildcat', :year => 1968, :doors => 2 )
+  end
+  let(:ford_39) do
+    car_class.receive( :name => :ford_39 )
+  end
+  let(:year_field ){ car_class.fields[:year] }
+  let(:doors_field){ car_class.fields[:doors] }
+  let(:style_field){ car_class.fields[:style] }
+
+  describe 'Field#default' do
+    it 'is itself a field on Gorillib::Model::Field (boy that is confusing)' do
+      Gorillib::Model::Field.should have_field(:default)
+    end
+    context '#has_default?' do
+      it 'is true if the default is set' do
+        year_field.should_not have_default
+        year_field.default = '2012'
+        year_field.should have_default
+      end
+    end
+  end
+
+  describe '#attribute_default' do
+    before{ car_class.class_eval{ public :attribute_default } }
+
+    it "if the default does not exist, returns nil" do
+      ford_39.attribute_default(year_field).should be_nil
+    end
+    it "if the default is a value, returns it, dup'd if possible" do
+      ford_39.attribute_default(style_field).should == :sedan
+      year_val = double ; dupd_year_val = double
+      year_val.should_receive(:try_dup).and_return(dupd_year_val)
+      year_field.default = year_val
+      ford_39.attribute_default(year_field).should equal(dupd_year_val)
+    end
+    it "if the default is a proc with no args, instance_exec it" do
+      ford_39.style = :sedan
+      ford_39.attribute_default(doors_field).should == 4
+      ford_39.style = :coupe
+      ford_39.attribute_default(doors_field).should == 2
+    end
+    it "if the default is a proc with no args, instance_exec it" do
+      year_field.default = ->{ self }
+      ford_39.attribute_default(year_field).should equal(ford_39)
+    end
+    it "if the default responds_to #call, call it, passing the instance and field name" do
+      callable = double ; expected = double
+      year_field.default = callable
+      callable.should_receive(:respond_to?).with(:call).and_return(true)
+      callable.should_receive(:call).with(ford_39, :year).and_return(expected)
+      ford_39.stub(:read_unset_attribute).and_return('bob')
+      ford_39.attribute_default(year_field).should equal(expected)
+    end
+    it "if the default is a proc with args, call it in current context with the model and field name" do
+      this = self ; expected = double
+      year_field.default = ->(inst, field_name){ [self, inst, field_name, expected] }
+      ford_39.attribute_default(year_field).should == [this, ford_39, :year, expected]
+    end
+  end
+
+  describe 'reading an attribute with a default' do
+    it "sets the default value on the field and returns it" do
+      ford_39.attribute_set?(:doors).should be_false
+      ford_39.read_attribute(:doors).should == 4
+    end
+    it "only calls a block default if the attribute is unset" do
+      val = 0
+      year_field.default = ->{ val += 1 }
+      ford_39.read_attribute(:year).should == 1
+      year_field.default.call.should == 2       # the next call to the block will return 3
+      ford_39.read_attribute(:year).should == 1 # repeated calls give the same value
+      ford_39.unset_attribute(:year)
+      ford_39.read_attribute(:year).should == 3 # see! since it was unset, the block was called again.
+    end
+    it "is attribute_set? after" do
+      ford_39.attribute_set?(:doors).should be_false
+      ford_39.read_attribute(:doors)
+      ford_39.attribute_set?(:doors).should be_true
+    end
+  end
+
+end