activefacts 1.0.2 → 1.1.0

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

@@ -13,7 +13,7 @@ module ActiveFacts
         end
 
         def prepare_roles clauses = nil
-          debug :binding, "preparing roles" do
+          trace :binding, "preparing roles" do
             @context ||= CompilationContext.new(@vocabulary)
             @context.bind clauses||[], @conditions, @returning
           end
@@ -28,7 +28,7 @@ module ActiveFacts
 
           # Build the query:
           unless @conditions.empty? and !@returning
-            debug :query, "building query for derived fact type" do
+            trace :query, "building query for derived fact type" do
               @query = build_variables(@conditions.flatten)
               @roles_by_binding = build_all_steps(@conditions)
               @query.validate
@@ -43,7 +43,7 @@ module ActiveFacts
           @conditions.each do |condition|
             next if condition.is_naked_object_type
             # REVISIT: Many conditions will imply a number of different steps, which need to be handled (similar to nested_clauses).
-            debug :projection, "matching condition fact_type #{condition.inspect}" do
+            trace :projection, "matching condition fact_type #{condition.inspect}" do
               fact_type = condition.match_existing_fact_type @context
               raise "Unrecognised fact type #{condition.inspect} in #{self.class}" unless fact_type
             end
@@ -131,7 +131,7 @@ module ActiveFacts
             @existing_clauses = [first_clause]
           elsif (n = @clauses.size - @existing_clauses.size) > 0
 	    raise "Cannot extend a negated fact type" if @existing_clauses.detect {|clause| clause.certainty == false }
-            debug :binding, "Extending existing fact type with #{n} new readings"
+            trace :binding, "Extending existing fact type with #{n} new readings"
           end
 
           # Now make any new readings:
@@ -236,7 +236,7 @@ module ActiveFacts
           return nil if fact_types.empty?   # There are no matched fact types
 
           if @clauses.size == 1 && @existing_clauses[0].side_effects.cost != 0
-            debug :matching, "There's only a single clause, but it's not an exact match"
+            trace :matching, "There's only a single clause, but it's not an exact match"
             return nil
           end
 
@@ -283,9 +283,9 @@ module ActiveFacts
 
           # We need to check uniqueness constraints after processing the whole vocabulary
           # raise "Fact type must be named as it has no identifying uniqueness constraint" unless @name || @fact_type.all_role.size == 1
-	  debug :constraint, "Need to check #{@fact_type.default_reading.inspect} for a uniqueness constraint"
+	  trace :constraint, "Need to check #{@fact_type.default_reading.inspect} for a uniqueness constraint"
           fact_type.check_and_add_spanning_uniqueness_constraint = proc do
-	    debug :constraint, "Checking #{@fact_type.default_reading.inspect} for a uniqueness constraint"
+	    trace :constraint, "Checking #{@fact_type.default_reading.inspect} for a uniqueness constraint"
 	    existing_pc = nil
             found = @fact_type.all_role.
 		detect do |role|
@@ -312,9 +312,9 @@ module ActiveFacts
 		:max_frequency => 1,
 		:is_preferred_identifier => true # (prefer || !!@fact_type.entity_type)
 	      )
-	      debug :constraint, "Made new fact type implicit PC GUID=#{pc.concept.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
+	      trace :constraint, "Made new fact type implicit PC GUID=#{pc.concept.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
 	    elsif pc
-	      debug :constraint, "Will rely on existing UC GUID=#{pc.concept.guid} #{pc.name} to be used as PI over #{rs.describe}"
+	      trace :constraint, "Will rely on existing UC GUID=#{pc.concept.guid} #{pc.name} to be used as PI over #{rs.describe}"
             end
 	  end
         end
@@ -349,7 +349,7 @@ module ActiveFacts
                 clauses_m = clauses_by_refs[variants[m]]
                 l_keys = variants[l]-common
                 m_keys = variants[m]-common
