activefacts 0.8.6 → 0.8.8

data/lib/activefacts/cql/Expressions.treetop

@@ -8,14 +8,12 @@ module ActiveFacts
   module CQL
     grammar Expressions
       rule comparison
-        e1:expression s comparator s e2:expression
+        e1:expression s
+	comparator s e2:expression
         {
-          def body
-            [ comparator.text_value,
-              e1.value,
-              e2.value
-            ]
-          end
+	  def ast
+	    Compiler::Comparison.new comparator.text_value, e1.ast, e2.ast
+	  end
         }
       end
 
@@ -32,16 +30,9 @@ module ActiveFacts
       rule sum
         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.op.text_value == '-' ? [ :"-", e.t1.value ] : e.t1.value
-                  }
-              )
-            ]
-          end
+	  def ast
+	    Compiler::Sum.new(t0.ast, *tail.elements.map{|e| e.op.text_value == '-' ? Compiler::Negate.new(e.t1.ast) : e.t1.ast})
+	  end
         }
       end
 
@@ -52,65 +43,38 @@ module ActiveFacts
       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.op.text_value != '*' ? [ :"-", e.f1.value ] : e.f1.value
-                  }
-              )
-            ]
-          end
+	  def ast
+	    Compiler::Product.new(f0.ast, *tail.elements.map{|e| e.op.text_value != '*' ? Compiler::DivideBy.new(e.op.text_value, e.f1.ast) : e.t1.ast})
+	  end
         }
       end
 
       rule factor
         literal u:unit? s
-            { def value
-                u.empty? ? literal.value : [ literal.value, u.text_value ]
-              end
+            {
+	      def ast
+		Compiler::Literal.new(literal.value, u.empty? ? nil : u.text_value)
+	      end
             }
         / derived_variable
-        / !context '(' s sum s ')' s                   { def value; sum.value; end }
+        / !context_note '(' s sum s ')' s                   { def ast; sum.ast; end }
       end
 
       rule derived_variable
-        variable s p:function_call*
+        variable:term s p:function_call*
         {
-          def value
-            r = variable.value
-            # Apply the function_call operators in order:
-            p.elements.each{|p| r = [ p.value, r ] }
-            r
-          end
-        }
-      end
-
-      rule variable
-        id0:id o0:( !written_as s id1:id )?
-        {
-          def value
-            # Variable names may consist of one or two words (optional adjective and a noun):
-            r = [ :variable, id0.value ]
-            r += [ o0.id1.value ] unless o0.empty?
-            r
-          end
+	  def ast
+	    Compiler::FunctionCallChain.new(term.ast, *p.elements.each{|f| f.ast})
+	  end
         }
       end
 
       rule function_call
         '.' s func:id s param_list:( '(' s params:( p0:expression s tail:( ',' s p1:expression s )* )? ')' s )?
         {
-          def 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|
-                r += [ e.p1.value ]
-              }
-            r
-          end
+	  def ast
+	    Compiler::FunctionCall.new(func.value, *param_list.elements.map{|param| param.ast })
+	  end
         }
       end
 

data/lib/activefacts/cql/FactTypes.treetop

@@ -9,32 +9,43 @@ module ActiveFacts
     grammar FactTypes
       rule named_fact_type
         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 }
+        s is s mapping_pragmas where    # REVISIT: Need a place to put mapping pragmas like [independent]
         anonymous_fact_type
         {
-          def value
-            f = anonymous_fact_type.value
-            f[0] = term_definition_name.value
-            f
-          end
+	  def ast
+	    ft = anonymous_fact_type.ast
+	    ft.name = term_definition_name.value
+	    ft
+	  end
         }
       end
 
       rule anonymous_fact_type
-        f0:fact_clause
-          ftail:( (',' / and ) s f1:fact_clause s )*
+        fact_clause
+          ftail:( (',' / and ) s fact_clause s )*
           ctail:( (':' / where) s c:conditions s)?
           returning_clause?
