gorillib 0.1.11 → 0.4.0pre

data/spec/extlib/mash_spec.rb

@@ -0,0 +1,312 @@
+# require 'spec_helper'
+# require 'extlib/mash'
+#
+# class AwesomeHash < Hash
+# end
+#
+# describe Mash do
+#   before(:each) do
+#     @hash = { "mash" => "indifferent", :hash => "different" }
+#     @sub  = AwesomeHash.new("mash" => "indifferent", :hash => "different")
+#   end
+#
+#   describe "#initialize" do
+#     it 'converts all keys into strings when param is a Hash' do
+#       mash = Mash.new(@hash)
+#
+#       mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
+#     end
+#
+#     it 'converts all pure Hash values into Mashes if param is a Hash' do
+#       mash = Mash.new :hash => @hash
+#
+#       mash["hash"].should be_an_instance_of(Mash)
+#       # sanity check
+#       mash["hash"]["hash"].should == "different"
+#     end
+#
+#     it 'doesn not convert Hash subclass values into Mashes' do
+#       mash = Mash.new :sub => @sub
+#       mash["sub"].should be_an_instance_of(AwesomeHash)
+#     end
+#
+#     it 'converts all value items if value is an Array' do
+#       mash = Mash.new :arry => { :hash => [@hash] }
+#
+#       mash["arry"].should be_an_instance_of(Mash)
+#       # sanity check
+#       mash["arry"]["hash"].first["hash"].should == "different"
+#
+#     end
+#
+#     it 'delegates to superclass constructor if param is not a Hash' do
+#       mash = Mash.new("dash berlin")
+#
+#       mash["unexisting key"].should == "dash berlin"
+#     end
+#   end # describe "#initialize"
+#
+#
+#
+#   describe "#update" do
+#     it 'converts all keys into strings when param is a Hash' do
+#       mash = Mash.new(@hash)
+#       mash.update("starry" => "night")
+#
+#       mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
+#     end
+#
+#     it 'converts all Hash values into Mashes if param is a Hash' do
+#       mash = Mash.new :hash => @hash
+#       mash.update(:hash => { :hash => "is buggy in Ruby 1.8.6" })
+#
+#       mash["hash"].should be_an_instance_of(Mash)
+#     end
+#   end # describe "#update"
+#
+#
+#
+#   describe "#[]=" do
+#     it 'converts key into string' do
+#       mash = Mash.new(@hash)
+#       mash[:hash] = { "starry" => "night" }
+#
+#       mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
+#     end
+#
+#     it 'converts all Hash value into Mash' do
+#       mash = Mash.new :hash => @hash
+#       mash[:hash] = { :hash => "is buggy in Ruby 1.8.6" }
+#
+#       mash["hash"].should be_an_instance_of(Mash)
+#     end
+#   end # describe "#[]="
+#
+#
+#
+#   describe "#key?" do
+#     before(:each) do
+#       @mash = Mash.new(@hash)
+#     end
+#
+#     it 'converts key before lookup' do
+#       @mash.key?("mash").should be(true)
+#       @mash.key?(:mash).should be(true)
+#
+#       @mash.key?("hash").should be(true)
+#       @mash.key?(:hash).should be(true)
+#
+#       @mash.key?(:rainclouds).should be(false)
+#       @mash.key?("rainclouds").should be(false)
+#     end
+#
+#     it 'is aliased as include?' do
+#       @mash.include?("mash").should be(true)
+#       @mash.include?(:mash).should be(true)
+#
+#       @mash.include?("hash").should be(true)
+#       @mash.include?(:hash).should be(true)
+#
+#       @mash.include?(:rainclouds).should be(false)
+#       @mash.include?("rainclouds").should be(false)
+#     end
+#
+#     it 'is aliased as member?' do
+#       @mash.member?("mash").should be(true)
+#       @mash.member?(:mash).should be(true)
+#
+#       @mash.member?("hash").should be(true)
+#       @mash.member?(:hash).should be(true)
+#
+#       @mash.member?(:rainclouds).should be(false)
+#       @mash.member?("rainclouds").should be(false)
+#     end
+#   end # describe "#key?"
+#
+#
+#   describe "#dup" do
+#     it 'returns instance of Mash' do
+#       Mash.new(@hash).dup.should be_an_instance_of(Mash)
+#     end
+#
+#     it 'preserves keys' do
+#       mash = Mash.new(@hash)
+#       dup  = mash.dup
+#
+#       mash.keys.sort.should == dup.keys.sort
+#     end
+#
+#     it 'preserves value' do
+#       mash = Mash.new(@hash)
+#       dup  = mash.dup
+#
+#       mash.values.sort.should == dup.values.sort
+#     end
+#   end
+#
+#
+#
+#   describe "#to_hash" do
+#     it 'returns instance of Mash' do
+#       Mash.new(@hash).to_hash.should be_an_instance_of(Hash)
+#     end
+#
+#     it 'preserves keys' do
+#       mash = Mash.new(@hash)
+#       converted  = mash.to_hash
+#
+#       mash.keys.sort.should == converted.keys.sort
+#     end
+#
+#     it 'preserves value' do
+#       mash = Mash.new(@hash)
+#       converted = mash.to_hash
+#
+#       mash.values.sort.should == converted.values.sort
+#     end
+#   end
+#
+#
+#
+#   describe "#symbolize_keys" do
+#     it 'returns instance of Mash' do
+#       Mash.new(@hash).symbolize_keys.should be_an_instance_of(Hash)
+#     end
+#
+#     it 'converts keys to symbols' do
+#       mash = Mash.new(@hash)
+#       converted  = mash.symbolize_keys
+#
+#       converted_keys = converted.keys.sort{|k1, k2| k1.to_s <=> k2.to_s}
+#       orig_keys = mash.keys.map{|k| k.to_sym}.sort{|i1, i2| i1.to_s <=> i2.to_s}
+#
+#       converted_keys.should == orig_keys
+#     end
+#
+#     it 'preserves value' do
+#       mash = Mash.new(@hash)
+#       converted = mash.symbolize_keys
+#
+#       mash.values.sort.should == converted.values.sort
+#     end
+#   end
+#
+#
+#
+#   describe "#delete" do
+#     it 'converts Symbol key into String before deleting' do
+#       mash = Mash.new(@hash)
+#
+#       mash.delete(:hash)
+#       mash.key?("hash").should be(false)
+#     end
+#
+#     it 'works with String keys as well' do
+#       mash = Mash.new(@hash)
+#
+#       mash.delete("mash")
+#       mash.key?("mash").should be(false)
+#     end
+#   end
+#
+#
+#
+#   describe "#except" do
+#     it "converts Symbol key into String before calling super" do
+#       mash = Mash.new(@hash)
+#
+#       hashless_mash = mash.except(:hash)
+#       hashless_mash.key?("hash").should be(false)
+#     end
+#
+#     it "works with String keys as well" do
+#       mash = Mash.new(@hash)
+#
+#       mashless_mash = mash.except("mash")
+#       mashless_mash.key?("mash").should be(false)
+#     end
+#
+#     it "works with multiple keys" do
+#       mash = Mash.new(@hash)
+#
+#       mashless = mash.except("hash", :mash)
+#       mashless.key?(:hash).should be(false)
+#       mashless.key?("mash").should be(false)
+#     end
+#
+#     it "should return a mash" do
+#       mash = Mash.new(@hash)
+#
+#       hashless_mash = mash.except(:hash)
+#       hashless_mash.class.should be(Mash)
+#     end
+#   end
+#
+#
+#
+#   describe "#merge" do
+#     before(:each) do
+#       @mash = Mash.new(@hash).merge(:no => "in between")
+#     end
+#
+#     it 'returns instance of Mash' do
+#       @mash.should be_an_instance_of(Mash)
+#     end
+#
+#     it 'merges in give Hash' do
+#       @mash["no"].should == "in between"
+#     end
+#   end
+#
+#
+#
+#   describe "#fetch" do
+#     before(:each) do
+#       @mash = Mash.new(@hash).merge(:no => "in between")
+#     end
+#
+#     it 'converts key before fetching' do
+#       @mash.fetch("no").should == "in between"
+#     end
+#
+#     it 'returns alternative value if key lookup fails' do
+#       @mash.fetch("flying", "screwdriver").should == "screwdriver"
+#     end
+#   end
+#
+#
+#   describe "#default" do
+#     before(:each) do
+#       @mash = Mash.new(:yet_another_technical_revolution)
+#     end
+#
+#     it 'returns default value unless key exists in mash' do
+#       @mash.default("peak oil is now behind, baby").should == :yet_another_technical_revolution
+#     end
+#
+#     it 'returns existing value if key is Symbol and exists in mash' do
+#       @mash.update(:no => "in between")
+#       @mash.default(:no).should == "in between"
+#     end
+#   end
+#
+#
+#   describe "#values_at" do
+#     before(:each) do
+#       @mash = Mash.new(@hash).merge(:no => "in between")
+#     end
+#
+#     it 'is indifferent to whether keys are strings or symbols' do
+#       @mash.values_at("hash", :mash, :no).should == ["different", "indifferent", "in between"]
+#     end
+#   end
+#
+#
+#   describe "#stringify_keys!" do
+#     it 'returns the mash itself' do
+#       mash = Mash.new(@hash)
+#
+#       mash.stringify_keys!.object_id.should == mash.object_id
+#     end
+#   end
+# end

