gorillib 0.4.0pre → 0.4.1pre

data/notes/structured-data-classes.md

@@ -0,0 +1,127 @@
+# gorillib's structured data classes -- Record, Model, Builder and Bucket
+
+## Overview
+
+Gorillib provides these general flavors of model:
+
+* `Gorillib::Record`: **lightweight structured records**. Easily assemble a dynamic data structure that enables both rich behavior and generic manipulation, serialization and transformation. Especially useful when you just need to pull something from JSON, attach some functionality, and get it back on the wire.
+
+      ```ruby
+      class Place
+        include Gorillib::Record
+        # fields can be simple...
+        field :name, String
+        field :country_id, String, :doc => 'Country code (2-letter alpha) containing the place'
+        # ... or complext
+        field :geo, GeoCoordinates, :doc => 'geographic location of the place'
+      end
+      
+      class GeoCoordinates
+        include Gorillib::Record
+        field :latitude,  Float, :doc => 'latitude in decimal degrees; negative numbers are south of the equator'
+        field :longitude, Float, :doc => 'longitude in decimal degrees; negative numbers are west of Greenwich'
+      end
+
+      # It's simple to instantiate complex nested data structures
+      lunch_spot = Place.receive({ :name => "Torchy's Tacos", :country_id => "us",
+        :geo => { :latitude => "30.295", :longitude => "-97.745" }})
+      ```
+
+* `Gorillib::Model`: **rich structured models** offering predictable magic with a disciplined footprint. Comparable to ActiveRecord or Datamapper, but for a world dominated by JSON+HTTP, not relational databases
+
+      ```ruby
+      class GeoCoordinates
+        include Gorillib::Model
+        field :latitude,  Float, :doc => 'latitude in decimal degrees; negative numbers are south of the equator', :validates => { :numericality => { :>= =>  -90, :<= =>  90  } }
+        field :longitude, Float, :doc => 'longitude in decimal degrees; negative numbers are west of Greenwich', :validates => { :numericality => { :>= => -180, :<= => 180  } }
+      end
+      position = GeoCoordinates.from_tuple(30.295, -97.745)
+      # A Gorillib::Model obeys the ActiveModel contract
+      GeoCoordinates.model_name.human # => 'Geo coordinates'
+      ```
+
+* `Gorillib::Builder`: **foundation models for elegant ruby DSLs** (Domain-Specific Languages). Relaxes ruby syntax to enable highly-readable specification of complex behavior.
+
+      ```ruby
+      workflow(:bake_pie) do
+        step   :make_crust
+        step   :add_filling
+        step   :bake
+        step   :cool
+      end
+      ```
+
+* `Gorillib::Bucket` (?name?): **record-style access to freeform hashes**. Provide a disciplined interface on top of arbitrarily-structured data. Used by [[Configliere]] and others.
+
+       ```ruby
+       # pre-defining a field gives you special powers...
+       Settings.define :port,   Integer, :doc => 'API server port number', :default => 80
+       # but you can still store or read anything you'd like...
+       Settings[:shout] = "SAN DIMAS HIGH SCHOOL FOOTBALL RULES"
+       # and treat the object as a hash when you'd like to
+       conn = Connections.open(Settings.merge(user_overrides))
+       ```
+
+## Decisions
+
+* **initializer** - *does not* inject an initializer; if you want one, do `alias_method :initialize, :receive!`
+* **frills** --
+  - *does inject*: `inspect` on the class, `inspect`, `to_s` on the instance
+  - *does inject*: accessors (`foo`, `foo=`) for each field.
+  - *does inject*: `==` on the instance
+  - *does not define*: `schema`, `initialize`
+* **field defaults** - evaluated on first read, at which point its value is fixed on the record.
+
+* **define_metamodel_record** -- visibility=false does not remove an existing method from the metamodel
+
+* ?? **hash vs mash** -- does `attributes` return a mash or hash?
+* are these basic functionality:
+  - **extra_attributes** -- ??
+  - **default**          -- ??
+
+* Record:
+  - class methods -- `field`, `fields`, `field_names`, `has_field?`, `metamodel`, `receive`, `inspect`
+  - instance methods  -- `read_attribute`, `write_attribute`, `unset_attribute`, `attribute_set?`, `attributes`, `receive!`, `update`, `inspect`, `to_s`, `==`
+  - with each attribute  -- `receive_foo`, `foo=`, `foo`
+
+* Builder:
+  - defining classes before they're used
+
+
+## Features
+
+### `Record`
+
+* `Record::Ordered`       -- sort order on fields (and thus record)
+* `Record::FieldAliasing` -- aliases for fields and receivers
+* `Record::Defaults`      -- default values
+* `Record::Schema`        -- icss schema
+* `Record::HashAccessors` -- adds `[]`, `[]=`, `delete`, `keys`, `#has_key?`, `to_hash`, and `update`. This allows it to be `hashlike`, but you must include that explicitly.
+* `Record::Hashlike`      -- mixes in `Record::HashAccessors` and `Gorillib::Hashlike`, making it behave in almost every respect like a hash. Use this when you want something that will *behave* like a hash but *be* a record. If you want something to *be* a hash but *behave* like a record, use the `Gorillib::MashRecord`
+
+### `Builder`
+
+* `Builder::GetsetField`  --
+
+### `HashRecord`
+
+### `Model`
+
+* `Model::Naming`
+* `Model::Conversion`     --
+
+### active_model / active_model_lite
+
+From `active_model` or `active_model_lite`:
+
+* `Model::Callbacks`      --
+* `Model::Dirty`          --
+* `Model::Serialization`  --
+* `Model::Validations`    -- implies `Model::Errors`, `Model::Callbacks`
+
+
+## Why, in a world with ActiveRecord, Datamapper, Hashie, Struct, ..., do we need yet another damn model framework?
+
+ActiveRecord and Datamapper excel in a world where data (and truth) live in the database. ActiveRecord sets the standard for elegant magic, but is fairly heavyweight (I don't want to include a full XML serialization suite just so I can validate records). This often means it's overkill for the myriad flyweight scripts, Goliath apps, and such that we deploy. Datamapper does a remarkable job of delivering power while still being light on its toes, but ultimately is too tightly bound to an ORM view of the world. Hashie, Structs and OStructs behave as both hashes and records. In my experience, this interface is too generous -- their use leads to mealymouthed code.
+
+More importantly, our data spends most of its time on the wire or being handled as an opaque blob of data; a good amount of time being handled as a generic bundle of properties; and (though most important) a relatively small amount of time as an active, assertive object. So type conversion and validation are fundamental actions, but shouldn't crud up my critical path or be required. Models should offer predictable and disciplined features, but be accessable as generic bags of facts.

data/spec/array/average_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'gorillib/array/average'
+
+describe Array do
+  describe '#average' do
+    context 'on non-float array element' do
+      it 'raises error' do
+        expect { [0.0, :b, 1.0].average }.should raise_error(ArgumentError)
+      end
+    end
+
+    context 'with empty' do
+      it 'returns nil' do
+        [].average.should be_nil
+      end
+    end
+
+    context 'given a numerical array' do
+      it 'returns the average of the elements' do
+        (1..10).to_a.average.should == 5.5
+      end
+    end
+  end
+end

data/spec/array/sorted_median_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'gorillib/array/sorted_median'
+
+describe Array do
+  describe '#sorted_median' do
+    context 'with empty' do
+      it 'returns nil' do
+        [].sorted_median.should be_nil
+      end
+    end
+
+    context 'given any array' do
+      it 'returns the middle element of odd-sized arrays' do
+        ("a".."y").to_a.sorted_median.should == "m"
+      end
+    end
+  end
+end

data/spec/array/sorted_percentile_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'gorillib/array/sorted_percentile'
+
+describe Array do
+  describe '#sorted_percentile' do
+    context 'with empty' do
+      it 'returns nil' do
+        [].sorted_percentile(0.0).should be_nil
+      end
+    end
+
+    context 'given any array' do
+      it 'returns the element closest to the given percentile' do
+        ("a".."y").to_a.sorted_percentile(  0.0).should == "a"
+        ("a".."y").to_a.sorted_percentile( 50.0).should == "m"
+        ("a".."y").to_a.sorted_percentile(100.0).should == "y"
+      end
+    end
+
+    # (Please do not define behavior for two elements equally close to
+    # a given percentile.)
+
+  end
+end

data/spec/array/sorted_sample_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'gorillib/array/sorted_sample'
+
+describe Array do
+  describe '#sorted_median' do
+    context 'with empty' do
+      it 'returns an empty array' do
+        [].sorted_sample(1).should be_empty
+      end
+    end
+
+    context 'given an undersized array' do
+      it 'does not return the same element more than once' do
+        ("a".."z").to_a.sorted_sample(27).should == ("a".."z").to_a
+      end
+    end
+
+    context 'given any array' do
+      it ('returns a sample of the given size as close to evenly ' \
+          'distributed over the array as possible') do
+        sample = (1..100).to_a.sorted_sample(26)
+        deltas = sample[0..-2].zip(sample[1..-1]).map{|a,b| b-a}
+        deltas.max.should <= 4
+        deltas.min.should >= 3
+      end
+    end
+  end
+end

data/spec/gorillib/builder_spec.rb

@@ -3,23 +3,39 @@ require 'spec_helper'
 # 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(:example_val  ){ mock('example val') }
-  subject{ car_class }
+
+  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)
+  #
+  it_behaves_like 'a model'
 
   context 'examples:' do
