activefacts 0.8.10 → 0.8.12

data/examples/CQL/ServiceDirector.cql

@@ -58,14 +58,14 @@ Data Store is one Major-Version;
 Data Store is one Minor-Version;
 Data Store is one Revision-Version;
 
-Date is identified by DDMMYYYY where
-	Date has one DDMMYYYY,
-	DDMMYYYY is of at most one Date;
-Credential has at most one Expiration-Date;
+Date Time YMDHMS is identified by MDYHMS where
+	Date Time YMDHMS has one MDYHMS,
+	MDYHMS is of at most one Date Time YMDHMS;
 
-Date Time is identified by MDYHMS where
-	Date Time has one MDYHMS,
-	MDYHMS is of at most one Date Time;
+DateYYMMDD is identified by DDMMYYYY where
+	DateYYMMDD has one DDMMYYYY,
+	DDMMYYYY is of at most one DateYYMMDD;
+Credential has at most one Expiration-DateYYMMDD;
 
 Duration is identified by Seconds where
 	Duration has one Seconds,
@@ -126,16 +126,16 @@ Recurring Schedule wednesday;
 
 Satellite Message is identified by its Id;
 Satellite Message is designated for one Data Store;
-Satellite Message one Insertion-Date Time;
 Satellite Message has at most one Message Data;
 Satellite Message has at most one Message Header;
 Satellite Message is of at most one Provider Type;
 Satellite Message has one Serial Number;
+Satellite Message has one insertion-Date Time YMDHMS;
 
 Subscription is identified by its Nr;
 Company has one Driver- Tech Subscription;
-Subscription has one Beginning-Date;
-Subscription has at most one Ending-Date;
+Subscription has one Beginning-DateYYMMDD;
+Subscription has at most one Ending-DateYYMMDD;
 Subscription is enabled;
 
 Switch is identified by its Id;
@@ -155,10 +155,10 @@ Switch is backup updates;
 Switch is send disabled;
 Switch is test vectors enabled;
 
-Time is identified by HHMMSS where
-	Time has one HHMMSS,
-	HHMMSS is of at most one Time;
-Recurring Schedule has one Start-Time;
+TimeHMS is identified by HHMMSS where
+	TimeHMS has one HHMMSS,
+	HHMMSS is of at most one TimeHMS;
+Recurring Schedule has one Start-TimeHMS;
 
 Transaction is identified by its Nr;
 Satellite Message has at most one Group-Transaction;
@@ -210,11 +210,11 @@ Data Store Service has one Subscription;
  */
 either Company is client or Company is vendor but not both;
 for each Credential exactly one of these holds:
-	Data Store(2) requires Credential,
+	Data Store (2) requires Credential,
 	Data Store Service requires Credential,
 	Vendor requires Credential,
 	Data Store File Host System has Internal-Credential,
-	Data Store(1) has Internal-Credential;
+	Data Store (1) has Internal-Credential;
 for each Network exactly one of these holds:
 	Network is used by Host System,
 	Company has Origin-Network,
@@ -227,7 +227,7 @@ either Host System runs Switch or Data Store has Legacy-Switch but not both;
 for each Network at most one of these holds:
 	Network is ip_single,
 	Network has Ending-IP;
-Data Store Service (where Service is from Data Store) belongs to Client
+Data Store Service (in which Service is from Data Store) belongs to Client
 	if and only if
 	Client has default Data Store;
 Network has Ending IP

data/examples/CQL/Supervision.cql

@@ -28,12 +28,10 @@ CEO runs Company,
 /*
  * Constraints:
  */
-either Employee reports to Manager(2) or Employee is a Manager(1) that is a CEO that runs Company but not both;
+either Employee reports to Manager(1) or Employee is a Manager(2) that is a CEO that runs Company but not both;
 Employee is a Manager that is a CEO that runs Company
 	if and only if
 	Employee works for Company;
-
-// This constraint cannot be expressed in NORMA until it adds explicit join paths:
-Employee(2) reports to Manager that is a kind of Employee(1) that works for Company
+Employee(1) reports to Manager that is a kind of Employee(2) that works for Company
 	if and only if
-	Employee(2) works for Company;
+	Employee(1) works for Company;

