activefacts 0.8.9 → 0.8.10

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

@@ -29,8 +29,8 @@ module ActiveFacts
               :discussion => @discussion
             )
           case target
-          when ActiveFacts::Metamodel::Concept
-            context_note.concept = target
+          when ActiveFacts::Metamodel::ObjectType
+            context_note.object_type = target
           when ActiveFacts::Metamodel::Constraint
             context_note.constraint = target
           when ActiveFacts::Metamodel::FactType
@@ -52,10 +52,13 @@ module ActiveFacts
       end
 
       class Constraint < Definition
-        def initialize context_note, enforcement, readings_lists = []
+        def initialize context_note, enforcement, clauses_lists = []
+          if context_note.is_a?(Treetop::Runtime::SyntaxNode)
+            context_note = context_note.empty? ? nil : context_note.ast
+          end
           @context_note = context_note
           @enforcement = enforcement
-          @readings_lists = readings_lists
+          @clauses_lists = clauses_lists
         end
 
         def compile
@@ -67,38 +70,29 @@ module ActiveFacts
           # Override for constraint types that need loose binding (same role player matching with different adjectives)
         end
 
-        # Return the unique array of all bindings in these readings, including in objectification joins
-        def all_bindings_in_readings readings
-          readings.map do |reading|
-            reading.role_refs.map do |rr|
-              [rr.binding] + (rr.objectification_join ? all_bindings_in_readings(rr.objectification_join) : [])
-            end
-          end.
-            flatten.
-            uniq
-        end
-
-        def bind_readings
+        def bind_clauses extra = []
           @context = CompilationContext.new(@vocabulary)
-
-          @readings_lists.map do |readings_list|
-            readings_list.each{ |reading| reading.identify_players_with_role_name(@context) }
-            readings_list.each{ |reading| reading.identify_other_players(@context) }
-            readings_list.each{ |reading| reading.bind_roles @context }  # Create the Compiler::Bindings
-            readings_list.each do |reading| 
-              fact_type = reading.match_existing_fact_type @context
-              raise "Unrecognised fact type #{reading.inspect} in #{self.class}" unless fact_type
+          @context.left_contraction_allowed = true
+
+          @context.bind @clauses_lists, extra
+          @clauses_lists.map do |clauses_list|
+            @context.left_contractable_clause = nil # Don't contract outside this set of clauses
+            clauses_list.each do |clause| 
+              fact_type = clause.match_existing_fact_type @context
+              raise "Unrecognised fact type #{clause.inspect} in #{self.class}" unless fact_type
             end
           end
 
+          # Any constrained roles will be first identified here.
+          # This means that they can't introduce role names.
           loose_binding
 
           # Ok, we have bound all players by subscript/role_name, by adjectives, and by loose binding,
           # and matched all the fact types that matter. Now assemble a join (with all join steps) for
-          # each join list, and build an array of the bindings that are involved in the join steps.
-          @bindings_by_list =
-            @readings_lists.map do |readings_list|
-              all_bindings_in_readings(readings_list)
+          # each join list, and build an array of the variables that are involved in the join steps.
+          @variables_by_list =
+            @clauses_lists.map do |clauses_list|
+              all_variables_in_clauses(clauses_list)
             end
 
           warn_ignored_joins
@@ -106,8 +100,8 @@ module ActiveFacts
 
         def warn_ignored_joins
           # Warn about ignored joins
-          @readings_lists.each do |readings_list|
-            fact_types = readings_list.map{|join| join.role_refs[0].role_ref.role.fact_type}.uniq
+          @clauses_lists.each do |clauses_list|
+            fact_types = clauses_list.map{|join| join.var_refs[0].role_ref.role.fact_type}.uniq
             if fact_types.size > 1
               puts "------->>>> Join ignored in #{self.class}: #{fact_types.map{|ft| ft.preferred_reading.expand}*' and '}"
             end
@@ -117,63 +111,61 @@ module ActiveFacts
         def loose_bind_wherever_possible
           # Apply loose binding over applicable roles:
           debug :binding, "Loose binding on #{self.class.name}" do