-    subject{ car_class }
+    let(:subject_class  ){ car_class }
     it 'type-converts values' do
-      obj = subject.receive(     :name => 'wildcat', :make_model => 'Buick Wildcat', :year => "1968", :doors => "2" )
+      obj = subject_class.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(
+      obj = subject_class.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 ]
@@ -41,18 +57,20 @@ describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
   end
 
   context 'receive!' do
-    it 'accepts a configurate block' do
+    it 'with a block, instance evals the block' do
       expect_7 = nil ; expect_obj = nil
       wildcat.receive!({}){    expect_7 = 7 ; expect_obj = self }
       expect_7.should == 7 ; expect_obj.should  == wildcat
+    end
+    it 'with a block of arity 1, calls the block passing self' do
       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 ".magic" do
+    let(:subject_class){ car_class }
     context do
       subject{ car_class.new }
       let(:sample_val){ 'fiat' }
@@ -61,30 +79,29 @@ describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
       it("#read_attribute is nil if never set"){ subject.read_attribute(:make_model).should == nil }
     end
 
+    it "does not create a writer method #foo=" do
+      subject_class.should     be_method_defined(:doors)
+      subject_class.should_not be_method_defined(:doors=)
+    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
+        subject.write_attribute(:doors, mock_val)
+        subject.should_receive(:read_attribute).with(:doors).at_least(:once).and_return(mock_val)
+        subject.doors.should == mock_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)
+        subject.should_receive(:write_attribute).with(:doors, mock_val).and_return('returned')
+        result = subject.doors(mock_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
@@ -95,14 +112,14 @@ describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
     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
+      wildcat.write_attribute(:doors, mock_val)
+      wildcat.should_receive(:read_attribute).with(:doors).at_least(:once).and_return(mock_val)
+      wildcat.doors.should == mock_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)
+      wildcat.should_receive(:write_attribute).with(:doors, mock_val).and_return('returned')
+      result = wildcat.doors(mock_val)
       result.should == 'returned'
     end
     it "calling the getset method #foo with multiple arguments is an error" do
