activefacts 0.7.0 → 0.7.1

data/lib/activefacts/generate/ruby.rb

@@ -1,14 +1,22 @@
 #
-# Generate Ruby for the ActiveFacts API from an ActiveFacts vocabulary.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#       ActiveFacts Generators.
+#       Generate Ruby classes for the ActiveFacts API from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 require 'activefacts/vocabulary'
 require 'activefacts/generate/oo'
 
 module ActiveFacts
-
   module Generate
+    # Generate Ruby module containing classes for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --ruby[=options] <file>.cql
+    # Options are comma or space separated:
+    # * help list available options
+    # * sql Emit the sql mapping for tables/columns (REVISIT: not functional at present)
     class RUBY < OO
+    private
 
       def set_option(option)
         @sql ||= false
@@ -131,7 +139,7 @@ module ActiveFacts
       end
 
       def role_dump(role)
-        other_role = role.fact_type.all_role[role.fact_type.all_role[0] != role ? 0 : -1]
+        other_role = role.fact_type.all_role.select{|r| r != role}[0] || role
         if @ar_by_role and @ar_by_role[other_role] and @sql
           puts "    # role #{role.fact_type.describe(role)}: absorbs in through #{preferred_role_name(other_role)}: "+@ar_by_role[other_role].map(&:column_name)*", "
         end

data/lib/activefacts/generate/sql/server.rb

@@ -1,15 +1,25 @@
 #
-# Generate an SQL Server schema from an ActiveFacts vocabulary.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#       ActiveFacts Generators.
+#       Generate SQL for SQL Server from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 require 'activefacts/vocabulary'
 require 'activefacts/persistence'
 
 module ActiveFacts
   module Generate
-    class SQL
+    class SQL #:nodoc:
+      # Generate SQL for SQL Server for an ActiveFacts vocabulary.
+      # Invoke as
+      #   afgen --sql/server[=options] <file>.cql
+      # Options are comma or space separated:
+      # * delay_fks Leave all foreign keys until the end, not just those that contain forward-references
+      # * norma Translate datatypes from NORMA to SQL Server
       class SERVER
+      private
         include Metamodel