-            @readings_lists.each do |readings_list|
-              readings_list.each do |reading|
-                reading.role_refs.each_with_index do |role_ref, i|
-                  next if role_ref.binding.refs.size > 1
-#                  if reading.side_effects && !reading.side_effects.role_side_effects[i].residual_adjectives
-#                    debug :binding, "Discounting #{role_ref.inspect} as needing loose binding because it has no residual_adjectives"
+            @clauses_lists.each do |clauses_list|
+              clauses_list.each do |clause|
+                clause.var_refs.each_with_index do |var_ref, i|
+                  next if var_ref.variable.refs.size > 1
+#                  if clause.side_effects && !clause.side_effects.role_side_effects[i].residual_adjectives
+#                    debug :binding, "Discounting #{var_ref.inspect} as needing loose binding because it has no residual_adjectives"
 #                    next
 #                  end
-                  # This role_ref didn't match any other role_ref. Have a scout around for a suitable partner
-                  candidates = @context.bindings.
-                    select do |key, binding|
-                      binding.player == role_ref.binding.player and
-                        binding != role_ref.binding and
-                        binding.role_name == role_ref.binding.role_name and  # Both will be nil if they match
-                        # REVISIT: Don't bind to a binding with a role occurrence in the same reading
-                        !binding.refs.detect{|rr|
-                          x = rr.reading == reading
-                          # puts "Discounting binding #{binding.inspect} as a match for #{role_ref.inspect} because it's already bound to a player in #{role_ref.reading.inspect}" if x
+                  # This var_ref didn't match any other var_ref. Have a scout around for a suitable partner
+                  candidates = @context.variables.
+                    select do |key, variable|
+                      variable.player == var_ref.variable.player and
+                        variable != var_ref.variable and
+                        variable.role_name == var_ref.variable.role_name and  # Both will be nil if they match
+                        # REVISIT: Don't bind to a variable with a role occurrence in the same clause
+                        !variable.refs.detect{|vr|
+                          x = vr.clause == clause
+                          # puts "Discounting variable #{variable.inspect} as a match for #{var_ref.inspect} because it's already bound to a player in #{var_ref.clause.inspect}" if x
                           x
                         }
                     end.map{|k,b| b}
                   next if candidates.size != 1  # Fail
-                  debug :binding, "Loose binding #{role_ref.inspect} to #{candidates[0].inspect}"
-                  role_ref.rebind_to(@context, candidates[0].refs[0])
+                  debug :binding, "Loose binding #{var_ref.inspect} to #{candidates[0].inspect}"
+                  var_ref.rebind_to(@context, candidates[0].refs[0])
                 end
               end
             end
           end
         end
 
-        def loose_bind_roles
+        def loose_bind
           # Apply loose binding over applicable @roles:
           debug :binding, "Check for loose bindings on #{@roles.size} roles in #{self.class.name}" do
-            @roles.each do |role_ref|
-              role_ref.identify_player @context
-              role_ref.bind @context
-              if role_ref.binding.refs.size < @readings_lists.size+1
-                debug :binding, "Insufficient bindings for #{role_ref.inspect} (#{role_ref.binding.refs.size}, expected #{@readings_lists.size+1}), attempting loose binding" do
-                  @readings_lists.each do |readings_list|
+            @roles.each do |var_ref|
+              if var_ref.variable.refs.size < @clauses_lists.size+1
+                debug :binding, "Insufficient bindings for #{var_ref.inspect} (#{var_ref.variable.refs.size}, expected #{@clauses_lists.size+1}), attempting loose binding" do
+                  @clauses_lists.each do |clauses_list|
                     candidates = []
-                    next if readings_list.
-                      detect do |reading|
-                        debug :binding, "Checking #{reading.inspect}"
-                        reading.role_refs.
-                          detect do |rr|
-                            already_bound = rr.binding == role_ref.binding
-                            if !already_bound && rr.player == role_ref.player
-                              candidates << rr
+                    next if clauses_list.
+                      detect do |clause|
+                        debug :binding, "Checking #{clause.inspect}"
+                        clause.var_refs.
+                          detect do |vr|
+                            already_bound = vr.variable == var_ref.variable
+                            if !already_bound && vr.player == var_ref.player
+                              candidates << vr
                             end
                             already_bound
                           end
                       end
-                    debug :binding, "Attempting loose binding for #{role_ref.inspect} in #{readings_list.inspect}, from the following candidates: #{candidates.inspect}"
+                    debug :binding, "Attempting loose binding for #{var_ref.inspect} in #{clauses_list.inspect}, from the following candidates: #{candidates.inspect}"
 
                     if candidates.size == 1
-                      debug :binding, "Rebinding #{candidates[0].inspect} to #{role_ref.inspect}"
-                      candidates[0].rebind_to(@context, role_ref)
+                      debug :binding, "Rebinding #{candidates[0].inspect} to #{var_ref.inspect}"
+                      candidates[0].rebind_to(@context, var_ref)
                     end
                   end
                 end
@@ -182,41 +174,45 @@ module ActiveFacts
           end
         end
 
-        def common_bindings
-          @common_bindings ||= @bindings_by_list[1..-1].inject(@bindings_by_list[0]) { |r, b| r & b }
-          raise "#{self.class} must cover some of the same roles, see #{@bindings_by_list.inspect}" unless @common_bindings.size > 0
-          @common_bindings
+        def common_variables
+          @common_variables ||= @variables_by_list[1..-1].inject(@variables_by_list[0]) { |r, b| r & b }
+          raise "#{self.class} must cover some of the same roles, see #{@variables_by_list.inspect}" unless @common_variables.size > 0
+          @common_variables
+        end
+
+        def to_s
+          "#{self.class.name.sub(/.*::/,'')}" + (@clauses_lists.size > 0 ? " over #{@clauses_lists.inspect}" : '')
         end
       end
 
       class PresenceConstraint < Constraint
-        def initialize context_note, enforcement, readings_lists, role_refs, quantifier
-          super context_note, enforcement, readings_lists
-          @role_refs = role_refs || []
+        def initialize context_note, enforcement, clauses_lists, var_refs, quantifier
+          super context_note, enforcement, clauses_lists
+          @var_refs = var_refs || []
           @quantifier = quantifier
         end
 
         def compile
-          @readings = @readings_lists.map do |readings_list|
-            raise "REVISIT: Join presence constraints not supported yet" if readings_list.size > 1 or
-              readings_list.detect{|reading| reading.role_refs.detect{|rr| rr.objectification_join } }
-            readings_list[0]
+          @clauses = @clauses_lists.map do |clauses_list|
+            raise "REVISIT: Join presence constraints not supported yet" if clauses_list.size > 1 or
+              clauses_list.detect{|clause| clause.var_refs.detect{|vr| vr.nested_clauses } }
+            clauses_list[0]
           end
 
-          bind_readings
+          bind_clauses @var_refs
 
-          if @role_refs.size > 0
-            bind_roles
+          if @var_refs.size > 0
+            bind_constrained_roles
           else
-            cb = common_bindings
+            cb = common_variables
             raise "Either/or must have only one duplicated role, not #{cb.inspect}" unless cb.size == 1
-            @role_refs = cb[0].refs.reverse # REVISIT: Should have order these by reading, not like this
+            @var_refs = cb[0].refs.reverse # REVISIT: Should have order these by clause, not like this
           end
 
           role_sequence = @constellation.RoleSequence(:new)
-          @role_refs.each do |role_ref|
-            raise "The constrained role #{role_ref.inspect} was not found in the invoked fact types" if role_ref.binding.refs.size == 1
-            (role_ref.binding.refs-[role_ref]).each do |ref|
+          @var_refs.each do |var_ref|
+            raise "The constrained role #{var_ref.inspect} was not found in the invoked fact types" if var_ref.variable.refs.size == 1
+            (var_ref.variable.refs-[var_ref]).each do |ref|
               role = (ref.role_ref && ref.role_ref.role) || ref.role
               raise "FactType role not found for #{ref.inspect}" unless role
               @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role)
