activefacts-cql 1.8.1 → 1.8.2

data/lib/activefacts/cql/parser/Context.treetop

@@ -9,18 +9,18 @@ module ActiveFacts
     grammar Context
       rule context_note
         '('
-        s w:who_says? s context_type discussion agreed:(',' a:as_agreed_by)? s
+        s w:who_says? s context_type description agreed:(',' a:as_agreed_by)? s
         ')' s
         {
-	  def value
-	    [ w.empty? ? nil : w.value, context_type.value, discussion.text_value, agreed.empty? ? [] : agreed.a.value]
-	  end
-	  def ast
-	    who = w.empty? ? nil : w.value
-	    ag = agreed.empty? ? [] : agreed.a.value
-	    Compiler::ContextNote.new context_type.value, discussion.text_value, who, ag
-	  end
-	}
+          def value
+            [ w.empty? ? nil : w.value, context_type.value, description.text_value, agreed.empty? ? [] : agreed.a.value]
+          end
+          def ast
+            who = w.empty? ? nil : w.value
+            ag = agreed.empty? ? [] : agreed.a.value
+            Compiler::ContextNote.new context_type.value, description.text_value, who, ag
+          end
+        }
       end
 
       rule who_says
@@ -35,13 +35,11 @@ module ActiveFacts
         to_avoid        { def value; 'to_avoid'; end }
       end
 
-      rule discussion
-        (
-	  '(' discussion ')' / (!( [()] / ',' as_agreed_by) .)*
-	)
-	{
-	  def node_type; :linking; end
-	}
+      rule description
+        '(' description ')' / (!( [()] / ',' as_agreed_by) .)*
+        {
+          def node_type; :linking; end
+        }
       end
     end
   end

data/lib/activefacts/cql/parser/Expressions.treetop

@@ -14,13 +14,13 @@ module ActiveFacts
       rule sum
         t0:product s tail:( op:add_op s t1:product s )*
         {
-	  def ast
-	    if tail.elements.empty?
-	      t0.ast
-	    else
-	      Compiler::Sum.new(t0.ast, *tail.elements.map{|e| e.op.text_value == '-' ? Compiler::Negate.new(e.t1.ast) : e.t1.ast})
-	    end
-	  end
+          def ast
+            if tail.elements.empty?
+              t0.ast
+            else
+              Compiler::Sum.new(t0.ast, *tail.elements.map{|e| e.op.text_value == '-' ? Compiler::Negate.new(e.t1.ast) : e.t1.ast})
+            end
+          end
         }
       end
 
@@ -31,22 +31,22 @@ module ActiveFacts
       rule product
         f0:factor s tail:( op:mul_op s f1:factor s )*
         {
-	  def ast
-	    if tail.elements.empty?
-	      f0.ast
-	    else
-	      Compiler::Product.new(f0.ast, *tail.elements.map{|e| e.op.text_value != '*' ? Compiler::Reciprocal.new(e.op.text_value, e.f1.ast) : e.f1.ast})
-	    end
-	  end
+          def ast
+            if tail.elements.empty?
+              f0.ast
+            else
+              Compiler::Product.new(f0.ast, *tail.elements.map{|e| e.op.text_value != '*' ? Compiler::Reciprocal.new(e.op.text_value, e.f1.ast) : e.f1.ast})
+            end
+          end
         }
       end
 
       rule factor
         literal u:unit? s
             {
-	      def ast
-		Compiler::Literal.new(literal.value, u.empty? ? nil : u.text_value)
-	      end
+              def ast
+                Compiler::Literal.new(literal.value, u.empty? ? nil : u.text_value)
+              end
             }
         / derived_variable
         / !context_note '(' s sum s ')' s                   { def ast; sum.ast; end }
@@ -55,10 +55,10 @@ module ActiveFacts
       rule derived_variable
         derived:term s role_id:(role_name / subscript )?
         {
-	  def ast quantifier = nil, value_constraint = nil, literal = nil, nested_clauses = nil
-	    role_name = role_id.empty? ? nil : role_id.value
-	    derived.ast(quantifier, nil, role_name, value_constraint, literal, nested_clauses)
-	  end
+          def ast quantifier = nil, value_constraint = nil, literal = nil, nested_clauses = nil
+            role_name = role_id.empty? ? nil : role_id.value
+            derived.ast(quantifier, nil, role_name, value_constraint, literal, nested_clauses)
+          end
         }
       end
 

