activefacts 0.8.9 → 0.8.10

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

@@ -8,18 +8,136 @@ module ActiveFacts
   module CQL
     grammar Language
 
-      rule subtype_prefix
-        'is' s 'a' s ('kind'/'subtype') s 'of' S
-      end
-
+      # >>>>>>>>>>>>>>>>>>>> Object Types <<<<<<<<<<<<<<<<<<<<
+      # The pattern to introduce a Value Type
       rule written_as
         s 'is' s 'written' S as s
       end
 
+      # The pattern to introduce an Entity Type
       rule identified_by
         identified s by s
       end
 
+      rule basetype_expression
+        is s i:( independent s )? identification
+      end
+
+      # The pattern to introduce an Entity Subtype
+      rule subtype_prefix
+        'is' s 'a' s ('kind'/'subtype') s 'of' S
+      end
+
+      rule subtype_expression
+        subtype_prefix i:( independent s )? supertype_list ident:identification?
+      end
+
+      # The pattern to introduce an objectified fact type with implicit identification
+      rule is_where
+	is s i:(independent s)? where
+	{ def independent; !i.empty?; end }
+      end
+
+      # Units conversion keyword
+      rule conversion
+	converts s a:(approximately s)? to s
+	{
+	  def approximate?
+	    !a.empty?
+	  end
+	}
+      end
+
+      # >>>>>>>>>>>>>>>>>>>> Constraints <<<<<<<<<<<<<<<<<<<<
+      # External presence constraint syntax:
+      rule each_occurs_in_clauses
+        s 'each' s ('combination' S)? role_list s occurs s quantifier s 'time' 's'? s enforcement 'in' s
+	  clauses_list s c:context_note? ';'
+	{
+	  def role_list_ast
+	    role_list.ast
+	  end
+	  def quantifier_ast
+	    quantifier.ast
+	  end
+	  def clauses_ast
+	    clauses_list.ast
+	  end
+	}
+      end
+
+      # Alternate external presence constraint syntax:
+      rule either_or
+      s either? s r1:clauses s or s r2:clauses c:context_note? enforcement ';'
+      {
+	  def role_list_ast
+	    nil
+	  end
+	  def quantifier_ast
+	    Compiler::Quantifier.new(1, nil)
+	  end
+	  def clauses_ast
+	    [r1.ast, r2.ast]
+	  end
+	}
+      end
+
+      # Exclusion (at most one) and mandatory exclusion (exactly one) constraint syntax:
+      rule for_each_how_many
+        s 'for' s 'each' s role_list s quantifier s 'of' s 'these' s 'holds' s enforcement ':' s
+	  clauses_list s c:context_note? ';'
+	{
+	  def role_list_ast
+	    role_list.ast
+	  end
+	  def quantifier_ast
+	    quantifier.ast
+	  end
+	  def clauses_ast
+	    clauses_list.ast
+	  end
+	}
+      end
+
+      # Alternate mandatory exclusion constraint syntax:
+      rule either_or_not_both
+        s either? s r1:clauses s or s r2:clauses but s not s both s c:context_note? enforcement ';'
+	{
+	  def role_list_ast
+	    nil
+	  end
+	  def quantifier_ast
+	    Compiler::Quantifier.new(1, 1)
+	  end
+	  def clauses_ast
+	    [r1.ast, r2.ast]
+	  end
+	}
+      end
+
+      # Subset constraint using "A only if B" syntax
+      rule a_only_if_b
+	s clauses s only s if s r2:clauses s c:context_note? enforcement ';'
+      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 ';'
+      end
+
+      # Equality constraint syntax:
+      rule if_and_only_if
+        s clauses s tail:( if s and s only s if s clauses s)+
+	  c:context_note? enforcement ';'
+      end
+
+      # During the prescan we need to know where terms in a role list finish.
+      # This rule matches any non-term expressions that may follow a role list.
+      rule role_list_constraint_followers
+	occurs s quantifier s 'time'
+      end
+
+      # >>>>>>>>>>>>>>>>>>>> Quantifiers <<<<<<<<<<<<<<<<<<<<
       rule quantifier
 	(
 	  each s                    { def value; [1, nil]; end }
@@ -40,7 +158,7 @@ module ActiveFacts
 				    }
 	  / at s most s quantity    { def value; [ nil, quantity.value ]; end }
 	  / from s numeric_range s  { def value; numeric_range.value; end }
