activefacts-cql 1.7.1

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

@@ -0,0 +1,167 @@
+#
+#       ActiveFacts CQL Parser.
+#       Parse rules relating to high-level CQL definitions and constraints.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/cql/parser/LexicalRules'
+require 'activefacts/cql/parser/Language/English'
+require 'activefacts/cql/parser/Expressions'
+require 'activefacts/cql/parser/Terms'
+require 'activefacts/cql/parser/ObjectTypes'
+require 'activefacts/cql/parser/ValueTypes'
+require 'activefacts/cql/parser/FactTypes'
+require 'activefacts/cql/parser/Context'
+
+module ActiveFacts
+  module CQL
+    grammar CQL
+      include LexicalRules
+      include Expressions
+      include Terms
+      include ObjectTypes
+      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
+
+      # Each definition has an ast() method that returns an instance of a subclass of Compiler::Definition
+      rule definition
+	definition_body s
+	{
+	  def ast
+	    definition_body.ast
+	  end
+
+	  def body
+	    definition_body.text_value
+	  end
+	}
+      end
+
+      rule definition_body
+        vocabulary_definition
+        / import_definition
+        / prescan           # Always fails, but its side-effects are needed in the following
+        / constraint
+        / unit_definition   # REVISIT: Move this above the prescan?
+        / object_type
+	/ query
+	/ s ';' s { def ast; nil; end }
+      end
+
+      rule vocabulary_definition
+        s vocabulary S vocabulary_name s ';'
+        {
+	  def ast
+	    Compiler::Vocabulary.new(vocabulary_name.value)
+	  end
+        }
+      end
+
+      rule vocabulary_name
+	id
+	{ def node_type; :vocabulary; end }
+      end
+
+      rule import_definition
+        s import S vocabulary_name alias_list ';'
+        {
+	  def ast
+	    Compiler::Import.new(import.input.parser, vocabulary_name.value, 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 aliased_from:alias_term S as S alias_to:alias_term s )*
+        {
+          def value
+            elements.inject({}){|h, e| h[e.aliased_from.value] = e.alias_to; h }
+          end
+        }
+      end
+
+      rule alias_term
+	id
+	{ def node_type; :term; end }
+      end
+
+      rule constraint
+        subset_constraint /
+        equality_constraint /
+        set_constraint /
+        presence_constraint
+        # REVISIT: / value_constraint
+      end
+
+      rule enforcement
+	s '(' s otherwise s action s a:agent? s ')' s
+	  {
+	    def ast; Compiler::Enforcement.new(action.text_value, a.empty? ? nil : a.text_value); end
+	  }
+	/
+	''
+	  {
+	    def ast; nil; end
+	  }
+      end
+
+      # An enforcement action, like SMS, email, log, alarm, etc.
+      rule action
+	id
+      end
+
+      # presence constraint:
+      rule presence_constraint
+	(each_occurs_in_clauses / either_or)
+        {
+	  def ast
+	    Compiler::PresenceConstraint.new c, enforcement.ast, clauses_ast, role_list_ast, quantifier_ast
+	  end
+	}
+      end
+
+      # set (exclusion, mandatory exclusion, complex equality) constraint
+      rule set_constraint
+	(for_each_how_many / either_or_not_both)
+          {
+	    def ast
+	      Compiler::SetExclusionConstraint.new c, enforcement.ast, clauses_ast, role_list_ast, quantifier_ast
+	    end
+	  }
+      end
+
+      rule subset_constraint
+        (a_only_if_b / if_b_then_a)
+        {
+	  def ast
+	    Compiler::SubsetConstraint.new c, enforcement.ast, [clauses.ast, r2.ast]
+	  end
+	}
+      end
+
+      rule equality_constraint
+	if_and_only_if
+        {
+	  def ast
+	    all_clauses = [clauses.ast, *tail.elements.map{|e| e.clauses.ast }]
+	    Compiler::SetEqualityConstraint.new c, enforcement.ast, all_clauses
+	  end
+	}
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+#
+#       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_note
+        '('
+        s w:who_says? s context_type discussion 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
+	}
+      end
+
+      rule who_says
+        according_to agents s ','
+        { def value; agents.value; end }
+      end
+
+      rule context_type
+        because s       { 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) .)*
+	)
+	{
+	  def node_type; :linking; end
+	}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+#
+#       ActiveFacts CQL Parser.
+#       Parse rules relating to Expressions
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module CQL
+    grammar Expressions
+      rule expression
+        sum
+      end
+
+      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
+        }
+      end
+
+      rule add_op
+        '+' / '-'
+      end
+
+      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
+        }
+      end
+
+      rule factor
+        literal u:unit? s
+            {
+	      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 }
+      end
+
+      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
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,358 @@
+#
+#       ActiveFacts CQL Parser.
+#       Parse rules relating to FactType definitions.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+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
+	}
+      end
+
+      rule named_fact_type
+	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
+        }
+      end
+
+      rule anonymous_fact_type
+        query_clauses
+          ctail:( (':' / where) s a:query_clauses s)?
+          returning_clause?
+        s ';'
+        {
+	  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
+        }
+      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?
+          ftail:( conjunction:(',' / and / or ) s qualified_clauses s )*
+	{
+	  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
+	}
+      end
+
+      rule returning_clause
+        returning s return (s ',' s return)*
+      end
+
+      rule return
+	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
+        }
+      end
+
+      rule certainty
+	negative_prefix { def value; false; end }
+	/
+        maybe { def value; nil; end }
+	/
+	definitely { def value; true; end }
+	/
+	'' { def value; true; end }
+      end
+
+      rule post_qualifiers
+        '[' 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}]
+          end
+        }
+      end
+
+      rule post_qualifier
+        static / transient /
+	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
+	}
+      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
+	}
+      end
+
+      rule contracted_clauses
+	comparison
+	/
+        (
+	  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
+        }
+      end
+
+      rule 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
+
+	    # 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
+	}
+      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
+	}
+        /
+	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
+        }
+      end
+
+      rule comparator
+        '<=' / '<>' / '<' / '=' / '>=' / '>' / '!='
+      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
+	  }
+      end
+
+      rule 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
+	}
+      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
+	}
+      end
+
+      # This is the rule that causes most back-tracking. I think you can see why.
+      rule simple_role
+	q:role_quantifier?
+        player:derived_variable
+        lr:(
+	  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
+
+	    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
+	}
+      end
+
+      rule role_name
+        '(' s as S r:term s ')' s
+        { def value; r.value; end }
+      end
+
+      rule subscript
+        '(' s i:([1-9] [0-9]*) s ')' s 
+        { def value; i.text_value.to_i; end }
+      end
+
+    end
+  end
+end