activefacts-cql 1.9.6 → 1.9.7

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

@@ -1,197 +0,0 @@
-#
-#       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
-        informally_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:
-          forget_failures_to_here
-
-          # puts "========== prescan is complete on #{(s.map{|e|e.text_value}*" ").inspect} =========="
-          false
-        }
-      end
-
-      rule informally_prescan
-        informally s ',' s
-          informal_description_subject_prescan s
-          informal_description_body
-          informal_description_closer
-      end
-
-      rule informal_description_subject_prescan
-        each S term_definition_name       # Informal definition of an object type
-        /
-        when S phrase+ s ','              # or a fact type; we can't forward-reference these
-                                          # This could memoize a bad parse for 'phrase'!!!
-      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
-          / S                               # White space and comments, must precede / and *
-          / [^;]                            # Skip anything else, we want the prescan to finish
-        )* [?;] 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.global_term_starts?(s[0].text_value, s[1]) }
-        tail:(s w:id &{|s| input.context.global_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/TransformRules.treetop

@@ -1,226 +0,0 @@
-#
-#       ActiveFacts CQL Parser.
-#       Parse rules relating to Transformation Rules.
-#
-# Copyright (c) 2017 Factil Pty Ltd. Read the LICENSE file.
-#
-module ActiveFacts
-  module CQL
-    grammar TransformRules
-
-      rule transform_rule
-        ctr:compound_matching s ';'
-        {
-          def ast
-            Compiler::TransformRule.new(ctr.ast)
-          end
-        }
-      end
-
-      rule compound_matching
-        s tl:term_list s '<==' s tq:transform_query? s '{' tr:transform_matchings s '}'
-        {
-          def ast
-            Compiler::CompoundMatching.new(tl.ast, tq.empty? ? nil : tq.ast, tr.ast)
-          end
-        }
-      end
-
-      rule simple_matching
-        s tl:term_list s '<--' s te:transform_expr?
-        {
-          def ast
-            Compiler::SimpleMatching.new(tl.ast, te.empty? ? nil : te.ast)
-          end
-        }
-      end
-
-      rule transform_query
-        cl:clauses_list             { def ast; cl.ast; end; }
-        / t:term                    { def ast; t.ast; end; }
-      end
-
-      rule transform_matchings
-        s r0:transform_matching tail:(s ',' s r1:transform_matching)*
-        {
-          def ast
-            [r0.ast, *tail.elements.map{|e| e.r1.ast }]
-          end
-        }
-      end
-
-      rule transform_matching
-        str:simple_matching            { def ast; str.ast; end; }
-        / ctr:compound_matching        { def ast; ctr.ast; end; }
-      end
-
-      rule term_list
-        s t0:term tail:(s '.' s t1:term_list)*
-        {
-          def ast
-            if tail.elements.empty?
-              [t0.ast]
-            else
-              [t0.ast, *tail.elements.map{|t| t.t1.ast }]
-            end
-          end
-        }
-      end
-
-      rule transform_expr
-        s c:logical_texpr s '?' s t0:logical_texpr s ':' s t1:logical_texpr
-          {
-            def ast
-              Compiler::Ternary.new(c.ast, t0.ast, t1.ast)
-            end
-          }
-        / s o:aggregate_op S agg_of s t:logical_texpr
-          {
-            def ast
-              Compiler::Aggregate.new(o.text_value, t.ast)
-            end
-          }
-        / s t0:logical_texpr    { def ast; t0.ast; end; }
-      end
-
-      rule aggregate_op
-        'sum' / 'average' / 'max' / 'min' / 'count'
-      end
-
-      rule logical_texpr
-        s t0:logical_and_texpr tail:(s op:or s t1:logical_and_texpr)*
-        {
-          def ast
-            if tail.elements.empty?
-              t0.ast
-            else
-              Compiler::LogicalOr.new(t0.ast, *tail.elements.map{|e| e.t1.ast})
-            end
-          end
-        }
-      end
-
-      rule logical_and_texpr
-        s t0:equality_texpr tail:(s op:and s t1:equality_texpr)*
-        {
-          def ast
-            if tail.elements.empty?
-              t0.ast
-            else
-              Compiler::LogicalAnd.new(t0.ast, *tail.elements.map{|e| e.t1.ast})
-            end
-          end
-        }
-      end
-
-      rule equality_texpr
-        s t0:relational_texpr operation:(s op:equality_op s t1:relational_texpr)?
-        {
-          def ast
-            if operation.empty?
-              t0.ast
-            else
-              Compiler::Comparison.new(op.text_value, t0.ast, operation.t1.ast)
-            end
-          end
-        }
-      end
-
-      rule equality_op
-        '=' / '!='
-      end
-
-      rule relational_texpr
-        s t0:additive_texpr operation:(s op:relational_op s t1:additive_texpr)?
-        {
-          def ast
-            if operation.empty?
-              t0.ast
-            else
-              Compiler::Comparison.new(op.text_value, t0.ast, operation.t1.ast)
-            end
-          end
-        }
-      end
-
-      rule relational_op
-        '<' / '>' / '>=' / '<='
-      end
-
-      rule additive_texpr
-        s t0:multiplicative_texpr tail:(s op:additive_op s t1:multiplicative_texpr)*
-        {
-          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 additive_op
-        '+' / '-'
-      end
-
-      rule multiplicative_texpr
-        s t0:unary_texpr tail:(s op:multiplicative_op s t1:unary_texpr)*
-        {
-          def ast
-            if tail.elements.empty?
-              t0.ast
-            else
-              Compiler::Product.new(
-                t0.ast,
-                *tail.elements.map{|e| e.op.text_value == '/' ? Compiler::Reciprocal.new(e.t1.ast) : e.t1.ast}
-              )
-            end
-          end
-        }
-      end
-
-      rule multiplicative_op
-        '*' / '/'
-      end
-
-      rule unary_texpr
-        s u:unary_op? s t:primary_texpr
-        {
-          def ast
-            if u.empty?
-              t.ast
-            else
-              u.text_value == '-' ? Compiler::Negate.new(t.ast) : Compiler::Negation.new(t.ast)
-            end
-          end
-        }
-      end
-
-      rule unary_op
-        '-' / '!'
-      end
-
-      rule primary_texpr
-        tl:term_list
-          {
-            def ast
-              Compiler::ExpressionTermList.new(tl.ast)
-            end
-          }
-        / l:literal
-          {
-            def ast
-              Compiler::Literal.new(l.value, nil)
-            end
-          }
-        # / '(' source_expr ')'
-        # / id '(' source_expr (s ',' s source_expr) * ')'
-      end
-
-    end
-  end
-end

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

@@ -1,244 +0,0 @@
-#
-#       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
-
-      # A ValueType name that might not yet have been identified or registered as a Term
-      # REVISIT: We'd like to support multi-word terms here (cannot include "where", "and", or anything that could follow in the value_type definition)
-      # REVISIT: We'd like these to be forward-referenced ObjectTypes too, not immediately created as ValueTypes
-      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:parameter s tail:( ',' s parameter s)*
-	{
-          def values
-            [head.value, *tail.elements.map{|i| i.parameter.value}]
-          end
-	}
-      end
-
-      rule parameter
-	number / named_parameter
-      end
-
-      rule ordered_parameter
-        number
-      end
-
-      rule named_parameter
-        (	# Set the value for a parameter
-          with s parameter_name as s literal:parameter_literal
-          /
-          parameter_name ':' s literal:parameter_literal
-        ) <Parser::ValueTypeParameterSetting>
-        /	# Define a new parameter
-        accepts s parameter_name as value_type:term s vr:(restricted s to s parameter_restriction)? <Parser::ValueTypeParameterDefinition>
-        /	# Restrict values for a parameter
-        restricts s parameter_name to s parameter_restriction <Parser::ValueTypeParameterRestriction>
-      end
-
-      rule parameter_name
-        !(with/accepts/restricts/as/term) id s
-        { def value; id.text_value; end }
-      end
-
-      rule parameter_literal
-	number
-	/   # We need the text_value of a string here, not the result of parsing it
-	string { def value; text_value; end }
-      end
-
-      rule parameter_restriction
-	range_list s
-	  { def values; range_list.ranges; end}
-	/
-	parameter_literal s direction:(min / max)? s
-	  { def values; [:value, parameter_literal.value, direction.text_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