data/lib/activefacts/cql/parser/FactTypes.treetop

@@ -8,28 +8,28 @@ module ActiveFacts
   module CQL
     grammar FactTypes
       rule query
-	s query_clauses r:returning_clause? '?'
-	{
-	  def ast
-	    Compiler::FactType.new nil, [], query_clauses.ast, (r.empty? ? nil : r)
-	  end
-	}
+        s query_clauses r:returning_clause? '?'
+        {
+          def ast
+            Compiler::FactType.new nil, [], query_clauses.ast, (r.empty? ? nil : r)
+          end
+        }
       end
 
       rule named_fact_type
-	s each?
+        s each?
         s term_definition_name
         mapping_pragmas is_where
         anonymous_fact_type
         {
-	  def ast
-	    ft = anonymous_fact_type.ast
-	    ft.name = term_definition_name.value
-	    pragmas = mapping_pragmas.value
-	    pragmas << 'independent' if is_where.independent
-	    ft.pragmas = pragmas
-	    ft
-	  end
+          def ast
+            ft = anonymous_fact_type.ast
+            ft.name = term_definition_name.value
+            pragmas = mapping_pragmas.value
+            pragmas << 'independent' if is_where.independent
+            ft.pragmas = pragmas
+            ft
+          end
         }
       end
 
@@ -39,46 +39,46 @@ module ActiveFacts
           returning_clause?
         s ';'
         {
-	  def ast
+          def ast
             clauses_ast = query_clauses.ast
             conditions = !ctail.empty? ? ctail.a.ast : []
-	    returning = respond_to?(:returning_clause) ? returning_clause.ast : nil
-	    value_derivation = clauses_ast.detect{|r| r.is_equality_comparison}
-	    if !value_derivation and
-		conditions.empty? and
-		clauses_ast.detect{|r| r.includes_literals}
-	      raise "Fact instances may not contain conditions" unless conditions.empty? && !returning
-	      Compiler::Fact.new clauses_ast
-	    elsif (clauses_ast.size == 1 &&
-	      clauses_ast[0].phrases.size == 1 &&
-	      (popname = clauses_ast[0].phrases[0]) &&
-	      !popname.is_a?(Compiler::Reference) &&
-	      conditions.detect{|r| r.includes_literals}
-	    )
-	      Compiler::Fact.new conditions, popname
-	    else
-	      Compiler::FactType.new nil, clauses_ast, conditions, returning
-	    end
-	  end
+            returning = respond_to?(:returning_clause) ? returning_clause.ast : nil
+            value_derivation = clauses_ast.detect{|r| r.is_equality_comparison}
+            if !value_derivation and
+                conditions.empty? and
+                clauses_ast.detect{|r| r.includes_literals}
+              raise "Fact instances may not contain conditions" unless conditions.empty? && !returning
+              Compiler::Fact.new clauses_ast
+            elsif (clauses_ast.size == 1 &&
+              clauses_ast[0].phrases.size == 1 &&
+              (popname = clauses_ast[0].phrases[0]) &&
+              !popname.is_a?(Compiler::Reference) &&
+              conditions.detect{|r| r.includes_literals}
+            )
+              Compiler::Fact.new conditions, popname
+            else
+              Compiler::FactType.new nil, clauses_ast, conditions, returning
+            end
+          end
         }
       end
 
       rule query_clauses
         qualified_clauses
-	  # REVISIT: This creates no precedence between and/or, which could cause confusion.
-	  # Should disallow mixed conjuntions - using a sempred?
+          # 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
+        {
+          def ast
             clauses_ast = qualified_clauses.ast
             ftail.elements.each{|e|
-	      conjunction = e.conjunction.text_value
-	      # conjunction = 'and' if conjunction == ','   # ',' means AND, but disallows left-contractions
-	      clauses_ast += e.qualified_clauses.ast(conjunction)
-	    }
-	    clauses_ast
-	  end
-	}
+              conjunction = e.conjunction.text_value
+              # conjunction = 'and' if conjunction == ','   # ',' means AND, but disallows left-contractions
+              clauses_ast += e.qualified_clauses.ast(conjunction)
+            }
+            clauses_ast
+          end
+        }
       end
 
       rule returning_clause
