activefacts 0.8.5 → 0.8.6

data/lib/activefacts/cql/CQLParser.treetop

@@ -75,30 +75,39 @@ module ActiveFacts
         # REVISIT: / value_constraint
       end
 
+      rule enforcement
+	s '(' s otherwise s action s agent? s ')' s
+	  { def value; [action.text_value, agent.empty? ? nil : agent.text_value]; end }
+	/
+	''
+	  { def value; []; end }
+      end
+
       # presence constraint:
       rule presence_constraint
-        s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' s 'in' s
+        s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' s enforcement 'in' s
         readings_list s
         c:context? ';' s
-        { def value; [ nil, [ :constraint, :presence, role_list.roles, quantifier.value, readings_list.value, c.empty? ? nil : c.value ] ]; end }
+        { def value; [ nil, [ :constraint, :presence, role_list.roles, quantifier.value, readings_list.value, c.empty? ? nil : c.value, enforcement.value ] ]; end }
       end
 
       # set (exclusion, mandatory exclusion, complex equality) constraint
       rule set_constraint
-        s 'for' s 'each' s role_list s quantifier s 'of' s 'these' s 'holds' s ':' s
+        s 'for' s 'each' s role_list s quantifier s 'of' s 'these' s 'holds' s enforcement ':' s
           readings_list s
           c:context? ';' s
-          { def value; [ nil, [ :constraint, :set, role_list.roles, quantifier.value, readings_list.value, c.empty? ? nil : c.value  ] ]; end }
+          { def value; [ nil, [ :constraint, :set, role_list.roles, quantifier.value, readings_list.value, c.empty? ? nil : c.value, enforcement.value ] ]; end }
         /
-        s either? s r1:readings s or s r2:readings exclusion:(but s not s both s)? c:context? ';' s
+        s either? s r1:readings s or s r2:readings exclusion:(but s not s both s)? c:context? enforcement ';' s
           { def value;
               [ nil, [ :constraint, :set,
                 nil,  # No roles names, rely on the join
                 exclusion.text_value.empty? ?
-                  [1, nil] :    # At least one (meaning 1 or 2/more)
+                  [1, nil] :		# At least one (meaning 1 or 2/more)
                   [1,1],                # Exactly one (1 and only 1)
                 [r1.value, r2.value],
-                c.empty? ? nil : c.value
+                c.empty? ? nil : c.value,
+		enforcement.value
               ] ];
             end
           }
@@ -106,14 +115,14 @@ module ActiveFacts
 
       rule subset_constraint
         s readings s only s if s r2:readings s
-        c:context? ';' s
-        { def value; [ nil, [ :constraint, :subset, [readings.value, r2.value], c.empty? ? nil : c.value ] ]; end }
+        c:context? enforcement ';' s
+        { def value; [ nil, [ :constraint, :subset, [readings.value, r2.value], c.empty? ? nil : c.value, enforcement.value ] ]; end }
       end
 
       rule equality_constraint
         s readings s tail:( if s and s only s if s readings s)+
-        c:context? ';' s
-        { def value; [ nil, [ :constraint, :equality, [readings.value] + tail.elements.map{|e| e.readings.value }, c.empty? ? nil : c.value ]]; end }
+        c:context? enforcement ';' s
+        { def value; [ nil, [ :constraint, :equality, [readings.value] + tail.elements.map{|e| e.readings.value }, c.empty? ? nil : c.value, enforcement.value ]]; end }
       end
 
       rule readings_list

data/lib/activefacts/cql/Concepts.treetop

@@ -69,8 +69,16 @@ module ActiveFacts
 
       rule identification
         # REVISIT: Consider distinguishing "-Id" from just "Id", and not prepending the entity type name if no "-"