-                debug :binding, "Try to collapse variant #{m} onto #{l}; diffs are #{l_keys.inspect} -> #{m_keys.inspect}"
+                trace :binding, "Try to collapse variant #{m} onto #{l}; diffs are #{l_keys.inspect} -> #{m_keys.inspect}"
                 rebindings = 0
                 l_keys.each_with_index do |l_key, i|
                   # Find possible rebinding candidates; there must be exactly one.
@@ -358,19 +358,19 @@ module ActiveFacts
                     m_key = m_keys[j]
                     l_ref = refs_by_clause_and_key[[clauses_l[0], l_key]]
                     m_ref = refs_by_clause_and_key[[clauses_m[0], m_key]]
-                    debug :binding, "Can we match #{l_ref.inspect} (#{i}) with #{m_ref.inspect} (#{j})?"
+                    trace :binding, "Can we match #{l_ref.inspect} (#{i}) with #{m_ref.inspect} (#{j})?"
                     next if m_ref.player != l_ref.player
                     if has_more_adjectives(m_ref, l_ref)
-                      debug :binding, "can rebind #{m_ref.inspect} to #{l_ref.inspect}"
+                      trace :binding, "can rebind #{m_ref.inspect} to #{l_ref.inspect}"
                       candidates << [m_ref, l_ref]
                     elsif has_more_adjectives(l_ref, m_ref)
-                      debug :binding, "can rebind #{l_ref.inspect} to #{m_ref.inspect}"
+                      trace :binding, "can rebind #{l_ref.inspect} to #{m_ref.inspect}"
                       candidates << [l_ref, m_ref]
                     end
                   end
 
-                  # debug :binding, "found #{candidates.size} rebinding candidates for this role"
-                  debug :binding, "rebinding is ambiguous so not attempted" if candidates.size > 1
+                  # trace :binding, "found #{candidates.size} rebinding candidates for this role"
+                  trace :binding, "rebinding is ambiguous so not attempted" if candidates.size > 1
                   if (candidates.size == 1)
                     candidates[0][0].rebind_to(@context, candidates[0][1])
                     rebindings += 1
@@ -379,7 +379,7 @@ module ActiveFacts
                 end
                 if (rebindings == l_keys.size)
                   # Successfully rebound this fact type
-                  debug :binding, "Successfully rebound clauses #{clauses_l.map{|r|r.inspect}*'; '} on to #{clauses_m.map{|r|r.inspect}*'; '}"
+                  trace :binding, "Successfully rebound clauses #{clauses_l.map{|r|r.inspect}*'; '} on to #{clauses_m.map{|r|r.inspect}*'; '}"
                   break
                 else
                   # No point continuing, we failed on this one.

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

@@ -4,11 +4,11 @@ module ActiveFacts
       class Definition
         # Make a Variable for every binding present in these clauses
         def build_variables(clauses_list)
-          debug :query, "Building variables" do
+          trace :query, "Building variables" do
             query = @constellation.Query(:new)
             all_bindings_in_clauses(clauses_list).
               each do |binding|
-                debug :query, "Creating variable #{query.all_variable.size} for #{binding.inspect}"
+                trace :query, "Creating variable #{query.all_variable.size} for #{binding.inspect}"
                 binding.variable = @constellation.Variable(query, query.all_variable.size, :object_type => binding.player)
 		if literal = binding.refs.detect{|r| r.literal}
 		  if literal.kind_of?(ActiveFacts::CQL::Compiler::Reference)
@@ -25,7 +25,7 @@ module ActiveFacts
 
         def build_all_steps(clauses_list)
           roles_by_binding = {}
-          debug :query, "Building steps" do
+          trace :query, "Building steps" do
             clauses_list.each do |clause|
               next if clause.is_naked_object_type
               build_steps(clause, roles_by_binding)
@@ -37,7 +37,7 @@ module ActiveFacts
         def build_steps clause, roles_by_binding = {}, objectification_node = nil
           plays = []
           incidental_roles = []