data/spec/{array → gorillib/array}/compact_blank_spec.rb

@@ -1,7 +1,7 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/array/compact_blank'
 
-describe Array do
+describe Array, :simple_spec => true do
 
   describe '#compact_blank' do
     it 'with empty' do

data/spec/{array → gorillib/array}/extract_options_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/array/extract_options'
 
 class HashSubclass < Hash
@@ -10,7 +10,7 @@ class ExtractableHashSubclass < Hash
   end
 end
 
-describe Array do
+describe Array, :simple_spec => true do
   describe '#extract_options!' do
     it 'pulls empty hash from empty array' do
       [].extract_options!.should == {}

data/spec/gorillib/builder_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+# libs under test
+require 'gorillib/builder'
+require 'gorillib/builder/field'
+
+# testing helpers
+require 'gorillib/hash/compact'
+require 'model_test_helpers'
+
+describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
+  let(:example_val  ){ mock('example val') }
+  subject{ car_class }
+
+  context 'examples:' do
+    subject{ car_class }
+    it 'type-converts values' do
+      obj = subject.receive(     :name => 'wildcat', :make_model => 'Buick Wildcat', :year => "1968", :doors => "2" )
+      obj.attributes.should == { :name => :wildcat,  :make_model => 'Buick Wildcat', :year =>  1968,  :doors =>  2, :engine => nil }
+    end
+    it 'handles nested structures' do
+      obj = subject.receive(
+        :name => 'wildcat', :make_model => 'Buick Wildcat', :year => "1968", :doors => "2",
+        :engine => { :carburetor => 'edelbrock', :volume => "455", :cylinders => '8' })
+      obj.attributes.values_at(:name, :make_model, :year, :doors).should == [:wildcat, 'Buick Wildcat', 1968,  2 ]
+      obj.engine.attributes.values_at(:carburetor, :volume, :cylinders).should == [:edelbrock, 455, 8 ]
+    end
+    it 'lets you dive down' do
+      wildcat.engine.attributes.values_at(:carburetor, :volume, :cylinders).should == [:stock, 455, 8 ]
+      wildcat.engine(:cylinders => 6) do
+        volume   383
+      end
+      wildcat.engine.attributes.values_at(:carburetor, :volume, :cylinders).should == [:stock, 383, 6 ]
+    end
+    it 'lazily autovivifies members' do
+      ford_39.read_attribute(:engine).should be_nil
+      ford_39.engine(:cylinders => 6)
+      ford_39.read_attribute(:engine).should be_a(Gorillib::Test::Engine)
+      ford_39.engine.read_attribute(:cylinders).should == 6
+    end
+  end
+
+  context 'receive!' do
+    it 'accepts a configurate block' do
+      expect_7 = nil ; expect_obj = nil
+      wildcat.receive!({}){    expect_7 = 7 ; expect_obj = self }
+      expect_7.should == 7 ; expect_obj.should  == wildcat
+      expect_7 = nil ; expect_obj = nil
+      wildcat.receive!({}){|c| expect_7 = 7 ; expect_obj = c }
+      expect_7.should    == 7 ; expect_obj.should  == wildcat
+    end
+  end
+
+  context ".field" do
+
+    context do
+      subject{ car_class.new }
+      let(:sample_val){ 'fiat' }
+      let(:raw_val   ){ :fiat  }
+      it_behaves_like "a model field", :make_model
+      it("#read_attribute is nil if never set"){ subject.read_attribute(:make_model).should == nil }
+    end
+
+    context 'calling the getset "#foo" method' do
+      subject{ wildcat }
+
+      it "with no args calls read_attribute(:foo)" do
+        subject.write_attribute(:doors, example_val)
+        subject.should_receive(:read_attribute).with(:doors).at_least(:once).and_return(example_val)
+        subject.doors.should == example_val
+      end
+      it "with an argument calls write_attribute(:foo)" do
+        subject.write_attribute(:doors, 'gone')
+        subject.should_receive(:write_attribute).with(:doors, example_val).and_return('returned')
+        result = subject.doors(example_val)
+        result.should == 'returned'
+      end
+      it "with multiple arguments is an error" do
+        expect{ subject.doors(1, 2) }.to raise_error(ArgumentError, "wrong number of arguments (2 for 0..1)")
+      end
+    end
+
+    it "does not create a writer method #foo=" do
+      subject{ car_class }
+      subject.should     be_method_defined(:doors)
+      subject.should_not be_method_defined(:doors=)
+    end
+  end
+
+  context ".member" do
+    subject{ car_class.new }
+    let(:sample_val){ example_engine }
+    let(:raw_val   ){ example_engine.attributes }
+    it_behaves_like "a model field", :engine
+    it("#read_attribute is nil if never set"){ subject.read_attribute(:engine).should == nil }
+
+    it "calling the getset method #foo with no args calls read_attribute(:foo)" do
+      wildcat.write_attribute(:doors, example_val)
+      wildcat.should_receive(:read_attribute).with(:doors).at_least(:once).and_return(example_val)
+      wildcat.doors.should == example_val
+    end
+    it "calling the getset method #foo with an argument calls write_attribute(:foo)" do
+      wildcat.write_attribute(:doors, 'gone')
+      wildcat.should_receive(:write_attribute).with(:doors, example_val).and_return('returned')
+      result = wildcat.doors(example_val)
+      result.should == 'returned'
+    end
+    it "calling the getset method #foo with multiple arguments is an error" do
+      ->{ wildcat.doors(1, 2) }.should raise_error(ArgumentError, "wrong number of arguments (2 for 0..1)")
+    end
+    it "does not create a writer method #foo=" do
+      wildcat.should     respond_to(:doors)
+      wildcat.should_not respond_to(:doors=)
+    end
+  end
+
+  context 'collections' do
+    subject{ garage }
+    let(:sample_val){ Gorillib::Collection.receive([wildcat], car_class, :name) }
+    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::Collection.new }
+
+    it 'a collection holds named objects' do
+      garage.cars.should be_empty
+
+      # create a car with a hash of attributes
+      garage.car(:cadzilla, :make_model => 'Cadillac, Mostly')
+      # ...and retrieve it by name
+      cadzilla = garage.car(:cadzilla)
+
+      # add a car explicitly
+      garage.car(:wildcat,  wildcat)
+      garage.car(:wildcat).should     equal(wildcat)
+
+      # duplicate a car
+      garage.car(:ford_39, ford_39.attributes.compact)
+      garage.car(:ford_39).should     ==(ford_39)
+      garage.car(:ford_39).should_not equal(ford_39)
+
+      # examine the whole collection
+      garage.cars.keys.should == [:cadzilla, :wildcat, :ford_39]
+      garage.cars.should == Gorillib::Collection.receive([cadzilla, wildcat, ford_39], car_class, :name)
+    end
+    it 'lazily autovivifies collection items' do
+      garage.cars.should be_empty
+      garage.car(:chimera).should be_a(car_class)
+      garage.cars.should == Gorillib::Collection.receive([{:name => :chimera}], car_class, :name)
+    end
+
+    context 'collection getset method' do
+      it 'clxn(:name, existing_object) -- replaces with given object, does not call block' do
+        test = nil
+        subject.car(:wildcat, wildcat).should equal(wildcat){ test = 3 }
+        test.should be_nil
+      end
+      it 'clxn(:name) (missing & no attributes given) -- autovivifies' do
+        subject.car(:cadzilla).should == Gorillib::Test::Car.new(:name => :cadzilla)
+      end
+      it 'clxn(:name, &block) (missing & no attributes given) -- autovivifies, execs block' do
+        test = nil
+        subject.car(:cadzilla){ test = 7 }
+        test.should == 7
+      end
+      it 'clxn(:name, :attr => val) (missing, attributes given) -- creates item' do
+        subject.car(:cadzilla, :doors => 3).should == Gorillib::Test::Car.new(:name => :cadzilla, :doors => 3)
+      end
+      it 'clxn(:name, :attr => val) (missing, attributes given) -- creates item, execs block' do
+        test = nil
+        subject.car(:cadzilla, :doors => 3){ test = 7 }
+        test.should == 7
+      end
+      it 'clxn(:name, :attr => val) (present, attributes given) -- updates item' do
+        subject.car(:wildcat, wildcat)
+        subject.car(:wildcat, :doors => 9)
+        wildcat.doors.should == 9
+      end
+      it 'clxn(:name, :attr => val) (present, attributes given) -- updates item, execs block' do
+        subject.car(:wildcat, wildcat)
+        subject.car(:wildcat, :doors => 9){ self.make_model 'WILDCAT' }
+        wildcat.doors.should == 9
+        wildcat.make_model.should == 'WILDCAT'
+      end
+
+    end
+  end
+end