-        identified_by its s id value_type_parameters r:restriction?          # Reference Mode; restriction may be needed for the ValueType
-          { def value; {:mode => id.value, :restriction => (r.text_value.empty? ? nil : r.ranges), :parameters => value_type_parameters.values }; end }
+        identified_by its s id value_type_parameters
+	r:(restriction enforcement)?          # Reference Mode; restriction may be needed for the ValueType
+          { def value
+	      { :mode => id.value,
+	        :restriction => (r.text_value.empty? ? nil : r.restriction.ranges),
+	        :enforcement => (r.text_value.empty? ? nil : r.enforcement.value),
+		:parameters => value_type_parameters.values
+	      }
+	    end
+	  }
         /
         identified_by role_list
           { def value; {:roles => role_list.roles }; end }

data/lib/activefacts/cql/Context.treetop

@@ -15,8 +15,8 @@ module ActiveFacts
       end
 
       rule who_says
-        according_to people s ','
-        { def value; people.value; end }
+        according_to agents s ','
+        { def value; agents.value; end }
       end
 
       rule context_type

data/lib/activefacts/cql/FactTypes.treetop

@@ -123,18 +123,21 @@ module ActiveFacts
       # When we have an expression, we will come down here perhaps multiple times,
       # but find no way out as soon as we hit the trailing non_role.
       rule role
-        q:quantifier?
+        q:(quantifier enforcement)?
         adj0:(a:role_word '-' s)?
         player:role_word !'-' s?
         adj1:( '-' a:(a:role_word s)? )?
         func:function_call?
         role_id:(role_name / subscript )?
-        lr:( literal / restriction )?
+        lr:( literal / restriction enforcement )?
         !non_role
         {
           def value
             r = {}
-            quantifier = !q.empty? && q.value   # "some" quantifier has nil value
+            if !q.empty?
+	      quantifier = q.quantifier.value   # "some" quantifier has nil value
+	      r[:quantifier_restriction] = q.enforcement.value
+	    end
 
             r[:quantifier] = quantifier if quantifier
             r[:leading_adjective] = adj0.a.value unless adj0.empty?
@@ -144,7 +147,10 @@ module ActiveFacts
             r[:trailing_adjective] = adj1.a.a.value unless adj1.empty?
             r[:function] = func.value if !func.empty?
             r[:role_name] = role_id.value unless role_id.empty?
-            r[:restriction] = lr.ranges if !lr.empty? && lr.respond_to?(:ranges)
+	    if !lr.empty? && lr.respond_to?(:restriction)
+	      r[:restriction] = lr.restriction.ranges
+	      r[:restriction_enforcement] = lr.enforcement.value
+	    end
             r[:literal] = lr.value if !lr.empty? && lr.respond_to?(:value)
 
             r

data/lib/activefacts/cql/Language/English.treetop

@@ -68,8 +68,8 @@ module ActiveFacts
       end
 
       rule as_agreed_by
-        s as s 'agreed' s d:('on' S date)? by s people
-        { def value; [ d.empty? ? nil : d.date.value, people.value ]; end }
+        s as s 'agreed' s d:('on' S date)? by s agents
+        { def value; [ d.empty? ? nil : d.date.value, agents.value ]; end }
       end
 
       rule date
@@ -77,15 +77,20 @@ module ActiveFacts
         { def value; d.text_value.strip; end }
       end
 
-      rule people
-        s h:person s t:(',' s !context_type person s)*
-        { def value; [h.text_value] + t.elements.map{|e| e.person.text_value }; end }
+      rule agents
+        s h:agent s t:(',' s !context_type agent s)*
+        { def value; [h.text_value] + t.elements.map{|e| e.agent.text_value }; end }
       end
 
-      rule person
+      rule agent
         id (s id)*
       end
 
+      # An enforcement action, like SMS, email, log, alarm, etc.
+      rule action
+	id
+      end
+
       rule acyclic 'acyclic' !alphanumeric end
       rule alias 'alias' !alphanumeric end 
       rule all 'all' !alphanumeric end
@@ -126,6 +131,7 @@ module ActiveFacts
       rule one 'one' !alphanumeric end
       rule only 'only' !alphanumeric end
       rule or 'or' !alphanumeric end 
+      rule otherwise 'otherwise' !alphanumeric end 
       rule partitioned 'partitioned' !alphanumeric end 
       rule personal 'personal' !alphanumeric end 
       rule restricted 'restricted' !alphanumeric end

data/lib/activefacts/cql/ValueTypes.treetop

@@ -14,7 +14,7 @@ module ActiveFacts
         base:id s
         value_type_parameters
         units
-        r:restriction?
+        r:(restriction enforcement)?
         mapping_pragmas
         s ';' s
         {
@@ -24,8 +24,9 @@ module ActiveFacts
               base.value,
               value_type_parameters.values,
               units.value,
-              (!r.empty? ? r.ranges : []),
-              mapping_pragmas.value
+              (!r.empty? ? r.restriction.ranges : []),
+              mapping_pragmas.value,
+              (!r.empty? ? r.enforcement.value : nil)
             ]
           end
 

data/lib/activefacts/cql/compiler.rb

@@ -69,7 +69,7 @@ module ActiveFacts
       end
 
     private
-      def value_type(name, base_type_name, parameters, unit, ranges, mapping_pragmas)
+      def value_type(name, base_type_name, parameters, unit, ranges, mapping_pragmas, enforcement)
         length, scale = *parameters
 
         # Create the base type:
@@ -91,11 +91,11 @@ module ActiveFacts
         # REVISIT: Find and apply the units
 
         if ranges.size != 0
-          vt.value_restriction = value_restriction ranges
+          vt.value_restriction = value_restriction(ranges, enforcement)
         end
       end
 
-      def value_restriction(ranges)
+      def value_restriction(ranges, enforcement)
         vr = @constellation.ValueRestriction(:new)
         ranges.each do |range|
           min, max = Array === range ? range : [range, range]
@@ -105,9 +105,15 @@ module ActiveFacts
             )
           ar = @constellation.AllowedRange(vr, v_range)
         end