@@ -238,207 +234,87 @@ module ActiveFacts
           super
         end
 
-        # In a PresenceConstraint, each role in "each XYZ" must occur in exactly one readings_list
+        # In a PresenceConstraint, each role in "each XYZ" must occur in exactly one clauses_list
         def loose_binding
           # loose_bind_wherever_possible
         end
 
-        def bind_roles
-          @role_refs.each do |role_ref|
-            role_ref.identify_player @context
-            role_ref.bind @context
-            if role_ref.binding.refs.size == 1
+        def bind_constrained_roles
+          @var_refs.each do |var_ref|
+            if var_ref.variable.refs.size == 1
               # Apply loose binding over the constrained roles
               candidates =
-                @readings.map do |reading|
-                  reading.role_refs.select{ |rr| rr.player == role_ref.player }
+                @clauses.map do |clause|
+                  clause.var_refs.select{ |vr| vr.player == var_ref.player }
                 end.flatten
               if candidates.size == 1
-                debug :binding, "Rebinding #{role_ref.inspect} to #{candidates[0].inspect} in presence constraint"
-                role_ref.rebind_to(@context, candidates[0])
+                debug :binding, "Rebinding #{var_ref.inspect} to #{candidates[0].inspect} in presence constraint"
+                var_ref.rebind_to(@context, candidates[0])
               end
             end
           end
         end
 