@@ -86,33 +86,33 @@ module ActiveFacts
       end
 
       rule return
-	ordering_prefix? phrase+
+        ordering_prefix? phrase+
       end
 
       rule qualified_clauses
         s certainty s contracted_clauses s p:post_qualifiers? s c:context_note?
         {
-	  def ast(conjunction = nil)
-	    r = contracted_clauses.ast	# An array of clause asts
-	    r[0].conjunction = conjunction
-	    # pre-qualifiers apply to the first clause, post_qualifiers and context_note to the last
-	    # REVISIT: This may be incorrect where the last is a nested clause
-	    r[0].certainty = certainty.value
-	    r[-1].qualifiers += p.list unless p.empty?
-	    r[-1].context_note = c.ast unless c.empty?
-	    r
-	  end
+          def ast(conjunction = nil)
+            r = contracted_clauses.ast  # An array of clause asts
+            r[0].conjunction = conjunction
+            # pre-qualifiers apply to the first clause, post_qualifiers and context_note to the last
+            # REVISIT: This may be incorrect where the last is a nested clause
+            r[0].certainty = certainty.value
+            r[-1].qualifiers += p.list unless p.empty?
+            r[-1].context_note = c.ast unless c.empty?
+            r
+          end
         }
       end
 
       rule certainty
-	negative_prefix { def value; false; end }
-	/
+        negative_prefix { def value; false; end }
+        /
         maybe { def value; nil; end }
-	/
-	definitely { def value; true; end }
-	/
-	'' { def value; true; end }
+        /
+        definitely { def value; true; end }
+        /
+        '' { def value; true; end }
       end
 
       rule post_qualifiers
@@ -126,110 +126,110 @@ module ActiveFacts
 
       rule post_qualifier
         static / transient /
-	intransitive / stronglyintransitive / transitive / acyclic / symmetric / asymmetric / antisymmetric / reflexive / irreflexive
+        intransitive / stronglyintransitive / transitive / acyclic / symmetric / asymmetric / antisymmetric / reflexive / irreflexive
       end
 
       rule clauses_list
         clauses tail:( ',' s clauses )*
         {
-	  def ast
-	    [clauses.ast, *tail.elements.map{|e| e.clauses.ast }]
-	  end
-	}
+          def ast
+            [clauses.ast, *tail.elements.map{|e| e.clauses.ast }]
+          end
+        }
       end
 
       rule clauses
         contracted_clauses s tail:( and s contracted_clauses s )*
         {
-	  def ast
-	    clauses = contracted_clauses.ast
-	    tail.elements.map{|e| clauses += e.contracted_clauses.ast }
-	    clauses
-	  end
-	}
+          def ast
+            clauses = contracted_clauses.ast
+            tail.elements.map{|e| clauses += e.contracted_clauses.ast }
+            clauses
+          end
+        }
       end
 
       rule contracted_clauses
-	comparison
-	/
+        comparison
+        /
         (
-	  contraction	  # A contraction will terminate this repetition by eating to the end
-	  /
-	  phrase
-	)+
+          contraction     # A contraction will terminate this repetition by eating to the end
+          /
+          phrase
+        )+
         {
-	  def ast
-	    asts = elements.map{ |r| r.ast }
-	    contracted_clauses = []
-	    qualifiers = []
-	    if asts[-1].is_a?(Array)	    # A contraction (Array of [role, qualifiers, *clauses])
-	      contracted_clauses = asts.pop	    # Pull off the contracted_clauses
-	      contracted_role = contracted_clauses.shift
-	      qualifiers = contracted_clauses.shift
-	      asts.push(contracted_role)  # And replace it by the role removed from the contracted_clauses
-	    end
-	    clause_ast = Compiler::Clause.new(asts, qualifiers)
-	    [clause_ast] + contracted_clauses
-	  end
+          def ast
+            asts = elements.map{ |r| r.ast }
+            contracted_clauses = []
+            qualifiers = []
+            if asts[-1].is_a?(Array)        # A contraction (Array of [role, qualifiers, *clauses])
+              contracted_clauses = asts.pop         # Pull off the contracted_clauses
+              contracted_role = contracted_clauses.shift
+              qualifiers = contracted_clauses.shift
+              asts.push(contracted_role)  # And replace it by the role removed from the contracted_clauses
+            end
+            clause_ast = Compiler::Clause.new(asts, qualifiers)
+            [clause_ast] + contracted_clauses
+          end
         }
       end
 
       rule contraction
