activefacts-api 0.8.9 → 0.8.10

data/spec/{api/value_type_spec.rb → value_type_spec.rb}

@@ -2,6 +2,7 @@
 # ActiveFacts tests: Value types in the Runtime API
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
+require 'rspec'
 require 'activefacts/api'
 
 describe "Value Type class definitions" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activefacts-api
 version: !ruby/object:Gem::Version 
-  hash: 45
-  prerelease: false
+  hash: 43
+  prerelease: 
   segments: 
   - 0
   - 8
-  - 9
-  version: 0.8.9
+  - 10
+  version: 0.8.10
 platform: ruby
 authors: 
 - Clifford Heath
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-08 00:00:00 +11:00
-default_executable: 
+date: 2011-06-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -66,6 +65,22 @@ dependencies:
         version: 1.5.2
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 4
+        - 2
+        version: 2.4.2
+  type: :development
+  version_requirements: *id004
 description: |
   
   The ActiveFacts API is a Ruby DSL for managing constellations of elementary facts.
@@ -82,6 +97,7 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE.txt
 - README.rdoc
+- TODO
 files: 
 - .document
 - .rspec
@@ -97,20 +113,22 @@ files:
 - lib/activefacts/api/numeric.rb
 - lib/activefacts/api/object_type.rb
 - lib/activefacts/api/role.rb
-- lib/activefacts/api/role_proxy.rb
 - lib/activefacts/api/role_values.rb
 - lib/activefacts/api/standard_types.rb
 - lib/activefacts/api/support.rb
 - lib/activefacts/api/value.rb
 - lib/activefacts/api/vocabulary.rb
-- spec/api/autocounter_spec.rb
-- spec/api/constellation_spec.rb
-- spec/api/entity_type_spec.rb
-- spec/api/instance_spec.rb
-- spec/api/roles_spec.rb
-- spec/api/value_type_spec.rb
+- lib/activefacts/tracer.rb
+- spec/autocounter_spec.rb
+- spec/constellation_spec.rb
+- spec/entity_type_spec.rb
+- spec/identification_spec.rb
+- spec/instance_spec.rb
+- spec/role_values_spec.rb
+- spec/roles_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
+- spec/value_type_spec.rb
+- TODO
 homepage: http://github.com/cjheath/activefacts-api
 licenses: 
 - MIT
@@ -140,15 +158,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: A semantic modeling and query language (CQL) and application runtime (the Constellation API)
-test_files: 
-- spec/api/autocounter_spec.rb
-- spec/api/constellation_spec.rb
-- spec/api/entity_type_spec.rb
-- spec/api/instance_spec.rb
-- spec/api/roles_spec.rb
-- spec/api/value_type_spec.rb
-- spec/spec_helper.rb
+summary: A fact-based data model DSL and API
+test_files: []
+

data/lib/activefacts/api/role_proxy.rb

@@ -1,71 +0,0 @@
-#
-#       ActiveFacts Runtime API
-#       RoleProxy class, still somewhat experimental
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'delegate'
-
-module ActiveFacts
-  module API
-    #
-    # When you use the accessor method created by has_one, one_to_one, or maybe, you get a RoleProxy for the actual value.
-    # This behaves almost exactly as the value, but it knows through which role you fetched it.
-    # That will allow it to verbalise itself using the correct reading for that role.
-    #
-    # Don't use "SomeClass === role_value" to test the type, use "role_value.is_a?(SomeClass)" instead.
-    #
-    # In future, retrieving a value by indexing into a RoleValues array will do the same thing.
-    #
-    class RoleProxy < SimpleDelegator
-      def initialize(role, o = nil)     #:nodoc:
-        @role = role                    # REVISIT: Use this to implement verbalise()
-        __setobj__(o)
-      end
-
-      def method_missing(m, *a, &b)     #:nodoc:
-        begin
-          super                         # Delegate first
-        rescue NoMethodError => e
-          __getobj__.method_missing(m, *a, &b)
-        rescue => e
-          raise
-        end
-      end
-
-      def class                         #:nodoc:
-        __getobj__.class
-      end
-
-      def is_a? klass                   #:nodoc:
-        __getobj__.is_a? klass
-      end
-
-      def to_s                          #:nodoc:
-        __getobj__.to_s
-      end
-
-      # This is strongly deprecated, and omitting it doesn't seem to hurt:
-      #def object_id                     #:nodoc:
-      #  __getobj__.object_id
-      #end
-
-      # REVISIT: Should Proxies hash and eql? the same as their wards?
-      def hash                          #:nodoc:
-        __getobj__.hash ^ self.class.hash
-      end
-
-      def eql?(o)                       #:nodoc:
-        self.class == o.class and __getobj__.eql?(o)
-      end
-
-      def ==(o)                         #:nodoc:
-        __getobj__.==(o)
-      end
-
-      def inspect                       #:nodoc:
-        "Proxy:#{__getobj__.inspect}"
-      end
-    end
-  end
-end