+        def to_s
+          "#{super} #{@quantifier.min}-#{@quantifier.max} over (#{@var_refs.map{|vr| vr.inspect}*', '})"
+        end
       end
 
       class SetConstraint < Constraint
-        def initialize context_note, enforcement, readings_lists
-          super context_note, enforcement, readings_lists
+        def initialize context_note, enforcement, clauses_lists
+          super context_note, enforcement, clauses_lists
         end
 
         def warn_ignored_joins
           # No warnings needed here any more
         end
 
-        # Make a JoinNode for every binding present in these readings
-        def build_join_nodes(readings_list)
-          debug :join, "Building join nodes" do
-            join = @constellation.Join(:new)
-            all_bindings_in_readings(readings_list).
-              each do |binding|
-                debug :join, "Creating join node #{join.all_join_node.size} for #{binding.inspect}"
-                binding.join_node = @constellation.JoinNode(join, join.all_join_node.size, :concept => binding.player)
-              end
-            join
-          end
-        end
-
-        def build_join_steps reading, constrained_rs, objectification_node = nil
-          join_roles = []
-          incidental_roles = []
-          debug :join, "Creating join Role Sequence for #{reading.inspect} with #{reading.role_refs.size} role refs" do
-            objectification_step = nil
-            reading.role_refs.each do |role_ref|
-              # These role_refs are the Compiler::RoleRefs. These have associated Metamodel::RoleRefs,
-              # but we need to create JoinRoles for those roles.  # REVISIT: JoinRoles may need to save residual_adjectives
-              binding = role_ref.binding
-              role = role_ref.role || role_ref.role_ref.role
-              join_role = nil
-
-              if (reading.fact_type.entity_type)
-                # This reading is of an objectified fact type.
-                # We need a join step from this role to the phantom role, but not
-                # for a role that has only one role_ref (this one) in their binding.
-                # Create the JoinNode and JoinRole in any case though.
-                refs_count = binding.refs.size
-                objectification_ref_count = 0
-                if role_ref.objectification_join
-                  role_ref.objectification_join.each do |r|
-                    objectification_ref_count += r.role_refs.select{|rr| rr.binding.refs.size > 1}.size
-                  end
-                end
-                refs_count += objectification_ref_count
-
-                debug :join, "Creating Join Node #{role_ref.inspect} (counts #{refs_count}/#{objectification_ref_count}) and objectification Join Step for #{role_ref.inspect}" do
+        def role_sequences_for_common_variables ignore_trailing_joins = false
+          @clauses_lists.
+              zip(@variables_by_list).
+              map do |clauses_list, variables|
+            # Does this clauses_list involve a join?
+            if clauses_list.size > 1 or
+              clauses_list.detect{|clause| clause.var_refs.detect{|var_ref| var_ref.nested_clauses } }
 
-                  raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name}" unless binding.join_node.concept == role.concept
-                  join_role = @constellation.JoinRole(binding.join_node, role)
+              debug :join, "Building join for #{clauses_list.inspect}" do
+                debug :join, "Constrained variables are #{@common_variables.inspect}"
+                # Every Variable in these clauses becomes a Join Node,
+                # and every clause becomes a JoinStep (and a RoleSequence).
+                # The returned RoleSequences contains the RoleRefs for the common_variables.
 