@@ -116,10 +133,10 @@ describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
 
   context 'collections' do
     subject{ garage }
-    let(:sample_val){ Gorillib::Collection.receive([wildcat], car_class, :name) }
+    let(:sample_val){ Gorillib::ModelCollection.receive([wildcat], :name, 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::Collection.new }
+    it("#read_attribute is an empty collection if never set"){ subject.read_attribute(:cars).should == Gorillib::ModelCollection.new }
 
     it 'a collection holds named objects' do
       garage.cars.should be_empty
@@ -140,12 +157,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::Collection.receive([cadzilla, wildcat, ford_39], car_class, :name)
+      garage.cars.should == Gorillib::ModelCollection.receive([cadzilla, wildcat, ford_39], :name, 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::Collection.receive([{:name => :chimera}], car_class, :name)
+      garage.cars.should == Gorillib::ModelCollection.receive([{:name => :chimera}], :name, car_class)
     end
 
     context 'collection getset method' do

data/spec/gorillib/collection_spec.rb

@@ -1,20 +1,205 @@
 require 'spec_helper'
 #
 require 'gorillib/model'
-require 'gorillib/model/field'
-require 'gorillib/model/defaults'
-#
+require 'gorillib/collection/model_collection'
+require 'gorillib/collection/list_collection'
 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
+shared_context :collection_spec do
+  # a collection with the internal :clxn mocked out, and a method 'innards' to
+  # let you access it.
+  let(:collection_with_mock_innards) do
     coll = described_class.new
-    coll.send(:define_singleton_method, :mock_clxn){ @clxn }
     coll.send(:instance_variable_set, :@clxn, mock('clxn hash') )
+    coll.send(:define_singleton_method, :innards){ @clxn }
+  end
+end
+
+shared_examples_for 'a collection' do
+  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_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
+
+  # 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
+  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
+    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, /(key not found: 69|index 69 outside)/
+    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, :collection_spec do
+
+  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'
+  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'
+
+    # 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"
+
+  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'
+  end
 end

data/spec/gorillib/model/lint_spec.rb

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