activefacts-cql 1.7.1

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

@@ -0,0 +1,210 @@
+#
+#       ActiveFacts CQL Parser.
+#       Parse rules relating to ObjectType definitions.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module CQL
+    grammar ObjectTypes
+      rule object_type
+        value_type
+        / entity_type
+        / named_fact_type
+        / anonymous_fact_type
+      end
+
+      rule entity_type
+	s each?
+        s term_definition_name
+	m1:mapping_pragmas
+	c:context_note?
+        sup:(basetype / subtype)
+	  &{|s|
+	    # There's an implicit type when we use an identification mode, register it:
+	    mode = s[6].identification_mode
+	    if mode
+	      input.context.object_type(s[3].value+mode, "identification mode type")
+	      input.context.object_type(s[3].value+' '+mode, "identification mode type")
+	    end
+	    true
+	  }
+        m2:mapping_pragmas
+	c2:context_note?
+        ec:entity_clauses?
+        ';'
+        {
+	  def ast
+	    name = term_definition_name.value
+	    clauses_ast = ec.empty? ? [] : ec.ast
+	    pragmas = m1.value+m2.value
+	    pragmas << 'independent' if sup.independent
+	    context_note = !c.empty? ? c.ast : (!c2.empty? ? c2.ast : nil)
+	    Compiler::EntityType.new name, sup.supers, sup.ast, pragmas, clauses_ast, context_note
+	  end
+        }
+      end
+
+      rule basetype
+	basetype_expression
+        {
+	  def ast; identification.ast; end
+	  def supers; []; end
+          def identification_mode; identification.mode; end
+	  def independent; !i.empty?; end
+        }
+      end
+
+      rule subtype
+	subtype_expression
+        {
+	  def ast; ident.empty? ? nil : ident.ast; end
+          def supers; supertype_list.value; end
+          def identification_mode; ident.empty? ? nil : ident.mode; end
+	  def independent; !i.empty?; end
+        }
+      end
+
+      rule supertype_list
+        primary:term s alternate_supertypes:( (','/'and' !alpha) s !identified_by name:term s )*
+        {
+	  def 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 i:(term/implicit_value_type_name) value_type_parameters
+	r:(value_constraint enforcement)?          # Reference Mode; value_constraint may be needed for the ValueType
+          {
+	    def ast
+	      if r.empty?
+		value_constraint = nil
+	      else
+		value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ast, r.enforcement.ast)
+	      end
+	      Compiler::ReferenceMode.new(i.value, value_constraint, value_type_parameters.values)
+	    end
+
+	    def mode
+	      i.value
+	    end
+	  }
+        /
+        identified_by role_list
+	  &{|s|
+	    role_list = s[-1]
+	    forwards = role_list.ast.
+	      map do |role|
+		next nil if role.is_a?(Compiler::Clause) # Can't forward-reference unaries
+		next nil if role.leading_adjective or role.trailing_adjective
+		role.term
+	      end.
+	      compact
+	    input.context.allowed_forward_terms(forwards)
+	    true
+	  }
+          {
+	    def ast
+	      role_list.ast
+	    end
+
+	    def mode
+	      nil
+	    end
+	  }
+      end
+
+      # Identified by roles... also used for constraints, beware
+      rule role_list 
+	a:any? s
+        head:term_or_unary s
+	tail:(
+	  ( and S / ',' s )
+	  any? s
+	  term_or_unary s
+	)*
+        {
+	  def ast
+	    [head.ast, *tail.elements.map{|e| e.term_or_unary.ast}]
+	  end
+        }
+      end
+
+      rule unary_text
+	(s !any !non_phrase !term id)*
+	{
+	  def node_type; :linking; end
+	}
+      end
+
+      rule term_or_unary
+	pre_text:unary_text s term post_text:unary_text s ss:subscript?
+	  {
+	    def ast
+	      t = term.ast
+	      t.role_name = ss.value if !ss.empty?
+	      if pre_text.elements.size == 0 && post_text.elements.size == 0
+		t
+	      else
+		pre_words = pre_text.elements.map{|w| w.id.text_value}
+		post_words = post_text.elements.map{|w| w.id.text_value}
+		Compiler::Clause.new(pre_words + [t] + post_words, [], nil)
+	      end
+	    end
+	  }
+	/
+	s !non_phrase id s &non_phrase s ss:subscript?
+	  { # A forward-referenced entity type
+	    # REVISIT: A change in this rule might allow forward-referencing a multi-word term
+	    def ast
+	      Compiler::Reference.new(id.text_value, nil, nil, nil, nil, ss.empty? ? nil : ss.value)
+	    end
+	  }
+      end
+
+      rule mapping_pragmas
+        '[' s h:mapping_pragma t:(s ',' s mapping_pragma)* s ']' s
+          {
+	    def value
+	      t.elements.inject([h.value*' ']) do |a, e|
+		a << e.mapping_pragma.value*' '
+	      end
+	    end
+	  }
+        /
+        s
+          { def value; []; end }
+      end
+
+      # Each mapping_pragma returns an array of words
+      rule mapping_pragma
+	was s names:(id s)+
+	{   # Old or previous name of an object type:
+	  def value
+	    [ was.text_value ] + names.elements.map{|n|n.text_value}
+	  end
+	}
+	/
+	head:id tail:(s id)*
+	{   # A sequence of one or more words denoting a pragma:
+	  def value
+	    ([head]+tail.elements.map(&:id)).map(&:text_value)
+	  end
+	}
+      end
+
+      rule entity_clauses
+        (':' / where) s query_clauses
+        {
+	  def ast
+            query_clauses.ast
+	  end
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+#
+#       ActiveFacts CQL Parser.
+#       Parse rules relating to Term names
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module CQL
+    grammar Terms
+      rule term_definition_name
+        id s t:(!non_term_def id s)*
+	  <Parser::TermDefinitionNameNode>
+      end
+
+      rule non_term_def
+        mapping_pragmas entity_prefix
+        / mapping_pragmas written_as			      # Value type
+        / mapping_pragmas is_where			      # Objectified type
+        / non_phrase
+	/ identified_by					      # as in: "a kind of X identified by..."
+	/ in_units
+	/ auto_assignment
+	/ value_constraint
+      end
+
+      rule entity_prefix
+        is s (independent s )? identified_by
+	/
+	subtype_prefix (independent s )? term_definition_name
+	  &{|e| input.context.object_type(e[2].value, "subtype") }
+      end
+
+      rule prescan
+        s each?
+	s (
+          term_definition_name mapping_pragmas entity_prefix
+		&{|e| input.context.object_type(e[0].value, "entity type") }
+          /
+          t1:term_definition_name mapping_pragmas written_as any? s t2:term_definition_name
+                &{|e|
+		  new_term = e[0].value
+		  input.context.object_type(new_term, "value type")
+		  base_term = e[5].value
+		  input.context.object_type(base_term, "value type")
+		}
+          /
+          term_definition_name s mapping_pragmas is_where
+                &{|e| input.context.object_type(e[0].value, "objectified_fact_type") }
+        )?
+        prescan_rest
+        &{|s|
+	  # Wipe any terminal failures that were added:
+          @terminal_failures = []
+          @max_terminal_failure_index = start_index
+
+          # puts "========== prescan is complete on #{(s.map{|e|e.text_value}*" ").inspect} =========="
+          false
+        }
+      end
+
+      # Do a first-pass mainly lexical analysis, looking for role name definitions and adjectives,
+      # for use in detecting terms later.
+      rule prescan_rest
+        &{|s| input.context.reset_role_names }
+        (
+          context_note                      # Context notes have different lexical conventions
+          / '(' as S term_definition_name s ')' s    # Prepare for a Role Name
+            &{|s| input.context.role_name(s[3].value) }
+	  / new_derived_value		    # Prepare for a derived term
+          / new_adjective_term		    # Prepare 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 *
+          / [-+{}\[\].,:^/%*()]             # All other punctuation and operators
+        )* [?;] s
+      end
+
+      # Not sure this is even needed, but it doesn't seem to hurt:
+      rule prescan_aggregate
+	aggregate_type:id s agg_of s global_term agg_in s &'('
+      end
+
+      rule new_derived_value
+        !global_term id derived_value_continuation? s '='
+	  &{|s|
+	    name = [s[1].text_value] + (s[2].empty? ? [] : s[2].value)
+	    input.context.object_type(name*' ', "derived value type")
+	  }
+	/
+	'=' s !global_term id derived_value_continuation? s (that/who)
+	  &{|s|
+	    name = [s[3].text_value] + (s[4].empty? ? [] : s[4].value)
+	    input.context.object_type(name*' ', "derived value type")
+	  }
+      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| 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| 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
+	(S !global_term id)*
+	{
+	  def value
+	    elements.size == 0 ? nil : elements.map{|e| e.id.text_value}*" "
+	  end
+	}
+      end
+
+      rule trail_intervening	# Words intervening between a new adjective and the term
+	(!global_term id S)*
+	{
+	  def value
+	    elements.size == 0 ? nil : elements.map{|e| e.id.text_value}*" "
+	  end
+	}
+      end
+
+      # 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 '-'? 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[5].ast.leading_adjective == nil }
+	  <Parser::TermLANode>
+      end
+
+      rule x
+	'' <SavedContext>
+      end
+
+      rule global_term
+        # This rule shouldn't be used outside the prescan, it will memoize the wrong things.
+        head:id x    &{|s| input.context.term_starts?(s[0].text_value, s[1]) }
+        tail:(s w:id &{|s| input.context.term_continues?(s[1].text_value) } )*
+        { def value
+            tail.elements.inject(head.value) { |t, e| "#{t} #{e.w.value}" }
+          end
+        }
+      end
+
+      rule non_phrase
+        # These words are illegal in (but maybe ok following) a clause where a phrase is expected:
+        and
+        / but
+        / if
+        / role_list_constraint_followers
+        / only_if
+        / or
+        / quantifier
+        / returning
+        / then
+        / value_constraint
+        / where
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,202 @@
+#
+#       ActiveFacts CQL Parser.
+#       Parse rules relating to ValueType definitions.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module CQL
+    grammar ValueTypes
+      rule value_type
+	s each?
+        s term_definition_name
+	m1:mapping_pragmas
+	# REVISIT: ORM2 would allow (subtype_prefix term)?
+        written_as
+	any? s
+        base:(term/implicit_value_type_name) s
+        value_type_parameters
+        u:in_units?
+	a:auto_assignment?
+	c:context_note?
+        r:(value_constraint enforcement)?
+        m2:mapping_pragmas
+	c2:context_note?
+        s ';' s
+        {
+	  def ast
+	    name = term_definition_name.value
+	    params = value_type_parameters.values
+	    value_constraint = nil
+	    unless r.empty? 
+	      value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ast, r.enforcement.ast)
+	    end
+	    units = u.empty? ? [] : u.units.value
+	    auto_assigned_at = a.empty? ? nil : a.auto_assigned_at
+	    pragmas = m1.value+m2.value
+	    context_note = !c.empty? ? c.ast : (!c2.empty? ? c2.ast : nil)
+	    Compiler::ValueType.new name, base.value, params, units, value_constraint, pragmas, context_note, auto_assigned_at
+	  end
+        }
+      end
+
+      rule in_units
+	in S units
+      end
+
+      rule implicit_value_type_name
+	id
+	{
+	  def node_type; :term; end
+	}
+      end
+
+      rule value_type_parameters
+        '(' s tpl:type_parameter_list? ')' s
+          { def values; tpl.empty? ? [] : tpl.values; end }
+        / s
+          { def values; []; end }
+      end
+
+      rule type_parameter_list
+        head:number s tail:( ',' s number s )*
+        {
+          def values
+            [head.value, *tail.elements.map{|i| i.number.value}]
+          end
+        }
+      end
+
+      rule unit_definition
+        u:(
+          s coeff:unit_coefficient? base:units? s o:unit_offset?
+	  conversion
+          singular:unit_name s plural:('/' s p:unit_name s)?
+        /
+          s singular:unit_name s plural:('/' s p:unit_name s)?
+	  conversion
+          coeff:unit_coefficient? base:units? s o:unit_offset?
+        )
+        q:(approximately '' / ephemera s url )? s
+        ';'
+        {
+	  def ast
+            singular = u.singular.text_value
+            plural = u.plural.text_value.empty? ? nil : u.plural.p.text_value 
+	    if u.coeff.empty?
+	      raise "Unit definition requires either a coefficient or an ephemera URL" unless q.respond_to?(:ephemera)
+	      numerator,denominator = 1, 1
+	    else
+	      numerator, denominator = *u.coeff.ast
+	    end
+            offset = u.o.text_value.empty? ? 0 : u.o.value
+	    bases = u.base.empty? ? [] : u.base.value
+	    approximately = q.respond_to?(:approximately) || u.conversion.approximate?
+	    ephemera = q.respond_to?(:ephemera) ? q.url.text_value : nil
+	    Compiler::Unit.new singular, plural, numerator, denominator, offset, bases, approximately, ephemera
+	  end
+        }
+      end
+
+      rule unit_name
+	id
+	{
+	  def node_type; :unit; end
+	}
+      end
+
+
+      rule unit_coefficient
+        numerator:number denominator:(s '/' s number)? s
+        {
+	  def ast
+            [ numerator.text_value,
+              (denominator.text_value.empty? ? "1" : denominator.number.text_value)
+	    ]
+	  end
+        }
+      end
+
+      rule unit_offset
+        sign:[-+] s number s
+        { def value
+            sign.text_value == '-' ? "-"+number.text_value : number.text_value
+          end
+        }
+      end
+
+      # In a unit definition, we may use undefined base units; this is the only way to get fundamental units
+      rule units
+        !non_unit maybe_unit s tail:(!non_unit maybe_unit s)* div:('/' s maybe_unit s tail:(!non_unit maybe_unit s)*)?
+        { def value
+	    tail.elements.inject([maybe_unit.value]) { |a, e| a << e.maybe_unit.value } +
+	      (div.text_value.empty? ? [] : div.tail.elements.inject([div.maybe_unit.inverse]) { |a, e| a << e.maybe_unit.inverse })
+          end
+        }
+      end
+
+      rule non_unit
+        restricted_to / conversion / approximately / ephemera / auto_assignment
+      end
+
+      rule unit
+	maybe_unit &{|s| input.context.unit?(s[0].unit_name.text_value) }
+      end
+
+      rule maybe_unit
+        unit_name pow:('^' '-'? [0-9])?
+        { def value
+            [unit_name.text_value, pow.text_value.empty? ? 1 : Integer(pow.text_value[1..-1])]
+          end
+          def inverse
+            a = value
+            a[1] = -a[1]
+            a
+          end
+        }
+      end
+
+      rule value_constraint
+	restricted_to restricted_values c:context_note?
+        {
+	  def ast
+	    v = restricted_values.values
+	    c[:context_note] = c.ast unless c.empty?
+	    v
+	  end
+        }
+	# REVISIT: "where the possible value/s of that <Term> is/are value (, ...)"
+      end
+
+      rule restricted_values
+	range_list s u:units?
+	{
+	  def values
+	    { :ranges => range_list.ranges,
+	      :units => u.empty? ? nil : u.value
+	    }
+	  end
+	}
+	/
+	regular_expression
+	{
+	  def values
+	    { :regular_expression => contents }
+	  end
+	}
+      end
+
+      rule range_list
+        '{' s
+          head:range s tail:( ',' s range )*
+        '}' s
+        {
+          def ranges
+            [head.value, *tail.elements.map{|e| e.range.value }]
+          end
+        }
+      end
+
+    end
+  end
+end