-          debug :query, "Creating Role Sequence for #{clause.inspect} with #{clause.refs.size} role refs" do
+          trace :query, "Creating Role Sequence for #{clause.inspect} with #{clause.refs.size} role refs" do
             objectification_step = nil
             clause.refs.each do |ref|
               # These refs are the Compiler::References, which have associated Metamodel::RoleRefs,
@@ -62,7 +62,7 @@ module ActiveFacts
                 end
                 refs_count += objectification_ref_count
 
-                debug :query, "Creating Variable #{ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Step for #{ref.inspect}" do
+                trace :query, "Creating Variable #{ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Step for #{ref.inspect}" do
 
                   raise "Internal error: Trying to add role of #{role.object_type.name} to variable for #{binding.variable.object_type.name}" unless binding.variable.object_type == role.object_type
                   play = @constellation.Play(binding.variable, role)
@@ -81,7 +81,7 @@ module ActiveFacts
                     # This is an implicit objectification, just the FT clause, not ET(where ...clause...)
                     # We need to create a Variable for this object, even though it has no References
                     query = binding.variable.query
-                    debug :query, "Creating JN#{query.all_variable.size} for #{clause.fact_type.entity_type.name} in objectification"
+                    trace :query, "Creating JN#{query.all_variable.size} for #{clause.fact_type.entity_type.name} in objectification"
                     objectification_node = @constellation.Variable(query, query.all_variable.size, :object_type => clause.fact_type.entity_type)
                   end
                   raise "Internal error: Trying to add role of #{role.link_fact_type.all_role.single.object_type.name} to variable for #{objectification_node.object_type.name}" unless objectification_node.object_type == role.link_fact_type.all_role.single.object_type
@@ -99,14 +99,14 @@ module ActiveFacts
 		  if clause.certainty == nil
 		    objectification_step.is_optional = true
 		  end
-                  debug :query, "New #{objectification_step.describe}"
-                  debug :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{objectification_step.describe}" if incidental_roles.size > 0
+                  trace :query, "New #{objectification_step.describe}"
+                  trace :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{objectification_step.describe}" if incidental_roles.size > 0
                   incidental_roles.each { |jr| jr.step = objectification_step }
                   incidental_roles = []
                   plays = []
                 end
               else
-                debug :query, "Creating Reference for #{ref.inspect}" do
+                trace :query, "Creating Reference for #{ref.inspect}" do
                     # REVISIT: If there's an implicit subtyping step here, create it; then always raise the error here.
                     # I don't want to do this for now because the verbaliser will always verbalise all steps.
                   if binding.variable.object_type != role.object_type and
@@ -129,7 +129,7 @@ module ActiveFacts
                 # Each of these ImplicitFactTypes has a single phantom role played by the objectifying entity type
                 # One of these phantom roles is likely to be the subject of an objectification step.
                 ref.nested_clauses.each do |r|
-                  debug :query, "Building objectification step for #{ref.nested_clauses.inspect}" do
+                  trace :query, "Building objectification step for #{ref.nested_clauses.inspect}" do
                     build_steps r, roles_by_binding, binding.variable
                   end
                 end
@@ -154,8 +154,8 @@ module ActiveFacts
 		:is_disallowed => clause.certainty == false,
 		:is_optional => clause.certainty == nil
 	      )
-            debug :query, "New #{js.describe}"
-            debug :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{js.describe}" if incidental_roles.size > 0
+            trace :query, "New #{js.describe}"
+            trace :query, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{js.describe}" if incidental_roles.size > 0
             incidental_roles.each { |jr| jr.step = js }
           end
           roles_by_binding

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

@@ -35,6 +35,15 @@ module ActiveFacts
         def <=>(other)
           key <=> other.key
         end
+
+	def add_ref ref
+	  @refs << ref
+	  ref
+	end
+
+	def delete_ref ref
+	  @refs.delete ref
+	end
       end
 
       class CompilationContext

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

@@ -29,9 +29,9 @@ module ActiveFacts
           end
           @offset = nil if @offset.to_f == 0
 