-	  / either_all_or_none s    { def value; [ -1, 1 ]; end }
+	# / either_all_or_none s    { def value; [ -1, 1 ]; end }
 	)
 	{
 	  def ast
@@ -50,31 +168,14 @@ module ActiveFacts
 	}
       end
 
+      # rule either_all_or_none either s all s or s ( none / no ) end
+
       rule quantity
         one s                     { def value; 1; end }
         / number s                { def value; number.value; end }
       end
 
-      rule according_to
-        'according' S to
-      end
-
-      rule because
-        'because' S
-      end
-
-      rule as_opposed_to
-        as S 'opposed' S to
-      end
-
-      rule so_that
-        'so' S that
-      end
-
-      rule to_avoid
-        to s 'avoid' !alphanumeric
-      end
-
+      # >>>>>>>>>>>>>>>>>>>> Context Notes <<<<<<<<<<<<<<<<<<<<
       rule as_agreed_by
         s as s 'agreed' s d:('on' S date)? by s agents
         { def value; [ d.empty? ? nil : d.date.value, agents.value ]; end }
@@ -87,78 +188,90 @@ module ActiveFacts
 
       rule agents
         s h:agent s t:(',' s !context_type agent s)*
-        { def value; [h.text_value] + t.elements.map{|e| e.agent.text_value }; end }
+        {
+	  def value; [h.text_value] + t.elements.map{|e| e.agent.text_value }; end
+	  def node_type; :linking; end
+	}
       end
 
       rule agent
         id (s id)*
       end
 
-      # An enforcement action, like SMS, email, log, alarm, etc.
-      rule action
-	id
-      end
+      # >>>>>>>>>>>>>>>>>>>> Internal vocabulary <<<<<<<<<<<<<<<<<<<<
+      rule all 'all' !alphanumeric end
+      rule ascending 'ascending' !alphanumeric end
+      rule at 'at' !alphanumeric end
+      rule both 'both' !alphanumeric end 
+      rule converts 'converts' !alphanumeric end 
+      rule descending 'descending' !alphanumeric end
+      rule each 'each' !alphanumeric end 
+      rule either 'either' !alphanumeric end 
+      rule entity 'entity' !alphanumeric end 
+      rule exactly 'exactly' !alphanumeric end
+      rule from  'from' !alphanumeric end
+      rule includes 'includes' !alphanumeric end
+      rule least 'least' !alphanumeric end
+      rule matches 'matches' !alphanumeric end
+      rule most 'most' !alphanumeric end
+      rule no 'no' !alphanumeric end
+      rule none 'none' !alphanumeric end
+      rule not 'not' !alphanumeric end
+      rule occurs 'occurs' !alphanumeric end
+      rule one 'one' !alphanumeric end
+      rule some 'some' !alphanumeric end
 
+      # >>>>>>>>>>>>>>>>>>>> External vocabulary <<<<<<<<<<<<<<<<<<<<
+      rule according_to 'according' S to end
       rule acyclic 'acyclic' !alphanumeric end
-      rule antisymmetric 'antisymmetric' !alphanumeric end
-      rule asymmetric 'asymmetric' !alphanumeric end
       rule alias 'alias' !alphanumeric end 
-      rule all 'all' !alphanumeric end
       rule and 'and' !alphanumeric end
+      rule antisymmetric 'antisymmetric' !alphanumeric end
       rule approximately 'approximately' !alphanumeric end
       rule as 'as' !alphanumeric end
-      rule at 'at' !alphanumeric end
-      rule both 'both' !alphanumeric end 
+      rule as_opposed_to as s 'opposed' S to end 
+      rule asymmetric 'asymmetric' !alphanumeric end
+      rule because 'because' !alphanumeric end
       rule but 'but' !alphanumeric end 
-      rule by 'by' !alphanumeric end 
-      rule converts 'converts' !alphanumeric end 
+      rule by 'by' !alphanumeric end			      # fix? Used in 'returning' for ordering
       rule definitely 'definitely' !alphanumeric end
