activefacts 1.6.0 → 1.7.1

data/lib/activefacts/cql/LexicalRules.treetop

@@ -1,253 +0,0 @@
-#
-#       ActiveFacts CQL Parser.
-#       Various lexical rules for CQL.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module CQL
-    grammar LexicalRules
-
-      rule range
-        (numeric_range / string_range)
-	{
-	  def node_type; :literal; end
-	}
-      end
-
-      rule numeric_range
-        number s tail:( '..' s end:number? s )?
-        {
-          def value
-            if !tail.empty?
-              last = tail.end.value unless tail.end.empty?
-              [ number.value, last ]
-            else
-              number.value
-            end
-          end
-        }
-        / '..' s number s
-        {
-          def value
-            [ nil, number.value ]
-          end
-        }
-      end
-
-      rule string_range
-        string s tail:( '..' s end:string? s )?
-        {
-          # Ranges require the original text of the string, not the content:
-          def value
-            first = string.text_value
-            if !tail.empty?
-              last = tail.end.text_value unless tail.end.empty?
-              [ first, last ]
-            else
-              first
-            end
-          end
-        }
-        / '..' s string s
-        {
-          def value
-            [ nil, string.value ]
-          end
-        }
-      end
-
-      rule url
-	# url_scheme ':' (user ( ':' !(port '/') password )? '@' )? hostname ( ':' port )? '/' path query? fragment?
-	( !(white / ';') .)+
-	{
-	  def node_type; :literal; end
-	}
-      end
-
-      rule literal
-        ( boolean_literal
-        / string
-        / number
-        ) s
-        {
-          def value
-            elements[0].value
-          end
-	  def node_type; :literal; end
-        }
-      end
-
-      rule boolean_literal
-        ( true { def value; true; end }
-        / false { def value; false; end }
-        ) !alphanumeric
-        {
-          def value; elements[0].value end
-        }
-      end
-
-      rule string
-        "'" (string_char)* "'"
-        {
-          def value
-            text_value
-            eval(text_value.sub(/\A'(.*)'\Z/,'"\1"'))
-          end
-        }
-      end
-
-      rule number
-        ( real /
-          fractional_real /
-          hexnumber /
-          octalnumber
-        ) !alphanumeric
-        {
-          def value
-            eval(text_value)
-          end
-	  def node_type; :literal; end
-        }
-      end
-
-      # All purely lexical rules from here down, no-one looks at the structure, just the text_value:
-
-      rule string_char
-        ( '\\' [befntr\\']
-        / '\\' [0-7] [0-7] [0-7]
-	/ '\\' [\r]* [\n] [\r]*
-        / '\\0'
-        / '\\x' [0-9A-Fa-f] [0-9A-Fa-f]
-        / '\\u' [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f]
-        / (![\'\\\0-\x07\x0A-\x1F] .)
-        )
-      end
-
-      rule real
-        [-+]? [1-9] [0-9]* fraction? exponent?
-      end
-
-      rule fractional_real
-        [-+]? '0' fraction exponent?
-      end
-
-      rule fraction
-        radix_point [0-9]+
-      end
-
-      rule exponent
-        ( [Ee] [-+]? [0-9]+ )
-      end
-
-      rule hexnumber
-        '0x' [0-9A-Fa-f]+
-      end
-
-      rule octalnumber
-        '0' [0-7]*
-      end
-
-      rule mul_op
-        '/' / '%' / '*'
-      end
-
-      rule id
-        alpha alphanumeric*
-        { def value; text_value; end }
-      end
-
-      rule alpha
-	[[:alpha:]_]
-      end
-
-      rule alphanumeric
-        alpha / [0-9]
-      end
-
-      rule s    # Optional space
-        S?
-      end
-
-      rule S    # Mandatory space
-        (white / comment_to_eol / comment_c_style)+
-      end
-
-      rule white
-        [ \t\n\r]+
-      end
-
-      rule comment_to_eol
-        '//' (!"\n" .)*
-	{
-	  def node_type; :comment; end
-	}
-      end
-
-      rule comment_c_style
-        '/*' (!'*/' . )* '*/'
-	{
-	  def node_type; :comment; end
-	}
-      end
-
-      rule regular_expression
-	'/' !'/' regular_expression_contents '/'
-	{
-	  def contents
-	    regular_expression_contents.text_value
-	  end
-	}
-      end
-
-      rule regular_expression_contents
-	regular_expression_alternate ( '|' regular_expression_alternate )*
-      end
-
-      rule regular_expression_alternate
-	regular_expression_sequence
-      end
-
-      rule regular_expression_sequence
-	regular_expression_atom*
-      end
-
-      rule regular_expression_atom
-	(
-	  '[' character_classes ']'
-	  / regular_expression_group
-	  / ![*+?()|/] string_char
-	) regular_expression_multiplicity?
-      end
-
-      rule character_classes
-	character_class+
-      end
-
-      rule character_class
-	!']' string_char '-' !']' string_char
-	/ '-'
-	/ !']' string_char
-      end
-
-      rule regular_expression_multiplicity
-	'*' / '+' / '?'
-      end
-
-      rule regular_expression_group
-	'('
-	  regular_expression_group_extension?
-	  regular_expression_contents
-	')'
-      end
-
-      rule regular_expression_group_extension
-	'?' (
-	  '<' ( !'>' .)+ '>'	# A tag for a regular expression group
-	# REVISIT: Add more group extensions as needed
-	)
-      end
-
-    end
-  end
-end

data/lib/activefacts/cql/ObjectTypes.treetop

@@ -1,210 +0,0 @@
-#
-#       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