icss 0.1.3 → 0.3.2

data/spec/type/record_schema_spec.rb

@@ -0,0 +1,161 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'yaml'
+require 'gorillib/object/try_dup'
+require 'icss/receiver_model/acts_as_hash'
+require 'icss/receiver_model/active_model_shim'
+require 'icss/type'                   #
+require 'icss/type/simple_types'      # Boolean, Integer, ...
+require 'icss/type/named_type'        # class methods for a named type: .metamodel .doc, .fullname, &c
+require 'icss/type/record_type'       # class methods for a record model: .field, .receive,
+require 'icss/type/record_model'      # instance methods for a record model
+require 'icss/type/type_factory'      # factory for instances based on type
+require 'icss/type/structured_schema' # generate type from array, hash, &c schema
+require 'icss/type/record_schema'
+require 'icss/type/record_field'
+
+require ENV.root_path('spec/support/icss_test_helper')
+include IcssTestHelper
+
+module Icss
+  module This
+    module That
+      class TheOther
+        def bob
+          'hi bob'
+        end
+      end
+    end
+    module Right
+      class Here
+        include Icss::Meta::RecordModel
+      end
+      class OverThere < Here
+      end
+    end
+  end
+  class ::Icss::Numeric < ::Numeric ; end
+end
+
+include IcssTestHelper
+
+describe Icss::Meta::RecordSchema do
+
+  BASIC_RECORD_SCHEMA = {:type => :record, :name => 'business.restaurant',
+    :doc => "y'know, for food and stuff",
+    :fields => [ { :name => 'menu', :type => 'string' } ] }
+  before(:each) do
+    remove_icss_constants('Business::Restaurant')
+    remove_icss_constants(:LabExperiment, :DayOfWeek, :GeoCoordinates)
+  end
+
+  describe "With basic schema" do
+    before(:each) do
+      @model_klass = Icss::Meta::RecordSchema.receive(BASIC_RECORD_SCHEMA)
+      @schema_writer = @model_klass._schema
+    end
+
+    it 'has schema_writer' do
+      @schema_writer.type.should  == :record
+      @schema_writer.fullname.should == 'business.restaurant'
+      @schema_writer.fields.length.should == 1
+    end
+
+    it 'creates a named class' do
+      @model_klass.name.to_s.should              == 'Icss::Business::Restaurant'
+      Icss::Business::Restaurant.fullname.should == "business.restaurant"
+      Icss::Business::Restaurant.doc.should      == "y'know, for food and stuff"
+    end
+
+    it 'has accessors and receivers for the fields' do
+      blank_model = Class.new{ include Icss::Meta::RecordModel }
+      (@model_klass.public_methods - blank_model.public_methods).sort.should == [
+        :_domain_id_field, :_schema, :is_a, :_doc_hints,
+      ].sort.uniq
+      (@model_klass.public_instance_methods - Object.public_instance_methods).sort.should == [
+        :attr_set?, :menu, :menu=, :receive!, :receive_menu
+      ].sort.uniq
+    end
+  end
+
+  describe '#is_a' do
+    [
+      [ [Icss::This::That::TheOther],               ['Icss::This::That::TheOther']],
+      [ ['this.that.the_other'],                    ['Icss::This::That::TheOther'] ],
+      [ ['this.right.here'],                        ['Icss::This::Right::Here',    'Icss::Meta::This::Right::HereModel'] ],
+      [ ['this.that.the_other', 'this.right.here'], ['Icss::This::That::TheOther', 'Icss::Meta::This::Right::HereModel'] ],
+    ].each do |given_is_a, expected_superklasses|
+      it "sets a superclass from #{given_is_a}" do
+        schema_hsh = BASIC_RECORD_SCHEMA.merge(:is_a => given_is_a)
+        @model_klass = Icss::Meta::RecordSchema.receive(schema_hsh)
+        expected_superklasses.each do |superklass|
+          @model_klass.should < superklass.constantize
+        end
+      end
+    end
+
+    it 'does NOT follow superclasses of multiple inheritance parents' do
+      schema_hsh = BASIC_RECORD_SCHEMA.merge(:is_a => ['this.that.the_other', 'this.right.over_there'])
+      @model_klass = Icss::Meta::RecordSchema.receive(schema_hsh)
+      @model_klass.should     <  Icss::This::That::TheOther
+      @model_klass.should_not <  Icss::This::Right::OverThere
+      @model_klass.should     <  Icss::This::Right::OverThere.metamodel
+      @model_klass.should_not <  Icss::This::Right::Here
+      @model_klass.should_not <  Icss::This::Right::Here.metamodel
+    end
+
+    it 'does allow explicitly-listed superclasses of multiple inheritance parents' do
+      schema_hsh = BASIC_RECORD_SCHEMA.merge(:is_a => ['this.that.the_other', 'this.right.over_there', 'this.right.here'])
+      @model_klass = Icss::Meta::RecordSchema.receive(schema_hsh)
+      @model_klass.should     <  Icss::This::That::TheOther
+      @model_klass.should_not <  Icss::This::Right::OverThere
+      @model_klass.should     <  Icss::This::Right::OverThere.metamodel
+      @model_klass.should_not <  Icss::This::Right::Here
+      @model_klass.should     <  Icss::This::Right::Here.metamodel
+    end
+  end
+end
+
+describe Icss::Meta::RecordModel do
+  context 'record schema' do
+    before do
+      @klass = Icss::Meta::TypeFactory.receive({
+          'type'   => 'record',
+          'name'   => 'lab_experiment',
+          'is_a'   => ['this.that.the_other', 'this.right.here'],
+          'fields' => [
+            { 'name' => 'temperature', 'type' => 'float' },
+            { 'name' => 'day', 'type' => {
+                'name' => 'day_of_week', :type => 'enum',
+                'symbols' => [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday] }},
+            { 'name' => 'geo', 'type' => {
+                :type => 'record', 'name' => 'geo_coordinates',
+                'fields' => [
+                  { 'name' => 'latitude',  'type' => 'float' },
+                  { 'name' => 'longitude', 'type' => 'float' },
+                  { 'name' => 'spatial_extent', 'type' =>
+                    { 'type' => 'array', 'items' => {
+                        'type' => 'array', 'items' => 'float' }}},
+              ]}},
+          ] })
+      @obj = @klass.receive({ :temperature => 97.4, :day => 'tuesday',
+          :geo => {
+            'longitude' => '-97.75', :latitude => "30.03",
+            'spatial_extent' => [ ['-97.75', '30.03'], ['-97.70', '30.1'], ['-97.90', '30.1'] ]
+          } })
+    end
+    it 'handles array of record of ...' do
+      @klass.to_s.should == 'Icss::LabExperiment'
+      @obj.should be_a(@klass)
+      @obj.should be_a(Icss::This::That::TheOther)
+      @obj.should be_a(Icss::This::Right::Here.metamodel)
+    end
+    it 'receives data' do
+      @obj.temperature.should == 97.4
+      @obj.day.should == :tuesday
+      @obj.geo.latitude.should == 30.03
+      @obj.geo.longitude.should == -97.75
+      @obj.geo.should be_a(Icss::GeoCoordinates)
+      @obj.geo.spatial_extent.should == [ [-97.75, 30.03], [-97.70, 30.1], [-97.90, 30.1] ]
+    end
+  end
+end