-      rule each 'each' !alphanumeric end 
-      rule either 'either' !alphanumeric end 
-      rule entity 'entity' !alphanumeric end 
       rule ephemera 'ephemera' !alphanumeric end 
-      rule exactly 'exactly' !alphanumeric end
       rule false 'false' !alphanumeric end 
       rule feminine 'feminine' !alphanumeric end 
-      rule from  'from' !alphanumeric end
       rule identified ('known'/'identified') !alphanumeric end 
-      rule independent 'independent' !alphanumeric end 
       rule if 'if' !alphanumeric end
       rule import 'import' !alphanumeric end
-      rule includes 'includes' !alphanumeric end
+      rule independent 'independent' !alphanumeric end 
       rule intransitive 'intransitive' !alphanumeric end
       rule irreflexive 'irreflexive' !alphanumeric end
       rule is 'is' !alphanumeric end 
       rule its 'its' !alphanumeric end
-      rule least 'least' !alphanumeric end
       rule masculine 'masculine' !alphanumeric end 
-      rule matches 'matches' !alphanumeric end
       rule maybe 'maybe' !alphanumeric end
-      rule most 'most' !alphanumeric end
-      rule no 'no' !alphanumeric end
-      rule none 'none' !alphanumeric end
-      rule not 'not' !alphanumeric end
-      rule either_all_or_none either s all s or s ( none / no ) end
-      rule one 'one' !alphanumeric end
       rule only 'only' !alphanumeric end
       rule or 'or' !alphanumeric end 
+      rule ordering_prefix by s (ascending/descending)? s end
       rule otherwise 'otherwise' !alphanumeric end 
       rule partitioned 'partitioned' !alphanumeric end 
       rule personal 'personal' !alphanumeric end 
-      rule restricted 'restricted' !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 some 'some' !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 then 'then' !alphanumeric end
       rule to 'to' !alphanumeric end
+      rule to_avoid to s 'avoid' !alphanumeric end
       rule transient 'transient' !alphanumeric end
       rule transitive 'transitive' !alphanumeric end
       rule true 'true' !alphanumeric end 
       rule vocabulary 'vocabulary' !alphanumeric end 
       rule where 'where' !alphanumeric end 
+      rule who 'who' !alphanumeric end 
 
     end
   end

data/lib/activefacts/cql/LexicalRules.treetop

@@ -9,7 +9,10 @@ module ActiveFacts
     grammar LexicalRules
 
       rule range
-        numeric_range / string_range
+        (numeric_range / string_range)
+	{
+	  def node_type; :literal; end
+	}
       end
 
       rule numeric_range
@@ -57,6 +60,9 @@ module ActiveFacts
       rule url
 	# url_scheme ':' (user ( ':' !(port '/') password )? '@' )? hostname ( ':' port )? '/' path query? fragment?
 	( !(white / ';') .)+
+	{
+	  def node_type; :literal; end
+	}
       end
 
       rule literal
@@ -68,6 +74,7 @@ module ActiveFacts
           def value
             elements[0].value
           end
+	  def node_type; :literal; end
         }
       end
 
@@ -100,6 +107,7 @@ module ActiveFacts
           def value
             eval(text_value)
           end
+	  def node_type; :literal; end
         }
       end
 
@@ -124,7 +132,7 @@ module ActiveFacts
       end
 
       rule fraction
-        '.' [0-9]+
+        radix_point [0-9]+
       end
 
       rule exponent
@@ -170,10 +178,16 @@ module ActiveFacts
 
       rule comment_to_eol
         '//' (!"\n" .)*
+	{
+	  def node_type; :comment; end
+	}
       end
 
       rule comment_c_style
         '/*' (!'*/' . )* '*/'
+	{
+	  def node_type; :comment; end
+	}
       end
 
     end

data/lib/activefacts/cql/{Concepts.treetop → ObjectTypes.treetop}

@@ -1,13 +1,13 @@
 #
 #       ActiveFacts CQL Parser.
-#       Parse rules relating to Concept definitions.
+#       Parse rules relating to ObjectType definitions.
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 module ActiveFacts
   module CQL
-    grammar Concepts
-      rule concept
+    grammar ObjectTypes
+      rule object_type
         value_type
         / entity_type
         / named_fact_type
