activefacts 0.7.3 → 0.8.5

data/lib/activefacts/cql/CQLParser.treetop

@@ -5,106 +5,127 @@
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 module ActiveFacts
-  grammar CQL
-    include LexicalRules
-    include Language        # One of the language modules provides this module
-    include Expressions
-    include Concepts
-    include DataTypes
-    include FactTypes
+  module CQL
+    grammar CQL
+      include LexicalRules
+      include Language        # One of the language modules provides this module
+      include Expressions
+      include Terms
+      include Concepts
+      include ValueTypes
+      include FactTypes
+      include Context
 
-    rule cql_file
-      s seq:definition*
-      {
-        def definitions
-          seq.elements.map{|e|
-              e.value rescue $stderr.puts "Can't call value() on #{e.inspect}"
-            }
-        end
-      }
-    end
+      rule cql_file
+        s seq:definition*
+        {
+          def definitions
+            seq.elements.map{|e|
+                e.value rescue $stderr.puts "Can't call value() on #{e.inspect}"
+              }
+          end
+        }
+      end
 
-    # Each definition has a value() method that returns an array like
-    # either [name, [kind, definition]] or [name, kind]:
-    rule definition
-      vocabulary_definition
-      / import_definition
-      / constraint
-      / concept
-    end
+      # Each definition has a value() method that returns an array like
+      # either [name, [kind, definition]] or [name, kind]:
+      rule definition
+        vocabulary_definition
+        / import_definition
+	/ prescan
+        / constraint
+        / unit_definition
+        / concept
+      end
 
-    rule vocabulary_definition
-      s vocabulary S id s ';' s
-      {
-        def value
-          [ id.text_value, [ :vocabulary ] ]
-        end
-      }
-    end
+      rule vocabulary_definition
+        s vocabulary S id s ';' s &{|e| input.context.vocabulary(e[3].text_value); true }
+        {
+          def value
+            [ id.value, [ :vocabulary ] ]
+          end
+        }
+      end
 
-    rule import_definition
-      s import S id alias_list ';' s
-      {
-        def value
-          puts "import #{id.text_value}: not implemented"
-          [ id.text_value, [ :import ], alias_list.value ]
-        end
-      }
-    end
+      rule import_definition
+        s import S id alias_list ';' s
+        {
+          def value
+            puts "import #{id.value}: not implemented"
+            [ id.value, [ :import ], alias_list.value ]
+          end
+        }
+      end
 
-    # REVISIT: Need a way to define equivalent readings for fact types here (and in the metamodel)
-    rule alias_list
-      ( s ',' s alias S aliase_from:id S as S alias_to:id s )*
-      {
-        def value
-          elements.inject({}){|h, e| h[e.aliase_from.text_value] = e.alias_to; h }
-        end
-      }
-    end
+      # REVISIT: Need a way to define equivalent readings for fact types here (and in the metamodel)
+      rule alias_list
+        ( s ',' s alias S aliased_from:id S as S alias_to:id s )*
+        {
+          def value
+            elements.inject({}){|h, e| h[e.aliased_from.value] = e.alias_to; h }
+          end
+        }
+      end
 
-    rule constraint
-      subset_constraint /
-      equality_constraint /
-      set_constraint /
-      presence_constraint
-      # REVISIT: / value_constraint
-    end
+      rule constraint
+        subset_constraint /
+        equality_constraint /
+        set_constraint /
+        presence_constraint
+        # REVISIT: / value_constraint
+      end
 
-    # presence constraint:
-    rule presence_constraint
-      s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' s 'in' s
-      readings_list s
-      ';' s
-      { def value; [ nil, [ :constraint, :presence, role_list.roles, quantifier.value, readings_list.value ] ]; end }
-    end
+      # presence constraint:
+      rule presence_constraint
+        s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' s '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 }
+      end
 
-    rule subset_constraint
-      s readings s only s if s r2:readings s ';' s
-      { def value; [ nil, [ :constraint, :subset, readings.value, r2.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
+          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 }
+        /
+        s either? s r1:readings s or s r2:readings exclusion:(but s not s both s)? c:context? ';' 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,1],                # Exactly one (1 and only 1)
+                [r1.value, r2.value],
+                c.empty? ? nil : c.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
-      readings_list s
-      ';' s
-      { def value; [ nil, [ :constraint, :set, role_list.roles, quantifier.value, *readings_list.value ] ]; end }
-    end
+      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 }
+      end
 