+        apply_enforcement(vr, enforcement) if enforcement
         vr
       end
 
+      def apply_enforcement(constraint, enforcement)
+        constraint.enforcement = enforcement[0]
+        constraint.enforcement.agent = enforcement[1] if enforcement[1]
+      end
+
       def entity_type(name, supertypes, identification, mapping_pragmas, clauses)
         #puts "Entity Type #{name}, supertypes #{supertypes.inspect}, id #{identification.inspect}, clauses = #{clauses.inspect}"
         debug :entity, "Defining Entity Type #{name}" do
@@ -139,7 +145,7 @@ module ActiveFacts
             end
             # REVISIT: If we do this, it gets emitted twice when we generate CQL. The generator should detect that the restriction is the same and not emit it.
             #if (ranges = identification[:restriction])
-            #  vt.value_restriction = value_restriction(ranges)
+            #  vt.value_restriction = value_restriction(ranges, identification[:enforcement])
             #end
           end
 
@@ -269,7 +275,7 @@ player, binding = @symbols.bind(names)
 
                 # REVISIT: The restriction applies only to the value role. There is good reason to apply it above to the value type as well.
                 if (ranges = identification[:restriction])
-                  value_role.role_value_restriction = value_restriction(ranges)
+                  value_role.role_value_restriction = value_restriction(ranges, identification[:enforcement])
                 end
 
                 # Forward reading, if it doesn't already exist:
@@ -315,10 +321,9 @@ player, binding = @symbols.bind(names)
                   debug :mode, "Using existing EntityType role sequence"
                 end
                 if (rs0.all_presence_constraint.size == 0)
