activefacts 0.8.6 → 0.8.8

data/lib/activefacts/api/support.rb

@@ -25,7 +25,9 @@ class String #:nodoc:
   end
 
   def camelwords
-    gsub(/([a-z])([A-Z])/,'\1_\2').split(/[_\s]+/)
+    gsub(/-([a-zA-Z])/){ $1.upcase }.                 # Break and upcase on hyphenated words
+      gsub(/([a-z])([A-Z])/,'\1_\2').
+      split(/[_\s]+/)
   end
 end
 

data/lib/activefacts/api/vocabulary.rb

@@ -36,6 +36,10 @@ module ActiveFacts
         Constellation.new(self)
       end
 
+      def populate &b
+        constellation.populate &b
+      end
+
       def verbalise
         "Vocabulary #{name}:\n\t" +
           @concept.keys.sort.map{|concept|

data/lib/activefacts/cql/CQLParser.treetop

@@ -27,33 +27,45 @@ module ActiveFacts
         }
       end
 
-      # Each definition has a value() method that returns an array like
-      # either [name, [kind, definition]] or [name, kind]:
+      # Each definition has an ast() method that returns an instance of a subclass of Compiler::Definition
       rule definition
+	definition_body s
+	{
+	  def ast
+	    definition_body.ast
+	  end
+
+	  def body
+	    definition_body.text_value
+	  end
+	}
+      end
+
+      rule definition_body
         vocabulary_definition
         / import_definition
-	/ prescan
+        / prescan           # Always fails, but its side-effects are needed in the following
         / constraint
-        / unit_definition
+        / unit_definition   # REVISIT: Move this above the prescan?
         / concept
+	/ s ';' s { def ast; nil; end }
       end
 
       rule vocabulary_definition
-        s vocabulary S id s ';' s &{|e| input.context.vocabulary(e[3].text_value); true }
+        s vocabulary S id s ';'
         {
-          def value
-            [ id.value, [ :vocabulary ] ]
-          end
+	  def ast
+	    Compiler::Vocabulary.new(id.value)
+	  end
         }
       end
 
       rule import_definition
-        s import S id alias_list ';' s
+        s import S id alias_list ';'
         {
-          def value
-            puts "import #{id.value}: not implemented"
-            [ id.value, [ :import ], alias_list.value ]
-          end
+	  def ast
+	    Compiler::Import.new(id.value, alias_list.value)
+	  end
         }
       end
 
@@ -76,63 +88,99 @@ module ActiveFacts
       end
 
       rule enforcement
-	s '(' s otherwise s action s agent? s ')' s
-	  { def value; [action.text_value, agent.empty? ? nil : agent.text_value]; end }
+	s '(' s otherwise s action s a:agent? s ')' s
+	  {
+	    def ast; Compiler::Enforcement.new(action.text_value, a.empty? ? nil : a.text_value); end
+	  }
 	/
 	''
-	  { def value; []; end }
+	  {
+	    def ast; nil; end
+	  }
       end
 
       # presence constraint:
       rule presence_constraint
-        s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' s enforcement 'in' s
+        s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' 's'? s enforcement 'in' s
         readings_list s
-        c:context? ';' s
-        { def value; [ nil, [ :constraint, :presence, role_list.roles, quantifier.value, readings_list.value, c.empty? ? nil : c.value, enforcement.value ] ]; end }
+        c:context_note? ';'
+        {
+	  def ast
+	    context_note = c.empty? ? nil : c.ast
+	    Compiler::PresenceConstraint.new context_note, enforcement.ast, readings_list.ast, role_list.ast, quantifier.ast
+	  end
+	}
       end
 
       # set (exclusion, mandatory exclusion, complex equality) constraint
       rule set_constraint
         s 'for' s 'each' s role_list s quantifier s 'of' s 'these' s 'holds' s enforcement ':' s
           readings_list s
-          c:context? ';' s
-          { def value; [ nil, [ :constraint, :set, role_list.roles, quantifier.value, readings_list.value, c.empty? ? nil : c.value, enforcement.value ] ]; end }
+          c:context_note? ';'
+          {
+	    def ast
+	      context_note = c.empty? ? nil : c.ast
+	      Compiler::SetExclusionConstraint.new context_note, enforcement.ast, readings_list.ast, role_list.ast, quantifier.ast
+	    end
+	  }
         /