data/spec/api/constellation_spec.rb

@@ -1,129 +0,0 @@
-#
-# ActiveFacts tests: Constellation instances in the Runtime API
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-
-require 'activefacts/api'
-
-describe "A Constellation instance" do
-  before :each do
-    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
-    module Mod
-      @base_types = [
-          Int, Real, AutoCounter, String, Date, DateTime
-        ]
-
-      # Create a value type and a subtype of that value type for each base type:
-      @base_types.each do |base_type|
-        eval %Q{
-          class #{base_type.name}Value < #{base_type.name}
-            value_type
-          end
-
-          class #{base_type.name}SubValue < #{base_type.name}Value
-            # Note no new "value_type" is required here, it comes through inheritance
-          end
-        }
-      end
-
-      class Name < StringValue
-        value_type
-        #has_one :attr, Name
-      end
-
-      class LegalEntity
-        identified_by :name
-        has_one :name
-      end
-
-      class SurrogateId
-        identified_by :auto_counter_value
-        has_one :auto_counter_value
-      end
-
-      class Company < LegalEntity
-        supertypes SurrogateId
-      end
-
-      class Person < LegalEntity
-        identified_by :name, :family_name     # REVISIT: want a way to role_alias :name, :given_name
-        supertypes SurrogateId
-
-        has_one :family_name, :class => Name
-      end
-    end
-    @constellation = ActiveFacts::API::Constellation.new(Mod)
-  end
-
-  it "should support fetching its vocabulary" do
-    @constellation.vocabulary.should == Mod
-  end
-
-#  it "should support fetching its query" do
-#    pending
-#    @constellation.query.should == Mod
-#  end
-
-  it "should support methods to construct instances of any object_type" do
-    name = foo = acme = fred_fly = nil
-    lambda {
-        name = @constellation.Name("foo")
-        foo = @constellation.LegalEntity("foo")
-        acme = @constellation.Company("Acme, Inc")
-        fred_fly = @constellation.Person("fred", "fly")
-      }.should_not raise_error
-    name.class.should == Mod::Name
-    name.constellation.should == @constellation
-    foo.class.should == Mod::LegalEntity
-    foo.constellation.should == @constellation
-    acme.class.should == Mod::Company
-    acme.constellation.should == @constellation
-    fred_fly.class.should == Mod::Person
-    fred_fly.constellation.should == @constellation
-  end
-
-  it "should re-use instances constructed the same way" do
-    name1 = @constellation.Name("foo")
-    foo1 = @constellation.LegalEntity("foo")
-    acme1 = @constellation.Company("Acme, Inc")
-    fred_fly1 = @constellation.Person("fred", "fly")
-
-    name2 = @constellation.Name("foo")
-    foo2 = @constellation.LegalEntity("foo")
-    acme2 = @constellation.Company("Acme, Inc")
-    fred_fly2 = @constellation.Person("fred", "fly")
-
-    name1.object_id.should == name2.object_id
-    foo1.object_id.should == foo2.object_id
-    acme1.object_id.should == acme2.object_id
-    fred_fly1.object_id.should == fred_fly2.object_id
-  end
-
-  it "should index value instances, including by its superclasses" do
-    baz = @constellation.Name("baz")
-    @constellation.Name.keys.sort.should == ["baz"]
-
-    @constellation.StringValue.keys.sort.should == ["baz"]
-  end
-
-  it "should index entity instances, including by its superclass and secondary supertypes" do
-    name = "Acme, Inc"
-    fred = "Fred"
-    fly = "Fly"
-    acme = @constellation.Company name, :auto_counter_value => :new
-    fred_fly = @constellation.Person fred, fly, :auto_counter_value => :new
-
-    # REVISIT: This should be illegal:
-    #fred_fly.auto_counter_value = :new
-
-    @constellation.Person.keys.sort.should == [[fred, fly]]
-    @constellation.Company.keys.sort.should == [[name]]
-
-    @constellation.LegalEntity.keys.sort.should be_include([name])
-    @constellation.LegalEntity.keys.sort.should be_include([fred])
-
-    @constellation.SurrogateId.values.should be_include(acme)
-    @constellation.SurrogateId.values.should be_include(fred_fly)
-  end
-
-end

