activefacts-cql 1.9.6 → 1.9.7

data/lib/activefacts/cql/parser/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/parser/ObjectTypes.treetop

@@ -1,209 +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
-        / 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	  # REVISIT: We'd like to be able to use implicit_value_type_names here too.
-          &{|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