-          debug :units, "Defining new unit #{@singular}#{@plural ? "/"+@plural : ""}" do
-            debug :units, "Coefficient is #{coefficient.numerator}#{coefficient.denominator != 1 ? "/#{coefficient.denominator}" : ""} #{coefficient.is_precise ? "exactly" : "approximately"}" if coefficient
-            debug :units, "Offset is #{@offset}" if @offset
+          trace :units, "Defining new unit #{@singular}#{@plural ? "/"+@plural : ""}" do
+            trace :units, "Coefficient is #{coefficient.numerator}#{coefficient.denominator != 1 ? "/#{coefficient.denominator}" : ""} #{coefficient.is_precise ? "exactly" : "approximately"}" if coefficient
+            trace :units, "Offset is #{@offset}" if @offset
             raise "Redefinition of unit #{@singular}" if @constellation.Unit.values.detect{|u| u.name == @singular}
             raise "Redefinition of unit #{@plural}" if @constellation.Unit.values.detect{|u| u.name == @plural}
             unit = @constellation.Unit(:new,
@@ -45,7 +45,7 @@ module ActiveFacts
               )
             @base_units.each do |base_unit, exponent|
               base = @constellation.Unit.values.detect{|u| u.name == base_unit || u.plural_name == base_unit }
-              debug :units, "Base unit #{base_unit}^#{exponent} #{base ? "" : "(implicitly fundamental)"}"
+              trace :units, "Base unit #{base_unit}^#{exponent} #{base ? "" : "(implicitly fundamental)"}"
               base ||= @constellation.Unit(:new, :name => base_unit, :is_fundamental => true, :vocabulary => @vocabulary)
               @constellation.Derivation(:derived_unit => unit, :base_unit => base, :exponent => exponent)
             end

data/lib/activefacts/cql/parser.rb

@@ -58,12 +58,12 @@ module ActiveFacts
         end
 
         def object_type(name, kind)
-          index_name(@terms, name) && debug(:context, "new #{kind} '#{name}'")
+          index_name(@terms, name) && trace(:context, "new #{kind} '#{name}'")
           true
         end
 
         def reset_role_names
-          debug :context, "\tresetting role names #{@role_names.keys.sort*", "}" if @role_names && @role_names.size > 0
+          trace :context, "\tresetting role names #{@role_names.keys.sort*", "}" if @role_names && @role_names.size > 0
           @role_names = {}
         end
 
@@ -72,17 +72,17 @@ module ActiveFacts
         end
 
         def new_leading_adjective_term(adj, term)
-          index_name(@role_names, "#{adj} #{term}", term) && debug(:context, "new compound term '#{adj}- #{term}'")
+          index_name(@role_names, "#{adj} #{term}", term) && trace(:context, "new compound term '#{adj}- #{term}'")
           true
         end
 
         def new_trailing_adjective_term(adj, term)
-          index_name(@role_names, "#{term} #{adj}", term) && debug(:context, "new compound term '#{term} -#{adj}'")
+          index_name(@role_names, "#{term} #{adj}", term) && trace(:context, "new compound term '#{term} -#{adj}'")
           true
         end
 
         def role_name(name)
-          index_name(@role_names, name) && debug(:context, "new role '#{name}'")
+          index_name(@role_names, name) && trace(:context, "new role '#{name}'")
           true
         end
 
@@ -98,11 +98,11 @@ module ActiveFacts
               @global_term = @term = @term_part
               @context_saver.context = {:term => @term, :global_term => @global_term }
             end
-            debug :context, "Term #{t[s] ? "is" : "starts"} '#{@term_part}'"
+            trace :context, "Term #{t[s] ? "is" : "starts"} '#{@term_part}'"
           elsif @allowed_forward_terms.include?(@term_part)
             @term = @term_part
             @context_saver.context = {:term => @term, :global_term => @term }
-            debug :context, "Term #{s} is an allowed forward"
+            trace :context, "Term #{s} is an allowed forward"
             return true
           end
           t
@@ -119,13 +119,13 @@ module ActiveFacts
             w = "role_name"
           end
           if t