data/spec/gorillib/collection_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+#
+require 'gorillib/model'
+require 'gorillib/model/field'
+require 'gorillib/model/defaults'
+#
+require 'model_test_helpers'
+
+module Gorillib::Test       ; end
+module Meta::Gorillib::Test ; end
+
+describe Gorillib::Collection, :model_spec => true do
+  it 'needs more tests'
+  let(:collection_with_mock_clxn) do
+    coll = described_class.new
+    coll.send(:define_singleton_method, :mock_clxn){ @clxn }
+    coll.send(:instance_variable_set, :@clxn, mock('clxn hash') )
+  end
+
+end

data/spec/gorillib/configurable_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'gorillib/configurable'
+
+describe Gorillib::Configurable do
+  include_context 'included_module'
+  
+  it 'defines a config() method on the class' do
+    subject.should respond_to(:config)
+  end
+  
+  it 'creates a class attribute :settings' do
+    subject.should respond_to(:settings)
+    subject.receive.should respond_to(:settings)
+  end
+  
+  it 'creates a class attribute :configuration_scope' do
+    subject.should respond_to(:configuration_scope)
+    subject.receive.should respond_to(:configuration_scope)      
+  end
+  
+  context 'config' do
+    let(:test_field)   { :gonads  }
+    let(:test_default) { 'strife' }
+    let(:test_type)    { String   }
+    
+    before(:each) { subject.config(test_field, test_type, :default => test_default) }
+    
+    # it 'defines a field on settings with optional defaults' do
+    #   subject.settings.send(test_field).should == test_default
+    # end
+    
+    it 'defines a receiver for the given field' do
+      subject.receive.send(test_field).should == test_default
+    end
+    
+  end
+  
+  context 'receive' do
+    
+    it 'resolves configuration in order' do
+      subject.settings.should_receive(:load_configuration_in_order!).and_return({})
+      subject.receive
+    end
+    
+    before do
+      subject.class_eval do
+        config :yo_momma, String, :default => 'is so ugly'
+        config :she,      String
+      end
+      subject.stub(:settings).and_return(test_settings) 
+    end
+    
+    let(:creation_attrs) { { yo_momma: 'is so fat',  she: 'eats wheat THICKS'       } }    
+    let(:configuration)  { { yo_momma: 'is so dumb', she: 'got hit by a parked car' } }
+    let(:test_settings)  { double :settings, :load_configuration_in_order! => configuration }
+    
+    it 'overrides attributes with configuration settings' do
+      subject.receive(creation_attrs).attributes.should include(creation_attrs.merge(configuration))
+    end
+  end
+end
+