@@ -16,55 +16,51 @@ module ActiveFacts
 
       rule entity_type
         s term_definition_name
+	m1:mapping_pragmas
         sup:(basetype / subtype)
 	  &{|s|
 	    # There's an implicit type when we use an identification mode, register it:
-	    mode = s[2].identification_mode
+	    mode = s[3].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")
 	    end
 	    true
 	  }
-        mapping_pragmas
-        ec:entity_conditions?
+        m2:mapping_pragmas
+        ec:entity_clauses?
         ';'
         {
 	  def ast
 	    name = term_definition_name.value
-	    readings = ec.empty? ? [] : ec.ast
-	    Compiler::EntityType.new name, sup.supers, sup.ast, mapping_pragmas.value, readings
+	    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
 	  end
         }
       end
 
       rule basetype
-        is s
-        # independency?
-        identification
+	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_prefix
-        # independency?
-        supertype_list ident:identification?
+	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
 
-      # REVISIT: This doesn't work, and I don't know why.
-      rule independency
-         ('independent' S / 'separate' S / 'partitioned' S)
-      end
-
       rule supertype_list
         primary:term s alternate_supertypes:( ',' s !identified_by name:term s )*
         {
@@ -76,14 +72,14 @@ module ActiveFacts
 
       rule identification
         # REVISIT: Consider distinguishing "-Id" from just "Id", and not prepending the entity type name if no "-"
-        identified_by its s i:(term/id) value_type_parameters
+        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.ranges, r.enforcement.ast)
+		value_constraint = Compiler::ValueConstraint.new(r.value_constraint.ranges, r.value_constraint.units, r.enforcement.ast)
 	      end
 	      Compiler::ReferenceMode.new(i.value, value_constraint, value_type_parameters.values)
 	    end
@@ -97,10 +93,10 @@ module ActiveFacts
 	  &{|s|
 	    role_list = s[-1]
 	    forwards = role_list.ast.
-	      map do |role_ref|
-		next nil if role_ref.is_a?(Compiler::Reading) # Can't forward-reference unaries
-		next nil if role_ref.leading_adjective or role_ref.trailing_adjective
-		role_ref.term
+	      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)
@@ -127,8 +123,15 @@ module ActiveFacts
         }
       end
 
+      rule unary_text
+	(s !non_phrase !term id)*
+	{
+	  def node_type; :linking; end
+	}
+      end
+
       rule term_or_unary
-	pre_text:(s !non_role_word !term id)* s term post_text:(s !non_role_word !term id)* s ss:subscript?
+	pre_text:unary_text s term post_text:unary_text s ss:subscript?
 	  {
 	    def ast
 	      t = term.ast
@@ -138,16 +141,16 @@ module ActiveFacts
 	      else
 		pre_words = pre_text.elements.map{|w| w.id.text_value}
 		post_words = post_text.elements.map{|w| w.id.text_value}
-		Compiler::Reading.new(pre_words + [t] + post_words, [], nil)
+		Compiler::Clause.new(pre_words + [t] + post_words, [], nil)
 	      end
 	    end
 	  }
 	/
-	s !non_role_word id s &non_role_word 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::RoleRef.new(id.text_value, nil, nil, nil, ss.empty? ? nil : ss.value)
+	      Compiler::VarRef.new(id.text_value, nil, nil, nil, ss.empty? ? nil : ss.value)
 	    end
 	  }
       end
@@ -156,7 +159,7 @@ module ActiveFacts
         '[' s h:mapping_pragma t:(s ',' s mapping_pragma)* s ']' s
           { def value; t.elements.inject([h.value]) { |a, e| a << e.mapping_pragma.value }; end }
         /
-        ''
+        s
           { def value; []; end }
       end
 
@@ -165,16 +168,12 @@ module ActiveFacts
           { def value; text_value; end }
       end
 
-      rule entity_conditions
-        (':' / where) s c:conditions?
+      rule entity_clauses
+        (':' / where) s joined_clauses
         {
 	  def ast
-            c.empty? ? [] : c.ast
+            joined_clauses.ast
 	  end
-
-          def conditions
-            c.empty? ? [] : c.condition_list
-          end
         }
       end