activefacts 0.8.16 → 0.8.18

data/lib/activefacts/cql/Language/English.treetop

@@ -6,7 +6,7 @@
 #
 module ActiveFacts
   module CQL
-    grammar Language
+    grammar English
 
       # >>>>>>>>>>>>>>>>>>>> Object Types <<<<<<<<<<<<<<<<<<<<
       # The pattern to introduce a Value Type
@@ -38,10 +38,9 @@ module ActiveFacts
 	{ def independent; !i.empty?; end }
       end
 
-      rule in_which	# Introduce an objectification join
+      rule in_which	# Introduce an objectification step
 	where /	    # Old syntax
 	in s which  # preferred syntax
-	{ def independent; !i.empty?; end }
       end
 
       # Units conversion keyword
@@ -126,6 +125,10 @@ module ActiveFacts
 	s clauses s only s if s r2:clauses s c:context_note? enforcement ';'
       end
 
+      rule only_if
+	only s if s
+      end
+
       # Subset constraint using "if A then B" syntax
       rule if_b_then_a
 	s if s clauses s then s r2:clauses s c:context_note? enforcement ';'
@@ -204,7 +207,18 @@ module ActiveFacts
         id (s id)*
       end
 
+      rule negative_prefix
+	s it s is s not s the s case s that s
+      end
+
+      rule agg_of of end 
+      rule agg_in in end 
+      rule restricted_to 'restricted' s 'to' s !alphanumeric end
+      # any is optionally used in an identifying role_list
+      rule any one / a end
+
       # >>>>>>>>>>>>>>>>>>>> Internal vocabulary <<<<<<<<<<<<<<<<<<<<
+      rule a ('a' !alphanumeric /'an' !alphanumeric) end
       rule all 'all' !alphanumeric end
       rule ascending 'ascending' !alphanumeric end
       rule at 'at' !alphanumeric end
@@ -240,6 +254,7 @@ module ActiveFacts
       rule because 'because' !alphanumeric end
       rule but 'but' !alphanumeric end 
       rule by 'by' !alphanumeric end			      # fix? Used in 'returning' for ordering
+      rule case 'case' !alphanumeric end 
       rule definitely 'definitely' !alphanumeric end
       rule ephemera 'ephemera' !alphanumeric end 
       rule false 'false' !alphanumeric end 
@@ -249,9 +264,11 @@ module ActiveFacts
       rule in 'in' !alphanumeric end
       rule import 'import' !alphanumeric end
       rule independent 'independent' !alphanumeric end 
+      rule stronglyintransitive 'stronglyintransitive' !alphanumeric end
       rule intransitive 'intransitive' !alphanumeric end
       rule irreflexive 'irreflexive' !alphanumeric end
       rule is 'is' !alphanumeric end 
+      rule it 'it' !alphanumeric end
       rule its 'its' !alphanumeric end
       rule masculine 'masculine' !alphanumeric end 
       rule maybe 'maybe' !alphanumeric end
@@ -264,13 +281,13 @@ module ActiveFacts
       rule personal 'personal' !alphanumeric end 
       rule radix_point '.' end
       rule reflexive 'reflexive' !alphanumeric end
-      rule restricted 'restricted' !alphanumeric end
       rule returning 'returning' !alphanumeric end
       rule separate 'separate' !alphanumeric end 
       rule so_that 'so' S that end
       rule static 'static' !alphanumeric end
       rule symmetric 'symmetric' !alphanumeric end
       rule that 'that' !alphanumeric end
+      rule the 'the' !alphanumeric end 
       rule then 'then' !alphanumeric end
       rule to 'to' !alphanumeric end
       rule to_avoid to s 'avoid' !alphanumeric end

data/lib/activefacts/cql/LexicalRules.treetop

@@ -116,6 +116,7 @@ module ActiveFacts
       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]
@@ -157,7 +158,7 @@ module ActiveFacts
       end
 
       rule alpha
-        [A-Za-z_]
+	[[:alpha:]]
       end
 
       rule alphanumeric