-        s ';' s
+        s ';'
         {
-          def value
-            readings = [ f0.body, *ftail.elements.map{|e| e.f1.body } ]
-            conditions = !ctail.empty? ? ctail.c.condition_list : []
-            [ nil, [ :fact_type, readings, conditions ] ]
-          end
+	  def ast
+            readings = fact_clause.ast
+            ftail.elements.each{|e| readings += e.fact_clause.ast }
+            conditions = !ctail.empty? ? ctail.c.ast : []
+	    returning = respond_to?(:returning_clause) ? returning_clause.ast : nil
+	    if (conditions.empty? && readings.detect{|r| r.includes_literals})
+	      raise "Fact instances may not contain conditions" unless conditions.empty? && !returning
+	      Compiler::Fact.new readings
+	    elsif (readings.size == 1 &&
+	      readings[0].phrases.size == 1 &&
+	      (popname = readings[0].phrases[0]) &&
+	      !popname.is_a?(Compiler::RoleRef) &&
+	      conditions.detect{|r| r.includes_literals}
+	    )
+	      Compiler::Fact.new conditions, popname
+	    else
+	      Compiler::FactType.new nil, readings, conditions, returning
+	    end
+	  end
         }
       end
 
@@ -49,47 +60,40 @@ module ActiveFacts
       rule conditions
         head:condition s tail:( (',' s / and S) next:condition s )*
         {
-          def condition_list
-            [head.value] + tail.elements.map{|i| i.next.value}
-          end
+	  def ast
+	    conditions = head.ast
+	    tail.elements.each{|i| conditions += i.next.ast}
+	    conditions
+	  end
         }
       end
 
       rule condition
-        head:clause s
-#        tail:(or S alternate:clause s )*
+        head:clause s # tail:(or S alternate:clause s )*
         {
-          def value
-#            if tail.elements.size == 0
-              head.clause
-#            else
-#              [:"||", head.clause] + tail.elements.map{|i| i.alternate.clause}
-#            end
-          end
+	  def ast
+	    head.ast
+            # Compiler::Alternates.new(head.ast, *tail.elements.map{|i| i.alternate.ast})
+	    # REVISIT: alternate conditions are not yet implemented
+	  end
         }
       end
 
       rule clause
         # REVISIT: No context for comparisons, yet
-        (comparison / fact_clause)
-        {
-          def clause
-            self.body
-          end
-        }
+        comparison / fact_clause
       end
 
       rule fact_clause
-        s q:qualifier? s reading s p:post_qualifiers? s c:context?
+        s q:qualifier? s reading s p:post_qualifiers? s c:context_note?
         {
-          def body
-            [ :fact_clause,
-              (q.empty? ? [] : [ q.text_value ]) +
-                (p.empty? ? [] : p.list),
-              reading.value,
-              c.empty? ? nil : c.value 
-            ]
-          end
+	  def ast
+	    r = reading.ast	# An array of readings
+	    r[0].qualifiers << q.text_value unless q.empty?
+	    r[-1].qualifiers += p.list unless p.empty?
+	    r[-1].context_note = c.ast unless c.empty?
+	    r
+	  end
         }
       end
 
@@ -101,96 +105,138 @@ module ActiveFacts
         '[' s q0:post_qualifier tail:( s ',' s q1:post_qualifier )* s ']' s
         {
           def list
-            [q0.text_value] + tail.elements.map{|e| e.q1.text_value}
+            [q0.text_value, *tail.elements.map{|e| e.q1.text_value}]
           end
         }
       end
 
       rule post_qualifier
-        static / transient / intransitive / transitive / acyclic / symmetric
+        static / transient /
+	intransitive / transitive / acyclic / symmetric / asymmetric / antisymmetric / reflexive / irreflexive
       end
 
       rule reading
-        role+
+        (
+	  contracted_reading
+	  /
+	  role    # A role reference containing a term, perhaps with attached paraphernalia
+	  /       # A hyphenated non-term. Important: no embedded spaces
+	  id tail:('-' !term id)+ s
+	    {
+	      def ast
+		[id.value, *tail.elements.map{|e| e.id.value}]*"-"
+	      end
+	    }
+	  /       # A normal non-term
+	  !non_role_word id s
+	    {
+	      def ast
+		id.value
+	      end
+	    }
+	)+
         {
-          def value
-            elements.map{|r| r.value}
-          end
+	  def ast
+	    asts = elements.map{ |r| r.ast }
+	    contraction = []
+	    qualifiers = []
+	    if asts[-1].is_a?(Array)	    # A contracted_reading (Array of [role, qualifiers, *readings])
+	      contraction = asts.pop	    # Pull off the contraction
+	      contracted_role = contraction.shift
+	      qualifiers = contraction.shift
+	      asts.push(contracted_role)  # And replace it by the role removed from the contraction
+	    end
+	    reading = Compiler::Reading.new(asts)
+	    reading.qualifiers += qualifiers
+	    [reading] + contraction
+	  end
         }
       end
 