data/spec/{datetime → gorillib/datetime}/parse_spec.rb

@@ -1,8 +1,8 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/datetime/flat'
+require 'spec_helper'
+require 'gorillib/datetime/to_flat'
 require 'gorillib/datetime/parse'
 
-describe DateTime do
+describe Time, :datetime_spec => true do
   describe '#parse_safely' do
     before do
       @time_utc  = Time.parse("2011-02-03T04:05:06 UTC")

data/spec/{datetime/flat_spec.rb → gorillib/datetime/to_flat_spec.rb}

@@ -1,8 +1,8 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/datetime/flat'
+require 'spec_helper'
+require 'gorillib/datetime/to_flat'
 require 'gorillib/datetime/parse'
 
-describe Time do
+describe Time, :datetime_spec => true do
   describe '#to_flat' do
     before do
       @time_utc  = Time.parse("2011-02-03T04:05:06 UTC")
@@ -23,7 +23,7 @@ describe Time do
   end
 end
 
-describe Date do
+describe Date, :datetime_spec => true do
   describe '#to_flat' do
     before do
       @date      = Date.new(2011, 2, 3)

data/spec/{enumerable → gorillib/enumerable}/sum_spec.rb

@@ -1,12 +1,12 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/enumerable/sum'
 
 Payment = Struct.new(:price)
 class SummablePayment < Payment
-  def +(p) self.class.new(price + p.price) end
+  def +(val) self.class.new(price + val.price) end
 end
 
-describe Enumerable do
+describe Enumerable, :simple_spec => true do
   describe '#sum' do
     it 'sums lists of numbers to a number' do
       [5, 15, 10].sum        .should == 30
@@ -27,8 +27,8 @@ describe Enumerable do
 
     it 'sums object with a synthetic "+" method' do
       payments = [ SummablePayment.new(5), SummablePayment.new(15) ]
-      payments.sum        .should == SummablePayment.new(20)
-      payments.sum{|p| p }.should == SummablePayment.new(20)
+      payments.sum            .should == SummablePayment.new(20)
+      payments.sum{|val| val }.should == SummablePayment.new(20)
     end
 
     it 'handles nil sums' do