data/spec/type/record_type_spec.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gorillib/object/try_dup'
+require 'icss/receiver_model/acts_as_hash'
+require 'icss/receiver_model/acts_as_loadable'
+require 'icss/receiver_model/acts_as_catalog'
+require 'icss/type'
+require 'icss/type/simple_types'
+require 'icss/type/named_type'
+require 'icss/type/record_type'
+require 'icss/type/record_model'      # instance methods for a record model
+require 'icss/type/type_factory'      #
+require 'icss/type/structured_schema'
+#
+require 'icss'
+#
+require ENV.root_path('spec/support/icss_test_helper')
+include IcssTestHelper
+
+describe Icss::Meta::RecordType do
+
+  before(:each) do
+    IcssTestHelper.remove_icss_constants('Smurf::Poppa', 'Smurf::Brainy', 'Smurf::Smurfette')
+    module Icss
+      module Smurf
+        class Poppa < Icss::SmurfRecord
+          field :smurfiness, :int
+        end
+        module Brainy
+          include Icss::Meta::RecordModel
+          field :has_glasses, Boolean
+        end
+        class Smurfette < Poppa
+          include Brainy
+          field :blondness, Integer
+        end
+      end
+    end
+  end
+
+  let(:new_smurf_klass){ k = Class.new(Icss::Smurf::Poppa)  }
+  let(:module_smurf   ){ m = Module.new; m.send(:extend, Icss::Meta::RecordType) ; m }
+  let(:poppa          ){ Icss::Smurf::Poppa.new() }
+  let(:smurfette      ){ Icss::Smurf::Smurfette.new() }
+
+  it 'adds few class methods' do
+    (Icss::Smurf::Smurfette.public_methods - Class.public_methods).sort.should == [
+      :after_receive, :after_receivers,
+      :field, :field_names, :fields, :has_field?, :field_named,
+      :metamodel, :to_schema, :is_core?,
+      :fullname, :namespace, :basename, :doc, :doc=,
+      :rcvr, :rcvr_alias, :rcvr_remaining, :receive, :pathname
+    ].sort
+  end
+  it 'adds few methods' do
+    (Icss::Smurf::Smurfette.new.public_methods -
+      Object.public_methods -
+      [ :attr_set?, :receive!, ] # maybe added later by record_model, they're OK
+      ).sort.should == [
+      :blondness, :blondness=, :has_glasses, :has_glasses=,
+      :receive_blondness,:receive_has_glasses,
+      :receive_smurfiness, :smurfiness, :smurfiness=
+    ].sort
+  end
+
+  context '.field' do
+    it 'adds field names' do
+      Icss::Smurf::Poppa.field_names.should == [:smurfiness]
+    end
+    it 'adds field info' do
+      Icss::Smurf::Poppa.field_named(:smurfiness).to_hash.should == {:name => :smurfiness, :type => :int}
+    end
+    it 'inherits parent fields' do
+      new_smurf_klass.field(:birthday, :time)
+      Icss::Smurf::Poppa.field_names.should == [:smurfiness]
+      Icss::Smurf::Poppa.field_named(:smurfiness).to_hash.should == {:name => :smurfiness, :type => :int}
+      new_smurf_klass.field_names.should == [:smurfiness, :birthday]
+      new_smurf_klass.field_named(:smurfiness).to_hash.should == {:name => :smurfiness, :type => :int}
+      new_smurf_klass.field_named(:birthday  ).to_hash.should == {:name => :birthday,   :type => :time}
+    end
+    it 'sets accessor visibility' do
+      new_smurf_klass.field(:field_1, Integer, :accessor => :none)
+      new_smurf_klass.field(:field_2, Integer, :accessor => :private)
+      new_smurf_klass.field(:field_3, Integer, :accessor => :protected)
+      new_smurf = new_smurf_klass.new
+      new_smurf.should_not respond_to('field_1=')
+      new_smurf.should_not respond_to('field_1')
+      lambda{ new_smurf.field_2 = :hi }.should raise_error(NoMethodError, /private method \`field_2=/)
+      lambda{ new_smurf.field_2       }.should raise_error(NoMethodError, /private method \`field_2/)
+      lambda{ new_smurf.field_3 = :yo }.should raise_error(NoMethodError, /protected method \`field_3=/)
+      lambda{ new_smurf.field_3       }.should raise_error(NoMethodError, /protected method \`field_3/)
+    end
+  end
+
+  context '.fields' do
+    it 'inheritance works without weirdness' do
+      Icss::Smurf::Poppa.field_names.should     == [:smurfiness]
+      Icss::Smurf::Smurfette.field_names.should == [:smurfiness, :has_glasses, :blondness]
+      Icss::Smurf::Brainy.field_names.should    == [:has_glasses]
+    end
+    #
+    it 'fields dynamically added to superclasses appear, in order of ancestry' do
+      new_smurf_klass.send(:include, module_smurf)
+      module_smurf.field_names.should == []
+      new_smurf_klass.field_names.should    == [:smurfiness]
+      #
+      module_smurf.field(:smurfberries, :integer)
+      new_smurf_klass.field_names.should    == [:smurfiness, :smurfberries]
+      #
+      new_smurf_klass.field(:singing, :boolean)
+      module_smurf.field(:smurfberry_crunch, :integer)
+      new_smurf_klass.field_names.should    == [:smurfiness, :smurfberries, :smurfberry_crunch, :singing]
+    end
+    #
+    it 're-announcing a field modifies its info hash downstream without rearranging' do
+      uncle_smurf = Class.new(Icss::Smurf::Poppa)
+      baby_smurf  = Class.new(uncle_smurf)
+      baby_smurf.field_names.should == [:smurfiness]
+      uncle_smurf.field_named(:smurfiness).to_hash.should == {:name => :smurfiness, :type => :int}
+      baby_smurf.field_named( :smurfiness).to_hash.should == {:name => :smurfiness, :type => :int}
+      #
+      uncle_smurf.field(:smurfiness, :float, :validates => { :numericality => true })
+      Icss::Smurf::Poppa.field_named(:smurfiness).to_hash.should == {:name => :smurfiness, :type => :int}
+      uncle_smurf.field_named(:smurfiness).to_hash.should == {:name => :smurfiness, :type => :float, :validates => { :numericality => true }}
+      baby_smurf.field_named(:smurfiness ).to_hash.should == {:name => :smurfiness, :type => :float, :validates => { :numericality => true }}
+    end
+    it 'does not override an existing method' do
+      new_smurf_klass.class_eval{ def foo() "hello!" end }
+      new_smurf_klass.field :foo, String
+      new_smurf_klass.new.foo.should == "hello!"
+    end
+  end
+
+  context 'class schema' do
+    it "has .fullname, .namespace, .basename, and .doc" do
+      [:fullname, :namespace, :basename, :doc].each do |meth|
+        Icss::Smurf::Smurfette.should         respond_to(meth)
+        Icss::Smurf::Smurfette.new.should_not respond_to(meth)
+      end
+    end
+    it "name corresponds to its class & module scope" do
+      Icss::Smurf::Smurfette.basename.should  == 'smurfette'
+      Icss::Smurf::Smurfette.namespace.should == 'smurf'
+      Icss::Smurf::Smurfette.fullname.should  == 'smurf.smurfette'
+    end
+    it "has a settable doc string" do
+      Icss::Smurf::Poppa.doc = "Poppa Doc: be cool with them Haitians"
+      Icss::Smurf::Poppa.doc.should     == "Poppa Doc: be cool with them Haitians"
+      Icss::Smurf::Smurfette.doc.should == "Poppa Doc: be cool with them Haitians"
+      Icss::Smurf::Smurfette.doc        =  "Gentlesmurfs prefer blondes"
+      Icss::Smurf::Smurfette.doc.should == "Gentlesmurfs prefer blondes"
+      Icss::Smurf::Poppa.doc.should     == "Poppa Doc: be cool with them Haitians"
+    end
+  end
+
+end

data/spec/type/simple_types_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'time'
+require 'icss/type'
+require 'icss/type/simple_types'
+require ENV.root_path('spec/support/icss_test_helper')
+include IcssTestHelper
+
+describe 'Icss::SIMPLE_TYPES' do
+  it('tests all of them'){ SIMPLE_TYPES_TO_TEST.values.map(&:first).map(&:to_s).sort.should == Icss::SIMPLE_TYPES.values.map(&:to_s).sort }
+  it('tests all of them'){ SIMPLE_TYPES_TO_TEST.keys.map(&:to_s).sort.should                == Icss::SIMPLE_TYPES.keys.map(&:to_s).sort   }
+
+  SIMPLE_TYPES_TO_TEST.each do |basename, (type_klass, parent_base_class, parent_instance)|
+    context type_klass do
+      it 'is named in Icss::SIMPLE_TYPES' do
+        basename = Icss::SIMPLE_TYPES.key(type_klass)
+        type_klass.to_schema == basename
+      end
+      it 'is named in Icss::SIMPLE_TYPES' do
+        basename = Icss::SIMPLE_TYPES.key(type_klass)
+        type_klass.to_schema == basename
+      end
+      it 'returns its type name as its schema' do
+        schema = type_klass.to_schema
+        schema.should be_a(Symbol)
+        Icss::SIMPLE_TYPES[schema].should == type_klass
+      end
+      it 'is simple? and simple?, but not record? or union?' do
+        Icss::Meta::Type.simple?( type_klass).should be_true
+        Icss::Meta::Type.simple?(    type_klass).should be_true
+        Icss::Meta::Type.union?(     type_klass).should be_false
+        Icss::Meta::Type.record?(    type_klass).should be_false
+      end
+
+      it 'descends from a base type' do
+        type_klass.should be <= parent_base_class unless type_klass == Boolean
+        type_klass.receive(parent_instance).should be_a(parent_base_class)
+      end
+
+      it 'has .receive' do
+        obj = type_klass.receive(parent_instance)
+        if FALSE_PARENTS.include?(type_klass.to_s)
+          obj.should be_a(parent_base_class)
+        else
+          obj.should be_a(type_klass)
+        end
+      end
+    end
+  end
+
+  describe '.receive' do
+    def self.it_correctly_converts(type, orig, desired)
+      it "for #{type} converts #{orig.inspect} to #{desired.inspect}" do
+        type.receive(orig).should == desired
+      end
+    end
+
+    describe 'type coercion' do
+      [
+        [Symbol,   'foo', :foo], [Symbol, :foo, :foo], [Symbol, nil, nil],     [Symbol, '', nil],
+        [Integer, '5', 5],       [Integer, 5,   5],    [Integer, nil, nil],    [Integer, '', nil],
+        [Integer, '5', 5],       [Integer, 5,   5],    [Integer, nil, nil],    [Integer, '', nil],
+        [Long,    '5', 5],       [Long,    5,   5],    [Long,    nil, nil],    [Long,    '', nil],
+        [Float,   '5.2', 5.2],   [Float,   5.2, 5.2],  [Float, nil, nil],      [Float, '', nil],
+        [Double,  '5.2', 5.2],   [Double,  5.2, 5.2],  [Double,nil, nil],      [Double,'', nil],
+        [String,  'foo', 'foo'], [String, :foo, 'foo'], [String, nil, ""],     [String, '', ""],
+        [String,  5.2, "5.2"],   [String, [1], "[1]"],  [String, 1, "1"],
+        [Binary,  'foo', 'foo'], [Binary, :foo, 'foo'], [Binary, nil, ""],     [Binary, '', ""],
+        [Binary,  5.2, "5.2"],   [Binary, [1], "[1]"],  [Binary, 1, "1"],
+        [Time,  '1985-11-05T04:03:02Z',             Time.parse('1985-11-05T04:03:02Z')],
+        [Time,  '1985-11-05T04:03:02+06:00',        Time.parse('1985-11-04T22:03:02Z')],
+        [Time,  Time.parse('1985-11-05T04:03:02Z'), Time.parse('1985-11-05T04:03:02Z')],
+        [Time, nil, nil],  [Time, '', nil], [Time, 'blah', nil],
+        [Boolean, '0', true],   [Boolean, 0, true],  [Boolean, '',  false], [Boolean, [],     true], [Boolean, nil, nil],
+        [Boolean, '1', true],   [Boolean, 1, true],  [Boolean, '5', true],  [Boolean, 'true', true],
+        [NilClass, nil, nil],
+      ].each do |type, orig, desired|
+        it_correctly_converts type, orig, desired
+      end
+
+      describe 'NilClass' do
+        it 'only accepts nil' do
+          lambda{ NilClass.receive('hello') }.should raise_error(ArgumentError, /must be initialized with nil, but \[hello\] was given/)
+        end
+      end
+    end
+  end
+end
+
+
+describe '::Boolean' do
+  let(:true_bool ){ ::Boolean.new(true)  }
+  let(:false_bool){ ::Boolean.new(false) }
+  it("has #class Boolean" ){ (true_bool.class).should == ::Boolean ; (false_bool.class).should == ::Boolean }
+  describe 'mimicking true/false' do
+    it(":!"     ){ (! true_bool).should    == (! true)     ; (! false_bool).should    == (! false)     }
+    it(":nil?"  ){ (true_bool.nil?).should == (true.nil?)  ; (false_bool.nil?).should == (false.nil?)  }
+    it(":to_s"  ){ (true_bool.to_s).should == (true.to_s)  ; (false_bool.to_s).should == (false.to_s)  }
+    { :!=           => [true, false, nil],
+      :!~           => [true, false, nil],
+      :&            => [true, false, nil],
+      :<=>          => [true, false, nil],
+      :==           => [true, false, nil],
+      :===          => [true, false, nil],
+      :=~           => [true, false, nil],
+      :^            => [true, false, nil],
+      :eql?         => [true, false, nil],
+      :|            => [true, false, nil],
+      :instance_of? => [::TrueClass, ::FalseClass, ::Object],
+      :is_a?        => [::TrueClass, ::FalseClass, ::Object],
+      :kind_of?     => [::TrueClass, ::FalseClass, ::Object],
+    }.each do |meth, meth_args|
+      it meth do
+        meth_args.each do |meth_arg|
+          true_bool.send( meth, meth_arg).should equal(true.send( meth, meth_arg))
+          false_bool.send(meth, meth_arg).should equal(false.send(meth, meth_arg))
+        end
+      end
+    end
+  end
+end
+

data/spec/type/structured_schema_spec.rb

@@ -0,0 +1,300 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gorillib/object/try_dup'
+require 'icss/receiver_model/acts_as_hash'
+require 'icss/type'                   #
+require 'icss/type/simple_types'      # Boolean, Integer, ...
+require 'icss/type/named_type'        # class methods for a named type: .metamodel .doc, .fullname, &c
+require 'icss/type/record_type'       # class methods for a record model: .field, .receive,
+require 'icss/type/record_model'      # instance methods for a record model
+require 'icss/type/type_factory'      # turn schema into types
+require 'icss/type/structured_schema' # loads array, hash, enum, fixed and simple schema
+#
+require ENV.root_path('spec/support/icss_test_helper')
+include IcssTestHelper
+
+
+module Icss
+  module Test
+    module Foo ; class Bar ; end ; end
+  end
+  class Top ; end
+end
+
+describe 'complex types' do
+  before(:each) do
+    IcssTestHelper.remove_icss_constants('Test::Foo::Bar', 'Test::Foo', 'St::Bob')
+    module Icss
+      module Test
+        module Foo ; class Bar ; end ; end
+      end
+    end
+  end
+
+  describe Icss::Meta::SimpleSchema do
+    let(:bob){ Icss::Meta::SimpleSchema.receive({ :name => 'st.bob', :type => :simple, :is_a => [Binary], :doc => "hi, bob" }) }
+    it 'loads types that inherit from simple base types' do
+      bob.should  < Binary
+      bob.should  < String
+      bob.should  < Icss::Meta::St::BobModel
+      bob.metamodel.should == Icss::Meta::St::BobModel
+    end
+    it 'has doc and all that' do
+      bob.fullname.should == 'st.bob'
+      bob.basename.should == :'bob'
+      bob.doc.should      == 'hi, bob'
+      bob.is_a.should     == [Binary]
+    end
+  end
+
+  describe Icss::Meta::ArraySchema do
+    [
+      [{:type => :array, :items => :'test.foo.bar'}, 'Icss::Test::Foo::Bar', ],
+      [{:type => :array, :items => :'int'     },     'Integer', ],
+      [{:type => :array, :items => :'top'},          'Icss::Top', ],
+    ].each do |schema, expected_item_factory|
+      describe "With #{schema}" do
+        before do
+          @model_klass = Icss::Meta::ArraySchema.receive(schema)
+          @schema_writer = @model_klass._schema
+        end
+        it 'is a descendent of Array and its metatype' do
+          @model_klass.should < Array
+          @model_klass.should be_a Icss::Meta::ArrayType
+          @model_klass.should be_a Icss::Meta::NamedType
+        end
+        it 'has items and an item_factory' do
+          @model_klass.should respond_to(:items)
+          @model_klass.items.should == expected_item_factory.constantize
+        end
+        it 'has schema_writer' do
+          @schema_writer.type.should  == :array
+          @schema_writer.to_hash.should == schema
+          # @schema_writer.should be_valid
+          @schema_writer.items = nil
+          # @schema_writer.should_not be_valid
+        end
+      end
+    end
+
+    context "klass name" do
+      [
+        [ 'ArrayOfSymbol', :symbol  ],
+        [ 'ArrayOfArrayOfInteger', { :type => :array, :items => :int } ],
+        [ 'ArrayOfHashOfArrayOfString', { :type => :map, :values => { :type => :array, :items => :string } } ],
+        [ 'ArrayOfTestDotFooDotBar', 'test.foo.bar' ],
+        [ 'ArrayOfHashOfArrayOfTestDotFooDotBar', { :type => :map, :values => { :type => :array, :items => 'test.foo.bar' } } ],
+      ].each do |expected_name, items_schema|
+        it "is #{expected_name} for #{items_schema}" do
+          schema = {:type => :array, :items => items_schema }
+          kl = Icss::Meta::ArraySchema.receive(schema)
+          kl.fullname.should == expected_name
+        end
+      end
+    end
+  end
+
+  describe Icss::Meta::ArrayType do
+    context '.receive' do
+      it 'generates an instance of the type' do
+        Icss::Meta::ArraySchema.receive({:type => :array, :items => :'int' })
+        inst = Icss::ArrayOfInteger.receive([1, 2.0, nil, "4.5", "8", "fnord"])
+        inst.should be_a(Array)
+        inst.should be_a(Icss::ArrayOfInteger)
+      end
+      it 'with nil or "" gives nil; with [] gives []' do
+        Icss::Meta::ArraySchema.receive({:type => :array, :items => :'int' })
+        inst = Icss::ArrayOfInteger.receive(nil)
+        inst.should be_nil
+        inst = Icss::ArrayOfInteger.receive('')
+        inst.should be_nil
+        inst = Icss::ArrayOfInteger.receive([])
+        inst.should == []
+        inst = Icss::ArrayOfInteger.receive({})
+        inst.should == []
+        inst.should be_a(Icss::ArrayOfInteger)
+      end
+      it 'applies the item_factory' do
+        Icss::Meta::ArraySchema.receive({:type => :array, :items => :'int' })
+        inst = Icss::ArrayOfInteger.receive([1, 2.0, nil, "4.5", "8", "fnord"])
+        inst.should eql([1, 2, nil, 4, 8, 0])  # (1 == 1.0) is true but 1.eql?(1.0) is false
+      end
+      it 'passes items through if they already is_a? the item factory type'
+    end
+  end
+
+  describe Icss::Meta::HashSchema do
+    [
+      [{:type => :map, :values => :'test.foo.bar'}, 'Icss::Test::Foo::Bar', ],
+      [{:type => :map, :values => :'int'     },     'Integer',           ],
+      [{:type => :map, :values => :'top'},          'Icss::Top', ],
+    ].each do |schema, expected_value_factory|
+      describe "With #{schema}" do
+        before do
+          @model_klass = Icss::Meta::HashSchema.receive(schema)
+          @schema_writer = @model_klass._schema
+        end
+        it 'is a descendent of Hash and of its metatype' do
+          @model_klass.should < Hash
+          @model_klass.should be_a Icss::Meta::HashType
+          @model_klass.should be_a Icss::Meta::NamedType
+        end
+        it 'has values and an value_factory' do
+          @model_klass.should respond_to(:values)
+          @model_klass.values.should == expected_value_factory.constantize
+        end
+        it 'has schema_writer' do
+          @schema_writer.type.should   == :map
+          @schema_writer.to_hash.should == schema
+          # @schema_writer.should be_valid
+          @schema_writer.values = nil
+          # @schema_writer.should_not be_valid
+        end
+      end
+    end
+    context "klass name" do
+      [
+        [ 'HashOfSymbol', :symbol  ],
+        [ 'HashOfHashOfInteger', { :type => :map, :values => :int } ],
+        [ 'HashOfHashOfArrayOfString', { :type => :map, :values => { :type => :array, :items => :string } } ],
+        [ 'HashOfTestDotFooDotBar', 'test.foo.bar' ],
+        [ 'HashOfHashOfArrayOfTestDotFooDotBar', { :type => :map, :values => { :type => :array, :items => 'test.foo.bar' } } ],
+      ].each do |expected_name, values_schema|
+        it "is #{expected_name} for #{values_schema}" do
+          schema = {:type => :map, :values => values_schema }
+          kl = Icss::Meta::HashSchema.receive(schema)
+          kl.fullname.should == expected_name
+        end
+      end
+    end
+  end
+
+  describe Icss::Meta::HashType do
+    context '.receive' do
+      it 'generates an instance of the type' do
+        Icss::Meta::HashSchema.receive({:type => :map, :values => :'int' })
+        inst = Icss::HashOfInteger.receive([1, 2.0, nil, "4.5", "8", "fnord"])
+        inst.should be_a(Hash)
+        inst.should be_a(Icss::HashOfInteger)
+      end
+      it 'with nil or "" gives nil; with [] gives []' do
+        Icss::Meta::HashSchema.receive({:type => :map, :values => :'int' })
+        inst = Icss::HashOfInteger.receive(nil)
+        inst.should be_nil
+        inst = Icss::HashOfInteger.receive('')
+        inst.should be_nil
+        inst = Icss::HashOfInteger.receive([])
+        inst.should == {}
+        inst = Icss::HashOfInteger.receive({})
+        inst.should == {}
+        inst.should be_a(Icss::HashOfInteger)
+      end
+      it 'applies the value_factory' do
+        Icss::Meta::HashSchema.receive({:type => :map, :values => :'int' })
+        inst = Icss::HashOfInteger.receive({ :a => 1, 'b' => 2.0, :c => nil, 'd' => "4.5", :e => "8", 99 => "fnord"})
+        inst.should eql({ :a => 1, 'b' => 2, :c => nil, 'd' => 4, :e => 8, 99 => 0})
+      end
+      it 'passes items through if they already is_a? the values factory type'
+      it 'warns when I supply "items" not "values"' do
+        lambda{
+          Icss::Meta::HashSchema.receive({:type => :map, :items => :int })
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe Icss::Meta::EnumSchema do
+    [
+      {:type => :enum, :name => 'games.coin_outcomes', :symbols => %w[heads tails sideways]},
+      {:type => :enum, :name => 'always_awesome',      :symbols => %w[AWESOME]},
+      {:type => :enum, :name => 'jackson.five',        :symbols => [:a, :b, :c]},
+    ].each do |schema|
+      describe "With #{schema}" do
+        before do
+          @model_klass = Icss::Meta::EnumSchema.receive(schema)
+          @schema_writer = @model_klass._schema
+        end
+        it 'is a descendent of Enum and of its metatype' do
+          @model_klass.should < Symbol
+          @model_klass.should be_a Icss::Meta::EnumType
+          @model_klass.should be_a Icss::Meta::NamedType
+        end
+        it 'has symbols' do
+          @model_klass.should respond_to(:symbols)
+          @schema_writer.symbols.should == schema[:symbols].map(&:to_sym)
+        end
+        it 'has schema_writer' do
+          @schema_writer.type.should  == :enum
+          # @schema_writer.should be_valid
+          @schema_writer.symbols = []
+          # @schema_writer.should_not be_valid
+        end
+      end
+    end
+
+    context '.receive' do
+      it 'applies the value_factory' do
+        Icss::Meta::EnumSchema.receive({:type => :enum, :name => 'games.coin_outcomes', :symbols => %w[heads tails sideways]})
+        inst = Icss::Games::CoinOutcomes.receive('heads')
+        inst.should == :heads    ; inst.should be_a(Symbol)
+        inst = Icss::Games::CoinOutcomes.receive(:heads)
+        inst.should == :heads    ; inst.should be_a(Symbol)
+        inst = Icss::Games::CoinOutcomes.receive('sideways')
+        inst.should == :sideways ; inst.should be_a(Symbol)
+      end
+      it 'raises an error on non-included value' do
+        Icss::Meta::EnumSchema.receive({:type => :enum, :name => 'games.coin_outcomes', :symbols => %w[heads tails sideways]})
+        lambda{ Icss::Games::CoinOutcomes.receive('ace_of_spades') }.should raise_error(ArgumentError, /Cannot receive ace_of_spades: must be one of heads,tails,sideways/)
+        Icss::Meta::EnumSchema.receive({:type => :enum, :name => 'herb.caen', :symbols => %w[parseley sage rosemary thyme]})
+        lambda{ Icss::Herb::Caen.receive('weed') }.should raise_error(ArgumentError, /Cannot receive weed: must be one of parseley,sage,rosemary,.../)
+      end
+      it 'raises an error on non-symbolizable value' do
+        Icss::Meta::EnumSchema.receive({:type => :enum, :name => 'games.coin_outcomes', :symbols => %w[heads tails sideways]})
+        lambda{ Icss::Games::CoinOutcomes.receive(77) }.should raise_error(NoMethodError, /undefined method .to_sym/)
+      end
+      it 'returns nil on nil/empty string value' do
+        Icss::Meta::EnumSchema.receive({:type => :enum, :name => 'games.coin_outcomes', :symbols => %w[heads tails sideways]})
+        Icss::Games::CoinOutcomes.receive(nil).should be_nil
+        Icss::Games::CoinOutcomes.receive('').should be_nil
+        Icss::Games::CoinOutcomes.receive(:"").should be_nil
+      end
+    end
+  end
+
+  describe Icss::Meta::FixedSchema do
+    [
+      {:type => :fixed, :name => 'geo_feature_category', :size => 1 },
+      {:type => :fixed, :name => 'sixteen_bytes_long',   :size => 16 },
+    ].each do |schema|
+      describe "With #{schema}" do
+        before do
+          @model_klass = Icss::Meta::FixedSchema.receive(schema)
+          @schema_writer = @model_klass._schema
+        end
+        it 'has schema_writer' do
+          @schema_writer.type.should  == :fixed
+          # @schema_writer.should be_valid
+          @schema_writer.size = nil
+          # @schema_writer.should_not be_valid
+        end
+      end
+    end
+
+    context '.receive' do
+      it 'applies the value_factory' do
+        Icss::Meta::FixedSchema.receive({:type => :fixed, :name => 'sixteen_bytes_long', :size => 16})
+        Icss::SixteenBytesLong.receive('123456789_123456').should == '123456789_123456'
+      end
+      it 'raises an error on too-long value' do
+        Icss::Meta::FixedSchema.receive({:type => :fixed, :name => 'sixteen_bytes_long', :size => 16})
+        lambda{ Icss::SixteenBytesLong.receive('123456789_1234567') }.should raise_error(ArgumentError, /Wrong size for a fixed-length type sixteen_bytes_long: got 17, not 16/)
+      end
+      it 'returns nil on nil/empty string value' do
+        Icss::Meta::FixedSchema.receive({:type => :fixed, :name => 'sixteen_bytes_long', :size => 16})
+        Icss::SixteenBytesLong.receive(nil).should be_nil
+        Icss::SixteenBytesLong.receive('').should be_nil
+        Icss::SixteenBytesLong.receive(:"").should be_nil
+      end
+    end
+  end
+
+end