-    rule equality_constraint
-      s readings s tail:( if s and s only s if s readings s)+ ';' s
-      { def value; [ nil, [ :constraint, :equality, *([readings.value] + tail.elements.map{|e| e.readings.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 }
+      end
 
-    rule readings_list
-      readings tail:( ',' s readings )*
-      { def value; [readings.value]+tail.elements.map{|e| e.readings.value }; end }
-    end
+      rule readings_list
+        readings tail:( ',' s readings )*
+        { def value; [readings.value]+tail.elements.map{|e| e.readings.value }; end }
+      end
 
-    rule readings
-      reading s tail:( and s reading s )*
-      { def value; [reading.value]+tail.elements.map{|e| e.reading.value }; end }
-    end
+      rule readings
+        reading s tail:( and s reading s )*
+        { def value; [reading.value]+tail.elements.map{|e| e.reading.value }; end }
+      end
 
+    end
   end
 end

data/lib/activefacts/cql/Concepts.treetop

@@ -8,20 +8,28 @@ module ActiveFacts
   module CQL
     grammar Concepts
       rule concept
-        entity_type
-        / data_type
+        value_type
+        / entity_type
         / named_fact_type
         / anonymous_fact_type
       end
 
       rule entity_type
-        s name:id s
+        s term_definition_name
         sup:(basetype / subtype)
+                &{|e| input.context.entity_type(e[1].value); true }
+        mapping_pragmas
         ec:entity_conditions?
         ';' s
         {
+          def defined_type
+            [ :entity_type, sup.supers, sup.identifier, mapping_pragmas.value, (ec.empty? ? nil : ec.conditions) ]
+          end
+
           def value
-            [ name.text_value, [ :entity_type, sup.supers, sup.identifier, ec.empty? ? nil : ec.conditions ] ]
+            [ term_definition_name.value,
+              defined_type
+            ]
           end
         }
       end
@@ -54,15 +62,15 @@ module ActiveFacts
         primary:id s
         alternate_supertypes:( ',' s !identified_by name:id s )*
         { def value
-            [primary.text_value]+alternate_supertypes.elements.map{|sup| sup.name.text_value}
+            [primary.value]+alternate_supertypes.elements.map{|sup| sup.name.value}
           end
         }
       end
 
       rule identification
         # REVISIT: Consider distinguishing "-Id" from just "Id", and not prepending the entity type name if no "-"
-        identified_by its s id s          # Reference Mode
-          { def value; {:mode => id.text_value }; end }
+        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 role_list
           { def value; {:roles => role_list.roles }; end }
@@ -93,15 +101,16 @@ module ActiveFacts
             l:lead_adj? tail:(s role_player_id)+ s t:trail_adj?
             {
               def value
-                (l.empty? ? [] : [l.role_player_id.text_value]) +
-                tail.elements.map{|e| e.role_player_id.text_value } +
-                (t.empty? ? [] : [t.role_player_id.text_value])
+                (l.empty? ? [] : [l.role_player_id.value]) +
+                tail.elements.map{|e| e.role_player_id.value } +
+                (t.empty? ? [] : [t.role_player_id.value])
               end
             }
           end
 
           rule role_player_id
             !(role_list_sep / quantifier) id
+            { def value; id.value; end }
           end
 
           rule role_list_sep
@@ -113,6 +122,19 @@ module ActiveFacts
             '(' s '.' s mode_name:id s ')' s
           end
 
+      rule mapping_pragmas
+        '[' s h:mapping_pragma t:(s ',' s mapping_pragma)* s ']' s
+          { def value; [h.value] + t.elements.map{|e| e.mapping_pragma.value}; end }
+        /
+        ''
+          { def value; []; end }
+      end
+
+      rule mapping_pragma
+        (independent / separate / partitioned / personal / feminine / masculine)
+          { def value; text_value; end }
+      end
+
       rule entity_conditions
         (':' / where) s c:conditions?
         {

data/lib/activefacts/cql/Context.treetop

@@ -0,0 +1,34 @@
+#
+#       ActiveFacts CQL Parser.
+#       Parse rules relating to definition context.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module CQL
+    grammar Context
+      rule context
+        '('
+        w:who_says? s context_type discussion agreed:(',' a:as_agreed_by)? s
+        ')'
+        { def value; [ w.empty? ? nil : w.value, context_type.value, discussion.text_value, agreed.empty? ? [] : agreed.a.value]; end }
+      end
+
+      rule who_says
+        according_to people s ','
+        { def value; people.value; end }
+      end
+
+      rule context_type
+        because         { def value; 'because'; end } /
+        as_opposed_to   { def value; 'as_opposed_to'; end } /
+        so_that         { def value; 'so_that'; end } /
+        to_avoid        { def value; 'to_avoid'; end }
+      end
+
+      rule discussion
+        '(' discussion ')' / (!( [()] / ',' as_agreed_by) .)*
+      end
+    end
+  end
+end

data/lib/activefacts/cql/Expressions.treetop

@@ -30,14 +30,14 @@ module ActiveFacts
       end
 
       rule sum
-        t0:term s tail:( o:add_op s t1:term s )*
+        t0:product s tail:( op:add_op s t1:product s )*
         {
           def value
             return t0.value if tail.empty?
             [ :"+",
               *([t0.value] +
                 tail.elements.map{|e|
-                    e.o.text_value == '-' ? [ :"-", e.t1.value ] : e.t1.value
+                    e.op.text_value == '-' ? [ :"-", e.t1.value ] : e.t1.value
                   }
               )
             ]
@@ -49,15 +49,15 @@ module ActiveFacts
         '+' / '-'
       end
 
-      rule term
-        f0:factor s tail:( o:mul_op s f1:factor s )*
+      rule product
+        f0:factor s tail:( op:mul_op s f1:factor s )*
         {
           def value
             return f0.value if tail.empty?
             [ :"*",
               *([f0.value] +
                 tail.elements.map{|e|
-                    e.o.text_value != '*' ? [ :"-", e.f1.value ] : e.f1.value
+                    e.op.text_value != '*' ? [ :"-", e.f1.value ] : e.f1.value
                   }
               )
             ]
@@ -72,7 +72,7 @@ module ActiveFacts
               end
             }
         / derived_variable
-        / '(' s sum s ')' s                   { def value; sum.value; end }
+        / !context '(' s sum s ')' s                   { def value; sum.value; end }
       end
 
       rule derived_variable
@@ -92,8 +92,8 @@ module ActiveFacts
         {
           def value
             # Variable names may consist of one or two words (optional adjective and a noun):
-            r = [ :variable, id0.text_value ]
-            r += [ o0.id1.text_value ] unless o0.empty?
+            r = [ :variable, id0.value ]
+            r += [ o0.id1.value ] unless o0.empty?
             r
           end
         }
@@ -103,7 +103,7 @@ module ActiveFacts
         '.' s func:id s param_list:( '(' s params:( p0:expression s tail:( ',' s p1:expression s )* )? ')' s )?
         {
           def value
-            r = [ :"(", func.text_value ]
+            r = [ :"(", func.value ]
             return r if param_list.empty? || param_list.params.empty?
             r += [ param_list.params.p0.value ]
             param_list.params.tail.elements.each{|e|

data/lib/activefacts/cql/FactTypes.treetop

@@ -8,12 +8,16 @@ module ActiveFacts
   module CQL
     grammar FactTypes
       rule named_fact_type
-        s name:id ( s '=' s / written_as / s is s where )
+        s term_definition_name
+        ( written_as      # REVISIT: What on earth was I thinking when I wrote this?
+        / s is s mapping_pragmas where    # REVISIT: Need a place to put mapping pragmas like [independent]
+        )
+                &{|e| input.context.objectified_fact_type(e[1].value); true }
         anonymous_fact_type
         {
           def value
             f = anonymous_fact_type.value
-            f[0] = name.text_value
+            f[0] = term_definition_name.value
             f
           end
         }
@@ -27,14 +31,9 @@ module ActiveFacts
         s ';' s
         {
           def value
-            [
-              nil,    # Anonymous fact type
-              [
-                :fact_type,
-                [ f0.body, *ftail.elements.map{|e| e.f1.body } ],
-                !ctail.empty? ? ctail.c.condition_list : []
-              ]
-            ]
+            readings = [ f0.body, *ftail.elements.map{|e| e.f1.body } ]
+            conditions = !ctail.empty? ? ctail.c.condition_list : []
+            [ nil, [ :fact_type, readings, conditions ] ]
           end
         }
       end
@@ -71,6 +70,7 @@ module ActiveFacts
       end
 
       rule clause
+        # REVISIT: No context for comparisons, yet
         (comparison / fact_clause)
         {
           def clause
@@ -80,13 +80,14 @@ module ActiveFacts
       end
 
       rule fact_clause
-        s q:qualifier? s reading s p:post_qualifiers? s
+        s q:qualifier? s reading s p:post_qualifiers? s c:context?
         {
           def body
             [ :fact_clause,
               (q.empty? ? [] : [ q.text_value ]) +
                 (p.empty? ? [] : p.list),
-              reading.value
+              reading.value,
+              c.empty? ? nil : c.value 
             ]
           end
         }
@@ -110,8 +111,6 @@ module ActiveFacts
       end
 
       rule reading
-        subtype_invocation
-        /
         role+
         {
           def value
@@ -120,18 +119,6 @@ module ActiveFacts
         }
       end
 
-      # REVISIT: This allows invocation from subtype to supertype. We need the reverse as well (Employee is a Manager).
-      # Now that subtyping fact types have readings created during compilation, perhaps these custom rules can be removed?
-      rule subtype_invocation
-        (('some'/'that') S)? subtype:id s subtype_prefix (('some'/'that') S)? supertype:id
-        {
-          def value
-            [{:subtype => subtype.text_value, :supertype => supertype.text_value }]
-            # [subtype.text_value, "is", "a", "subtype", "of", supertype.text_value].map{|w| {:word => w}}
-          end
-        }
-      end
-
       # This is the rule that causes most back-tracking. I think you can see why.
       # 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.
@@ -141,7 +128,7 @@ module ActiveFacts
         player:role_word !'-' s?
         adj1:( '-' a:(a:role_word s)? )?
         func:function_call?
-        role_name:( '(' s as S r:id s ')' s )?
+        role_id:(role_name / subscript )?
         lr:( literal / restriction )?
         !non_role
         {
@@ -150,13 +137,13 @@ module ActiveFacts
             quantifier = !q.empty? && q.value   # "some" quantifier has nil value
 
             r[:quantifier] = quantifier if quantifier
-            r[:leading_adjective] = adj0.a.text_value unless adj0.empty?
+            r[:leading_adjective] = adj0.a.value unless adj0.empty?
 
-            r[:word] = player.text_value
+            r[:word] = player.value
 
-            r[:trailing_adjective] = adj1.a.a.text_value unless adj1.empty?
+            r[:trailing_adjective] = adj1.a.a.value unless adj1.empty?
             r[:function] = func.value if !func.empty?
-            r[:role_name] = role_name.r.text_value unless role_name.empty?
+            r[:role_name] = role_id.value unless role_id.empty?
             r[:restriction] = lr.ranges if !lr.empty? && lr.respond_to?(:ranges)
             r[:literal] = lr.value if !lr.empty? && lr.respond_to?(:value)
 
@@ -165,6 +152,16 @@ module ActiveFacts
         }
       end
 
+      rule role_name
+        '(' s as S r:id s ')' s
+        { def value; r.value; end }
+      end
+
+      rule subscript
+        '(' i:([1-9] [0-9]*) ')' s 
+        { def value; i.text_value.to_i; end }
+      end
+
       rule non_role
         # Any of these is illegal in or following a reading:
         comparator
@@ -174,6 +171,7 @@ module ActiveFacts
 
       rule role_word
         !non_role_word id
+        { def value; id.value; end }
       end
 
       rule non_role_word
@@ -184,6 +182,7 @@ module ActiveFacts
         / or
         / quantifier
         / restriction
+        / but
       end
 
     end