-                  @constellation.PresenceConstraint(
+                  constraint = @constellation.PresenceConstraint(
                     :new,
                     :name => '',
-                    :enforcement => '',
                     :vocabulary => @vocabulary,
                     :role_sequence => rs0,
                     :min_frequency => 1,
@@ -344,10 +349,9 @@ player, binding = @symbols.bind(names)
                   debug :mode, "Using existing ValueType role sequence"
                 end
                 if (rs1.all_presence_constraint.size == 0)
-                  @constellation.PresenceConstraint(
+                  constraint = @constellation.PresenceConstraint(
                     :new,
                     :name => '',
-                    :enforcement => '',
                     :vocabulary => @vocabulary,
                     :role_sequence => rs1,
                     :min_frequency => 0,
@@ -870,7 +874,7 @@ player, binding = @symbols.bind(names)
         role_sequences
       end
 
-      def presence_constraint(constrained_role_names, quantifier, phrases_list, context)
+      def presence_constraint(constrained_role_names, quantifier, phrases_list, context, enforcement)
         raise "REVISIT: Join presence constraints not supported yet" if phrases_list[0].size > 1
         phrases_list = phrases_list.map{|r| r[0] }
         #p phrases_list
@@ -929,10 +933,9 @@ player, binding = @symbols.bind(names)
 
         # REVISIT: Check that no existing PC spans the same roles (nor a superset nor subset?)
 
-        @constellation.PresenceConstraint(
+        constraint = @constellation.PresenceConstraint(
             :new,
             :name => '',
-            :enforcement => '',
             :vocabulary => @vocabulary,
             :role_sequence => rs,
             :min_frequency => quantifier[0],
@@ -940,9 +943,10 @@ player, binding = @symbols.bind(names)
             :is_preferred_identifier => false,
             :is_mandatory => quantifier[0] && quantifier[0] > 0
           )
+        apply_enforcement(constraint, enforcement) if enforcement
       end
 
-      def set_constraint(constrained_roles, quantifier, joins_list, context)
+      def set_constraint(constrained_roles, quantifier, joins_list, context, enforcement)
         role_sequences = bind_joins_as_role_sequences(joins_list)
 
         if quantifier[1] == nil
@@ -953,10 +957,9 @@ player, binding = @symbols.bind(names)
           second_role_ref = @constellation.RoleRef(:role_sequence => role_sequences[0], :ordinal => 1, :role => second_role)
           @constellation.deny(role_sequences[1].all_role_ref.single)
           @constellation.deny(role_sequences[1])
-          @constellation.PresenceConstraint(
+          constraint = @constellation.PresenceConstraint(
               :new,
               :name => '',
-              :enforcement => '',
               :vocabulary => @vocabulary,
               :role_sequence => role_sequences[0],
               :min_frequency => quantifier[0],
@@ -964,6 +967,7 @@ player, binding = @symbols.bind(names)
               :is_preferred_identifier => false,
               :is_mandatory => true
             )
+          apply_enforcement(constraint, enforcement) if enforcement
         else
           # Create a normal (mandatory) exclusion constraint:
           constraint = @constellation.SetExclusionConstraint(:new)
@@ -971,11 +975,12 @@ player, binding = @symbols.bind(names)
           role_sequences.each_with_index do |rs, i|
             @constellation.SetComparisonRoles(constraint, i, :role_sequence => rs)
           end
+          apply_enforcement(constraint, enforcement) if enforcement
           constraint.is_mandatory = quantifier[0] == 1
         end
       end
 
-      def subset_constraint(joins_list, context)
+      def subset_constraint(joins_list, context, enforcement)
         role_sequences = bind_joins_as_role_sequences(joins_list)
 
         #puts "subset_constraint:\n\t#{subset_readings.inspect}\n\t#{superset_readings.inspect}"
@@ -990,10 +995,11 @@ player, binding = @symbols.bind(names)
         #constraint.enforcement = 
         constraint.subset_role_sequence = role_sequences[0]
         constraint.superset_role_sequence = role_sequences[1]
+        apply_enforcement(constraint, enforcement) if enforcement
       end
 
-      def equality_constraint(joins_list, context)
-        #puts "REVISIT: equality\n\t#{joins_list.map{|rl| rl.inspect}*"\n\tif and only if\n\t"}"
+      def equality_constraint(joins_list, context, enforcement)
+        #puts "equality\n\t#{joins_list.map{|rl| rl.inspect}*"\n\tif and only if\n\t"}"
 
         role_sequences = bind_joins_as_role_sequences(joins_list)
 
@@ -1003,6 +1009,7 @@ player, binding = @symbols.bind(names)
         role_sequences.each_with_index do |rs, i|
           @constellation.SetComparisonRoles(constraint, i, :role_sequence => rs)
         end
+        apply_enforcement(constraint, enforcement) if enforcement
       end
 
       # Search the supertypes of 'subtype' looking for an inheritance path to 'supertype',
@@ -1195,7 +1202,7 @@ player, binding = @symbols.bind(names)
 
             # Save a role value restriction
             if (ranges = role_phrase[:restriction])
-              role.role_value_restriction = value_restriction(ranges)
+              role.role_value_restriction = value_restriction(ranges, role_phrase[:restriction_enforcement])
             end
 
             roles << role

data/lib/activefacts/cql/parser.rb

@@ -53,6 +53,14 @@ module ActiveFacts
         def index(*a)
           @input.index(*a)
         end
+
+        def line_of(x)
+          @input.line_of(x)
+        end
+
+        def column_of(x)
+          @input.column_of(x)
+        end
       end
 
       def context

data/lib/activefacts/version.rb

@@ -5,5 +5,5 @@
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 module ActiveFacts
-  VERSION = '0.8.5'
+  VERSION = '0.8.6'
 end

data/lib/activefacts/vocabulary/metamodel.rb

@@ -7,6 +7,10 @@ module ActiveFacts
       value_type :length => 64
     end
 
+    class AgentName < String
+      value_type 
+    end
+
     class Assimilation < String
       value_type 
       restrict 'partitioned', 'separate'
@@ -37,7 +41,7 @@ module ActiveFacts
       value_type 
     end
 
-    class Enforcement < String
+    class EnforcementCode < String
       value_type :length => 16
     end
 
@@ -85,10 +89,6 @@ module ActiveFacts
       value_type :length => 32
     end
 
-    class PersonName < String
-      value_type 
-    end
-
     class Pronoun < String
       value_type :length => 20
       restrict 'feminine', 'masculine', 'neuter', 'personal'
@@ -114,8 +114,9 @@ module ActiveFacts
       value_type 
     end
 
-    class ValueRestrictionId < AutoCounter
-      value_type 
+    class Agent
+      identified_by :agent_name
+      one_to_one :agent_name, :mandatory => true  # See AgentName.agent
     end
 
     class Coefficient
@@ -143,6 +144,12 @@ module ActiveFacts
       has_one :fact_type                          # See FactType.all_context_note
     end
 
+    class Enforcement
+      identified_by :enforcement_code
+      has_one :agent                              # See Agent.all_enforcement
+      one_to_one :enforcement_code, :mandatory => true  # See EnforcementCode.enforcement
+    end
+
     class Fact
       identified_by :fact_id
       one_to_one :fact_id, :mandatory => true     # See FactId.fact
@@ -164,11 +171,6 @@ module ActiveFacts
       has_one :value                              # See Value.all_instance
     end
 
-    class Person
-      identified_by :person_name
-      one_to_one :person_name, :mandatory => true  # See PersonName.person
-    end
-
     class PresenceConstraint < Constraint
       maybe :is_mandatory
       maybe :is_preferred_identifier
@@ -239,9 +241,7 @@ module ActiveFacts
       has_one :unit                               # See Unit.all_value
     end
 
-    class ValueRestriction
-      identified_by :value_restriction_id
-      one_to_one :value_restriction_id, :mandatory => true  # See ValueRestrictionId.value_restriction
+    class ValueRestriction < Constraint
     end
 
     class Vocabulary
@@ -270,15 +270,15 @@ module ActiveFacts
     end
 
     class ContextAccordingTo
-      identified_by :context_note, :person
+      identified_by :context_note, :agent
+      has_one :agent, :mandatory => true          # See Agent.all_context_according_to
       has_one :context_note, :mandatory => true   # See ContextNote.all_context_according_to
-      has_one :person, :mandatory => true         # See Person.all_context_according_to
     end
 
     class ContextAgreedBy
-      identified_by :agreement, :person
+      identified_by :agreement, :agent
+      has_one :agent, :mandatory => true          # See Agent.all_context_agreed_by
       has_one :agreement, :mandatory => true      # See Agreement.all_context_agreed_by
-      has_one :person, :mandatory => true         # See Person.all_context_agreed_by
     end
 
     class Derivation

data/spec/absorption_ruby_spec.rb

@@ -15,7 +15,7 @@ include ActiveFacts
 describe "Column lists from absorption compared with Ruby's" do
   ABSORPTION_RUBY_FAILURES = {
     "Metamodel" => "Overlaps with ActiveFacts Metamodel",
-    "MetamodelTerms" => "Overlaps with ActiveFacts Metamodel",
+    "MetamodelNext" => "Overlaps with ActiveFacts Metamodel",
     "ServiceDirector" => "Lacks standard AutoTimestamp class"
   }
 

data/spec/cql/context_spec.rb

@@ -15,39 +15,39 @@ describe "Business Context Notes" do
   Notes = [
     # Constraints:
     [ 'each Person occurs one time in Person is employed, Person is unemployed (because it can be no other way!);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "because", "it can be no other way!", []]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "because", "it can be no other way!", []], []]]]
     ],
     [ 'each Person occurs one time in Person is employed, Person is unemployed (as opposed to blah!);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "as_opposed_to", " blah!", []]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :presence, [["Person"]], [1, 1], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"unemployed"}]]], [nil, "as_opposed_to", " blah!", []], []]]]
     ],
     [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", []]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", []], []]]]
     ],
     [ 'Person is good credit risk only if Person is employed (to avoid lending to people who can\'t repay);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :subset, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :subset, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []], []]]]
     ],
     [ 'Person is good credit risk if and only if Person is employed (to avoid lending to people who can\'t repay);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :equality, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :equality, [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"good"}, {:word=>"credit"}, {:word=>"risk"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]]], [nil, "to_avoid", " lending to people who can't repay", []], []]]]
     ],
     # Entity and Fact types
     [ 'Foo is identified by Bar [independent] where Foo has one Bar (so that we have an id);',
-      [["Person", [:value_type, "Person", [], [], [], []]], ["Foo", [:entity_type, [], {:roles=>[["Bar"]]}, ["independent"], [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:word=>"Bar", :quantifier=>[1, 1]}], [nil, "so_that", " we have an id", []]]]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], ["Foo", [:entity_type, [], {:roles=>[["Bar"]]}, ["independent"], [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:quantifier=>[1, 1], :quantifier_restriction=>[], :word=>"Bar"}], [nil, "so_that", " we have an id", []]]]]]]
     ],
     [ 'Foo has one Bar (so that we have an id), Bar is of one Foo (because we need that);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:word=>"Bar", :quantifier=>[1, 1]}], [nil, "so_that", " we have an id", []]], [:fact_clause, [], [{:word=>"Bar"}, {:word=>"is"}, {:word=>"of"}, {:word=>"Foo", :quantifier=>[1, 1]}], [nil, "because", "we need that", []]]], []]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:fact_type, [[:fact_clause, [], [{:word=>"Foo"}, {:word=>"has"}, {:quantifier=>[1, 1], :quantifier_restriction=>[], :word=>"Bar"}], [nil, "so_that", " we have an id", []]], [:fact_clause, [], [{:word=>"Bar"}, {:word=>"is"}, {:word=>"of"}, {:quantifier=>[1, 1], :quantifier_restriction=>[], :word=>"Foo"}], [nil, "because", "we need that", []]]], []]]]
     ],
     # REVISIT: No context notes on quantifiers yet
     # As agreed by:
     [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah, as agreed by Jim);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", [nil, ["Jim"]]]]]] 
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", [nil, ["Jim"]]], []]]] 
     ],
     # REVISIT: Populate an "as agreed by" with a date
     [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (so that blah, as agreed on 29 March by Jim);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", ["29 March", ["Jim"]]]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [nil, "so_that", " blah", ["29 March", ["Jim"]]], []]]]
     ],
     # According to:
     [ 'for each Person at least one of these holds: Person is employed, Person is a bad credit risk (according to jim, so that blah);',
-      [["Person", [:value_type, "Person", [], [], [], []]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [["jim"], "so_that", " blah", []]]]]
+      [["Person", [:value_type, "Person", [], [], [], [], nil]], [nil, [:constraint, :set, [["Person"]], [1, nil], [[[{:word=>"Person"}, {:word=>"is"}, {:word=>"employed"}]], [[{:word=>"Person"}, {:word=>"is"}, {:word=>"a"}, {:word=>"bad"}, {:word=>"credit"}, {:word=>"risk"}]]], [["jim"], "so_that", " blah", []], []]]]
     ],
   ]
 