-	reading_contraction /
-	condition_contraction
+        reading_contraction /
+        condition_contraction
       end
 
       rule reading_contraction
-	role p:post_qualifiers? conjunction:(that/who) s certainty s contracted_clauses s
-	{
-	  def ast
-	    # contracted_clauses.ast will return an array of Clauses, but the first clause is special. We must:
-	    # * prepend a new role (we get the Role to build *two* ast nodes)
-	    # * attach the qualifiers
-	    clauses_ast = contracted_clauses.ast
-	    clauses_ast[0].conjunction = conjunction.text_value
-	    clauses_ast[0].phrases.unshift(role.ast)
-	    clauses_ast[0].certainty = certainty.value
+        role p:post_qualifiers? conjunction:(that/who) s certainty s contracted_clauses s
+        {
+          def ast
+            # contracted_clauses.ast will return an array of Clauses, but the first clause is special. We must:
+            # * prepend a new role (we get the Role to build *two* ast nodes)
+            # * attach the qualifiers
+            clauses_ast = contracted_clauses.ast
+            clauses_ast[0].conjunction = conjunction.text_value
+            clauses_ast[0].phrases.unshift(role.ast)
+            clauses_ast[0].certainty = certainty.value
 
-	    # A contraction returns an array containing:
-	    # * a role AST
-	    # * a qualifiers array
-	    # * an array of Clauses
-	    [role.ast, p.empty? ? [] : p.list] + clauses_ast
-	  end
-	}
+            # A contraction returns an array containing:
+            # * a role AST
+            # * a qualifiers array
+            # * an array of Clauses
+            [role.ast, p.empty? ? [] : p.list] + clauses_ast
+          end
+        }
       end
 
       rule condition_contraction
-	role pq:post_qualifiers? certainty 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, certainty.value)
-	    c.conjunction = comparator.text_value
-	    [ role.ast, pq.empty? ? [] : pq.list, c ]
-	  end
-	}
+        role pq:post_qualifiers? certainty 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, certainty.value)
+            c.conjunction = comparator.text_value
+            [ role.ast, pq.empty? ? [] : pq.list, c ]
+          end
+        }
       end
 
       rule comparison
-	e1:expression s certainty s comparator s contraction p:post_qualifiers?
-	{
-	  def ast
-	    role, qualifiers, *clauses_ast = *contraction.ast
-	    clauses_ast[0].qualifiers += p.list unless p.empty?	# apply post_qualifiers to the contracted clause
-	    # clauses_ast[0].conjunction = 'and' # AND is implicit for a contraction
-	    c = Compiler::Comparison.new(comparator.text_value, e1.ast, role, certainty.value)
-	    [c] + clauses_ast
-	  end
-	}
+        e1:expression s certainty s comparator s contraction p:post_qualifiers?
+        {
+          def ast
+            role, qualifiers, *clauses_ast = *contraction.ast
+            clauses_ast[0].qualifiers += p.list unless p.empty? # apply post_qualifiers to the contracted clause
+            # clauses_ast[0].conjunction = 'and' # AND is implicit for a contraction
+            c = Compiler::Comparison.new(comparator.text_value, e1.ast, role, certainty.value)
+            [c] + clauses_ast
+          end
+        }
         /
-	certainty e1:expression s comparator s e2:expression # comparisons have no post-qualifiers: p:post_qualifiers?
+        certainty e1:expression s comparator s e2:expression # comparisons have no post-qualifiers: p:post_qualifiers?
         {
-	  def ast
-	    c = Compiler::Comparison.new(comparator.text_value, e1.ast, e2.ast, certainty.value)
-	    [c]
-	  end
+          def ast
+            c = Compiler::Comparison.new(comparator.text_value, e1.ast, e2.ast, certainty.value)
+            [c]
+          end
         }
       end
 
