activefacts 1.1.0 → 1.2.0

data/lib/activefacts/cql/compiler/clause.rb

@@ -37,8 +37,8 @@ module ActiveFacts
           to_s
         end
 
-        def inspect phrases = nil
-          to_s(phrases||@phrases)
+        def inspect
+          to_s
         end
 
         def to_s phrases = nil
@@ -52,21 +52,34 @@ module ActiveFacts
             # else 'definitely '
             end
           }#{
-            quotes = false
-            phrases.inject(""){|s, p|
-              if String === p
-                s + (quotes ? '' : (quotes = true; '"')) + p.to_s + ' '
-#              REVISIT: Add something here when I re-add functions
-#              elsif FunctionCallChain === p
-#                s[0..-2] + (quotes ? (quotes = false; '" ') : '') + p.to_s
-              else # if Reference === p
-                s[0..-2] + (quotes ? (quotes = false; '" ') : '') + p.to_s +
-                  ((oj = p.nested_clauses) ?  ' ('+ oj.map{|c| ((j=c.conjunction) ? j+' ' : '') + c.to_s}*' ' + ')' : '') +
-                ' '
-#              else
-#                raise "Unexpected phrase type in clause: #{p.to_s}"
-              end
-            }.sub(/ $/,'') + (quotes ? '"' : '')
+	    (
+	      phrases.map do |phrase|
+		case phrase
+		when String
+		  '"' + phrase.to_s + '"'
+		when Reference
+		  phrase.to_s +
+		    if phrase.nested_clauses
+		      ' (in which ' +
+			phrase.nested_clauses.map do |c|
+			  ((j = c.conjunction) ? j+' ' : '') +
+			    c.to_s
+			end*' ' +
+		      ')'
+		    else
+		      ''
+		    end
+		when Operation
+		  phrase.inspect
+		when Literal
+		  phrase.inspect
+		#when FunctionCallChain		# REVISIT: Add something here when I re-add functions
+		#  phrase.inspect
+		else
+		  raise "Unexpected phrase type in clause: #{phrase.class}"
+		end
+	      end * ' '
+	    ).gsub(/" "/, ' ')
           }#{
             @context_note && ' ' + @context_note.inspect
           }"
@@ -131,6 +144,22 @@ module ActiveFacts
         def match_existing_fact_type context, options = {}
           raise "Cannot match a clause that contains no object types" if refs.size == 0
           raise "Internal error, clause already matched, should not match again" if @fact_type
+
+	  if is_naked_object_type
+	    ref = refs[0]	# "There can be only one"
+	    return true unless ref.nested_clauses
+	    ref.nested_clauses.each do |nested|
+	      ft = nested.match_existing_fact_type(context)
+	      raise "Unrecognised fact type #{nested.display} nested under #{inspect}" unless ft
+	      if (ft.entity_type == ref.player)
+		ref.objectification_of = ft
+		nested.objectified_as = ref
+	      end
+	    end
+	    raise "#{ref.inspect} contains objectification steps that do not objectify it" unless ref.objectification_of
+	    return true
+	  end
+
           # If we fail to match, try a left contraction (or save this for a subsequent left contraction):
           left_contract_this_onto = context.left_contractable_clause
           new_conjunction = (conjunction == nil || conjunction == ',')
@@ -195,7 +224,7 @@ module ActiveFacts
 
             player_names = players.map{|p| p.name}
 
-            trace :matching, "Looking for existing #{players.size}-ary fact types matching '#{inspect(phrases)}'" do
+            trace :matching, "Looking for existing #{players.size}-ary fact types matching '#{inspect}'" do
               trace :matching, "Players are '#{player_names.inspect}'"
 
               # Match existing fact types in nested clauses first:
@@ -204,12 +233,12 @@ module ActiveFacts
                 vrs.each do |ref|
                   next if ref.is_a?(Operation)
                   next unless steps = ref.nested_clauses and !steps.empty?
-                  ref.nested_clauses.each do |oj|
-                    ft = oj.match_existing_fact_type(context)
-                    raise "Unrecognised fact type #{oj.display}" unless ft
+                  ref.nested_clauses.each do |nested|
+                    ft = nested.match_existing_fact_type(context)
+                    raise "Unrecognised fact type #{nested.display}" unless ft
                     if (ft && ft.entity_type == ref.player)
                       ref.objectification_of = ft
-                      oj.objectified_as = ref
+                      nested.objectified_as = ref
                     end
                   end
                   raise "#{ref.inspect} contains objectification steps that do not objectify it" unless ref.objectification_of