+      # REVISIT: and later, similarly for contracted conditions (including comparisons)
+      rule contracted_reading
+	role p:post_qualifiers? that s q:qualifier? s reading s
+	{
+	  def ast
+	    # reading.ast will return an array of Readings, but the first reading is special. We must:
+	    # * prepend a new role
+	    # * attach the qualifiers
+	    readings = reading.ast
+	    readings[0].phrases.unshift(role.ast)
+	    readings[0].qualifiers << q.text_value unless q.empty?  # Add maybe/definitely
+
+	    # A contracted_reading returns an array containing:
+	    # * a role AST
+	    # * a qualifiers array
+	    # * an array of Readings
+	    [role.ast, p.empty? ? [] : p.list] + readings
+	  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.
       rule role
         q:(quantifier enforcement)?
-        adj0:(a:role_word '-' s)?
-        player:role_word !'-' s?
-        adj1:( '-' a:(a:role_word s)? )?
-        func:function_call?
+        player:term
+        func:function_call? s
         role_id:(role_name / subscript )?
-        lr:( literal / restriction enforcement )?
-        !non_role
+        lr:(
+	  literal u:unit?
+	  /
+	  value_constraint enforcement
+	)?
+	oj:objectification_join?
+        !non_role     # If we integrate fact_clauses with comparisons, this can go.
         {
-          def value
-            r = {}
-            if !q.empty?
-	      quantifier = q.quantifier.value   # "some" quantifier has nil value
-	      r[:quantifier_restriction] = q.enforcement.value
+	  def ast
+	    if !q.empty? && q.quantifier.value
+	      quantifier = Compiler::Quantifier.new(q.quantifier.value[0], q.quantifier.value[1], q.enforcement.ast)
 	    end
-
-            r[:quantifier] = quantifier if quantifier
-            r[:leading_adjective] = adj0.a.value unless adj0.empty?
-
-            r[:word] = player.value
-
-            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?
-	    if !lr.empty? && lr.respond_to?(:restriction)
-	      r[:restriction] = lr.restriction.ranges
-	      r[:restriction_enforcement] = lr.enforcement.value
+	    role_name = role_id.empty? ? nil : role_id.value
+	    function_call = nil
+	    if !lr.empty?
+	      if lr.respond_to?(:literal)
+		literal = lr.literal.value
+		raise "Literals with units are not yet processed" unless lr.u.empty?
+	      end
+	      value_constraint = Compiler::ValueConstraint.new(lr.value_constraint.ranges, lr.enforcement.ast) if lr.respond_to?(:value_constraint)
+	      raise "It is not permitted to provide both a literal value and a value restriction" if value_constraint and literal
 	    end
-            r[:literal] = lr.value if !lr.empty? && lr.respond_to?(:value)
 
-            r
-          end
+	    objectification_join = oj.empty? ? nil : oj.ast
+	    player.ast(quantifier, function_call, role_name, value_constraint, literal, objectification_join)
+	  end
         }
       end
 
+      rule objectification_join
+        '(' s where s fact_clause s ')' s
+	{
+	  def ast
+	    fact_clause.ast
+	  end
+	}
+      end
+
       rule role_name
-        '(' s as S r:id s ')' s
+        '(' s as S r:term s ')' s
         { def value; r.value; end }
       end
 
       rule subscript
-        '(' i:([1-9] [0-9]*) ')' s 
+        '(' s i:([1-9] [0-9]*) s ')' s 
         { def value; i.text_value.to_i; end }
       end
 
       rule non_role
-        # Any of these is illegal in or following a reading:
+        # Any of these is illegal in or following a reading (they indicate a comparison is coming). Later, this will change:
         comparator
         / add_op
         / mul_op
       end
 
-      rule role_word
-        !non_role_word id
-        { def value; id.value; end }
-      end
-
-      rule non_role_word
-        # These words are illegal in (but maybe ok following) a reading where a role word is expected:
-        and
-        / if
-        / only
-        / or
-        / quantifier
-        / restriction
-        / but
-      end
-
     end
   end
 end

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

@@ -21,25 +21,33 @@ module ActiveFacts
       end
 
       rule quantifier
-        each s                    { def value; [1, nil]; end }
-        / some s                  { def value; nil; end }
-          # REVISIT: "Some" means that any prior occurrence of this role player is to be ignored; this is a new occurrence
-          # "that" on the other hand means that this role player was *previously* designated using "some".
-          # These distinctions are lost here
-        / that s                  { def value; nil; end }
-        / one s                   { def value; [1, 1]; end }
-        / no s                    { def value; [0, 0]; end }
-        / exactly s quantity      { def value; q = quantity.value; [q, q]; end }
-        / at s least s quantity most:( and s at s most s q:quantity )?
-                                  { def value;
-                                      [ quantity.value,
-                                        most.empty? ? nil : most.q.value
-                                      ]
-                                    end
-                                  }
-        / at s most s quantity    { def value; [ nil, quantity.value ]; end }
-        / from s numeric_range s  { def value; numeric_range.value; end }
-        / either_all_or_none s    { def value; [ -1, 1 ]; end }
+	(
+	  each s                    { def value; [1, nil]; end }
+	  / some s                  { def value; nil; end }
+	    # REVISIT: "Some" means that any prior occurrence of this role player is to be ignored; this is a new occurrence
+	    # "that" on the other hand means that this role player was *previously* designated using "some".
+	    # These distinctions are lost here
+	  / that s                  { def value; nil; end }
+	  / one s                   { def value; [1, 1]; end }
+	  / no s                    { def value; [0, 0]; end }
+	  / exactly s quantity      { def value; q = quantity.value; [q, q]; end }
+	  / at s least s quantity most:( and s at s most s q:quantity )?
+				    { def value;
+					[ quantity.value,
+					  most.empty? ? nil : most.q.value
+					]
+				      end
+				    }
+	  / at s most s quantity    { def value; [ nil, quantity.value ]; end }
+	  / from s numeric_range s  { def value; numeric_range.value; end }
+	  / either_all_or_none s    { def value; [ -1, 1 ]; end }
+	)
+	{
+	  def ast
+	    v = value
+	    Compiler::Quantifier.new(v[0], v[1])
+	  end
+	}
       end
 
       rule quantity
@@ -92,6 +100,8 @@ module ActiveFacts
       end
 
       rule acyclic 'acyclic' !alphanumeric end
+      rule antisymmetric 'antisymmetric' !alphanumeric end
+      rule asymmetric 'asymmetric' !alphanumeric end
       rule alias 'alias' !alphanumeric end 
       rule all 'all' !alphanumeric end
       rule and 'and' !alphanumeric end
@@ -106,7 +116,7 @@ module ActiveFacts
       rule each 'each' !alphanumeric end 
       rule either 'either' !alphanumeric end 
       rule entity 'entity' !alphanumeric end 
-      rule ephemeral 'ephemeral' !alphanumeric end 
+      rule ephemera 'ephemera' !alphanumeric end 
       rule exactly 'exactly' !alphanumeric end
       rule false 'false' !alphanumeric end 
       rule feminine 'feminine' !alphanumeric end 
@@ -117,6 +127,7 @@ module ActiveFacts
       rule import 'import' !alphanumeric end
       rule includes 'includes' !alphanumeric end
       rule intransitive 'intransitive' !alphanumeric end
+      rule irreflexive 'irreflexive' !alphanumeric end
       rule is 'is' !alphanumeric end 
       rule its 'its' !alphanumeric end
       rule least 'least' !alphanumeric end
@@ -127,7 +138,7 @@ module ActiveFacts
       rule no 'no' !alphanumeric end
       rule none 'none' !alphanumeric end
       rule not 'not' !alphanumeric end
-      rule either_all_or_none either s all s or s none end
+      rule either_all_or_none either s all s or s ( none / no ) end
       rule one 'one' !alphanumeric end
       rule only 'only' !alphanumeric end
       rule or 'or' !alphanumeric end 
@@ -135,6 +146,7 @@ module ActiveFacts
       rule partitioned 'partitioned' !alphanumeric end 
       rule personal 'personal' !alphanumeric end 
       rule restricted 'restricted' !alphanumeric end
+      rule reflexive 'reflexive' !alphanumeric end
       rule returning 'returning' !alphanumeric end
       rule separate 'separate' !alphanumeric end 
       rule some 'some' !alphanumeric end