activefacts-api 0.8.12 → 0.9.1

data/spec/{instance_spec.rb → constellation/instance_spec.rb}

@@ -2,8 +2,6 @@
 # ActiveFacts tests: Value instances in the Runtime API
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rspec'
-require 'activefacts/api'
 
 describe "An instance of every type of ObjectType" do
   before :each do
@@ -19,20 +17,20 @@ describe "An instance of every type of ObjectType" do
         t.name.snakecase
       end
       @role_names = @base_type_roles.inject([]) {|a, t|
-          a << :"#{t}_value"
+          a << :"#{t}_val"
         } +
         @base_type_roles.inject([]) {|a, t|
-          a << :"#{t}_sub_value"
+          a << :"#{t}_sub_val"
         }
 
       # Create a value type and a subtype of that value type for each base type:
       @base_types.each do |base_type|
-        eval <<-END
-          class #{base_type.name}Value < #{base_type.name}
+        Mod.module_eval <<-END
+          class #{base_type.name}Val < #{base_type.name}
             value_type
           end
 
-          class #{base_type.name}SubValue < #{base_type.name}Value
+          class #{base_type.name}SubVal < #{base_type.name}Val
             # Note no new "value_type" is required here, it comes through inheritance
           end
         END
@@ -44,11 +42,11 @@ describe "An instance of every type of ObjectType" do
       @base_types.each do |base_type|
         code = <<-END
           class TestBy#{base_type.name}
-            identified_by :#{base_type.name.snakecase}_value#{
+            identified_by :#{base_type.name.snakecase}_val#{
               @role_names.map do |role_name|
                 %Q{
-            has_one :#{role_name}#{
-              mandatory = (role_name == (base_type.name.snakecase+'_value').to_sym ? ', :mandatory => true' : '')
+            #{
+              (role_name == (base_type.name.snakecase+'_val').to_sym ? "one_to_one :#{role_name}, :mandatory => true" : "has_one :#{role_name}")
             }
             one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase}}
               end*""
@@ -56,10 +54,12 @@ describe "An instance of every type of ObjectType" do
           end
 
           class TestBy#{base_type.name}Sub
-            identified_by :#{base_type.name.snakecase}_sub_value#{
+            identified_by :#{base_type.name.snakecase}_sub_val#{
               @role_names.map do |role_name|
                 %Q{
-            has_one :#{role_name}
+            #{
+              (role_name == (base_type.name.snakecase+'_sub_val').to_sym ? "one_to_one :#{role_name}" : "has_one :#{role_name}")
+            }
             one_to_one :one_#{role_name}, :class => #{role_name.to_s.camelcase}}
               end*""
             }
@@ -74,7 +74,7 @@ describe "An instance of every type of ObjectType" do
             one_to_one :test_by_#{base_type.name.snakecase}
           end
         END
-        eval code
+        Mod.module_eval code
       end
     end
 
@@ -89,29 +89,29 @@ describe "An instance of every type of ObjectType" do
     @decimal = BigDecimal.new('98765432109876543210')
 
     # 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)
+    @int_value = Mod::IntVal.new(1)
+    @real_value = Mod::RealVal.new(1.0)
+    @auto_counter_value = Mod::AutoCounterVal.new(1)
+    @new_auto_counter_value = Mod::AutoCounterVal.new(:new)
+    @string_value = Mod::StringVal.new("one")
+    @date_value = Mod::DateVal.new(2008, 04, 20)
     # Parse the date:
-    @date_value = Mod::DateValue.new '2nd Nov 2001'
+    @date_value = Mod::DateVal.new '2nd Nov 2001'
     d = ::Date.civil(2008, 04, 20)
-    @date_time_value = Mod::DateTimeValue.new d # 2008, 04, 20, 10, 28, 14
+    @date_time_value = Mod::DateTimeVal.new d # 2008, 04, 20, 10, 28, 14
     # This next isn't in the same pattern; it makes a Decimal from a BigDecimal rather than a String (coverage reasons)