@@ -883,7 +912,7 @@ module ActiveFacts
         end
 
         def includes_literals
-          @nested_clauses && @nested_clauses.detect{|oj| oj.includes_literals}
+          @nested_clauses && @nested_clauses.detect{|nested| nested.includes_literals}
         end
 
         # We create value types for the results of arithmetic expressions, and they get assigned here:
@@ -1064,6 +1093,7 @@ module ActiveFacts
         end
       end
 
+      # REVISIT: This needs to handle annotations for some/that/which, etc.
       class Quantifier
         attr_accessor :enforcement
         attr_accessor :context_note

data/lib/activefacts/cql/compiler/entity_type.rb

@@ -170,10 +170,6 @@ module ActiveFacts
         end
 
         def create_identifying_fact_type context, clauses
-          # Remove uninteresting assertions:
-          clauses.reject!{|clause| clause.is_existential_type }
-          return nil unless clauses.size > 0    # Nothing interesting was said.
-
           # See if any fact type already exists (this ET cannot be a player, but might objectify it)
           existing_clauses = clauses.select{ |clause| clause.match_existing_fact_type context }
 	  if negation = existing_clauses.detect{|c| c.certainty == false }

data/lib/activefacts/cql/compiler/expression.rb

@@ -137,10 +137,6 @@ module ActiveFacts
           @fact_type
         end
 
-        def is_existential_type
-          false
-        end
-
         def is_equality_comparison
           false
         end
@@ -179,7 +175,7 @@ module ActiveFacts
         end
 
         def result_type_name(context)
-          "compare#{operator}(#{[@e1,@e2].map{|e| e.player.name}*', '}))"
+          "COMPARE#{operator}<#{[@e1,@e2].map{|e| e.player.name}*' WITH '})>"
         end
 
         def is_equality_comparison
@@ -210,7 +206,7 @@ module ActiveFacts
         def inspect; to_s; end
 
         def to_s
-          "compare#{
+          "COMPARE#{
 	    operator
 	  }(#{
 	    case @certainty
@@ -220,7 +216,7 @@ module ActiveFacts
 	    end
           }#{
 	    e1.to_s
-	  } #{
+	  } WITH #{
 	    e2.to_s
 	  }#{
 	    @qualifiers.empty? ? '' : ', ['+@qualifiers*', '+']'
@@ -255,7 +251,7 @@ module ActiveFacts
         end
 
         def result_type_name(context)
-          "sum(#{ @terms.map{|f| f.player.name}*', ' })"
+          "SUM_OF<#{ @terms.map{|f| f.player.name}*', ' }>"
         end
 
 =begin
@@ -269,7 +265,7 @@ module ActiveFacts
         def inspect; to_s; end
 
         def to_s
-          'sum(' + @terms.map{|term| "#{term.to_s}" } * ' ' + ')'
+          'SUM(' + @terms.map{|term| "#{term.to_s}" } * ' PLUS ' + ')'
         end
       end
 
@@ -299,7 +295,7 @@ module ActiveFacts
         end
 
         def result_type_name(context)
-          "product(#{ @factors.map{|f| f.player.name}*', ' })"
+          "PRODUCT_OF<#{ @factors.map{|f| f.player.name}*' ' }>"
         end
 
 =begin
@@ -313,7 +309,7 @@ module ActiveFacts
         def inspect; to_s; end
 
         def to_s
-          'product(' + @factors.map{|factor| "#{factor.to_s}" } * ' ' + ')'
+          'PRODUCT(' + @factors.map{|factor| "#{factor.to_s}" } * ' TIMES ' + ')'
         end
       end
 
@@ -350,7 +346,7 @@ module ActiveFacts
         def inspect; to_s; end
 
         def to_s
-          "reciprocal(#{factor.to_s})"
+          "RECIPROCAL(#{factor.to_s})"
         end
       end
 
@@ -381,7 +377,7 @@ module ActiveFacts
         def inspect; to_s; end
 
         def to_s
-          "negate(#{term.to_s})"
+          "NEGATIVE(#{term.to_s})"
         end
       end
 

data/lib/activefacts/cql/compiler/fact.rb

@@ -24,7 +24,7 @@ module ActiveFacts
 
           # Figure out the simple existential facts and find fact types:
           @bound_facts = []
-          @unbound_clauses = all_clauses.
+          @unbound_clauses = all_clauses(@clauses).
             map do |clause|
               bind_literal_or_fact_type clause
             end.