-            debug :context, "Multi-word #{w} #{t[@term_part] ? 'ends at' : 'continues to'} #{@term_part.inspect}"
+            trace :context, "Multi-word #{w} #{t[@term_part] ? 'ends at' : 'continues to'} #{@term_part.inspect}"
 
             # Record the name of the full term and the underlying global term:
             if t[@term_part]
               @term = @term_part if t[@term_part]
               @global_term = (t = t[@term_part]) == true ? @term_part : t
-              debug :context, "saving context #{@term}/#{@global_term}"
+              trace :context, "saving context #{@term}/#{@global_term}"
               @context_saver.context = {:term => @term, :global_term => @global_term }
             end
           end

data/lib/activefacts/generate/cql.rb

@@ -15,8 +15,9 @@ module ActiveFacts
     #   afgen --cql <file>.cql
     class CQL < Helpers::OrderedDumper
     private
-      def vocabulary_start(vocabulary)
-        puts "vocabulary #{vocabulary.name};\n\n"
+      def vocabulary_start
+        puts "vocabulary #{@vocabulary.name};\n\n"
+	build_indices
       end
 
       def vocabulary_end
@@ -56,7 +57,7 @@ module ActiveFacts
       end
 
       def entity_type_dump(o)
-	@object_types_dumped[o] = true
+	o.ordered_dumped!
 	pi = o.preferred_identifier
 
 	supers = o.supertypes
@@ -67,7 +68,7 @@ module ActiveFacts
 	else
 	  non_subtype_dump(o, pi)
 	end
-	@constraints_used[pi] = true
+	pi.ordered_dumped! if pi
       end
 
       def append_ring_to_reading(reading, ring)
@@ -124,8 +125,8 @@ module ActiveFacts
             end
           end
         end
-        debug :mode, "Didn't find standard forward reading" unless forward_reading
-        debug :mode, "Didn't find standard reverse reading" unless reverse_reading
+        trace :mode, "Didn't find standard forward reading" unless forward_reading
+        trace :mode, "Didn't find standard reverse reading" unless reverse_reading
         [forward_reading, reverse_reading]
       end
 
@@ -149,7 +150,7 @@ module ActiveFacts
         return nil if entity_type.fact_type and
           entity_type.fact_type.all_role.detect{|role| role.object_type == value_role.object_type }
 
-        @fact_types_dumped[fact_type] = true  # We've covered this fact type
+        fact_type.ordered_dumped!  # We've covered this fact type
 
         # Elide the constraints that would have been emitted on the standard readings.
         # If there is a UC that's not in the standard form for a reference mode,
@@ -158,13 +159,13 @@ module ActiveFacts
         fact_constraints.each do |pc|
           if (pc.role_sequence.all_role_ref.size == 1 and pc.max_frequency == 1)
             # It's a uniqueness constraint, and will be regenerated
-            @constraints_used[pc] = true
+            pc.ordered_dumped!
           end
         end
 
         # Figure out which non-standard readings exist, if any:
         nonstandard_readings = fact_type.all_reading - [forward_reading, reverse_reading]
-        debug :mode, "--- nonstandard_readings.size now = #{nonstandard_readings.size}" if nonstandard_readings.size > 0
+        trace :mode, "--- nonstandard_readings.size now = #{nonstandard_readings.size}" if nonstandard_readings.size > 0
 
         verbaliser = ActiveFacts::Metamodel::Verbaliser.new
 
@@ -214,7 +215,7 @@ module ActiveFacts
         identifying_facts.each do |fact_type|
           # The RoleRefs for corresponding roles across all readings are for the same player.
           verbaliser.alternate_readings fact_type.all_reading
-          @fact_types_dumped[fact_type] = true unless fact_type.entity_type # Must dump objectification still!
+          fact_type.ordered_dumped! unless fact_type.entity_type # Must dump objectification still!
         end
         verbaliser.create_subscripts(:rolenames)
 