@@ -238,109 +238,109 @@ module ActiveFacts
       end
 
       rule phrase
-	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
-	    def node_type; :linking; end
-	  }
-	/       # A normal non-term
-	!non_phrase id s
-	  {
-	    def ast
-	      id.value
-	    end
-	    def node_type; :linking; end
-	  }
+        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
+            def node_type; :linking; end
+          }
+        /       # A normal non-term
+        !non_phrase id s
+          {
+            def ast
+              id.value
+            end
+            def node_type; :linking; end
+          }
       end
 
       rule role
-	aggregate
-	/
-	simple_role
+        aggregate
+        /
+        simple_role
       end
 
       rule aggregate
-	aggregate:id s
-	agg_of s term_or_unary s agg_in s    # REVISIT: this term may need to pre-scanned in the qualified_clauses
-	'(' qualified_clauses s ')' # REVISIT: Need to test to verify this is the right level (not query_clauses, etc)
-	{
-	  def ast
-	    raise "Not implemented: AST for '#{aggregate.text_value} of #{term_or_unary.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
-	}
+        aggregate:id s
+        agg_of s term_or_unary s agg_in s    # REVISIT: this term may need to pre-scanned in the qualified_clauses
+        '(' qualified_clauses s ')' # REVISIT: Need to test to verify this is the right level (not query_clauses, etc)
+        {
+          def ast
+            raise "Not implemented: AST for '#{aggregate.text_value} of #{term_or_unary.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
 
       rule role_quantifier
-	quantifier mapping_pragmas enforcement cn:context_note?
-	{
-	  def ast
-	    Compiler::Quantifier.new(
-	      quantifier.value[0],
-	      quantifier.value[1],
-	      enforcement.ast,
-	      cn.empty? ? nil : cn.ast,
-	      mapping_pragmas.value
-	    )
-	  end
-	}
+        quantifier mapping_pragmas enforcement cn:context_note?
+        {
+          def ast
+            Compiler::Quantifier.new(
+              quantifier.value[0],
+              quantifier.value[1],
+              enforcement.ast,
+              cn.empty? ? nil : cn.ast,
+              mapping_pragmas.value
+            )
+          end
+        }
       end
 
       # This is the rule that causes most back-tracking. I think you can see why.
       rule simple_role
-	q:role_quantifier?
+        q:role_quantifier?
         player:derived_variable
         lr:(
-	  literal u:unit?
-	  /
-	  value_constraint enforcement
-	)?
-	oj:objectification_step?
+          literal u:unit?
+          /
+          value_constraint enforcement
+        )?
+        oj:objectification_step?
         {
-	  def ast
-	    if !q.empty? && q.quantifier.value
-	      quantifier = q.ast
-	    end
-	    if !lr.empty?
-	      if lr.respond_to?(:literal)
-		literal = Compiler::Literal.new(lr.literal.value, lr.u.empty? ? nil : lr.u.text_value)
-	      end
-	      value_constraint = Compiler::ValueConstraint.new(lr.value_constraint.ast, 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
-	    end
+          def ast
+            if !q.empty? && q.quantifier.value
+              quantifier = q.ast
+            end
+            if !lr.empty?
+              if lr.respond_to?(:literal)
+                literal = Compiler::Literal.new(lr.literal.value, lr.u.empty? ? nil : lr.u.text_value)
+              end
+              value_constraint = Compiler::ValueConstraint.new(lr.value_constraint.ast, 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
+            end
 
-	    nested_clauses =
-	      if oj.empty?
-		nil
-	      else
-		ast = oj.ast
-		ast[0].conjunction = 'where'
-		ast
-	      end
-	    player.ast(quantifier, value_constraint, literal, nested_clauses)
-	  end
+            nested_clauses =
+              if oj.empty?
+                nil
+              else
+                ast = oj.ast
+                ast[0].conjunction = 'where'
+                ast
+              end
+            player.ast(quantifier, value_constraint, literal, nested_clauses)
+          end
         }
       end
 
       rule objectification_step
         '(' s in_which s facts:query_clauses s ')' s
-	{
-	  def ast
-	    facts.ast
-	  end
-	}
+        {
+          def ast
+            facts.ast
+          end
+        }
       end
 
       rule role_name