-                  if (refs_count <= 1)   # Our work here is done if there are no other refs
-                    if objectification_step
-                      join_role.join_step = objectification_step
-                    else
-                      incidental_roles << join_role
-                    end
-                    next
-                  end
-
-                  join_roles << join_role
-                  unless objectification_node
-                    # This is an implicit objectification, just the FT reading, not ET(where ...reading...)
-                    # We need to create a JoinNode for this object, even though it has no RoleRefs
-                    join = binding.join_node.join
-                    debug :join, "Creating JN#{join.all_join_node.size} for #{reading.fact_type.entity_type.name} in objectification"
-                    objectification_node = @constellation.JoinNode(join, join.all_join_node.size, :concept => reading.fact_type.entity_type)
-                  end
-                  raise "Internal error: Trying to add role of #{role.implicit_fact_type.all_role.single.concept.name} to join node for #{objectification_node.concept.name}" unless objectification_node.concept == role.implicit_fact_type.all_role.single.concept
-
-                  irole = role.implicit_fact_type.all_role.single
-                  raise "Internal error: Trying to add role of #{irole.concept.name} to join node for #{objectification_node.concept.name}" unless objectification_node.concept == irole.concept
-                  objectification_role = @constellation.JoinRole(objectification_node, role.implicit_fact_type.all_role.single)
-                  objectification_step = @constellation.JoinStep(objectification_role, join_role, :fact_type => role.implicit_fact_type)
-                  debug :join, "New #{objectification_step.describe}"
-                  debug :join, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{objectification_step.describe}" if incidental_roles.size > 0
-                  incidental_roles.each { |jr| jr.join_step = objectification_step }
-                  incidental_roles = []
-                  join_roles = []
-                end
-              else
-                debug :join, "Creating Role Ref for #{role_ref.inspect}" do
-                    # REVISIT: If there's an implicit subtyping join 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 join steps.
-                  if binding.join_node.concept != role.concept and
-                    0 == (binding.join_node.concept.supertypes_transitive & role.concept.supertypes_transitive).size
-                    raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name} in '#{reading.fact_type.default_reading}'"
-                  end
-                  raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name}" unless binding.join_node.concept == role.concept
-                  join_role = @constellation.JoinRole(binding.join_node, role)
-                  join_roles << join_role
-                end
-              end
-
-              if role_ref.objectification_join
-                # We are looking at a role whose player is an objectification of a fact type,
-                # which will have ImplicitFactTypes for each role.
-                # 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 join step.
-                role_ref.objectification_join.each do |r|
-                  debug :join, "Building objectification join for #{role_ref.objectification_join.inspect}" do
-                    build_join_steps r, constrained_rs, binding.join_node
-                  end
-                end
-              end
-              if (@common_bindings.include?(binding))
-                debug :join, "#{binding.inspect} is a constrained binding, add the Role Ref for #{role.concept.name}"
-                raise "Internal error: Trying to add role of #{role.concept.name} to join node for #{binding.join_node.concept.name}" unless binding.join_node.concept == role.concept
-                @constellation.RoleRef(constrained_rs, constrained_rs.all_role_ref.size, :role => role, :join_role => join_role)
-              end
-            end
-          end
-
-          if join_roles.size > 0
-            end_node = join_roles[-1].join_node
-            if !reading.fact_type.entity_type and role = reading.fact_type.all_role.single
-              # Don't give the ImplicitBoolean a join_node. We can live without one, for now.
-              # The Join Step will have a duplicate node, and the fact type will tell us what's happening
-              join_roles << join_roles[0]
-            end
-            # We aren't talking about objectification here, so there must be exactly two roles.
-            raise "REVISIT: Internal error constructing join for #{reading.inspect}" if join_roles.size != 2
-            js = @constellation.JoinStep(join_roles[0], join_roles[1], :fact_type => reading.fact_type)
-            debug :join, "New Join Step #{js.describe}"
-            debug :join, "Associating #{incidental_roles.map(&:describe)*', '} incidental roles with #{js.describe}" if incidental_roles.size > 0
-            incidental_roles.each { |jr| jr.join_step = js }
-          end
-        end
-
-        def role_sequences_for_common_bindings ignore_trailing_joins = false
-          @readings_lists.
-              zip(@bindings_by_list).
-              map do |readings_list, bindings|
-            # Does this readings_list involve a join?
-            if readings_list.size > 1 or
-              readings_list.detect{|reading| reading.role_refs.detect{|role_ref| role_ref.objectification_join } }
-
-              debug :join, "Building join for #{readings_list.inspect}" do
-                debug :join, "Constrained bindings are #{@common_bindings.inspect}"
-                # Every Binding in these readings becomes a Join Node,
-                # and every reading becomes a JoinStep (and a RoleSequence).
-                # The returned RoleSequences contains the RoleRefs for the common_bindings.
-
-                # Create a join with a join node for every binding:
-                join = build_join_nodes(readings_list)
+                # Create a join with a join node for every variable and all join steps:
+                join = build_join_nodes(clauses_list)
+                roles_by_variable = build_all_join_steps(clauses_list)
+                join.validate
 