@@ -53,7 +53,7 @@ module ActiveFacts
             player = ref.binding.player
             # raise "A literal may not be an objectification" if ref.role_ref.nested_clauses
             # raise "Not processing facts involving nested clauses yet" if ref.role_ref
-            trace :instance, "Making #{player.class.basename} #{player.name} using #{l.inspect}" do
+            trace :instance_detail, "Making #{player.class.basename} #{player.name} using #{l.inspect}" do
               ref.binding.instance = instance_identified_by_literal(player, l)
             end
             ref
@@ -92,8 +92,8 @@ module ActiveFacts
               true
             end
 
-          trace :instance, "Considering '#{clause.display}' with "+
-            (bare_roles.empty? ? "no bare roles" : "bare roles: #{bare_roles.map{|ref| ref.player.name}*", "}") do
+	  trace :instance_detail, "Considering '#{clause.display}' with "+
+	    (bare_roles.empty? ? "no bare roles" : "bare roles: #{bare_roles.map{|ref| ref.player.name}*", "}") do
 
             # If all the roles are in place, we can bind the rest of this clause:
             return true if bare_roles.size == 0 && bind_complete_fact(clause)
@@ -109,7 +109,7 @@ module ActiveFacts
             end
 
             return true if progress
-            trace :instance, "Can't make progress on '#{clause.display}'"
+            trace :instance_detail, "Delaying until all role players are asserted: #{clause.fact_type.default_reading.inspect}"
             nil
           end
         end
@@ -120,37 +120,36 @@ module ActiveFacts
           @pass += 1
 
           progress = false
-          trace :instance, "Pass #{@pass} with #{@unbound_clauses.size} clauses to consider" do
+          trace :instance_detail, "Pass #{@pass} with #{@unbound_clauses.size} clauses to consider" do
             @unbound_clauses =
               @unbound_clauses.select do |clause|
                 action = bind_clause(clause)
                 progress = true if action
                 !action
               end
-            trace :instance, "end of pass, unbound clauses are #{@unbound_clauses.map(&:display)*', '}"
+            trace :instance_detail, "end of pass, unbound clauses are #{@unbound_clauses.map(&:display)*', '}"
           end # debug
           progress
         end
 
-        # Occasionally we need to search through all the clauses:
-        def all_clauses
-          @clauses.map do |clause|
-            [clause] + clause.refs.map{|vr| vr.nested_clauses}
+        # Occasionally we need to search through all the clauses. This builds a flat list
+        def all_clauses clauses
+          clauses.map do |clause|
+            [clause] + clause.refs.map{|vr| vr.nested_clauses ? all_clauses(vr.nested_clauses) : []}
           end.flatten.compact
         end
 
         def bind_complete_fact clause
           return true unless clause.fact_type  # An bare objectification
-          trace :instance, "All bindings in '#{clause.display}' contain instances; assert the fact type"
           instances = clause.refs.map{|vr| vr.binding.instance }
-          trace :instance, "Instances are #{instances.map{|i| "#{i.verbalise}"}*", "}"
+          trace :instance_detail, "All role players exist for #{clause.display.inspect} exist: #{instances.map{|i| "#{i.verbalise}"}*", "}"
 
           if e = clause.fact_type.entity_type and
             clause.refs[0].binding.instance.object_type == e
             fact = clause.refs[0].binding.instance.fact
           else
             # Check that this fact doesn't already exist
-	    trace :instance, "Searching for existing fact instance"
+	    trace :instance_detail, "Searching for existing fact instance"
 
             fact = clause.fact_type.all_fact.detect do |f|
 
@@ -165,26 +164,27 @@ module ActiveFacts
           end
           if fact
             clause.fact = fact
-            trace :instance, "Found existing fact"
+            trace :instance, "Already known: #{fact.verbalise.inspect}"
           else
-            trace :instance, "Creating new fact of type #{clause.fact_type.default_reading}"
+            trace :instance_detail, "Asserting fact of type #{clause.fact_type.default_reading.inspect}"
             fact =
               clause.fact =
               @constellation.Fact(:new, :fact_type => clause.fact_type, :population => @population)
             @bound_facts << fact
             clause.reading.role_sequence.all_role_ref_in_order.zip(instances).each do |rr, instance|