@@ -190,6 +191,63 @@ module ActiveFacts
 	}
       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

@@ -15,19 +15,22 @@ module ActiveFacts
       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[3].identification_mode
+	    mode = s[6].identification_mode
 	    if mode
-	      input.context.object_type(s[1].value+mode, "identification mode type")
-	      input.context.object_type(s[1].value+' '+mode, "identification mode type")
+	      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?
         ';'
         {
@@ -36,7 +39,8 @@ module ActiveFacts
 	    clauses_ast = ec.empty? ? [] : ec.ast
 	    pragmas = m1.value+m2.value
 	    pragmas << 'independent' if sup.independent
-	    Compiler::EntityType.new name, sup.supers, sup.ast, pragmas, clauses_ast
+	    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
@@ -62,7 +66,7 @@ module ActiveFacts
       end
 
       rule supertype_list
-        primary:term s alternate_supertypes:( ',' s !identified_by name:term s )*
+        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 } ]
@@ -79,7 +83,7 @@ module ActiveFacts
 	      if r.empty?
 		value_constraint = nil
 	      else
-		value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ranges, r.value_constraint.units, r.enforcement.ast)
+		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
@@ -115,7 +119,13 @@ module ActiveFacts
 
       # Identified by roles... also used for constraints, beware
       rule role_list 
-        head:term_or_unary s tail:( ( and S / ',' s ) term_or_unary s )*
+	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}]
@@ -124,7 +134,7 @@ module ActiveFacts
       end
 
       rule unary_text
-	(s !non_phrase !term id)*
+	(s !any !non_phrase !term id)*
 	{
 	  def node_type; :linking; end
 	}
@@ -146,11 +156,11 @@ module ActiveFacts
 	    end
 	  }
 	/
-	s !non_phrase id s &non_phrase s ss:subscript
+	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::VarRef.new(id.text_value, nil, nil, nil, ss.empty? ? nil : ss.value)
+	      Compiler::Reference.new(id.text_value, nil, nil, nil, ss.empty? ? nil : ss.value)
 	    end
 	  }
       end
@@ -171,10 +181,10 @@ module ActiveFacts
       end
 
       rule entity_clauses
-        (':' / where) s joined_clauses
+        (':' / where) s query_clauses
         {
 	  def ast
-            joined_clauses.ast
+            query_clauses.ast
 	  end
         }
       end

data/lib/activefacts/cql/Terms.treetop

@@ -25,20 +25,24 @@ module ActiveFacts
         is s (independent s )? identified_by
 	/
 	subtype_prefix (independent s )? term_definition_name
-	&{|e| input.context.object_type(e[2].value, "subtype") }
+	  &{|e| input.context.object_type(e[2].value, "subtype") }
       end
 
       rule prescan
-        s (
+        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 t2:term_definition_name
-                &{|e| input.context.object_type(e[0].value, "value type")
-		  input.context.object_type(e[3].value, "value 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 s (independent s )? where
+          term_definition_name s mapping_pragmas is_where
                 &{|e| input.context.object_type(e[0].value, "objectified_fact_type") }
         )?
         prescan_rest
@@ -61,7 +65,7 @@ module ActiveFacts
           / '(' 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		    # Prepae for an existing term with new Adjectives
+          / 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
@@ -76,7 +80,7 @@ module ActiveFacts
 
       # Not sure this is even needed, but it doesn't seem to hurt:
       rule prescan_aggregate
-	aggregate_type:id s of s global_term in s &'('
+	aggregate_type:id s agg_of s global_term agg_in s &'('
       end
 
       rule new_derived_value
@@ -163,7 +167,7 @@ module ActiveFacts
         / but
         / if
         / role_list_constraint_followers
-        / only
+        / only_if
         / or
         / quantifier
         / returning

data/lib/activefacts/cql/ValueTypes.treetop

@@ -8,15 +8,19 @@ 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:units?
+	c:context_note?
         r:(value_constraint enforcement)?
         m2:mapping_pragmas
+	c2:context_note?
         s ';' s
         {
 	  def ast
@@ -24,11 +28,12 @@ module ActiveFacts
 	    params = value_type_parameters.values
 	    value_constraint = nil
 	    unless r.empty? 
-	      value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ranges, r.value_constraint.units, r.enforcement.ast)
+	      value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ast, r.enforcement.ast)
 	    end
 	    units = u.empty? ? [] : u.value
 	    pragmas = m1.value+m2.value
-	    Compiler::ValueType.new name, base.value, params, units, value_constraint, pragmas
+	    context_note = !c.empty? ? c.ast : (!c2.empty? ? c2.ast : nil)
+	    Compiler::ValueType.new name, base.value, params, units, value_constraint, pragmas, context_note
 	  end
         }
       end