data/spec/cql/unit_spec.rb

@@ -167,7 +167,7 @@ end
 describe "Value Types" do
   ValueTypes = [
     [ "a is written as b(1, 2) inch restricted to { 3 .. 4 } inch ;",
-      [["a", [:value_type, "b", [ 1, 2 ], [["inch", 1]], [[3, 4]], []]]]
+      [["a", [:value_type, "b", [1, 2], [["inch", 1]], [[3, 4]], [], []]]]
     ],
 #    [ "a c  is written as b(1, 2) inch restricted to { 3 .. 4 } inch ;",
 #      [["a c", [:value_type, "b", [1, 2], "inch", [[3, 4]]]]]
@@ -195,16 +195,16 @@ end
 describe "Entity Types" do
   EntityTypes_RefMode = [
     [ "a is identified by its id;",                     # Entity type declaration with reference mode
-      [["a", [:entity_type, [], {:mode=>"id", :parameters=> [], :restriction=>nil}, [], nil]]]
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :restriction=>nil}, [], nil]]] 
     ],
     [ "a is identified by its number(12);",                     # Entity type declaration with reference mode
-      [["a", [:entity_type, [], {:mode=>"number", :parameters => [12], :restriction=>nil}, [], nil]]]
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"number", :parameters=>[12], :restriction=>nil}, [], nil]]]
     ],
     [ "a is identified by its id:c;",                   # Entity type declaration with reference mode and fact type(s)
-      [["a", [:entity_type, [], {:mode=>"id", :parameters=> [], :restriction=>nil}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :restriction=>nil}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
     ],
     [ "a is identified by its id where c;",             # Entity type declaration with reference mode and where
-      [["a", [:entity_type, [], {:mode=>"id", :parameters=> [], :restriction=>nil}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
+      [["a", [:entity_type, [], {:enforcement=>nil, :mode=>"id", :parameters=>[], :restriction=>nil}, [], [[:fact_clause, [], [{:word=>"c"}], nil]]]]]
     ],
   ]
 
@@ -222,12 +222,10 @@ describe "Entity Types" do
       [["a", [:entity_type, [], {:roles=>[["b"], ["c"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
     ],
     [ "a is written as b(); c is identified by a:d;",
-      [["a", [:value_type, "b", [], [], [], []]],
-        ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
+      [["a", [:value_type, "b", [], [], [], [], nil]], ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
     ],
     [ " a is written as b ( ) ; c is identified by a : d ; ",
-      [["a", [:value_type, "b", [], [], [], []]],
-        ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
+      [["a", [:value_type, "b", [], [], [], [], nil]], ["c", [:entity_type, [], {:roles=>[["a"]]}, [], [[:fact_clause, [], [{:word=>"d"}], nil]]]]]
     ],
     [ "a is identified by c:maybe d;",
       [["a", [:entity_type, [], {:roles=>[["c"]]}, [], [[:fact_clause, ["maybe"], [{:word=>"d"}], nil]]]]]
@@ -343,7 +341,7 @@ describe "Fact Types" do
 
   Constraints = [
     [ "each combination FamilyName, GivenName occurs at most one time in Competitor has FamilyName, Competitor has GivenName;",
-      [nil, [:constraint, :presence, [["FamilyName"], ["GivenName"]], [nil, 1], [[[{:word=>"Competitor"}, {:word=>"has"}, {:word=>"FamilyName"}]], [[{:word=>"Competitor"}, {:word=>"has"}, {:word=>"GivenName"}]]], nil]]
+      [nil, [:constraint, :presence, [["FamilyName"], ["GivenName"]], [nil, 1], [[[{:word=>"Competitor"}, {:word=>"has"}, {:word=>"FamilyName"}]], [[{:word=>"Competitor"}, {:word=>"has"}, {:word=>"GivenName"}]]], nil, []]]
     ],
   ]
 

data/spec/cql_cql_spec.rb

@@ -16,12 +16,12 @@ describe "CQL Loader" do
   cql_failures = {
     "Airline" => "Contains queries, unsupported",
     "CompanyQuery" => "Contains queries, unsupported",
+    "MetamodelNext" => "Fails due to weak adjective/role matching",
     "OrienteeringER" => "Doesn't parse due to difficult fact type match",
     "ServiceDirector" => "Doesn't parse some constraints due to mis-matched adjectives"
   }
   cql_cql_failures = {
     "Insurance" => "Misses a subtype join in a constraint verbalisation",
-    "MetamodelTerms" => "Fails due to weak adjective/role matching",
 #    "OddIdentifier" => "Doesn't support identification of object fact types using mixed external/internal roles",
   }
   # Generate and return the CQL for the given vocabulary

data/spec/norma_tables_spec.rb

@@ -20,7 +20,7 @@ Exceptions = {
   "Blog" => ["Author", "Comment", "Paragraph", "Post", "Topic"],
   "JoinEquality" => ["Event", "Seat", "Ticket", "Venue"],
   "Metamodel" => ["AllowedRange", "Concept", "Constraint", "ContextAccordingTo", "ContextAgreedBy", "ContextNote", "Derivation", "Fact", "FactType", "Instance", "Join", "ParamValue", "Reading", "Role", "RoleRef", "RoleSequence", "RoleValue", "SetComparisonRoles", "Unit", "ValueRestriction" ],
-  "MetamodelTerms" => ["AllowedRange", "Constraint", "ContextAccordingTo", "ContextAgreedBy", "ContextNote", "Derivation", "Fact", "FactType", "Instance", "Join", "ParamValue", "Reading", "Role", "RoleRef", "RoleSequence", "RoleValue", "SetComparisonRoles", "Term", "Unit", "ValueRestriction"],
+  "MetamodelNext" => ["AllowedRange", "Constraint", "ContextAccordingTo", "ContextAgreedBy", "ContextNote", "Derivation", "Fact", "FactType", "Instance", "Join", "ParamValue", "Reading", "Role", "RoleRef", "RoleSequence", "RoleValue", "SetComparisonRoles", "Term", "Unit", "ValueConstraint"],
   "OilSupply" => ["AcceptableSubstitutes", "Month", "ProductionForecast", "RegionalDemand", "TransportRoute"],
   "Orienteering" => ["Club", "Entry", "Event", "EventControl", "EventScoringMethod", "Map", "Person", "Punch", "PunchPlacement", "Series", "Visit"],
   "SeparateSubtype" => ["Claim", "VehicleIncident"],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: activefacts
 version: !ruby/object:Gem::Version 
-  version: 0.8.5
+  version: 0.8.6
 platform: ruby
 authors: 
 - Clifford Heath
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-24 00:00:00 +10:00
+date: 2010-04-09 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.3.2
+        version: 2.3.3
     version: 
 description: |