+        include Persistence
         ColumnNameMax = 40
 
         RESERVED_WORDS = %w{
@@ -98,7 +108,8 @@ module ActiveFacts
           [sql_type, length]
         end
 
-        def generate(out = $>)
+      public
+        def generate(out = $>)      #:nodoc:
           @out = out
           #go "CREATE SCHEMA #{@vocabulary.name}"
 
@@ -116,7 +127,9 @@ module ActiveFacts
               column.references[0].is_simple_reference
             end
 
-            columns = table.columns.map do |column|
+            columns = table.columns.sort_by do |column|
+              column.name(nil)
+            end.map do |column|
               name = escape column.name("")
               padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
               type, params, restrictions = column.type
@@ -145,11 +158,22 @@ module ActiveFacts
                 ")"
 
             inline_fks = []
-            table.foreign_keys.each do |fk|
+            table.foreign_keys.sort_by do |fk|
+              # Put the Foreign keys in a defined order:
+              [ fk.to.name,
+                fk.to_columns.map{|col| col.name(nil).sort},
+                fk.from_columns.map{|col| col.name(nil).sort}
+              ]
+            end.each do |fk|
+              # Put the column pairs in a defined order, sorting key pairs by to-name:
+              froms, tos = fk.from_columns.zip(fk.to_columns).sort_by { |pair|
+                pair[1].name(nil)
+              }.transpose
+
               fk_text = "FOREIGN KEY (" +
-                fk.from_columns.map{|column| column.name}*", " +
+                froms.map{|column| column.name}*", " +
                 ") REFERENCES #{escape fk.to.name} (" +
-                fk.to_columns.map{|column| column.name}*", " +
+                tos.map{|column| column.name}*", " +
                 ")"
               if !@delay_fks and              # We don't want to delay all Fks
                 (tables_emitted[fk.to] or     # The target table has been emitted
@@ -163,7 +187,10 @@ module ActiveFacts
             indices = table.indices
             inline_indices = []
             delayed_indices = []
-            indices.each do |index|
+            indices.sort_by do |index|
+              # Put the indices in a defined order:
+              index.columns.map(&:name)
+            end.each do |index|
               next if index.over == table && index.is_primary   # Already did the primary keys
               abbreviated_column_names = index.abbreviated_column_names*""
               column_names = index.column_names
@@ -203,11 +230,16 @@ CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.c
           end
         end
 
+      private
         def check_clause(column_name, restrictions)
           return "" if restrictions.empty?
           # REVISIT: Merge all restrictions (later; now just use the first)
           " CHECK(" +
-            restrictions[0].all_allowed_range.map do |ar|
+            restrictions[0].all_allowed_range.sort_by do |ar|
+              # Put the allowed ranges into a defined order:
+              ((min = ar.value_range.minimum_bound) && min.value) ||
+                ((max = ar.value_range.maximum_bound) && max.value)
+            end.map do |ar|
               vr = ar.value_range
               min = vr.minimum_bound
               max = vr.maximum_bound

data/lib/activefacts/generate/text.rb

@@ -1,12 +1,16 @@
 #
-# Generate text output for ActiveFacts vocabularies.
+#       ActiveFacts Generators.
+#       Generate text output (verbalise the meta-vocabulary) for ActiveFacts vocabularies.
 #
-# Copyright (c) 2007 Clifford Heath. Read the LICENSE file.
-# Author: Clifford Heath.
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 module ActiveFacts
   module Generate
+    # Generate a text verbalisation of the metamodel constellation created for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --text <file>.cql
     class TEXT
+    private
       def initialize(vocabulary)
         @vocabulary = vocabulary
         @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary

data/lib/activefacts/input/cql.rb

@@ -1,6 +1,8 @@
 #
-# Compile a CQL file into an ActiveFacts vocabulary.
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#       ActiveFacts Vocabulary Input.
+#       Compile a CQL file into an ActiveFacts vocabulary.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 require 'activefacts/vocabulary'
 require 'activefacts/cql/parser'
@@ -9,10 +11,11 @@ require 'ruby-debug'
 
 module ActiveFacts
   module Input #:nodoc:
-    # The CQL Input module is activated whenever afgen is called upon to process a file
-    # whose name ends in .cql. The file is parsed to a constellation and the vocabulary
-    # object defined in that file is returned.
+    # Compile CQL to an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --<generator> <file>.cql
     class CQL
+    private
       include ActiveFacts
       include ActiveFacts::Metamodel
 
@@ -44,8 +47,9 @@ module ActiveFacts
         @filename = filename
       end
 
+    public
       # Read the input, returning a new Vocabulary:
-      def read
+      def read  #:nodoc:
         @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
 
         @parser = ActiveFacts::CQLParser.new
@@ -86,6 +90,7 @@ module ActiveFacts
         @vocabulary
       end
 
+    private
       def value_type(name, base_type_name, parameters, unit, ranges)
         length, scale = *parameters
 
@@ -167,7 +172,7 @@ module ActiveFacts
           clauses_by_fact_type(clauses).each do |clauses_for_fact_type|
             fact_type = nil
             @symbols.embedded_presence_constraints = [] # Clear embedded_presence_constraints for each fact type
-            debug "New Fact Type for entity #{name}" do
+            debug :entity, "New Fact Type for entity #{name}" do
               clauses_for_fact_type.each do |clause|
                 type, qualifiers, reading = *clause
                 debug :reading, "Clause: #{clause.inspect}" do
@@ -179,6 +184,7 @@ module ActiveFacts
             end
 
             # Find the role that this entity type plays in the fact type, if any:
+            debug :reading, "Roles are: #{fact_type.all_role.map{|role| (role.concept == entity_type ? "*" : "") + role.concept.name }*", "}"
             player_roles = fact_type.all_role.select{|role| role.concept == entity_type }
             raise "#{role.concept.name} may only play one role in each identifying fact type" if player_roles.size > 1
             if player_role = player_roles[0]
@@ -187,11 +193,14 @@ module ActiveFacts
               raise "#{name} cannot be identified by a role in a non-binary fact type" if non_player_roles.size > 1
             elsif identification
               # This situation occurs when an objectified fact type has an entity identifier
-              raise "Entity type #{name} may only objectify a single fact type" if entity_type.fact_type
+              #raise "Entity type #{name} cannot objectify fact type #{fact_type.describe}, it already objectifies #{entity_type.fact_type.describe}" if entity_type.fact_type
+              raise "Entity type #{name} cannot objectify fact type #{identification.inspect}, it already objectifies #{entity_type.fact_type.describe}" if entity_type.fact_type
+              debug :entity, "Entity type #{name} objectifies fact type #{fact_type.describe} with distinct identifier"
 
               entity_type.fact_type = fact_type
               fact_type_identification(fact_type, name, false)
             else
+              debug :entity, "Entity type #{name} objectifies fact type #{fact_type.describe}"
               # it's an objectified fact type, such as a subtype
               entity_type.fact_type = fact_type
             end
@@ -255,13 +264,9 @@ module ActiveFacts
 
                 debug :mode, "Processing Reference Mode for #{name}#{mode_fact_type ? " with existing '#{mode_fact_type.default_reading}'" : ""}"
 
-                # WARNING: Several things here depend on the method and order of creation of roles and role sequences above
-                # But heck, that's what tests are for, right?
-
                 # Fact Type:
                 if (ft = mode_fact_type)
-                  entity_role = ft.all_role[n = (ft.all_role[0].concept == entity_type ? 0 : 1)]
-                  value_role = ft.all_role[1-n]
+                  entity_role, value_role = ft.all_role.partition{|role| role.concept == entity_type}.flatten
                 else
                   ft = @constellation.FactType(:new)
                   entity_role = @constellation.Role(ft, 0, entity_type)
@@ -271,23 +276,28 @@ module ActiveFacts
 
                 # Forward reading, if it doesn't already exist:
                 rss = entity_role.all_role_ref.map{|rr| rr.role_sequence.all_role_ref.size == 2 ? rr.role_sequence : nil }.compact
-                rs01 = rss.select{|rs| rs.all_role_ref[1].role == value_role }[0]
-                rs10 = rss.select{|rs| rs.all_role_ref[1].role == entity_role }[0]
+                # Find or create RoleSequences for the forward and reverse readings:
+                rs01 = rss.select{|rs| rs.all_role_ref.sort_by{|rr| rr.ordinal}.map(&:role) == [entity_role, value_role] }[0]
                 if !rs01
                   rs01 = @constellation.RoleSequence(:new)
                   @constellation.RoleRef(rs01, 0, :role => entity_role)
                   @constellation.RoleRef(rs01, 1, :role => value_role)
+                end
+                if rs01.all_reading.empty?
                   @constellation.Reading(ft, ft.all_reading.size, :role_sequence => rs01, :reading_text => "{0} has {1}")
                   debug :mode, "Creating new forward reading '#{name} has #{vt.name}'"
                 else
-                  debug :mode, "Using existing forward reading #{rs01.all_reading[0].expand}"
+                  debug :mode, "Using existing forward reading"
                 end
 
                 # Reverse reading:
+                rs10 = rss.select{|rs| rs.all_role_ref.sort_by{|rr| rr.ordinal}.map(&:role) == [value_role, entity_role] }[0]
                 if !rs10
                   rs10 = @constellation.RoleSequence(:new)
                   @constellation.RoleRef(rs10, 0, :role => value_role)
                   @constellation.RoleRef(rs10, 1, :role => entity_role)
+                end
+                if rs10.all_reading.empty?
                   @constellation.Reading(ft, ft.all_reading.size, :role_sequence => rs10, :reading_text => "{0} is of {1}")
                   debug :mode, "Creating new reverse reading '#{vt.name} is of #{name}'"
                 else
@@ -552,6 +562,9 @@ module ActiveFacts
 
         # Create the role sequences and their role references.
         # Each role sequence contain one RoleRef for each common binding
+        # REVISIT: This results in ordering all RoleRefs according to the order of the common_bindings.
+        # This for example means that a set constraint having joins might have the join order changed so they all match.
+        # When you create e.g. a subset constraint in NORMA, make sure that the subset roles are created in the order of the preferred readings.
         role_sequences = readings_list.map{|r| @constellation.RoleSequence(:new) }
         common_bindings.each_with_index do |binding, index|
           role_sequences.each_with_index do |rs, rsi|
@@ -572,6 +585,8 @@ module ActiveFacts
 
         #puts "subset_constraint:\n\t#{subset_readings.inspect}\n\t#{superset_readings.inspect}"
         #puts "\t#{role_sequences.map{|rs| rs.describe}.inspect}"
+        #puts "subset_role_sequence = #{role_sequences[0].describe}"
+        #puts "superset_role_sequence = #{role_sequences[1].describe}"
 
         # create the constraint:
         constraint = @constellation.SubsetConstraint(:new)
@@ -591,8 +606,8 @@ module ActiveFacts
         # Create the constraint:
         constraint = @constellation.SetExclusionConstraint(:new)
         constraint.vocabulary = @vocabulary
-        role_sequences.each do |rs|
-          @constellation.SetComparisonRoles(constraint, rs)
+        role_sequences.each_with_index do |rs, i|
+          @constellation.SetComparisonRoles(constraint, i, :role_sequence => rs)
         end
         constraint.is_mandatory = quantifier[0] == 1
       end
@@ -605,8 +620,8 @@ module ActiveFacts
         # Create the constraint:
         constraint = @constellation.SetEqualityConstraint(:new)
         constraint.vocabulary = @vocabulary
-        role_sequences.each do |rs|
-          @constellation.SetComparisonRoles(constraint, rs)
+        role_sequences.each_with_index do |rs, i|
+          @constellation.SetComparisonRoles(constraint, i, :role_sequence => rs)
         end
       end
 
@@ -666,6 +681,9 @@ module ActiveFacts
           rr.role = role
         end
         #puts "New external PresenceConstraint with quantifier = #{quantifier.inspect} over #{rs.describe}"
+
+        # REVISIT: Check that no existing PC spans the same roles (nor a superset nor subset?)
+
         @constellation.PresenceConstraint(
             :new,
             :name => '',
@@ -679,6 +697,8 @@ module ActiveFacts
           )
       end
 
+      # Search the supertypes of 'subtype' looking for an inheritance path to 'supertype',
+      # and returning the array of TypeInheritance fact types from supertype to subtype.
       def inheritance_path(subtype, supertype)
         direct_inheritance = subtype.all_supertype_inheritance.select{|ti| ti.supertype == supertype}
         return direct_inheritance if (direct_inheritance[0])
@@ -692,12 +712,16 @@ module ActiveFacts
       # For a given reading from the parser, find the matching declared reading, and return
       # the array of Role object in the same order as they occur in the reading.
       def invoked_fact_roles(reading)
+        # REVISIT: Possibly this special reading from the parser can be removed now?
         if (reading[0] == "!SUBTYPE!")
           subtype = reading[1][:binding].concept
           supertype = reading[2][:binding].concept
           raise "#{subtype.name} is not a subtype of #{supertype.name}" unless subtype.supertypes_transitive.include?(supertype)
           ip = inheritance_path(subtype, supertype)
-          return [ip[0].all_role[0], ip[-1].all_role[1]]
+          return [
+            ip[-1].all_role.detect{|r| r.concept == subtype},
+            ip[0].all_role.detect{|r| r.concept == supertype}
+          ]
         end
 
         bindings = reading.select{|p| Hash === p}
@@ -721,7 +745,7 @@ module ActiveFacts
                 to_match = reading.clone
                 players_to_match = players.clone
                 candidate_reading.words_and_role_refs.each do |wrr|
-                  if (RoleRef === wrr)
+                  if (wrr.is_a?(RoleRef))
                     break unless Hash === to_match.first
                     break unless binding = to_match[0][:binding]
                     # REVISIT: May need to match super- or sub-types here too!
@@ -745,7 +769,7 @@ module ActiveFacts
                 # we need to accumulate all possible matches to be sure
                 # there's only one, or the match is exact, or risk ambiguity.
                 debug "Reading match was #{to_match.size == 0 ? "ok" : "bad"}"
-                return candidate_reading.role_sequence.all_role_ref.map{|rr| rr.role} if to_match.size == 0
+                return candidate_reading.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}.map{|rr| rr.role} if to_match.size == 0
               end
             end
           end
@@ -753,7 +777,7 @@ module ActiveFacts
 
         # Hmm, that didn't work, try the subtypes of the first player.
         # When a fact type matches like this, there is an implied join to the subtype.
-        players[0].subtypes.map do |subtype|
+        players[0].subtypes.each do |subtype|
           players[0] = subtype
           fr = invoked_fact_roles_by_players(reading, players)
           return fr if fr
@@ -831,7 +855,9 @@ module ActiveFacts
 
       def fact_type_identification(fact_type, name, prefer)
         if !@symbols.embedded_presence_constraints.detect{|pc| pc.max_frequency == 1}
-          first_role_sequence = fact_type.all_reading[0].role_sequence
+          # Provide a default identifier for a fact type that's lacking one (over all roles):
+          first_role_sequence = fact_type.preferred_reading.role_sequence
+          #puts "Creating PC for #{name}: #{fact_type.describe}"
           identifier = @constellation.PresenceConstraint(
               :new,
               :vocabulary => @vocabulary,
@@ -887,6 +913,7 @@ module ActiveFacts
             constraint = find_pc_over_roles(constrained_roles)
             if constraint
               debug "Setting max frequency to #{quantifier[1]} for existing constraint #{constraint.object_id} over #{constraint.role_sequence.describe} in #{fact_type.describe}"
+              raise "Conflicting maximum frequency for constraint" if constraint.max_frequency && constraint.max_frequency != quantifier[1]
               constraint.max_frequency = quantifier[1]
             else
               role_sequence = @constellation.RoleSequence(:new)
@@ -917,11 +944,11 @@ module ActiveFacts
         ring_constraints, qualifiers = qualifiers.partition{|q| RingTypes.include?(q) }
         unless ring_constraints.empty?
           # A Ring may be over a supertype/subtype pair, and this won't find that.
-          role_refs = role_sequence.all_role_ref
+          role_refs = Array(role_sequence.all_role_ref)
           role_pairs = []
           player_supertypes_by_role = role_refs.map{|rr|
               concept = rr.role.concept
-              EntityType === concept ? supertypes(concept) : [concept]
+              concept.is_a?(EntityType) ? supertypes(concept) : [concept]
             }
           role_refs.each_with_index{|rr1, i|
             player1 = rr1.role.concept
@@ -967,7 +994,7 @@ module ActiveFacts
         return nil if roles.size == 0 # Safeguard; this would chuck an exception otherwise
         roles[0].all_role_ref.each do |role_ref|
           next if role_ref.role_sequence.all_role_ref.map(&:role) != roles
-          pc = role_ref.role_sequence.all_presence_constraint[0]
+          pc = role_ref.role_sequence.all_presence_constraint.only  # Will throw an exception if there's more than one.
           #puts "Existing PresenceConstraint matches those roles!" if pc
           return pc if pc
         end

data/lib/activefacts/input/orm.rb

@@ -1,7 +1,8 @@
 #
-# Read a NORMA file into an ActiveFacts vocabulary
+#       ActiveFacts Vocabulary Input.
+#       Read a NORMA file into an ActiveFacts vocabulary
 #
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 # This code uses variables prefixed with x_ when they refer to Rexml nodes.
 # Every node having an id="..." is indexed in @x_by_id[] hash before processing.
@@ -13,10 +14,12 @@ require 'activefacts/vocabulary'
 
 module ActiveFacts
   module Input
-    # The ORM Input module is activated whenever afgen is called upon to process a file
-    # whose name ends in .orm (a file from NORMA). This parser uses Rexml so it's very slow.
-    # The file is parsed to a constellation and the vocabulary object defined in that file is returned.
+    # Compile a NORMA (.orm) file to an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --<generator> <file>.orm
+    # This parser uses Rexml so it's very slow.
     class ORM
+    private
       def self.readfile(filename)
         File.open(filename) {|file|
           self.read(file, filename)
@@ -32,7 +35,8 @@ module ActiveFacts
         @filename = filename
       end
 
-      def read
+    public
+      def read          #:nodoc:
         begin
           @document = REXML::Document.new(@file)
         rescue => e
@@ -56,6 +60,8 @@ module ActiveFacts
         @vocabulary
       end
 
+    private
+
       def read_vocabulary
         @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
         @vocabulary = @constellation.Vocabulary(@x_model.attributes['Name'])
@@ -420,8 +426,9 @@ module ActiveFacts
       end
 
       def extract_adjectives(reading_text, role_sequence)
-        (0...role_sequence.all_role_ref.size).each{|i|
-          role_ref = role_sequence.all_role_ref[i]
+        all_role_refs = role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}
+        (0...all_role_refs.size).each{|i|
+          role_ref = all_role_refs[i]
           role = role_ref.role
 
           word = '\b([A-Za-z][A-Za-z0-9_]*)\b'
@@ -455,7 +462,7 @@ module ActiveFacts
         # REVISIT: This searches all role sequences. Perhaps we could narrow it down first instead?
         role_sequence = @constellation.RoleSequence.values.detect{|c|
           #puts "Checking RoleSequence [#{c.all_role_ref.map{|rr| rr.role.concept.name}*", "}]"
-          role_array == c.all_role_ref.map{|rr| rr.role }
+          role_array == c.all_role_ref.sort_by{|rr| rr.ordinal}.map{|rr| rr.role }
           }
         # puts "Found matching RoleSequence!" if role_sequence
         return role_sequence if role_sequence
@@ -622,12 +629,15 @@ module ActiveFacts
           #    (pi ? " (preferred id for #{pi.name})" : "") +
           #    (mc ? " (mandatory)" : "") if pi && !mc
 
-          # A TypeInheritance fact type has a UC on each role.
-          # If it's on the identification path, mark it as preferred identifier
-          role = roles.all_role_ref[0].role
-          supertype_constraint = role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) &&
-            role.concept == role.fact_type.supertype &&
-            role.fact_type.provides_identification
+          # A TypeInheritance fact type has a uniqueness constraint on each role.
+          # If this UC is on the supertype and identifies the subtype, it's preferred:
+          is_supertype_constraint =
+            roles.all_role_ref.size == 1 &&
+            (role = roles.all_role_ref.only.role) &&
+            (fact_type = role.fact_type) &&
+            fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) &&
+            role.concept == fact_type.supertype &&
+            fact_type.provides_identification
 
           pc = @constellation.PresenceConstraint(:new)
           pc.vocabulary = @vocabulary
@@ -636,7 +646,7 @@ module ActiveFacts
           pc.is_mandatory = true if mc
           pc.min_frequency = mc ? 1 : 0
           pc.max_frequency = 1 
-          pc.is_preferred_identifier = true if pi || unary_identifier || supertype_constraint
+          pc.is_preferred_identifier = true if pi || unary_identifier || is_supertype_constraint
           #puts "#{name} covers #{roles.describe} has min=#{pc.min_frequency}, max=1, preferred=#{pc.is_preferred_identifier.inspect}" if emit_special_debug
 
           #puts roles.verbalise
@@ -673,9 +683,9 @@ module ActiveFacts
           ec.vocabulary = @vocabulary
           ec.name = name
           # ec.enforcement = 
-          role_sequences.each{|rs|
-            @constellation.SetComparisonRoles(ec, rs)
-          }
+          role_sequences.each_with_index do |rs, i|
+            @constellation.SetComparisonRoles(ec, i, :role_sequence => rs)
+          end
           ec.is_mandatory = true if x_mandatory
         }
       end
@@ -699,9 +709,9 @@ module ActiveFacts
           ec.vocabulary = @vocabulary
           ec.name = name
           # ec.enforcement = 
-          role_sequences.each{|rs|
-            @constellation.SetComparisonRoles(ec, rs)
-          }
+          role_sequences.each_with_index do |rs, i|
+            @constellation.SetComparisonRoles(ec, i, :role_sequence => rs)
+          end
         }
       end