@@ -304,7 +305,7 @@ module ActiveFacts
         if reading_texts.size > 1
           ambiguity =
             fact_type.all_role.to_a[0].object_type.all_role.map{|r| r.fact_type}.
-              select{|f| f != fact_type && @fact_types_dumped.include?(f) }.
+              select{|f| f != fact_type && f.ordered_dumped }.
               detect do |dft|
                 ambiguous_readings =
                   reading_texts & dft.all_reading.map{|r| naiive_expand(r)}
@@ -397,16 +398,16 @@ module ActiveFacts
 
         # Tell the verbaliser all we know, so it can figure out which players to subscript:
         players = []
-        debug :subscript, "Preparing query across projected roles in set comparison constraint" do
+        trace :subscript, "Preparing query across projected roles in set comparison constraint" do
           transposed_role_refs.each do |role_refs|
             verbaliser.role_refs_have_subtype_steps role_refs
             join_over, = ActiveFacts::Metamodel.plays_over(role_refs.map{|rr| rr.role})
             players << join_over
           end
         end
-        debug :subscript, "Preparing query between roles in set comparison constraint" do
+        trace :subscript, "Preparing query between roles in set comparison constraint" do
           role_sequences.each do |role_sequence|
-            debug :subscript, "role sequence is #{role_sequence.describe}" do
+            trace :subscript, "role sequence is #{role_sequence.describe}" do
               verbaliser.prepare_role_sequence role_sequence
             end
           end
@@ -559,8 +560,8 @@ module ActiveFacts
         value_constraints = []
         roles.each do |role|
           value_constraints <<
-            if vc = role.role_value_constraint and !@constraints_used[vc]
-              @constraints_used[vc] = true
+            if vc = role.role_value_constraint and !vc.ordered_dumped
+              vc.ordered_dumped!
               vc.describe
             else
               nil
@@ -571,10 +572,10 @@ module ActiveFacts
               constraint = fact_constraints.
                 detect do |c|  # Find a UC that spans all other Roles
                   c.is_a?(ActiveFacts::Metamodel::PresenceConstraint) &&
-                    !@constraints_used[c] &&  # Already verbalised
+                    !c.ordered_dumped &&  # Already verbalised
                     roles-c.role_sequence.all_role_ref.map(&:role) == [role]
                 end
-              @constraints_used[constraint] = true if constraint
+              constraint.ordered_dumped! if constraint
               constraint && constraint.frequency
             else
               nil
@@ -585,8 +586,8 @@ module ActiveFacts
 	expanded = "it is not the case that "+expanded if (reading.is_negative)
 
         if (ft_rings = @ring_constraints_by_fact[reading.fact_type]) &&
-           (ring = ft_rings.detect{|rc| !@constraints_used[rc]})
-          @constraints_used[ring] = true
+           (ring = ft_rings.detect{|rc| !rc.ordered_dumped})
+          ring.ordered_dumped!
           append_ring_to_reading(expanded, ring)
         end
         expanded
@@ -609,6 +610,26 @@ module ActiveFacts
 	expanded
       end
 
+      def build_indices
+	@presence_constraints_by_fact = Hash.new{ |h, k| h[k] = [] }
+	@ring_constraints_by_fact = Hash.new{ |h, k| h[k] = [] }
+
+	@vocabulary.all_constraint.each { |c|
+	    case c
+	    when ActiveFacts::Metamodel::PresenceConstraint
+	      fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq  # All fact types spanned by this constraint
+	      if fact_types.size == 1     # There's only one, save it:
+		# trace "Single-fact constraint on #{fact_types[0].concept.guid}: #{c.name}"
+		(@presence_constraints_by_fact[fact_types[0]] ||= []) << c
+	      end
+	    when ActiveFacts::Metamodel::RingConstraint
+	      (@ring_constraints_by_fact[c.role.fact_type] ||= []) << c
+	    else
+	      # trace "Found unhandled constraint #{c.class} #{c.name}"
+	    end
+	  }
+      end
+
     end
   end