data/examples/CQL/WaiterTips.cql

@@ -28,6 +28,6 @@ Service earned a tip of at most one Amount;
 /*
  * Constraints:
  */
-Service (where Waiter served Meal) earned a tip of Amount
+Service (in which Waiter served Meal) earned a tip of Amount
 	if and only if
 	Waiter for serving Meal reported a tip of Amount;

data/examples/CQL/unit.cql

@@ -3,7 +3,7 @@ vocabulary Units;
 /*
  * Units
  */
-1 converts to K;
+1000.0 converts to K;
 0.000000000000000001 converts to atto;
 13.0 converts to bakersdozen;
 1 converts to bit;

data/lib/activefacts/cql/FactTypes.treetop

@@ -64,6 +64,8 @@ module ActiveFacts
 
       rule joined_clauses
         qualified_clauses
+	  # REVISIT: This creates no precedence between and/or, which could cause confusion.
+	  # Should disallow mixed conjuntions - using a sempred?
           ftail:( conjunction:(',' / and / or ) s qualified_clauses s )*
 	{
 	  def ast
@@ -192,13 +194,13 @@ module ActiveFacts
       end
 
       rule condition_contraction
-	role p:post_qualifiers? q:qualifier? s comparator s e2:expression
+	role pq:post_qualifiers? q:qualifier? s comparator s e2:expression
 	  !phrase	  # The contracted_clauses must not continue here!
 	{
 	  def ast
 	    c = Compiler::Comparison.new(comparator.text_value, role.ast, e2.ast, q.empty? ? [] : [q.text_value])
 	    c.conjunction = comparator.text_value
-	    [ role.ast, p.empty? ? [] : p.list, c ]
+	    [ role.ast, pq.empty? ? [] : pq.list, c ]
 	  end
 	}
       end
@@ -248,9 +250,36 @@ module ActiveFacts
 	  }
       end
 
-      # This is the rule that causes most back-tracking. I think you can see why.
       rule role