data/spec/api/instance_spec.rb

@@ -1,462 +0,0 @@
-#
-# ActiveFacts tests: Value instances in the Runtime API
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/api'
-
-describe "An instance of every type of ObjectType" do
-  before :each do
-    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
-    module Mod
-      # These are the base value types we're going to test:
-      @base_types = [
-          Int, Real, AutoCounter, String, Date, DateTime, Decimal
-        ]
-
-      # Construct the names of the roles they play:
-      @base_type_roles = @base_types.map do |t|
-        t.name.snakecase
-      end
-      @role_names = @base_type_roles.inject([]) {|a, t|
-          a << :"#{t}_value"
-        } +
-        @base_type_roles.inject([]) {|a, t|
-          a << :"#{t}_sub_value"
-        }
-
-      # Create a value type and a subtype of that value type for each base type:
-      @base_types.each do |base_type|
-        eval %Q{
-          class #{base_type.name}Value < #{base_type.name}
-            value_type
-          end
-
-          class #{base_type.name}SubValue < #{base_type.name}Value
-            # Note no new "value_type" is required here, it comes through inheritance
-          end
-        }
-      end
-
-      # Create a TestByX, TestByXSub, and TestSubByX class for all base types X
-      # Each class has a has_one and a one_to_one for all roles.
-      # and is identified by the has_one :x role
-      @base_types.each do |base_type|
-        code = %Q{
-          class TestBy#{base_type.name}
-            identified_by :#{base_type.name.snakecase}_value#{
-              @role_names.map do |role_name|
-                %Q{
-            has_one :#{role_name}
-            one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase}}
-              end*""
-            }
-          end
-
-          class TestBy#{base_type.name}Sub
-            identified_by :#{base_type.name.snakecase}_sub_value#{
-              @role_names.map do |role_name|
-                %Q{
-            has_one :#{role_name}
-            one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase}}
-              end*""
-            }
-          end
-
-          class TestSubBy#{base_type.name} < TestBy#{base_type.name}
-            # Entity subtypes, inherit identification and all roles
-          end
-
-          class TestBy#{base_type.name}Entity
-            identified_by :test_by_#{base_type.name.snakecase}
-            one_to_one :test_by_#{base_type.name.snakecase}
-          end}
-          eval code
-      end
-    end
-
-    # Simple Values
-    @int = 0
-    @real = 0.0
-    @auto_counter = 0
-    @new_auto_counter = :new
-    @string = "zero"
-    @date = [2008, 04, 19]
-    @date_time = [2008, 04, 19, 10, 28, 14]
-
-    # Value Type instances
-    @int_value = Mod::IntValue.new(1)
-    @real_value = Mod::RealValue.new(1.0)
-    @auto_counter_value = Mod::AutoCounterValue.new(1)
-    @new_auto_counter_value = Mod::AutoCounterValue.new(:new)
-    @string_value = Mod::StringValue.new("one")
-    @date_value = Mod::DateValue.new(2008, 04, 20)
-    @date_time_value = Mod::DateTimeValue.new(2008, 04, 20, 10, 28, 14)
-
-    # Value SubType instances
-    @int_sub_value = Mod::IntSubValue.new(4)
-    @real_sub_value = Mod::RealSubValue.new(4.0)
-    @auto_counter_sub_value = Mod::AutoCounterSubValue.new(4)
-    @auto_counter_sub_value_new = Mod::AutoCounterSubValue.new(:new)
-    @string_sub_value = Mod::StringSubValue.new("five")
-    @date_sub_value = Mod::DateSubValue.new(2008, 04, 25)
-    @date_time_sub_value = Mod::DateTimeSubValue.new(2008, 04, 26, 10, 28, 14)
-
-    # Entities identified by Value Type, SubType and Entity-by-value-type instances
-    @test_by_int = Mod::TestByInt.new(2)
-    @test_by_real = Mod::TestByReal.new(2.0)
-    @test_by_auto_counter = Mod::TestByAutoCounter.new(2)
-    @test_by_auto_counter_new = Mod::TestByAutoCounter.new(:new)
-    @test_by_string = Mod::TestByString.new("two")
-    @test_by_date = Mod::TestByDate.new(Date.new(2008,04,28))
-    #@test_by_date = Mod::TestByDate.new(2008,04,28)
-    @test_by_date_time = Mod::TestByDateTime.new(2008,04,28,10,28,15)
-    #@test_by_date_time = Mod::TestByDateTime.new(DateTime.new(2008,04,28,10,28,15))
-
-    @test_by_int_sub = Mod::TestByIntSub.new(2)
-    @test_by_real_sub = Mod::TestByRealSub.new(5.0)
-    @test_by_auto_counter_sub = Mod::TestByAutoCounterSub.new(6)
-    @test_by_auto_counter_new_sub = Mod::TestByAutoCounterSub.new(:new)
-    @test_by_string_sub = Mod::TestByStringSub.new("six")
-    @test_by_date_sub = Mod::TestByDateSub.new(Date.new(2008,04,27))
-    @test_by_date_time_sub = Mod::TestByDateTimeSub.new(2008,04,29,10,28,15)
-
-    @test_by_int_entity = Mod::TestByIntEntity.new(@test_by_int)
-    @test_by_real_entity = Mod::TestByRealEntity.new(@test_by_real)
-    @test_by_auto_counter_entity = Mod::TestByAutoCounterEntity.new(@test_by_auto_counter)
-    @test_by_auto_counter_new_entity = Mod::TestByAutoCounterEntity.new(@test_by_auto_counter_new)
-    @test_by_string_entity = Mod::TestByStringEntity.new(@test_by_string)
-    @test_by_date_entity = Mod::TestByDateEntity.new(@test_by_date)
-    @test_by_date_time_entity = Mod::TestByDateTimeEntity.new(@test_by_date_time)
-
-    # Entity subtypes
-    @test_sub_by_int = Mod::TestSubByInt.new(2)
-    @test_sub_by_real = Mod::TestSubByReal.new(2.0)
-    @test_sub_by_auto_counter = Mod::TestSubByAutoCounter.new(2)
-    @test_sub_by_auto_counter_new = Mod::TestSubByAutoCounter.new(:new)
-    @test_sub_by_string = Mod::TestSubByString.new("two")
-    @test_sub_by_date = Mod::TestSubByDate.new(Date.new(2008,04,28))
-    @test_sub_by_date_time = Mod::TestSubByDateTime.new(2008,04,28,10,28,15)
-
-    # These arrays get zipped together in various ways. Keep them aligned.
-    @values = [
-        @int, @real, @auto_counter, @new_auto_counter,
-        @string, @date, @date_time,
-      ]
-    @classes = [
-        Int, Real, AutoCounter, AutoCounter,
-        String, Date, DateTime,
-      ]
-    @value_types = [
-        Mod::IntValue, Mod::RealValue, Mod::AutoCounterValue, Mod::AutoCounterValue,
-        Mod::StringValue, Mod::DateValue, Mod::DateTimeValue,
-        Mod::IntSubValue, Mod::RealSubValue, Mod::AutoCounterSubValue, Mod::AutoCounterSubValue,
-        Mod::StringSubValue, Mod::DateSubValue, Mod::DateTimeSubValue,
-        ]
-    @value_instances = [
-        @int_value, @real_value, @auto_counter_value, @new_auto_counter_value,
-        @string_value, @date_value, @date_time_value,
-        @int_sub_value, @real_sub_value, @auto_counter_sub_value, @auto_counter_sub_value_new,
-        @string_sub_value, @date_sub_value, @date_time_sub_value,
-        @int_value, @real_value, @auto_counter_value, @new_auto_counter_value,
-        @string_value, @date_value, @date_time_value,
-      ]
-    @entity_types = [
-        Mod::TestByInt, Mod::TestByReal, Mod::TestByAutoCounter, Mod::TestByAutoCounter,
-        Mod::TestByString, Mod::TestByDate, Mod::TestByDateTime,
-        Mod::TestByIntSub, Mod::TestByRealSub, Mod::TestByAutoCounterSub, Mod::TestByAutoCounterSub,
-        Mod::TestByStringSub, Mod::TestByDateSub, Mod::TestByDateTimeSub,
-        Mod::TestSubByInt, Mod::TestSubByReal, Mod::TestSubByAutoCounter, Mod::TestSubByAutoCounter,
-        Mod::TestSubByString, Mod::TestSubByDate, Mod::TestSubByDateTime,
-      ]
-    @entities = [
-        @test_by_int, @test_by_real, @test_by_auto_counter, @test_by_auto_counter_new,
-        @test_by_string, @test_by_date, @test_by_date_time,
-        @test_by_int_sub, @test_by_real_sub, @test_by_auto_counter_sub, @test_by_auto_counter_new_sub,
-        @test_by_string_sub, @test_by_date_sub, @test_by_date_time_sub,
-        @test_sub_by_int, @test_sub_by_real, @test_sub_by_auto_counter, @test_sub_by_auto_counter_new,
-        @test_sub_by_string, @test_sub_by_date, @test_sub_by_date_time,
-      ]
-    @entities_by_entity = [
-        @test_by_int_entity,
-        @test_by_real_entity,
-        @test_by_auto_counter_entity,
-        @test_by_auto_counter_new_entity,
-        @test_by_string_entity,
-        @test_by_date_entity,
-        @test_by_date_time_entity,
-      ]
-    @entities_by_entity_types = [
-        Mod::TestByIntEntity, Mod::TestByRealEntity, Mod::TestByAutoCounterEntity, Mod::TestByAutoCounterEntity,
-        Mod::TestByStringEntity, Mod::TestByDateEntity, Mod::TestByDateTimeEntity,
-      ]
-    @test_role_names = [
-        :int_value, :real_value, :auto_counter_value, :auto_counter_value,
-        :string_value, :date_value, :date_time_value,
-        :int_sub_value, :real_sub_value, :auto_counter_sub_value, :auto_counter_sub_value,
-        :string_sub_value, :date_sub_value, :date_time_sub_value,
-        :int_value, :real_value, :auto_counter_value, :auto_counter_value,
-        :string_value, :date_value, :date_time_value,
-      ]
-    @role_values = [
-        3, 3.0, 6, 7,
-        "three", Date.new(2008,4,21), DateTime.new(2008,4,22,10,28,16),
-      ]
-    @subtype_role_instances = [
-        Mod::IntSubValue.new(6), Mod::RealSubValue.new(6.0),
-        Mod::AutoCounterSubValue.new(:new), Mod::AutoCounterSubValue.new(8),
-        Mod::StringSubValue.new("seven"),
-        Mod::DateSubValue.new(2008,4,29), Mod::DateTimeSubValue.new(2008,4,30,10,28,16)
-      ]
-  end
-
-  it "if a value type, should verbalise" do
-    @value_types.each do |value_type|
-      #puts "#{value_type} verbalises as #{value_type.verbalise}"
-      value_type.respond_to?(:verbalise).should be_true
-      verbalisation = value_type.verbalise
-      verbalisation.should =~ %r{\b#{value_type.basename}\b}
-      verbalisation.should =~ %r{\b#{value_type.superclass.basename}\b}
-    end
-  end
-
-  it "if an entity type, should verbalise" do
-    @entity_types.each do |entity_type|
-      #puts entity_type.verbalise
-      entity_type.respond_to?(:verbalise).should be_true
-      verbalisation = entity_type.verbalise
-      verbalisation.should =~ %r{\b#{entity_type.basename}\b}
-
-      # All identifying roles should be in the verbalisation.
-      # Strictly this should be the role name, but we don't set names here.
-      entity_type.identifying_role_names.each do |ir|
-          role = entity_type.roles(ir)
-          role.should_not be_nil
-          counterpart_object_type = role.counterpart_object_type
-          verbalisation.should =~ %r{\b#{counterpart_object_type.basename}\b}
-        end
-    end
-  end
-
-  it "if a value, should verbalise" do
-    @value_instances.each do |value|
-      #puts value.verbalise
-      value.respond_to?(:verbalise).should be_true
-      verbalisation = value.verbalise
-      verbalisation.should =~ %r{\b#{value.class.basename}\b}
-    end
-  end
-
-  it "if an entity, should respond to verbalise" do
-    (@entities+@entities_by_entity).each do |entity|
-      #puts entity.verbalise
-      entity.respond_to?(:verbalise).should be_true
-      verbalisation = entity.verbalise
-      verbalisation.should =~ %r{\b#{entity.class.basename}\b}
-      entity.class.identifying_role_names.each do |ir|
-          role = entity.class.roles(ir)
-          role.should_not be_nil
-          counterpart_object_type = role.counterpart_object_type
-          verbalisation.should =~ %r{\b#{counterpart_object_type.basename}\b}
-        end
-    end
-  end
-
-  it "should respond to constellation" do
-    (@value_instances+@entities+@entities_by_entity).each do |instance|
-      instance.respond_to?(:constellation).should be_true
-    end
-  end
-
-  it "should respond to all its roles" do
-    @entities.each do |entity|
-      @test_role_names.each do |role_name|
-        entity.respond_to?(role_name).should be_true
-        entity.respond_to?(:"#{role_name}=").should be_true
-        entity.respond_to?(:"one_#{role_name}").should be_true
-        entity.respond_to?(:"one_#{role_name}=").should be_true
-      end
-    end
-    @entities_by_entity.each do |entity|
-      role = entity.class.roles(entity.class.identifying_role_names[0])
-      role_name = role.name
-      entity.respond_to?(role_name).should be_true
-      entity.respond_to?(:"#{role_name}=").should be_true
-    end
-  end
-
-  it "should return the ObjectType in response to .class()" do
-    @value_types.zip(@value_instances).each do |object_type, instance|
-      instance.class.should == object_type
-    end
-    @entity_types.zip(@entities).each do |object_type, instance|
-      instance.class.should == object_type
-      end
-    @entities_by_entity_types.zip(@entities_by_entity).each do |object_type, instance|
-      instance.class.should == object_type
-    end
-  end
-
-  it "should return the module in response to .vocabulary()" do
-    (@value_types+@entity_types).zip((@value_instances+@entities+@entities_by_entity)).each do |object_type, instance|
-      instance.class.vocabulary.should == Mod
-    end
-  end
-
-  it "each entity type should be able to be constructed using simple values" do
-    @entity_types.zip(@values+@values+@values, @classes+@classes+@classes).each do |entity_type, value, klass|
-      # An identifier parameter can be an array containing a simple value too
-      [ value,
-        Array === value ? nil : [value],
-#        entity_type.new(value) # REVISIT: It's not yet the case that an instance of the correct type can be used as a constructor parameter
-      ].compact.each do |value|
-        e = nil
-        lambda {
-            #puts "Constructing #{entity_type} using #{value.class} #{value.inspect}:"
-            e = entity_type.new(value)
-          }.should_not raise_error
-        # Verify that the identifying role has a equivalent value (except AutoCounter):
-        role_name = entity_type.identifying_role_names[0]
-        role = entity_type.roles(role_name)
-        counterpart_object_type = role.counterpart_object_type
-        player_superclasses = [ counterpart_object_type.superclass, counterpart_object_type.superclass.superclass ]
-        e.send(role_name).should == klass.new(*value) unless player_superclasses.include?(AutoCounter)
-      end
-    end
-  end
-
-  it "should allow its non-identifying roles to be assigned values" do
-    @entities.zip(@test_role_names).each do |entity, identifying_role|
-      @test_role_names.zip(@role_values).each do |role_name, value|
-        # No roles of ValueType instances are tested in this file:
-        raise hell unless entity.class.included_modules.include?(ActiveFacts::API::Entity)
-        next if entity.class.identifying_role_names.include?(role_name)
-        lambda {
-            begin
-              entity.send(:"#{role_name}=", value)
-            rescue => e
-              raise
-            end
-          }.should_not raise_error
-        lambda {
-            entity.send(:"one_#{role_name}=", value)
-          }.should_not raise_error
-      end
-    end
-  end
-
-  it "that is an entity type should not allow its identifying roles to be re-assigned" do
-    @entities.zip(@test_role_names).each do |entity, identifying_role|
-      @test_role_names.zip(@role_values).each do |role_name, value|
-        if entity.class.identifying_role_names.include?(role_name) && entity.send(role_name) != nil && value != nil
-          lambda {
-              entity.send(:"#{role_name}=", value)
-            }.should raise_error
-        end
-        one_role = :"one_#{role_name}"
-        if entity.class.identifying_role_names.include?(one_role) && entity.send(one_role) != nil
-          lambda {
-              entity.send(:"one_#{role_name}=", value)
-            }.should raise_error
-        end
-      end
-    end
-  end
-
-  it "that is an entity type should allow its identifying roles to be assigned to and from nil" do
-    @entities.zip(@test_role_names).each do |entity, identifying_role|
-      @test_role_names.zip(@role_values).each do |role_name, value|
-        if entity.class.identifying_role_names.include?(role_name)
-          # Nullify the value first:
-          entity.send(:"#{role_name}=", nil)
-          lambda {
-              entity.send(:"#{role_name}=", value)
-            }.should_not raise_error
-        end
-        one_role = :"one_#{role_name}"
-        if entity.class.identifying_role_names.include?(one_role) && entity.send(one_role) == nil
-          entity.send(one_role, nil)
-          lambda {
-              entity.send(one_role, value)
-            }.should_not raise_error
-        end
-      end
-    end
-  end
-
-  it "should allow its non-identifying roles to be assigned instances" do
-    @entities.zip(@test_role_names).each do |entity, identifying_role|
-      @test_role_names.zip(@value_types, @role_values).each do |role_name, klass, value|
-        next unless value
-        next if role_name == identifying_role
-        instance = klass.new(value)
-        lambda {
-            entity.send(:"#{role_name}=", instance)
-          }.should_not raise_error
-        entity.send(role_name).class.should == klass
-        lambda {
-            entity.send(:"one_#{role_name}=", instance)
-          }.should_not raise_error
-        entity.send(:"one_#{role_name}").class.should == klass
-      end
-    end
-  end
-
-  it "should allow its non-identifying roles to be assigned instances of value subtypes, retaining the subtype" do
-    @entities.zip(@test_role_names).each do |entity, identifying_role|
-      @test_role_names.zip(@subtype_role_instances).each do |role_name, instance|
-        next unless instance
-        next if role_name == identifying_role
-        lambda {
-            entity.send(:"#{role_name}=", instance)
-          }.should_not raise_error
-        entity.send(role_name).class.should == instance.class
-        lambda {
-            entity.send(:"one_#{role_name}=", instance)
-          }.should_not raise_error
-        entity.send(:"one_#{role_name}").class.should == instance.class
-      end
-    end
-  end
-
-  it "should add to has_one's counterpart role when non-identifying roles are assigned values" do
-    @entities.zip(@test_role_names).each do |entity, identifying_role|
-      @test_role_names.zip(@role_values).each do |role_name, value|
-        next if role_name == identifying_role or !value
-
-        # Test the has_one role:
-        role = entity.class.roles(role_name)
-        old_counterpart = entity.send(:"#{role_name}")
-        entity.send(:"#{role_name}=", value)
-        counterpart = entity.send(:"#{role_name}")
-        old_counterpart.should_not == counterpart
-        counterpart.send(role.counterpart.name).should be_include(entity)
-        old_counterpart.send(role.counterpart.name).should_not be_include(entity) if old_counterpart
-
-        # Test the one_to_one role:
-        role = entity.class.roles(:"one_#{role_name}")
-        old_counterpart = entity.send(:"one_#{role_name}")
-        entity.send(:"one_#{role_name}=", value)
-        counterpart = entity.send(:"one_#{role_name}")
-        old_counterpart.should_not == counterpart   # Make sure we changed it!
-        counterpart.send(role.counterpart.name).should == entity
-        old_counterpart.send(role.counterpart.name).should be_nil if old_counterpart
-      end
-    end
-  end
-
-  it "should allow its non-identifying roles to be assigned nil" do
-    @entities.zip(@test_role_names).each do |entity, identifying_role|
-      @test_role_names.zip(@role_values).each do |role_name, value|
-        next if role_name == identifying_role
-        entity.send(:"#{role_name}=", value)
-        lambda {
-            entity.send(:"#{role_name}=", nil)
-          }.should_not raise_error
-        lambda {
-            entity.send(:"one_#{role_name}=", nil)
-          }.should_not raise_error
-      end
-    end
-  end
-
-end