activefacts-cql 1.8.1 → 1.8.2

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

@@ -15,165 +15,165 @@ module ActiveFacts
       end
 
       rule entity_type
-	s each?
+        s each?
         s term_definition_name
-	m1:mapping_pragmas
-	c:context_note?
+        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
-	  }
+          &{|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?
+        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
+          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
+        basetype_expression
         {
-	  def ast; identification.ast; end
-	  def supers; []; end
+          def ast; identification.ast; end
+          def supers; []; end
           def identification_mode; identification.mode; end
-	  def independent; !i.empty?; end
+          def independent; !i.empty?; end
         }
       end
 
       rule subtype
-	subtype_expression
+        subtype_expression
         {
-	  def ast; ident.empty? ? nil : ident.ast; end
+          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
+          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
-	}
+          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
+        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 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
-	  }
+            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
-	  }
+          &{|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 ast
+              role_list.ast
+            end
 
-	    def mode
-	      nil
-	    end
-	  }
+            def mode
+              nil
+            end
+          }
       end
 
       # Identified by roles... also used for constraints, beware
       rule role_list 
-	a:any? s
+        a:any? s
         head:term_or_unary s
-	tail:(
-	  ( and S / ',' s )
-	  any? s
-	  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
+          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
-	}
+        (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
-	  }
+        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
-	  }
+            def value
+              t.elements.inject([h.value*' ']) do |a, e|
+                a << e.mapping_pragma.value*' '
+              end
+            end
+          }
         /
         s
           { def value; []; end }
@@ -181,27 +181,27 @@ module ActiveFacts
 
       # 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
-	}
+        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
+          def ast
             query_clauses.ast
-	  end
+          end
         }
       end
 

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

@@ -9,47 +9,47 @@ module ActiveFacts
     grammar Terms
       rule term_definition_name
         id s t:(!non_term_def id s)*
-	  <Parser::TermDefinitionNameNode>
+          <Parser::TermDefinitionNameNode>
       end
 
       rule non_term_def
         mapping_pragmas entity_prefix
-        / mapping_pragmas written_as			      # Value type
-        / mapping_pragmas is_where			      # Objectified type
+        / 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
+        / 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") }
+        /
+        subtype_prefix (independent s )? term_definition_name
+          &{|e| input.context.object_type(e[2].value, "subtype") }
       end
 
       rule prescan
         s each?
-	s (
+        s (
           term_definition_name mapping_pragmas entity_prefix
-		&{|e| input.context.object_type(e[0].value, "entity type") }
+                &{|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")
-		}
+                  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:
+          # Wipe any terminal failures that were added:
           @terminal_failures = []
           @max_terminal_failure_index = start_index
 
@@ -66,13 +66,13 @@ module ActiveFacts
           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:
+          / 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
+          / prescan_aggregate
           / id
-	  # / literal # REVISIT: Literals might contain "(as Foo)" and mess things up
+          # / 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 *
@@ -82,75 +82,75 @@ module ActiveFacts
 
       # 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 &'('
+        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")
-	  }
+          &{|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
-	}
+        {
+          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
+        !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
+        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
-	}
+      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
-	}
+      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]) }
+        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>
+          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>
+        '' <SavedContext>
       end
 
       rule global_term