-        q:(quantifier enforcement)?
+	aggregate
+	/
+	simple_role
+      end
+
+      rule aggregate
+	aggregate:id s of s term s	# REVISIT: this term may need to pre-scanned in the qualified_clauses
+	in s '('
+	  qualified_clauses	# REVISIT: Need to test to verify this is the right level (not joined_clauses, etc)
+	s ')'
+	{
+	  def ast
+	    raise "Not implemented: AST for '#{aggregate.text_value} of #{term.text_value}'"
+	    # This returns just the role with the nested clauses, which doesn;t even work:
+	    term.ast(
+	      nil,	# No quantifier
+	      nil,	# No function call
+	      nil,	# No role_name
+	      nil,	# No value_constraint
+	      nil,	# No literal
+	      qualified_clauses.ast
+	    )
+	  end
+	}
+      end
+
+      # This is the rule that causes most back-tracking. I think you can see why.
+      rule simple_role
+	q:(quantifier enforcement cn:context_note?)?
         player:derived_variable
         lr:(
 	  literal u:unit?
@@ -261,12 +290,16 @@ module ActiveFacts
         {
 	  def ast
 	    if !q.empty? && q.quantifier.value
-	      quantifier = Compiler::Quantifier.new(q.quantifier.value[0], q.quantifier.value[1], q.enforcement.ast)
+	      quantifier = Compiler::Quantifier.new(
+		q.quantifier.value[0],
+		q.quantifier.value[1],
+		q.enforcement.ast,
+		q.cn.empty? ? nil : q.cn.ast
+	      )
 	    end
 	    if !lr.empty?
 	      if lr.respond_to?(:literal)
-		literal = lr.literal.value
-		raise "Literals with units are not yet processed" unless lr.u.empty?
+		literal = Compiler::Literal.new(lr.literal.value, lr.u.empty? ? nil : lr.u.text_value)
 	      end
 	      value_constraint = Compiler::ValueConstraint.new(lr.value_constraint.ranges, lr.value_constraint.units, lr.enforcement.ast) if lr.respond_to?(:value_constraint)
 	      raise "It is not permitted to provide both a literal value and a value constraint" if value_constraint and literal
@@ -286,7 +319,7 @@ module ActiveFacts
       end
 
       rule objectification_join
-        '(' s where s facts:joined_clauses s ')' s
+        '(' s in_which s facts:joined_clauses s ')' s
 	{
 	  def ast
 	    facts.ast

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

@@ -38,6 +38,12 @@ module ActiveFacts
 	{ def independent; !i.empty?; end }
       end
 
+      rule in_which	# Introduce an objectification join
+	where /	    # Old syntax
+	in s which  # preferred syntax
+	{ def independent; !i.empty?; end }
+      end
+
       # Units conversion keyword
       rule conversion
 	converts s a:(approximately s)? to s
@@ -240,6 +246,7 @@ module ActiveFacts
       rule feminine 'feminine' !alphanumeric end 
       rule identified ('known'/'identified') !alphanumeric end 
       rule if 'if' !alphanumeric end
+      rule in 'in' !alphanumeric end
       rule import 'import' !alphanumeric end
       rule independent 'independent' !alphanumeric end 
       rule intransitive 'intransitive' !alphanumeric end
@@ -250,6 +257,7 @@ module ActiveFacts
       rule maybe 'maybe' !alphanumeric end
       rule only 'only' !alphanumeric end
       rule or 'or' !alphanumeric end 
+      rule of 'of' !alphanumeric end 
       rule ordering_prefix by s (ascending/descending)? s end
       rule otherwise 'otherwise' !alphanumeric end 
       rule partitioned 'partitioned' !alphanumeric end 
@@ -271,6 +279,8 @@ module ActiveFacts
       rule true 'true' !alphanumeric end 
       rule vocabulary 'vocabulary' !alphanumeric end 
       rule where 'where' !alphanumeric end 
+      rule which 'which' !alphanumeric end 
+      rule was 'was' !alphanumeric end 
       rule who 'who' !alphanumeric end 
 
     end

data/lib/activefacts/cql/ObjectTypes.treetop

@@ -164,7 +164,9 @@ module ActiveFacts
       end
 
       rule mapping_pragma
-        (independent / separate / partitioned / personal / feminine / masculine)
+        (independent / separate / partitioned / personal / feminine / masculine /
+	  was s names:(id s)+ { def text_value; [ was.text_value, names.elements.map{|n|n.text_value} ]; end }
+	)
           { def value; text_value; end }
       end
 

data/lib/activefacts/cql/Terms.treetop

@@ -8,19 +8,8 @@ module ActiveFacts
   module CQL
     grammar Terms
       rule term_definition_name
-        id s
-         t:(!non_term_def id s)*
-        {
-	  def value
-            t.elements.inject([
-              id.value
-            ]){|a, e| a << e.id.value}*' '
-          end
-
-	  def node_type
-	    :term
-	  end
-        }
+        id s t:(!non_term_def id s)*
+	  <Parser::TermDefinitionNameNode>
       end
 
       rule non_term_def
@@ -69,12 +58,15 @@ module ActiveFacts
         &{|s| input.context.reset_role_names }
         (
           context_note                      # Context notes have different lexical conventions
-          / '(' as S term_definition_name s ')' s    # Prescan for a Role Name
+          / '(' as S term_definition_name s ')' s    # Prepare for a Role Name
             &{|s| input.context.role_name(s[3].value) }
-	  / new_derived_value
-          / new_adjective_term		    # Adjective definitions
+	  / new_derived_value		    # Prepare for a derived term
+          / new_adjective_term		    # Prepae for an existing term with new Adjectives
+	# The remaining rules exist to correctly eat up anything that doesn't match the above:
           / global_term                     # If we see A B - C D, don't recognise B as a new adjective for C D.
+	  / prescan_aggregate
           / id
+	  # / literal # REVISIT: Literals might contain "(as Foo)" and mess things up
           / range                           # Covers all numbers and strings
           / comparator                      # handle two-character operators
           / S                               # White space and comments, must precede / and *
@@ -82,13 +74,9 @@ module ActiveFacts
         )* [?;] s
       end
 
-      rule derived_value_continuation
-        s '-' tail:(s !global_term !(that/who) id)*
-	{
-	  def value
-	    tail.elements.map{|e| e.id.text_value}
-	  end
-	}
+      # Not sure this is even needed, but it doesn't seem to hurt:
+      rule prescan_aggregate
+	aggregate_type:id s of s global_term in s &'('
       end
 
       rule new_derived_value
@@ -105,12 +93,24 @@ module ActiveFacts
 	  }
       end
 
+      # Derived values are new terms introduced by an = sign before an expression
+      # This rule handles trailing words of a multi-word derived value
+      rule derived_value_continuation
+        s '-' tail:(s !global_term !(that/who) id)*
+	{
+	  def value
+	    tail.elements.map{|e| e.id.text_value}
+	  end
+	}
+      end
+
+      # Used during the pre-scan, match a term with new adjective(s)
       rule new_adjective_term
-        !global_term adj:id '-' lead_intervening s global_term	  # Definitely a new leading adjective for this term
-          &{|s| input.context.new_leading_adjective_term([s[1].text_value, s[3].value].compact*" ", s[5].text_value) }
+        !global_term adj:id '-' '-'? lead_intervening s global_term	  # Definitely a new leading adjective for this term
+          &{|s| adj = [s[1].text_value, s[4].value].compact*" "; input.context.new_leading_adjective_term(adj, s[6].text_value) }
         /
-        global_term s trail_intervening '-' !global_term adj:id	  # Definitely a new trailing adjective for this term
-          &{|s| input.context.new_trailing_adjective_term([s[2].value, s[5].text_value].compact*" ", s[0].text_value) }
+        global_term s trail_intervening '-' '-'? !global_term adj:id	  # Definitely a new trailing adjective for this term
+          &{|s| adj = [s[2].value, s[6].text_value].compact*" "; input.context.new_trailing_adjective_term(adj, s[0].text_value) }
       end
 
       rule lead_intervening	# Words intervening between a new adjective and the term
@@ -133,33 +133,14 @@ module ActiveFacts
 
       # This is the rule to use after the prescan; it only succeeds on a complete term or role reference
       rule term
-        s head:id x             &{|s| w = s[1].text_value; input.context.term_starts?(w, s[2]) }
-        tail:(s '-'? s w:id     &{|s| w = s[3].text_value; input.context.term_continues?(w) })*
-                                &{|s| input.context.term_complete? }
-        {
-	  def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, nested_clauses = nil
-	    t = x.context[:term]
-	    gt = x.context[:global_term]
-	    leading_adjective = t[0...-gt.size-1] if t.size > gt.size and t[-gt.size..-1] == gt
-	    trailing_adjective = t[gt.size+1..-1] if t.size > gt.size and t[0...gt.size] == gt
-	    Compiler::VarRef.new(gt, leading_adjective, trailing_adjective, quantifier, function_call, role_name, value_constraint, literal, nested_clauses)
-	  end
-
-	  def value		# Sometimes we just want the full term name
-            x.context[:term]
-          end
-	  def node_type; :term; end
-        }
+        s head:id x		  &{|s| w = s[1].text_value; input.context.term_starts?(w, s[2]) }
+        tail:(
+	  s '-'? dbl:'-'? s w:id  &{|s| w = s[4].text_value; input.context.term_continues?(w) }
+	)*			  &{|s| input.context.term_complete? }
+	  <Parser::TermNode>
 	/
-	s head:id '-' s term	&{|s| s[4].ast.leading_adjective == nil }
-	{
-	  def ast quantifier = nil, function_call = nil, role_name = nil, value_constraint = nil, literal = nil, nested_clauses = nil
-	    ast = term.ast(quantifier, function_call, role_name, value_constraint, literal, nested_clauses)
-	    ast.leading_adjective = head.text_value
-	    ast
-	  end
-	  def node_type; :term; end
-	}
+	s head:id '-' '-'? s term	&{|s| s[5].ast.leading_adjective == nil }
+	  <Parser::TermLANode>
       end
 
       rule x

data/lib/activefacts/cql/compiler.rb

@@ -72,7 +72,7 @@ module ActiveFacts
 
       def unit? s
         name = @constellation.Name[s]
-        units = !name ? [] : name.all_unit.to_a + name.all_unit_as_plural_name.to_a
+        units = (!name ? [] : Array(name.unit) + Array(name.unit_as_plural_name)).uniq
         debug :units, "Looking for unit #{s}, got #{units.map{|u|u.name}.inspect}"
         units.size > 0
       end

data/lib/activefacts/cql/compiler/clause.rb

@@ -351,13 +351,15 @@ module ActiveFacts
               if la = role_ref.leading_adjective and !la.empty?
                 # The leading adjectives must match, one way or another
                 la = la.split(/\s+/)
-                return nil unless la[0,intervening_words.size] == intervening_words
+                # We may have hyphenated adjectives. Break them up to check:
+                iw = intervening_words.map{|w| w.split(/-/)}.flatten
+                return nil unless la[0,iw.size] == iw
                 # Any intervening_words matched, see what remains
-                la.slice!(0, intervening_words.size)
+                la.slice!(0, iw.size)
 
                 # If there were intervening_words, the remaining reading adjectives must match the phrase's leading_adjective exactly.
                 phrase_la = (next_player_phrase.leading_adjective||'').split(/\s+/)
-                return nil if !intervening_words.empty? && la != phrase_la
+                return nil if !iw.empty? && la != phrase_la
                 # If not, the phrase's leading_adjectives must *end* with the reading's
                 return nil if phrase_la[-la.size..-1] != la
                 role_has_residual_adjectives = true if phrase_la.size > la.size
@@ -468,7 +470,8 @@ module ActiveFacts
               # the role_ref, those must be local, and we'll need to extract them.
 
               if rra = side_effect.role_ref.trailing_adjective
-                debug :matching, "Deleting matched trailing adjective '#{rra}'#{side_effect.absorbed_followers>0 ? " in #{side_effect.absorbed_followers} followers" : ""}"
+                debug :matching, "Deleting matched trailing adjective '#{rra}'#{side_effect.absorbed_followers>0 ? " in #{side_effect.absorbed_followers} followers" : ""}, cost is #{side_effect.cost}"
+                side_effect.cancel_cost side_effect.absorbed_followers
 
                 # These adjective(s) matched either an adjective here, or a follower word, or both.
                 if a = phrase.trailing_adjective
@@ -487,7 +490,8 @@ module ActiveFacts
               end
 
               if rra = side_effect.role_ref.leading_adjective
-                debug :matching, "Deleting matched leading adjective '#{rra}'#{side_effect.absorbed_precursors>0 ? " in #{side_effect.absorbed_precursors} precursors" : ""}}"
+                debug :matching, "Deleting matched leading adjective '#{rra}'#{side_effect.absorbed_precursors>0 ? " in #{side_effect.absorbed_precursors} precursors" : ""}, cost is #{side_effect.cost}"
+                side_effect.cancel_cost side_effect.absorbed_precursors
 
                 # These adjective(s) matched either an adjective here, or a precursor word, or both.
                 if a = phrase.leading_adjective
@@ -694,11 +698,16 @@ module ActiveFacts
           @absorbed_followers = absorbed_followers
           @common_supertype = common_supertype
           @residual_adjectives = residual_adjectives
+          @cancelled_cost = 0
           debug :matching_fails, "Saving side effects for #{@phrase.term}, absorbs #{@absorbed_precursors}/#{@absorbed_followers}#{@common_supertype ? ', join over supertype '+ @common_supertype.name : ''}" if @absorbed_precursors+@absorbed_followers+(@common_supertype ? 1 : 0) > 0
         end
 
         def cost
-          absorbed_precursors + absorbed_followers + (common_supertype ? 1 : 0)
+          absorbed_precursors + absorbed_followers + (common_supertype ? 1 : 0) - @cancelled_cost
+        end
+
+        def cancel_cost c
+          @cancelled_cost += c
         end
 
         def to_s
@@ -963,16 +972,20 @@ module ActiveFacts
 
       class Quantifier
         attr_accessor :enforcement
+        attr_accessor :context_note
         attr_reader :min, :max
 
-        def initialize min, max, enforcement = nil
+        def initialize min, max, enforcement = nil, context_note = nil
           @min = min
           @max = max
           @enforcement = enforcement
+          @context_note = context_note
         end
 
         def inspect
-          "[#{@min}..#{@max}]"
+          "[#{@min}..#{@max}]#{
+            @context_note && ' ' + @context_note.inspect
+          }"
         end
       end