-    @decimal_value = Mod::DecimalValue.new(BigDecimal.new('98765432109876543210'))
+    @decimal_value = Mod::DecimalVal.new(BigDecimal.new('98765432109876543210'))
 
     # 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(::DateTime.civil(2008, 04, 26, 10, 28, 14))
+    @int_sub_value = Mod::IntSubVal.new(4)
+    @real_sub_value = Mod::RealSubVal.new(4.0)
+    @auto_counter_sub_value = Mod::AutoCounterSubVal.new(4)
+    @auto_counter_sub_value_new = Mod::AutoCounterSubVal.new(:new)
+    @string_sub_value = Mod::StringSubVal.new("five")
+    @date_sub_value = Mod::DateSubVal.new(2008, 04, 25)
+    @date_time_sub_value = Mod::DateTimeSubVal.new(::DateTime.civil(2008, 04, 26, 10, 28, 14))
     # This next isn't in the same pattern; it makes a Decimal from a BigNum rather than a String (coverage reasons)
-    @decimal_sub_value = Mod::DecimalSubValue.new(98765432109876543210)
+    @decimal_sub_value = Mod::DecimalSubVal.new(98765432109876543210)
 
     # Entities identified by Value Type, SubType and Entity-by-value-type instances
     @test_by_int = Mod::TestByInt.new(2)
@@ -164,10 +164,10 @@ describe "An instance of every type of ObjectType" do
         String, Date, DateTime, Decimal
       ]
     @value_types = [
-        Mod::IntValue, Mod::RealValue, Mod::AutoCounterValue, Mod::AutoCounterValue,
-        Mod::StringValue, Mod::DateValue, Mod::DateTimeValue, Mod::DecimalValue,
-        Mod::IntSubValue, Mod::RealSubValue, Mod::AutoCounterSubValue, Mod::AutoCounterSubValue,
-        Mod::StringSubValue, Mod::DateSubValue, Mod::DateTimeSubValue, Mod::DecimalSubValue,
+        Mod::IntVal, Mod::RealVal, Mod::AutoCounterVal, Mod::AutoCounterVal,
+        Mod::StringVal, Mod::DateVal, Mod::DateTimeVal, Mod::DecimalVal,
+        Mod::IntSubVal, Mod::RealSubVal, Mod::AutoCounterSubVal, Mod::AutoCounterSubVal,
+        Mod::StringSubVal, Mod::DateSubVal, Mod::DateTimeSubVal, Mod::DecimalSubVal,
         ]
     @value_instances = [
         @int_value, @real_value, @auto_counter_value, @new_auto_counter_value,
@@ -226,11 +226,11 @@ describe "An instance of every type of ObjectType" do
         '98765432109876543211'
       ]
     @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),
-        Mod::DecimalSubValue.new('98765432109876543210'),
+        Mod::IntSubVal.new(6), Mod::RealSubVal.new(6.0),
+        Mod::AutoCounterSubVal.new(:new), Mod::AutoCounterSubVal.new(8),
+        Mod::StringSubVal.new("seven"),
+        Mod::DateSubVal.new(2008,4,29), Mod::DateTimeSubVal.new(2008,4,30,10,28,16),
+        Mod::DecimalSubVal.new('98765432109876543210'),
       ]
   end
 
@@ -308,7 +308,7 @@ describe "An instance of every type of ObjectType" do
 
   it "should disallow treating an unresolved AutoCounter as an integer" do
     c = ActiveFacts::API::Constellation.new(Mod)
-    a = c.AutoCounterValue(:new)
+    a = c.AutoCounterVal(:new)
     lambda {
       b = 2 + a
     }.should raise_error
@@ -322,7 +322,7 @@ describe "An instance of every type of ObjectType" do
   it "should complain when not enough identifying values are provided for an entity" do
     c = ActiveFacts::API::Constellation.new(Mod)
     lambda {
-      c.TestByInt(:int_value => nil)
+      c.TestByInt(:int_val => nil)
     }.should raise_error
   end
 