@@ -125,7 +130,7 @@ module ActiveFacts
       end
 
       rule non_unit
-        restricted / conversion / approximately / ephemera
+        restricted_to / conversion / approximately / ephemera
       end
 
       rule unit
@@ -146,20 +151,34 @@ module ActiveFacts
       end
 
       rule value_constraint
-	restricted s to s range_list s u:units?
+	restricted_to restricted_values c:context_note?
         {
-          def ranges
-            range_list.ranges
-          end
-
-	  def units
-	    u.empty? ? nil : u.value
+	  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
 
-      # REVISIT: Value constraint for ValueType or EntityType&Refmode: "the possible values of <TYPE> are value (, ...)"
+      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

data/lib/activefacts/cql/compiler.rb

@@ -12,17 +12,24 @@ require 'activefacts/cql/compiler/fact_type'
 require 'activefacts/cql/compiler/expression'
 require 'activefacts/cql/compiler/fact'
 require 'activefacts/cql/compiler/constraint'
-require 'activefacts/cql/compiler/join'
+require 'activefacts/cql/compiler/query'
 
 module ActiveFacts
   module CQL
     class Compiler < ActiveFacts::CQL::Parser
+      LANGUAGES = {
+        'en' => 'English',
+        'fr' => 'French',
+        'cn' => 'Mandarin'
+      }
       attr_reader :vocabulary
 
-      def initialize(filename = "stdin")
-        @filename = filename
+      def initialize *a
+        @filename = a.shift || "stdio"
+        super *a
         @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
-        debug :file, "Parsing '#{filename}'"
+        @language = nil
+        debug :file, "Parsing '#{@filename}'"
       end
 
       def compile_file filename
@@ -35,8 +42,25 @@ module ActiveFacts
         @vocabulary
       end
 
+      # Load the appropriate natural language module
+      def detect_language
+        @filename =~ /.*\.(..)\.cql$/i
+        language_code = $1
+        @language = LANGUAGES[language_code] || 'English'
+      end
+
+      def include_language
+        detect_language unless @langage
+        require 'activefacts/cql/Language/'+@language
+        language_module = ActiveFacts::CQL.const_get(@language)
+        extend language_module
+      end
+
       def compile input
+        include_language
+
         @string = input
+
         # The syntax tree created from each parsed CQL statement gets passed to the block.
         # parse_all returns an array of the block's non-nil return values.
         ok = parse_all(@string, :definition) do |node|
@@ -69,9 +93,12 @@ module ActiveFacts
       def compile_import file, aliases
         saved_index = @index
         saved_block = @block
+        saved_string = @string
+        saved_input_length = @input_length
         old_filename = @filename
-        @filename = file+'.cql'
+        @filename = file+'.cql'   # REVISIT: Use File.dirname(@filename)+@filename ?
 
+        # REVISIT: Save and use another @vocabulary for this file?
         File.open(@filename) do |f|
           ok = parse_all(f.read, nil, &@block)
         end
@@ -83,6 +110,8 @@ module ActiveFacts
       ensure
         @block = saved_block
         @index = saved_index
+        @input_length = saved_input_length
+        @string = saved_string
         @filename = old_filename
         nil
       end