+                # Create the projected RoleSequence for the constraint:
                 role_sequence = @constellation.RoleSequence(:new)
-                debug :join, "Building join steps" do
-                  readings_list.each do |reading|
-                    build_join_steps(reading, role_sequence)
-                  end
+                @common_variables.each do |variable|
+                  role, join_role = *roles_by_variable[variable]
+                  @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => role, :join_role => join_role)
                 end
-                join.validate
 
                 role_sequence
               end
             else
-              # There's no join in this readings_list, just create a role_sequence
+              # There's no join in this clauses_list, just create a role_sequence
               role_sequence = @constellation.RoleSequence(:new)
-              join_bindings = bindings-@common_bindings
-              unless join_bindings.empty? or ignore_trailing_joins && join_bindings.size <= 1
-                debug :constraint, "REVISIT: #{self.class}: Ignoring join from #{@common_bindings.inspect} to #{join_bindings.inspect} in #{readings_list.inspect}"
+              join_variables = variables-@common_variables
+              unless join_variables.empty? or ignore_trailing_joins && join_variables.size <= 1
+                debug :constraint, "REVISIT: #{self.class}: Ignoring join from #{@common_variables.inspect} to #{join_variables.inspect} in #{clauses_list.inspect}"
               end
-              @common_bindings.each do |binding|
-                roles = readings_list.
-                  map do |reading|
-                    reading.role_refs.detect{|rr| rr.binding == binding }
+              @common_variables.each do |variable|
+                roles = clauses_list.
+                  map do |clause|
+                    clause.var_refs.detect{|vr| vr.variable == variable }
                   end.
-                  compact.  # A join reading will probably not have the common binding
-                  map do |role_ref|
-                    role_ref.role_ref && role_ref.role_ref.role or role_ref.role
+                  compact.  # A join clause will probably not have the common variable
+                  map do |var_ref|
+                    var_ref.role_ref && var_ref.role_ref.role or var_ref.role
                   end.
                   compact
-                # REVISIT: Should use reading side effects to preserve residual adjectives here.
+                # REVISIT: Should use clause side effects to preserve residual adjectives here.
                 @constellation.RoleRef(role_sequence, role_sequence.all_role_ref.size, :role => roles[0])
               end
               role_sequence
@@ -448,18 +324,18 @@ module ActiveFacts
       end
 
       class SubsetConstraint < SetConstraint
-        def initialize context_note, enforcement, readings_lists
-          super context_note, enforcement, readings_lists
-          @subset_readings = @readings_lists[0]
-          @superset_readings = @readings_lists[1]
+        def initialize context_note, enforcement, clauses_lists
+          super context_note, enforcement, clauses_lists
+          @subset_clauses = @clauses_lists[0]
+          @superset_clauses = @clauses_lists[1]
         end
 
         def compile
-          bind_readings
-          common_bindings
+          bind_clauses
+          common_variables
 
           role_sequences =