-              trace :instance, "Assigning fact role #{instance.object_type.name} to #{instance.value ? instance.value.inspect : instance.verbalise}"
+              trace :instance_detail, "Assigning fact role #{instance.object_type.name} to #{instance.value ? instance.value.inspect : instance.verbalise}"
               # REVISIT: Any residual adjectives after the fact type matching are lost here.
               @constellation.RoleValue(:fact => fact, :instance => instance, :role => rr.role, :population => @population)
             end
+            trace :instance, "Assert #{fact.verbalise.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}" unless clause.fact_type.entity_type
           end
 
           if !fact.instance && clause.fact_type.entity_type
             # Objectified fact type; create the instance
             # Create the instance that objectifies this fact. We don't have the binding to assign it to though; that'll happen in our caller
-            trace :instance, "Objectifying fact as #{clause.fact_type.entity_type.name}"
             instance =
               @constellation.Instance(:new, :object_type => clause.fact_type.entity_type, :fact => fact, :population => @population)
+            trace :instance, "Assert #{instance.verbalise.inspect}"
             @bound_facts << instance
           end
 
@@ -207,23 +207,24 @@ module ActiveFacts
           return false unless identifying_binding # This happens when we have a bare objectification
           identifying_instance = identifying_binding.instance
           preferred_identifier = entity_type.preferred_identifier
+	  role_count = preferred_identifier.role_sequence.all_role_ref.size 
 
-          trace :instance, "This clause associates a new #{binding.player.name} with a #{identifying_binding.player.name}#{identifying_instance ? " which exists" : ""}"
+          trace :instance, "A #{binding.player.name} is #{role_count > 1 ? 'partly ':''}identified in #{clause.inspect}"
 
           identifying_role_ref = preferred_identifier.role_sequence.all_role_ref.detect { |rr|
               rr.role.fact_type == clause.fact_type && rr.role.object_type == identifying_binding.player
             }
           unless identifying_role_ref
-            # This shold never happen; we already bound all refs
+            # This should never happen; we already bound all refs
             trace :instance, "Failed to find a #{identifying_instance.object_type.name}"
             return false # We can't do this yet
           end
           role_value = identifying_instance.all_role_value.detect do |rv|
             rv.fact.fact_type == identifying_role_ref.role.fact_type
           end
-          if role_value
+          if role_value && role_count == 1
             instance = (role_value.fact.all_role_value.to_a-[role_value])[0].instance
-            trace :instance, "Found an existing instance (of #{instance.object_type.name}) from a previous definition"
+            trace :instance, "Existential fact already known: #{instance.verbalise.inspect}"
             binding.instance = instance
             return true  # Done with this clause
           end
@@ -234,7 +235,7 @@ module ActiveFacts
           identifiers =
             pi_role_refs.map do |rr|
               # Find a clause that provides the identifying_ref for this player:
-              identifying_clause = all_clauses.detect do |clause|
+              identifying_clause = all_clauses(@clauses).detect do |clause|
                 rr.role.fact_type == clause.fact_type &&
                   clause.refs.detect{|vr| vr.binding == binding}
               end
@@ -250,22 +251,21 @@ module ActiveFacts
             return false
           end
 
-          trace :instance, "Creating Entity #{binding.player.name} using #{identifiers.size} roles" do
-            instance = @constellation.Instance(:new, :object_type => entity_type, :population => @population)
-            binding.instance = instance
-            @bound_facts << instance
-            identifiers.each do |rr, identifying_clause, identifying_binding, identifying_instance|
-              # This clause provides the identifying literal for the entity_type
-	      trace :instance, "Creating existential fact #{rr.role.fact_type.default_reading} for value #{identifying_instance.value.inspect}"
-              id_fact =
-                identifying_clause.fact =
-                @constellation.Fact(:new, :fact_type => rr.role.fact_type, :population => @population)
-              @bound_facts << id_fact
-              role = (rr.role.fact_type.all_role.to_a-[rr.role])[0]
-              @constellation.RoleValue(:instance => instance, :fact => id_fact, :population => @population, :role => role)
-              @constellation.RoleValue(:instance => identifying_instance, :fact => id_fact, :role => rr.role, :population => @population)
-            end
-          end
+	  instance = @constellation.Instance(:new, :object_type => entity_type, :population => @population)
+	  binding.instance = instance
+	  @bound_facts << instance
+	  identifiers.each do |rr, identifying_clause, identifying_binding, identifying_instance|
+	    # This clause provides the identifying literal for the entity_type
+	    id_fact =
+	      identifying_clause.fact =
+	      @constellation.Fact(:new, :fact_type => rr.role.fact_type, :population => @population)
+	    @bound_facts << id_fact
+	    role = (rr.role.fact_type.all_role.to_a-[rr.role])[0]
+	    @constellation.RoleValue(:instance => instance, :fact => id_fact, :population => @population, :role => role)
+	    @constellation.RoleValue(:instance => identifying_instance, :fact => id_fact, :role => rr.role, :population => @population)
+	    trace :instance, "Assert #{id_fact.verbalise.inspect} (existential) #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
+	  end
+	  trace :instance, "Assert #{instance.verbalise.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
 
           true  # Done with this clause
         end