@@ -333,6 +333,13 @@ describe "An instance of every type of ObjectType" do
     }.should raise_error
   end
 
+  it "should complain when wrong type is used for an entity" do
+    c = ActiveFacts::API::Constellation.new(Mod)
+    lambda {
+      c.TestByInt("Not an Int")
+    }.should raise_error
+  end
+
   it "should handle a non-mandatory missing identifying role" do
     module Mod2
       class Word
@@ -380,5 +387,4 @@ describe "An instance of every type of ObjectType" do
     f.is_ok.should == false
     s.is_ok.should == true
   end
-
 end

data/spec/{role_values_spec.rb → fact_type/role_values_spec.rb}

@@ -2,8 +2,6 @@
 # ActiveFacts tests: Value instances in the Runtime API
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rspec'
-require 'activefacts/api'
 
 VALUE_TYPES = Int, Real, AutoCounter, String, Date, DateTime, Decimal
 RAW_VALUES = [2, 3.0, 4, "5", Date.new(2008, 04, 20), DateTime.new(2008, 04, 20, 10, 28, 14)]
@@ -22,20 +20,20 @@ module TestValueTypesModule
     value_type
   end
   BASE_VALUE_TYPE_ROLE_NAMES = VALUE_TYPES.map { |base_type| base_type.name.snakecase }
-  VALUE_TYPE_ROLE_NAMES = BASE_VALUE_TYPE_ROLE_NAMES.map { |n| [ :"#{n}_value", :"#{n}_sub_value" ] }.flatten
+  VALUE_TYPE_ROLE_NAMES = BASE_VALUE_TYPE_ROLE_NAMES.map { |n| [ :"#{n}_val", :"#{n}_sub_val" ] }.flatten
   VALUE_TYPES.map do |value_type|
     code = <<-END
-      class #{value_type.name}Value < #{value_type.name}
+      class #{value_type.name}Val < #{value_type.name}
         value_type
       end
 
-      class #{value_type.name}ValueSub < #{value_type.name}Value
+      class #{value_type.name}ValSub < #{value_type.name}Val
         # Note no new "value_type" is required here, it comes through inheritance
       end
 
       class #{value_type.name}Entity
-        identified_by :#{identifying_role_name = "id_#{value_type.name.snakecase}_value"}
-        has_one :#{identifying_role_name}, :class => #{value_type.name}Value
+        identified_by :#{identifying_role_name = "id_#{value_type.name.snakecase}_val"}
+        one_to_one :#{identifying_role_name}, :class => #{value_type.name}Val
       end
 
       class #{value_type.name}EntitySub < #{value_type.name}Entity
@@ -43,13 +41,13 @@ module TestValueTypesModule
 
       class #{value_type.name}EntitySubCtr < #{value_type.name}Entity
         identified_by :counter
-        has_one :counter, :class => "ESCID"
+        one_to_one :counter, :class => "ESCID"
       end
 