-            role_sequences_for_common_bindings
+            role_sequences_for_common_variables
 
           @constraint =
             @constellation.SubsetConstraint(
@@ -478,24 +354,24 @@ module ActiveFacts
       end
 
       class SetComparisonConstraint < SetConstraint
-        def initialize context_note, enforcement, readings_lists
-          super context_note, enforcement, readings_lists
+        def initialize context_note, enforcement, clauses_lists
+          super context_note, enforcement, clauses_lists
         end
       end
 
       class SetExclusionConstraint < SetComparisonConstraint
-        def initialize context_note, enforcement, readings_lists, roles, quantifier
-          super context_note, enforcement, readings_lists
+        def initialize context_note, enforcement, clauses_lists, roles, quantifier
+          super context_note, enforcement, clauses_lists
           @roles = roles || []
           @quantifier = quantifier
         end
 
         def compile
-          bind_readings
-          common_bindings
+          bind_clauses @roles
+          common_variables
 
           role_sequences =
-            role_sequences_for_common_bindings
+            role_sequences_for_common_variables
 
           @constraint = @constellation.SetExclusionConstraint(
             :new,
@@ -509,28 +385,28 @@ module ActiveFacts
           super
         end
 
-        # In a SetExclusionConstraint, each role in "for each XYZ" must occur in each readings_list
+        # In a SetExclusionConstraint, each role in "for each XYZ" must occur in each clauses_list
         def loose_binding
           if @roles.size == 0
             loose_bind_wherever_possible
           else
-            loose_bind_roles
+            loose_bind
           end
         end
 
       end
 
       class SetEqualityConstraint < SetComparisonConstraint
-        def initialize context_note, enforcement, readings_lists
-          super context_note, enforcement, readings_lists
+        def initialize context_note, enforcement, clauses_lists
+          super context_note, enforcement, clauses_lists
         end
 
         def compile
-          bind_readings
-          common_bindings
+          bind_clauses
+          common_variables
 
           role_sequences =
-            role_sequences_for_common_bindings
+            role_sequences_for_common_variables
 
           @constraint = @constellation.SetEqualityConstraint(
             :new,
@@ -546,7 +422,6 @@ module ActiveFacts
         def loose_binding
           loose_bind_wherever_possible
         end
-
       end
 
       class RingConstraint < Constraint
@@ -564,10 +439,10 @@ module ActiveFacts
           # Process the ring constraints:
           return if @rings.empty?
 
-          role_refs = @role_sequence.all_role_ref.to_a
+          role_refs = @role_sequence.all_role_ref_in_order.to_a
           supertypes_by_position = role_refs.
             map do |role_ref|
-              role_ref.role.concept.supertypes_transitive
+              role_ref.role.object_type.supertypes_transitive
             end
           role_pairs = []
           supertypes_by_position.each_with_index do |sts, i|
@@ -606,16 +481,22 @@ module ActiveFacts
           debug :constraint, "Added #{@constraint.verbalise} #{@constraint.class.roles.keys.map{|k|"#{k} => "+@constraint.send(k).verbalise}*", "}"
           super
         end
+
+        def to_s
+          "#{super} #{@rings*','} over #{@clauses_lists.inspect}"
+        end
       end
 
       class ValueConstraint < Constraint
-        def initialize value_ranges, enforcement
+        def initialize value_ranges, units, enforcement
           super nil, enforcement
           @value_ranges = value_ranges
+          @units = units
         end
 
         def compile
           @constraint = @constellation.ValueConstraint(:new)
+          $stderr.puts "REVISIT: units on value constraints are not yet processed" if @units
           @value_ranges.each do |range|
             min, max = Array === range ? range : [range, range]
             v_range = @constellation.ValueRange(
@@ -627,6 +508,28 @@ module ActiveFacts
           @enforcement.compile(@constellation, @constraint) if @enforcement
           super
         end
+
+        def vrto_s vr
+          if Array === vr
+            min = vr[0]
+            max = vr[1]
+            if Numeric === min or Numeric === max
+              infinite = 1.0/0
+              min ||= -infinite
+              max ||= infinite
+            else
+              min ||= 'MIN'
+              max ||= 'MAX'
+            end
+            Range.new(min, max)
+          else
+            vr
+          end
+        end
+
+        def to_s
+          "#{super} to (#{@value_ranges.map{|vr| vrto_s(vr) }.inspect })#{ @units ? " in #{@units.inspect}" : ''}"
+        end
       end
 
     end