@@ -274,29 +274,29 @@ module ActiveFacts
           if object_type.is_a?(ActiveFacts::Metamodel::EntityType)
             entity_identified_by_literal object_type, literal
           else
-            trace :instance, "Assert Value #{object_type.name} #{literal.inspect}" do
+            trace :instance_detail, "Assert Value #{object_type.name} #{literal.inspect}" do
               is_literal_string = literal.literal.is_a?(String)
 	      # REVISIT: Check for subtypes and supertypes also, and promote type if necessary
 	      instance = object_type.all_instance.detect do |i|
               #instance = @constellation.Instance.detect do |key, i|
                   # REVISIT: And same unit
-		  trace :instance, "Comparing #{i.value.literal.inspect} to #{literal.literal.inspect}"
+		  trace :instance_detail2, "Comparing #{i.value.literal.inspect} to #{literal.literal.to_s.inspect}"
                   i.population == @population &&
                     i.value &&
-                    i.value.literal.inspect == literal.literal.inspect &&
+                    i.value.literal.inspect == literal.literal.to_s.inspect &&
                     i.value.is_literal_string == is_literal_string
                 end
               #instance = object_type.all_instance.detect { |instance|
               #  instance.population == @population && instance.value == literal
               #}
 	      if instance
-		trace :instance, "This #{object_type.name} value already exists"
+		trace :instance, "Instance already known: #{instance.verbalise.inspect}"
               else
-		trace :instance, "Creating Value #{object_type.name} #{literal.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
                 instance = @constellation.Instance(:new)
                 instance.object_type = object_type
                 instance.population = @population
                 instance.value = [literal.to_s, is_literal_string, nil]
+		trace :instance, "Assert #{instance.verbalise.inspect} #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
                 @bound_facts << instance
               end
               instance
@@ -307,7 +307,7 @@ module ActiveFacts
         def entity_identified_by_literal object_type, literal
           # A literal that identifies an entity type means the entity type has only one identifying role
           # That role is played either by a value type, or by another similarly single-identified entity type
-          trace :instance, "Assert Entity #{object_type.name} identified by '#{literal}'" do
+          trace :instance_detail, "Assert Entity #{object_type.name} identified by '#{literal}'" do
             identifying_role_refs = object_type.preferred_identifier.role_sequence.all_role_ref
             raise "Single literal cannot satisfy multiple identifying roles for #{object_type.name}" if identifying_role_refs.size > 1
             role = identifying_role_refs.single.role
@@ -323,19 +323,20 @@ module ActiveFacts
             }
             if instance_rv
               instance = existing_instance
-              trace :instance, "This #{object_type.name} entity already exists"
+	      trace :instance, "Already known: #{instance.verbalise.inspect}"
             else
               # This fact has no clause.
-	      trace :instance, "Creating implicit existential fact #{role.fact_type.default_reading}"
+	      trace :instance_detail, "Creating implicit existential fact #{role.fact_type.default_reading}"
               fact = @constellation.Fact(:new, :fact_type => role.fact_type, :population => @population)
               @bound_facts << fact
               # This instance will be associated with its binding by our caller
               instance = @constellation.Instance(:new, :object_type => object_type, :population => @population)
-	      trace :instance, "Creating Entity #{object_type.name} identified by '#{literal}' #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
+	      trace :instance_detail, "Creating Entity #{object_type.name} identified by '#{literal}' #{@population.name.size>0 ? " in "+@population.name.inspect : ''}"
               @bound_facts << instance
               # The identifying fact type has two roles; create both role instances:
               @constellation.RoleValue(:instance => identifying_instance, :fact => fact, :population => @population, :role => role)
               @constellation.RoleValue(:instance => instance, :fact => fact, :population => @population, :role => (role.fact_type.all_role-[role])[0])
+	      trace :instance, "Assert #{instance.verbalise.inspect}"
             end
             instance
           end