-        s either? s r1:readings s or s r2:readings exclusion:(but s not s both s)? c:context? enforcement ';' s
-          { def value;
-              [ nil, [ :constraint, :set,
-                nil,  # No roles names, rely on the join
-                exclusion.text_value.empty? ?
-                  [1, nil] :		# At least one (meaning 1 or 2/more)
-                  [1,1],                # Exactly one (1 and only 1)
-                [r1.value, r2.value],
-                c.empty? ? nil : c.value,
-		enforcement.value
-              ] ];
-            end
+        s either? s r1:readings s or s r2:readings exclusion:(but s not s both s)? c:context_note? enforcement ';'
+          {
+	    def ast
+	      context_note = c.empty? ? nil : c.ast
+
+	      if exclusion.text_value.empty?
+		Compiler::PresenceConstraint.new context_note, enforcement.ast, [r1.ast, r2.ast], nil, Compiler::Quantifier.new(1, nil)
+	      else
+		quantifier = Compiler::Quantifier.new(*(exclusion.text_value.empty? ? [1, nil] : [1, 1]))
+		#quantifier = Compiler::Quantifier.new(1, 1)
+		Compiler::SetExclusionConstraint.new context_note, enforcement.ast, [r1.ast, r2.ast], nil, quantifier
+	      end
+	    end
           }
       end
 
       rule subset_constraint
         s readings s only s if s r2:readings s
-        c:context? enforcement ';' s
-        { def value; [ nil, [ :constraint, :subset, [readings.value, r2.value], c.empty? ? nil : c.value, enforcement.value ] ]; end }
+        c:context_note? enforcement ';'
+        {
+	  def ast
+	    context_note = c.empty? ? nil : c.ast
+	    Compiler::SubsetConstraint.new context_note, enforcement.ast, [readings.ast, r2.ast]
+	  end
+	}
       end
 
       rule equality_constraint
         s readings s tail:( if s and s only s if s readings s)+
-        c:context? enforcement ';' s
-        { def value; [ nil, [ :constraint, :equality, [readings.value] + tail.elements.map{|e| e.readings.value }, c.empty? ? nil : c.value, enforcement.value ]]; end }
+        c:context_note? enforcement ';'
+        {
+	  def ast
+	    context_note = c.empty? ? nil : c.ast
+	    all_readings = [readings.ast, *tail.elements.map{|e| e.readings.ast }]
+	    Compiler::SetEqualityConstraint.new context_note, enforcement.ast, all_readings
+	  end
+	}
       end
 
       rule readings_list
         readings tail:( ',' s readings )*
-        { def value; [readings.value]+tail.elements.map{|e| e.readings.value }; end }
+        {
+	  def ast
+	    [readings.ast, *tail.elements.map{|e| e.readings.ast }]
+	  end
+	}
       end
 
       rule readings
         reading s tail:( and s reading s )*
-        { def value; [reading.value]+tail.elements.map{|e| e.reading.value }; end }
+        {
+	  def ast
+	    readings = reading.ast
+	    tail.elements.map{|e| readings += e.reading.ast }
+	    readings
+	  end
+	}
       end
 
     end

data/lib/activefacts/cql/Concepts.treetop

@@ -17,20 +17,24 @@ module ActiveFacts
       rule entity_type
         s term_definition_name
         sup:(basetype / subtype)
-                &{|e| input.context.entity_type(e[1].value); true }
+	  &{|s|
+	    # There's an implicit type when we use an identification mode, register it:
+	    mode = s[2].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?
-        ';' s
+        ';'
         {
-          def defined_type
-            [ :entity_type, sup.supers, sup.identifier, mapping_pragmas.value, (ec.empty? ? nil : ec.conditions) ]
-          end
-
-          def value
-            [ term_definition_name.value,
-              defined_type
-            ]
-          end
+	  def ast
+	    name = term_definition_name.value
+	    readings = ec.empty? ? [] : ec.ast
+	    Compiler::EntityType.new name, sup.supers, sup.ast, mapping_pragmas.value, readings
+	  end
         }
       end
 
@@ -38,8 +42,10 @@ module ActiveFacts
         is s
         # independency?
         identification
-        { def supers; [] end
-          def identifier; identification.value; end
+        {
+	  def ast; identification.ast; end
+	  def supers; []; end
+          def identification_mode; identification.mode; end
         }
       end
 
@@ -48,8 +54,9 @@ module ActiveFacts
         # independency?
         supertype_list ident:identification?
         {
+	  def ast; ident.empty? ? nil : ident.ast; end
           def supers; supertype_list.value; end
-          def identifier; ident.empty? ? nil : ident.value; end
+          def identification_mode; ident.empty? ? nil : ident.mode; end
         }
       end
 
@@ -59,80 +66,95 @@ module ActiveFacts
       end
 
       rule supertype_list
-        primary:id s
-        alternate_supertypes:( ',' s !identified_by name:id s )*
-        { def value
-            [primary.value]+alternate_supertypes.elements.map{|sup| sup.name.value}
-          end
-        }
+        primary:term s alternate_supertypes:( ',' 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 id value_type_parameters
-	r:(restriction enforcement)?          # Reference Mode; restriction may be needed for the ValueType
-          { def value
-	      { :mode => id.value,
-	        :restriction => (r.text_value.empty? ? nil : r.restriction.ranges),
-	        :enforcement => (r.text_value.empty? ? nil : r.enforcement.value),
-		:parameters => value_type_parameters.values
-	      }
+        identified_by its s i:(term/id) 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)
+	      end
+	      Compiler::ReferenceMode.new(i.value, value_constraint, value_type_parameters.values)
+	    end
+
+	    def mode
+	      i.value
 	    end
 	  }
         /
         identified_by role_list
-          { def value; {:roles => role_list.roles }; end }
+	  &{|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
+	      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 
-        head:role_player s tail:( ( and S / ',' s ) role:role_player s )*
+        head:term_or_unary s tail:( ( and S / ',' s ) term_or_unary s )*
         {
-          def roles
-            [head.value] + tail.elements.map{|i| i.role.value}
-          end
+	  def ast
+	    [head.ast, *tail.elements.map{|e| e.term_or_unary.ast}]
+	  end
         }
       end
 
-          # We can't tell which word is an adjective and which is a concept here.
-          # The concept might be forward-referenced, but not if adjectives are used.
-          # REVISIT: This accepts double-adjective expressions (three words) but they don't work elsewhere
-          rule lead_adj
-            role_player_id '-'
-          end
-
-          rule trail_adj
-            '-' role_player_id
-          end
-
-          rule role_player
-            l:lead_adj? tail:(s role_player_id)+ s t:trail_adj?
-            {
-              def value
-                (l.empty? ? [] : [l.role_player_id.value]) +
-                tail.elements.map{|e| e.role_player_id.value } +
-                (t.empty? ? [] : [t.role_player_id.value])
-              end
-            }
-          end
-
-          rule role_player_id
-            !(role_list_sep / quantifier) id
-            { def value; id.value; end }
-          end
-
-          rule role_list_sep
-            (where / and / 'occurs')
-          end
-
-          rule reference_mode
-            # REVISIT: Adopt ORM2-style reference mode patterns here
-            '(' s '.' s mode_name:id s ')' s
-          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?
+	  {
+	    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::Reading.new(pre_words + [t] + post_words, [], nil)
+	      end
+	    end
+	  }
+	/
+	s !non_role_word id s &non_role_word 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)
+	    end
+	  }
+      end
 
       rule mapping_pragmas
         '[' s h:mapping_pragma t:(s ',' s mapping_pragma)* s ']' s
-          { def value; [h.value] + t.elements.map{|e| e.mapping_pragma.value}; end }
+          { def value; t.elements.inject([h.value]) { |a, e| a << e.mapping_pragma.value }; end }
         /
         ''
           { def value; []; end }
@@ -146,6 +168,10 @@ module ActiveFacts
       rule entity_conditions
         (':' / where) s c:conditions?
         {
+	  def ast
+            c.empty? ? [] : c.ast
+	  end
+
           def conditions
             c.empty? ? [] : c.condition_list
           end

data/lib/activefacts/cql/Context.treetop

@@ -7,11 +7,20 @@
 module ActiveFacts
   module CQL
     grammar Context
-      rule context
+      rule context_note
         '('
         w:who_says? s context_type discussion agreed:(',' a:as_agreed_by)? s
         ')'
-        { def value; [ w.empty? ? nil : w.value, context_type.value, discussion.text_value, agreed.empty? ? [] : agreed.a.value]; end }
+        {
+	  def value
+	    [ w.empty? ? nil : w.value, context_type.value, discussion.text_value, agreed.empty? ? [] : agreed.a.value]
+	  end
+	  def ast
+	    who = w.empty? ? nil : w.value
+	    ag = agreed.empty? ? [] : agreed.a.value
+	    Compiler::ContextNote.new context_type.value, discussion.text_value, who, ag
+	  end
+	}
       end
 
       rule who_says