-      VALUE_SUB_FOR_VALUE[#{value_type.name}Value] = #{value_type.name}ValueSub
+      VALUE_SUB_FOR_VALUE[#{value_type.name}Val] = #{value_type.name}ValSub
       classes = [
-          #{value_type.name}Value,
-          #{value_type.name}ValueSub,
+          #{value_type.name}Val,
+          #{value_type.name}ValSub,
           #{value_type.name}Entity,
           #{value_type.name}EntitySub,
           #{value_type.name}EntitySubCtr,
@@ -57,13 +55,13 @@ module TestValueTypesModule
       OBJECT_TYPES.concat(classes)
       classes.each { |klass| VALUE_TYPE_FOR_OBJECT_TYPE[klass] = value_type }
     END
-    eval code
+    TestValueTypesModule.module_eval code
   end
   OBJECT_TYPE_NAMES = OBJECT_TYPES.map{|object_type| object_type.basename}
 
   class Octopus
     identified_by :zero
-    has_one :zero, :class => IntValue
+    one_to_one :zero, :class => IntVal
     maybe :has_a_unary
     OBJECT_TYPE_NAMES.each do |object_type_name|
       has_one object_type_name.snakecase.to_sym
@@ -94,7 +92,7 @@ end
 describe "Object type role values" do
   def object_identifying_parameters object_type_name, value
     if object_type_name =~ /^(.*)EntitySubCtr$/
-      [{ :"id_#{$1.snakecase}_value" => value, :counter => :new}]
+      [{ :"id_#{$1.snakecase}_val" => value, :counter => :new}]
     else
       [value]
     end
@@ -110,7 +108,7 @@ describe "Object type role values" do
       it "should allow instantiation of a bare #{object_type_name}" do
         object_identifying_parameters =
           if object_type_name =~ /^(.*)EntitySubCtr$/
-            [{ :"id_#{$1.snakecase}_value" => values[0], :counter => :new}]
+            [{ :"id_#{$1.snakecase}_val" => values[0], :counter => :new}]
           else
             [values[0]]
           end
@@ -275,7 +273,7 @@ describe "Object type role values" do
             reflection = assigned.send(role.counterpart.name)
             reflection.should_not be_empty
             reflection.size.should == 1
-            reflection.should be_include(@object)
+            reflection.should include @object
           end
 
           # Update the role to the second value:
@@ -299,7 +297,7 @@ describe "Object type role values" do
             # The counterpart should include us in its RoleValues
             reflection2 = assigned2.send(role.counterpart.name)
             reflection2.size.should == 1
-            reflection2.should be_include(@object)
+            reflection2.should include @object
           end
 
           # Nullify the role
@@ -388,12 +386,23 @@ describe "Object type role values" do
 
           it "should support each" do
             count = 0
-            @role_values.each { |rv| count += 1 }
+            @role_values.each do |v, *a|
+              a.size.should == 0
+              v.should_not be_nil
+              count += 1
+            end
             count.should == 1
           end
 
           it "should support detect" do
-            @role_values.detect { |rv| true }.should be_true
+            count = 0
+            @role_values.detect do |v, *a|
+              a.size.should == 0
+              v.should_not be_nil
+              count += 1
+              false
+            end
+            count.should == 1
           end
 
           it "should verbalise" do

data/spec/{roles_spec.rb → fact_type/roles_spec.rb}

@@ -2,19 +2,21 @@
 # ActiveFacts tests: Roles of object_type classes in the Runtime API
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
-require 'rspec'
-require 'activefacts/api'
 
 describe "Roles" do
   before :each do
     Object.send :remove_const, :Mod if Object.const_defined?("Mod")
     module Mod
       class Name < String
-        value_type :length => 40, :scale => 0, :restrict => /^[A-Z][a-z]*/
+        value_type :length => 40, :scale => 0, :restrict => /^[A-Z][a-z0-9]*/
+      end
+      class Identifier
+        identified_by :name
+        one_to_one :name
       end
       class LegalEntity
         identified_by :name
-        has_one :name
+        one_to_one :name
       end
       class Contract
         identified_by :first, :second
@@ -30,6 +32,11 @@ describe "Roles" do
         alias :given= :name=
         has_one :related_to, :class => LegalEntity
       end
+      class Employee
+        identified_by :name
+        one_to_one :identifier
+        one_to_one :name
+      end
     end
     # print "object_type: "; p Mod.object_type
   end
@@ -116,10 +123,10 @@ describe "Roles" do
     le = Mod::LegalEntity.new(foo)
     le.respond_to?(:name).should be_true
     name = le.name
-    name.respond_to?(:all_legal_entity).should be_true
+    name.respond_to?(:legal_entity).should be_true
 
     #pending
-    Array(name.all_legal_entity).should === [le]
+    [name.legal_entity].should === [le]
   end
 
   it "should instantiate subclasses sensibly" do
@@ -127,7 +134,7 @@ describe "Roles" do
     bloggs = c.LegalEntity("Bloggs & Co")
     p = c.Person("Fred", "Bloggs")
     p.related_to = "Bloggs & Co"
-    p.related_to.should be_is_a(Mod::LegalEntity)
+    p.related_to.should be_an_instance_of Mod::LegalEntity
     p.related_to.should == bloggs
 
     # REVISIT: The raw instance doesn't override == to compare itself to a RoleProxy unfortunately...
@@ -136,28 +143,55 @@ describe "Roles" do
   end
 
   it "should forward missing methods on the role proxies" do
+   c = ActiveFacts::API::Constellation.new(Mod)
+   p = c.Person("Fred", "Bloggs")
+   lambda {p.family.foo}.should raise_error(NoMethodError)
+  end
+
+  it "should forward re-raise exceptions from missing methods on the role proxies" do
     c = ActiveFacts::API::Constellation.new(Mod)
     p = c.Person("Fred", "Bloggs")
+    class String
+      def foo
+        raise "Yawning"
+      end
+    end
 
-    # Make sure that RoleProxy's method_missing delegates, then forwards the send
-    lambda {
-      p.family.foo
-    }.should raise_error(NoMethodError)
+    lambda {p.family.foo}.should raise_error(RuntimeError)
   end
 
-  it "should forward re-raise exceptions from missing methods on the role proxies" do
+  it "should keep a trace of the overwritten class when changing identification" do
+    pending
     c = ActiveFacts::API::Constellation.new(Mod)
-    p = c.Person("Fred", "Bloggs")
+    e = c.Employee(:identifier => "Project2501")
+    e.overrides_identification_of.is_a?(Mod::LegalEntity).should be_true
+  end
 
-    # x = p.family.__getobj__
-    #def x.barf
-    #  raise "Yawning..."
-    #end
-    lambda {
-      p.family.barf
-    #}.should raise_error(RuntimeError)
-    }.should raise_error(NoMethodError)
+  it "should be able to import an entity from another constellation" do
+    c1 = ActiveFacts::API::Constellation.new(Mod)
+    c2 = ActiveFacts::API::Constellation.new(Mod)
 
+    e = c1.Employee("PuppetMaster")
+    identifier = c2.Identifier("Project2501", :employee => e)
+    identifier.employee.name.should == "PuppetMaster"
   end
 
+  it "should be able to import an entity from another constellation which subclass another entity" do
+    pending "fails because identify_role_values get only the current class identifying roles" do
+      # in this example, it returns :identifier, but not :name from LegalEntity
+      module Mod
+        class Person2 < LegalEntity
+          identified_by :identifier
+          one_to_one :identifier
+        end
+      end
+
+      c1 = ActiveFacts::API::Constellation.new(Mod)
+      c2 = ActiveFacts::API::Constellation.new(Mod)
+
+      p = c1.Person2("Person2Name", :identifier => "Project2501")
+      identifier = c2.Identifier("Project2501", :person2 => p)
+      identifier.person2.name.should == "Person2Name"
+    end
+  end
 end

data/spec/fixtures/tax.rb

@@ -0,0 +1,45 @@
+require 'activefacts/api'
+
+module Tax
+
+  class Name < String
+    value_type
+  end
+
+  class Person
+    identified_by :name
+    one_to_one :name
+  end
+
+  class Australian < Person
+  end
+
+  class TaxPayer < Person
+  end
+
+  class TFN < Int
+    value_type
+  end
+
+  class AustralianTaxPayer < Australian
+    supertypes TaxPayer
+    identified_by :tfn
+    one_to_one :tfn, :class => TFN  # Capitalisation rules!
+  end
+
+  class YearNr < Int
+    value_type
+  end
+
+  class Year
+    identified_by :year_nr
+    one_to_one :year_nr
+  end
+
+  class AustralianTaxReturn
+    identified_by :australian_tax_payer, :year
+    has_one :australian_tax_payer
+    has_one :year
+  end
+
+end