activefacts 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9375bff433eb3d5ca379bb09c75cf61dbf06d0f9
-  data.tar.gz: 0eb5ae1999ee3022eb304366dcff00d0416e5562
+  metadata.gz: 4e9276d073a9b3444de848bf033b76f373784a51
+  data.tar.gz: 0ab5602a9298cc84ce688168a3635bd7f4d976a8
 SHA512:
-  metadata.gz: ea7c95187824dcbceb58d036483f63611d1ed079deea269b53b1f52b0a1db53f62fe525c65561bd79aea4592902671dc69d607b84739392eab776bf785c460e6
-  data.tar.gz: ebc6351f9ef09824dd11629be72734cc55f99092c6f4b7e90405ae5aeb062ede4eea0ea7376c1ef8b714bdd36d3f75061f3d046e808c1b9dff987dc992d8fa67
+  metadata.gz: a984577de5c0aa667d5975f70b35c76f2bb4ab65555fc6a19ca0b7a8bae635cd77fb6d3fbac3959f9f9d76bc53c81846214940ea5109d3e58c6ae5b06197c6c5
+  data.tar.gz: 169adf1025e3c1bb46fa58fd45e79d05c2eb45e4ffb069c25bec1c10b786f3dddca32c97f54556353bd48fb9580e2becc279f5a11185373857af4dff64694635

data/examples/CQL/Metamodel.cql

@@ -16,7 +16,7 @@ Enforcement Code is written as String(16);
 Ephemera URL is written as String;
 Exponent is written as Signed Integer(16);
 Frequency is written as Unsigned Integer(32);
-Guid is written as Guid;
+Guid is written as Guid auto-assigned at assert;
 Implication Rule Name is written as String;
 Length is written as Unsigned Integer(32);
 Literal is written as String;

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

@@ -122,7 +122,7 @@ module ActiveFacts
           if (pc)
             pc.is_preferred_identifier = true
             pc.name = "#{@entity_type.name}PK" unless pc.name
-            trace "Existing PC #{pc.verbalise} is now PK for #{@entity_type.name}"
+            trace :constraint, "Existing PC #{pc.verbalise} is now PK for #{@entity_type.name}"
           else
             # Add a unique constraint over all identifying roles
             pc = @constellation.PresenceConstraint(
@@ -254,7 +254,7 @@ module ActiveFacts
             @constellation.RoleRef(rs2, 0, :role => super_role)
             @constellation.RoleRef(rs2, 1, :role => sub_role)
             # Decide in which order to include is a/is an. Provide both, but in order.
-            n = 'aeiouh'.include?(sub_role.object_type.name.downcase[0]) ? 'n' : ''
+            n = 'aeioh'.include?(sub_role.object_type.name.downcase[0]) ? 'n' : ''
             @constellation.Reading(inheritance_fact, 2, :role_sequence => rs2, :text => "{0} is a#{n} {1}", :is_negative => false)
 
             if is_identifying_supertype

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

@@ -287,6 +287,7 @@ module ActiveFacts
             epc = ref.embedded_presence_constraint or next
             epc.max_frequency == 1 or next
             next if epc.enforcement
+            trace :constraint, "Converting UC into PI for #{@fact_type.entity_type.name}"
             epc.is_preferred_identifier = true
             return
           end

data/lib/activefacts/generate/helpers/ordered.rb

@@ -131,13 +131,16 @@ module ActiveFacts
             sorted.each{|o|
 		next if o.ordered_dumped	    # Already done
 
+		trace :ordered, "Panicing to dump #{panic.name}" if panic
                 # Can we do this yet?
+		remaining_precursors = Array(@precursors[o])-[o]
                 if (o != panic and                  # We don't *have* to do it (panic mode)
-                    (p = @precursors[o]) and        # There might be...
-                    p.size > 0)                     # precursors - still blocked
+                    remaining_precursors.size > 0)  # precursors - still blocked
+		  trace :ordered, "Can't dump #{o.name} despite panic for #{panic.name}, it still needs #{remaining_precursors.map(&:name)*', '}" if panic
                   skipped_this_pass += 1
                   next
                 end
+		trace :ordered, "Dumping #{o.name} in panic mode, even though it still needs #{remaining_precursors.map(&:name)*', '}" if panic
 
                 entity_type_banner unless done_banner
                 done_banner = true
@@ -162,26 +165,39 @@ module ActiveFacts
 
               # Check that we made progress if there's any to make:
               if count_this_pass == 0 && skipped_this_pass > 0
+=begin
                 if panic        # We were already panicing... what to do now?
                   # This won't happen again unless the above code is changed to decide it can't dump "panic".
+		  bad = sorted.select do |o|
+		      o.is_a?(ActiveFacts::Metamodel::EntityType) &&
+		      !o.ordered_dumped &&
+		      (Array(@precursors[o])-[o]).size > 0 &&
+		      (Array(@followers[o])-[o]).size > 0
+		    end
+
                   raise "Unresolvable cycle of forward references: " +
-                    (bad = sorted.select{|o| EntityType === o && !o.ordered_dumped}).map{|o| o.name }.inspect +
-                    ":\n\t" + bad.map{|o|
-                      o.name +
-                      ": " +
-                      @precursors[o].map{|p| p.name}.uniq.inspect
-                    } * "\n\t" + "\n"
-                else
+                    bad.map { |o| o.name }*', ' +
+                    ":\n\t" +
+		    (
+		      bad.map do |o|
+			o.name +
+			  " depends on " +
+			  (@precursors[o].uniq.map{|p| p.name}.sort*', ')
+		      end
+		    ) * "\n\t" +
+		    "\n"
+=end
+#                else
                   # Find the object that has the most followers and no fwd-ref'd supertypes:
                   # This selection might be better if we allow PI roles to be fwd-ref'd...
                   panic = sorted.
-                    select{|o| o.ordered_dumped }.
+                    select{|o| !o.ordered_dumped }.
                     sort_by{|o|
-                        f = @followers[o] || []; 
+                        f = (@followers[o] || []) - [o];
                         o.supertypes.detect{|s| !s.ordered_dumped } ? 0 : -f.size
                       }[0]
-                  # trace "Panic mode, selected #{panic.name} next"
-                end
+                  trace :ordered, "Panic mode, selected #{panic.name} next"
+#                end
               end
 
               break if skipped_this_pass == 0       # All done.

data/lib/activefacts/generate/html/glossary.rb

@@ -19,6 +19,16 @@ module ActiveFacts
         end
 
         def set_option(option)
+          @gen_bootstrap = false
+          case option
+          when 'help', '?'
+            $stderr.puts "Usage:\t\tafgen --html/glossary[=option] input_file.cql\n"+
+                "\t\tbootstrap\tGenerate bootstrap styled glossary html"
+            exit 0
+          when /bootstrap/
+            @gen_bootstrap = true
+          else super
+          end
         end
 
         def puts(*a)
@@ -31,134 +41,156 @@ module ActiveFacts
 
         def generate(out = $>)
           @out = out
+          
+      	  @all_object_type =
+      	    @vocabulary.
+      	      all_object_type.
+      	      sort_by{|o| o.name.gsub(/ /,'').downcase}
+          
           vocabulary_start
 
-          object_types_dump()
-
+          if @gen_bootstrap
+            object_types_dump_toc()
+            object_types_dump_def()
+          else
+            object_types_dump_def()
+            object_types_dump_toc()
+          end
           vocabulary_end
         end
 
         def vocabulary_start
-          # puts "<link rel='stylesheet' href='css/orm2.css' media='screen' type='text/css'/>"
-	  File.open(File.dirname(__FILE__)+"/../../../../css/orm2.css") do |f|
-	    puts "<style media='screen' type='text/css'>"
-	    puts f.read
-	    puts %Q{
-	      .glossary-facttype, .glossary-constraints { display: block; }
-	      .glossary-doc.hide-alternates .glossary-alternates { display: none; }
-	      .glossary-doc.hide-constraints .glossary-constraints { display: none; }
-	      .glossary-doc.hide-examples .glossary-example { display: none; }
-	    }.gsub(/^\s+/, '')
-	    puts "</style>"
-	  end
-
-	  puts %Q{
-	    <style media='print' type='text/css'>
-	    .keyword { color: #0000CC; font-style: italic; display: inline; }
-	    .vocabulary, .object_type { color: #8A0092; font-weight: bold; }
-	    .copula { color: #0E5400; }
-	    .value { color: #FF990E; display: inline; }
-	    .glossary-toc { display: none; }
-	    .glossary-facttype, .glossary-reading { display: inline; }
-	    </style>
-	  }.gsub(/^\s+/, '')
+          if !@gen_bootstrap
+            # puts "<link rel='stylesheet' href='css/orm2.css' media='screen' type='text/css'/>"
+            css_file = "/../../../../css/orm2.css"
+          
+        	  File.open(File.dirname(__FILE__)+css_file) do |f|
+        	    puts "<style media='screen' type='text/css'>"
+        	    puts f.read
+        	    puts %Q{
+        	      .glossary-facttype, .glossary-constraints { display: block; }
+        	      .glossary-doc.hide-alternates .glossary-alternates { display: none; }
+        	      .glossary-doc.hide-constraints .glossary-constraints { display: none; }
+        	      .glossary-doc.hide-examples .glossary-example { display: none; }
+        	    }.gsub(/^\s+/, '')
+        	    puts "</style>"
+        	  end
+
+        	  puts %Q{
+        	    <style media='print' type='text/css'>
+        	    .keyword { color: #0000CC; font-style: italic; display: inline; }
+        	    .vocabulary, .object_type { color: #8A0092; font-weight: bold; }
+        	    .copula { color: #0E5400; }
+        	    .value { color: #FF990E; display: inline; }
+        	    .glossary-toc { display: none; }
+        	    .glossary-facttype, .glossary-reading { display: inline; }
+        	    </style>
+        	  }.gsub(/^\s+/, '')
+          end
         end
 
         def vocabulary_end
-	  puts %Q{
-	  <script type="text/javascript">
-	  function toggle_class(e, c) {
-	    if (!e) return;
-	    var n = e.className;
-	    var i = n.indexOf(c);
-	    if (i == -1) {
-	      e.className = n+' '+c;
-	    } else {
-	      e.className = n.slice(0, i)+n.slice(i+c.length);
-	    }
-	    if (document.location.toString().indexOf('#') >= 0)
-	      document.location = document.location; // Re-scroll to the current fragment
-	  }
-	  function toggle_constraints() {
-	    toggle_class(document.getElementById('glossary-doc'), 'hide-constraints');
-	  }
-	  function toggle_alternates() {
-	    toggle_class(document.getElementById('glossary-doc'), 'hide-alternates');
-	  }
-	  function toggle_examples() {
-	    toggle_class(document.getElementById('glossary-doc'), 'hide-examples');
-	  }
-	  </script>
-	  }.gsub(/^\s+/, '')
+          if !@gen_bootstrap
+        	  puts %Q{
+          	  <script type="text/javascript">
+          	  function toggle_class(e, c) {
+          	    if (!e) return;
+          	    var n = e.className;
+          	    var i = n.indexOf(c);
+          	    if (i == -1) {
+          	      e.className = n+' '+c;
+          	    } else {
+          	      e.className = n.slice(0, i)+n.slice(i+c.length);
+          	    }
+          	    if (document.location.toString().indexOf('#') >= 0)
+          	      document.location = document.location; // Re-scroll to the current fragment
+          	  }
+          	  function toggle_constraints() {
+          	    toggle_class(document.getElementById('glossary-doc'), 'hide-constraints');
+          	  }
+          	  function toggle_alternates() {
+          	    toggle_class(document.getElementById('glossary-doc'), 'hide-alternates');
+          	  }
+          	  function toggle_examples() {
+          	    toggle_class(document.getElementById('glossary-doc'), 'hide-examples');
+          	  }
+          	  </script>
+        	  }.gsub(/^\s+/, '')
+          end
         end
 
-        def object_types_dump
-	  all_object_type =
-	    @vocabulary.
-	      all_object_type.
-	      sort_by{|o| o.name.gsub(/ /,'').downcase}
-
-	  # Put out a table of contents first:
-	  puts '<div class="glossary-sidebar">'
-	  puts '<ol class="glossary-toc">'
-	  all_object_type.
-	  reject do |o|
-	    o.name == '_ImplicitBooleanValueType' or
-	    o.kind_of?(ActiveFacts::Metamodel::ValueType) && o.all_role.size == 0 or
-	    o.kind_of?(ActiveFacts::Metamodel::TypeInheritance)
-	  end.
-	    each do |o|
-	      puts "<li>#{termref(o.name)}</li>"
-	    end
-	  puts '</ol>'
-	  puts '<div class="glossary-controls">'
-	  puts '  <input type="button" onclick="toggle_constraints()" value="Constraints" class="glossary-toggle-constraint">'
-	  puts '  <input type="button" onclick="toggle_alternates()" value="Alternates" class="glossary-toggle-alternates">'
-	  puts '  <input type="button" onclick="toggle_examples()" value="Examples" class="glossary-toggle-examples">'
-	  puts '</div>'
-	  puts '</div>'
-
-	  puts '<div class="glossary-doc hide-alternates hide-constraints" id="glossary-doc">'
-	    puts "<h1>#{@vocabulary.name}</h1>"
-	    puts '<dl>'
-	    all_object_type.
-	      each do |o|
-		case o
-		when ActiveFacts::Metamodel::TypeInheritance
-		  nil
-		when ActiveFacts::Metamodel::ValueType
-		  value_type_dump(o)
-		else
-		  if o.fact_type
-		    objectified_fact_type_dump(o)
-		  else
-		    entity_type_dump(o)
-		  end
-		end
-	      end
-	    puts '</dl>'
-	  puts '</div>'
-	end
+        def object_types_dump_toc
+      	  if @gen_bootstrap
+            puts '<div class="col-md-3 glossary-sidebar">'
+          else
+        	  puts '<div class="glossary-sidebar">'
+          end
+      	  puts '<h1 style="visibility: hidden">X</h1>'
+          puts '<ol class="glossary-toc">'
+      	  @all_object_type.
+        	  reject do |o|
+        	    o.name == '_ImplicitBooleanValueType' or
+        	    o.kind_of?(ActiveFacts::Metamodel::ValueType) && o.all_role.size == 0 or
+        	    o.kind_of?(ActiveFacts::Metamodel::TypeInheritance)
+        	  end.
+        	    each do |o|
+        	      puts "<li>#{termref(o.name)}</li>"
+        	    end
+          puts '</ol>'
+      	  puts '<div class="glossary-controls">'
+      	  puts '  <input type="button" onclick="toggle_constraints()" value="Constraints" class="glossary-toggle-constraint">'
+      	  puts '  <input type="button" onclick="toggle_alternates()" value="Alternates" class="glossary-toggle-alternates">'
+      	  puts '  <input type="button" onclick="toggle_examples()" value="Examples" class="glossary-toggle-examples">'
+      	  puts '</div>'
+      	  puts '</div>'
+        end
+        
+        def object_types_dump_def
+      	  if @gen_bootstrap
+            puts '<div class="col-md-5 glossary-doc hide-alternates hide-constraints" id="glossary-doc">'
+          else
+            puts '<div class="glossary-doc hide-alternates hide-constraints" id="glossary-doc">'
+          end
+    	    puts "<h1>#{@vocabulary.name}</h1>"
+    	    puts '<dl>'
+    	    @all_object_type.
+    	      each do |o|
+        		case o
+          		when ActiveFacts::Metamodel::TypeInheritance
+          		  nil
+          		when ActiveFacts::Metamodel::ValueType
+          		  value_type_dump(o)
+          		else
+          		  if o.fact_type
+          		    objectified_fact_type_dump(o)
+          		  else
+          		    entity_type_dump(o)
+          		  end
+          		end
+      	    end
+      	  puts '</dl>'
+      	  puts '</div>'
+      	end
 
         def element(text, attrs, tag = 'span')
           "<#{tag}#{attrs.empty? ? '' : attrs.map{|k,v| " #{k}='#{v}'"}*''}>#{text}</#{tag}>"
         end
 
-	def span(text, klass = nil)
-	  element(text, klass ? {:class => klass} : {})
-	end
+      	def span(text, klass = nil)
+      	  element(text, klass ? {:class => klass} : {})
+      	end
 
-	def div(text, klass = nil)
-	  element(text, klass ? {:class => klass} : {}, 'div')
-	end
+      	def div(text, klass = nil)
+      	  element(text, klass ? {:class => klass} : {}, 'div')
+      	end
 
-	def h1(text, klass = nil)
-	  element(text, klass ? {:class => klass} : {}, 'h1')
-	end
+      	def h1(text, klass = nil)
+      	  element(text, klass ? {:class => klass} : {}, 'h1')
+      	end
 
-	def dl(text, klass = nil)
-	  element(text, klass ? {:class => klass} : {}, 'dl')
-	end
+      	def dl(text, klass = nil)
+      	  element(text, klass ? {:class => klass} : {}, 'dl')
+      	end
 
         # A definition of a term
         def termdef(name)
@@ -178,54 +210,54 @@ module ActiveFacts
 
         def value_type_dump(o)
           return if o.all_role.size == 0 or  # Skip value types that are only used as supertypes
-	    o.name == '_ImplicitBooleanValueType'
-          puts "  <dt>" +
-            "#{termdef(o.name)} " +
-	    (if o.supertype
-	      span('is written as ', :keyword) + termref(o.supertype.name)
-	    else
-	      " (a fundamental data type)"
-	    end) +
-            "</dt>"
-
-          puts "  <dd>"
-	  value_sub_types(o)
-          relevant_facts_and_constraints(o)
-	  values(o)
-          puts "  </dd>"
+      	    o.name == '_ImplicitBooleanValueType'
+            puts "  <dt>" +
+              "#{termdef(o.name)} " +
+        	    (if o.supertype
+        	      span('is written as ', :keyword) + termref(o.supertype.name)
+        	    else
+        	      " (a fundamental data type)"
+        	    end) +
+                    "</dt>"
+
+            puts "  <dd>"
+        	  value_sub_types(o)
+            relevant_facts_and_constraints(o)
+        	  values(o)
+            puts "  </dd>"
         end
 
-	def value_sub_types(o)
-	  o.
-	    all_value_type_as_supertype.    # All value types for which o is a supertype
-	    sort_by{|sub| sub.name}.
-	    each do |sub|
-	      puts div(
-		"#{termref(sub.name)} #{span('is written as', 'keyword')} #{termref(o.name)}",
-		'glossary-facttype'
-	      )
-	    end
-	end
-
-	def values(o)
-	  o.all_instance.
-	  sort_by{|i|
-	    [i.population.name, i.value.literal]
-	  }.
-	  each do |i|
-	    v = i.value
-	    puts div(
-		(i.population.name.empty? ? '' : i.population.name+': ') +
-		termref(o.name) + ' ' +
-		div(
-		# v.is_literal_string ? v.literal.inspect : v.literal,
-		  v.literal.inspect,
-		  'value'
-		),
-		'glossary-example'
-	      )
-	  end
-	end
+      	def value_sub_types(o)
+      	  o.
+      	    all_value_type_as_supertype.    # All value types for which o is a supertype
+      	    sort_by{|sub| sub.name}.
+      	    each do |sub|
+      	      puts div(
+      		"#{termref(sub.name)} #{span('is written as', 'keyword')} #{termref(o.name)}",
+      		'glossary-facttype'
+      	      )
+      	    end
+      	end
+
+      	def values(o)
+      	  o.all_instance.
+      	  sort_by{|i|
+      	    [i.population.name, i.value.literal]
+      	  }.
+      	  each do |i|
+      	    v = i.value
+      	    puts div(
+      		(i.population.name.empty? ? '' : i.population.name+': ') +
+      		termref(o.name) + ' ' +
+      		div(
+      		# v.is_literal_string ? v.literal.inspect : v.literal,
+      		  v.literal.inspect,
+      		  'value'
+      		),
+      		'glossary-example'
+      	      )
+      	  end
+      	end
 
         def relevant_facts_and_constraints(o)
           puts(
@@ -234,14 +266,14 @@ module ActiveFacts
               map{|r| r.fact_type}.
               uniq.
               reject do |ft|
-		ft.is_a?(ActiveFacts::Metamodel::LinkFactType)
-	      end.
-              map { |ft| [ft, "    #{fact_type_with_constraints(ft, o)}"] }.
-              sort_by{|ft, text|
-		[ ft.is_a?(ActiveFacts::Metamodel::TypeInheritance) ? 0 : 1, text]
-	      }.
-	      map{|ft, text| text}.
-	      join "\n"
+            		ft.is_a?(ActiveFacts::Metamodel::LinkFactType)
+      	      end.
+                map { |ft| [ft, "    #{fact_type_with_constraints(ft, o)}"] }.
+                sort_by{|ft, text|
+              		[ ft.is_a?(ActiveFacts::Metamodel::TypeInheritance) ? 0 : 1, text]
+        	      }.
+          	      map{|ft, text| text}.
+            	      join "\n"
           )
         end
 
@@ -259,9 +291,9 @@ module ActiveFacts
           element(
             reading.expand([], include_rolenames) do |rr, freq_con, l_adj, name, t_adj, role_name_def, literal|
 	      if role_name_def
-		role_name_def = role_name_def.gsub(/\(as ([^)]+)\)/) {
-		  span("(as #{ termref(rr.role.object_type.name, $1) })", 'keyword')
-		}
+      		role_name_def = role_name_def.gsub(/\(as ([^)]+)\)/) {
+      		  span("(as #{ termref(rr.role.object_type.name, $1) })", 'keyword')
+      		}
 	      end
               role_ref rr, freq_con, l_adj, name, t_adj, role_name_def, literal
             end,
@@ -270,53 +302,53 @@ module ActiveFacts
         end
 
         def fact_type_block(ft, include_alternates = true, wrt = nil, include_rolenames = true)
-	  div(fact_type(ft, include_alternates, wrt, include_rolenames), 'glossary-facttype')
-	end
+      	  div(fact_type(ft, include_alternates, wrt, include_rolenames), 'glossary-facttype')
+      	end
 
         def fact_type(ft, include_alternates = true, wrt = nil, include_rolenames = true)
           role = ft.all_role.detect{|r| r.object_type == wrt}
           preferred_reading = ft.reading_preferably_starting_with_role(role)
           alternate_readings = ft.all_reading.reject{|r| r == preferred_reading}
 
-	  div(
-	    expand_reading(preferred_reading, include_rolenames),
-	    'glossary-reading'
-	  )+
-	  (if include_alternates and alternate_readings.size > 0
-	    div(
-	      "(alternatively: " +
-	      alternate_readings.map do |reading|
-		div(
-		  expand_reading(reading, include_rolenames),
-		  'glossary-reading'
-		)
-	      end*",\n"+')',
-	      'glossary-alternates'
-	    )
-	  else
-	    ''
-	  end
-	  )
+      	  div(
+      	    expand_reading(preferred_reading, include_rolenames),
+      	    'glossary-reading'
+      	  )+
+      	  (if include_alternates and alternate_readings.size > 0
+      	    div(
+      	      "(alternatively: " +
+      	      alternate_readings.map do |reading|
+      		div(
+      		  expand_reading(reading, include_rolenames),
+      		  'glossary-reading'
+      		)
+      	      end*",\n"+')',
+      	      'glossary-alternates'
+      	    )
+      	  else
+      	    ''
+      	  end
+      	  )
         end
 
         def fact_type_with_constraints(ft, wrt = nil)
-	  if ft.entity_type
-	    div(
-	      termref(ft.entity_type.name) +
-		div(' is where ', 'keyword') +
-		fact_type(ft, true, wrt),
-	      'glossary-objectification'
-	    )
-	  else
-	    fact_type_block(ft, true, wrt)
-	  end +
-            %Q{\n<ul class="glossary-constraints">\n}+
-	    (unless ft.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-	      fact_type_constraints(ft)
-	    else
-	      ''
-	    end) +
-            "</ul>"
+      	  if ft.entity_type
+      	    div(
+      	      termref(ft.entity_type.name) +
+      		div(' is where ', 'keyword') +
+      		fact_type(ft, true, wrt),
+      	      'glossary-objectification'
+      	    )
+      	  else
+      	    fact_type_block(ft, true, wrt)
+      	  end +
+                  %Q{\n<ul class="glossary-constraints">\n}+
+      	    (unless ft.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+      	      fact_type_constraints(ft)
+      	    else
+      	      ''
+      	    end) +
+                  "</ul>"
         end
 
         def fact_type_constraints(ft)
@@ -327,14 +359,14 @@ module ActiveFacts
                 reading.role_sequence.all_role_ref_in_order[reading.role_numbers[-1]].role == residual_role
               }
             next nil unless reading
-	    div(
-	      element(
-		reading.expand_with_final_presence_constraint { |*a| role_ref(*a) },
-		{:class => 'copula'}
-	      ),
-	      'glossary-constraint'
-	    )+"\n"
-          end.compact*''
+        	    div(
+        	      element(
+        		reading.expand_with_final_presence_constraint { |*a| role_ref(*a) },
+        		{:class => 'copula'}
+        	      ),
+        	      'glossary-constraint'
+        	    )+"\n"
+                  end.compact*''
         end
 
         def objectified_fact_type_dump(o)
@@ -345,7 +377,7 @@ module ActiveFacts
           # REVISIT: Handle separate identification
 
           puts "  <dd>"
-	  puts fact_type_with_constraints(o.fact_type)
+      	  puts fact_type_with_constraints(o.fact_type)
 
           o.fact_type.all_role_in_order.each do |r|
             n = r.object_type.name
@@ -367,59 +399,59 @@ module ActiveFacts
             [
               (supers.size > 0 ? "#{span('is a kind of', 'keyword')} #{supers.map{|s| termref(s.name)}*', '}" : nil),
               (if pi
-		"#{span('is identified by', 'keyword')} " +
-		pi.role_sequence.all_role_ref_in_order.map do |rr|
-		  termref(
-		    rr.role.object_type.name,
-		    [ rr.leading_adjective,
-		      rr.role.role_name || rr.role.object_type.name,
-		      rr.trailing_adjective
-		    ].compact*'-'
-		  )
-		end*", "
-	      else
-		nil
-	      end)
+            		"#{span('is identified by', 'keyword')} " +
+            		pi.role_sequence.all_role_ref_in_order.map do |rr|
+            		  termref(
+            		    rr.role.object_type.name,
+            		    [ rr.leading_adjective,
+            		      rr.role.role_name || rr.role.object_type.name,
+            		      rr.trailing_adjective
+            		    ].compact*'-'
+            		  )
+            		end*", "
+            	      else
+            		nil
+            	      end)
             ].compact*', '
-            "</dt>"
+                  "</dt>"
 
-          puts "  <dd>"
-          relevant_facts_and_constraints(o)
-	  entities(o)
-          puts "  </dd>"
+                puts "  <dd>"
+                relevant_facts_and_constraints(o)
+            	  entities(o)
+                puts "  </dd>"
         end
 
-	def entities(o)
-	  return if o.preferred_identifier.role_sequence.all_role_ref.size > 1 # REVISIT: Composite identification
-	  o.all_instance.each do |i|
-	    v = i.value
-	    ii = i    # The identifying instance
-
-	    until v
-	      pi = ii.object_type.preferred_identifier		  # ii is an Entity Type
-	      break if pi.role_sequence.all_role_ref.size > 1	  # REVISIT: Composite identification
-
-	      identifying_fact_type = pi.role_sequence.all_role_ref.single.role.fact_type
-	      # Find the role played by this instance through which it is identified:
-	      irv = i.all_role_value.detect{|rv| rv.fact.fact_type == identifying_fact_type }
-	      # Get the other RoleValue in what must be a binary fact type:
-	      orv = irv.fact.all_role_value.detect{|rv| rv != irv}
-	      ii = orv.instance
-	      v = ii.value    # Does this instance have a value? If so, we're done.
-	    end
-
-	    next unless v
-	    puts div(
-		(i.population.name.empty? ? '' : i.population.name+': ') +
-		termref(o.name) + ' ' +
-		div(
-		# v.is_literal_string ? v.literal.inspect : v.literal,
-		  v.literal.inspect,
-		  'value'),
-		'glossary-example'
-	      )
-	  end
-	end
+      	def entities(o)
+      	  return if o.preferred_identifier.role_sequence.all_role_ref.size > 1 # REVISIT: Composite identification
+      	  o.all_instance.each do |i|
+      	    v = i.value
+      	    ii = i    # The identifying instance
+
+      	    until v
+      	      pi = ii.object_type.preferred_identifier		  # ii is an Entity Type
+      	      break if pi.role_sequence.all_role_ref.size > 1	  # REVISIT: Composite identification
+
+      	      identifying_fact_type = pi.role_sequence.all_role_ref.single.role.fact_type
+      	      # Find the role played by this instance through which it is identified:
+      	      irv = i.all_role_value.detect{|rv| rv.fact.fact_type == identifying_fact_type }
+      	      # Get the other RoleValue in what must be a binary fact type:
+      	      orv = irv.fact.all_role_value.detect{|rv| rv != irv}
+      	      ii = orv.instance
+      	      v = ii.value    # Does this instance have a value? If so, we're done.
+      	    end
+
+      	    next unless v
+      	    puts div(
+          		(i.population.name.empty? ? '' : i.population.name+': ') +
+          		termref(o.name) + ' ' +
+          		div(
+          		# v.is_literal_string ? v.literal.inspect : v.literal,
+          		  v.literal.inspect,
+          		  'value'),
+          		'glossary-example'
+      	      )
+      	  end
+      	end
 
       end
     end

data/lib/activefacts/generate/rails/schema.rb

@@ -143,13 +143,14 @@ module ActiveFacts
 
 	      foreign_keys.concat(
 		if (from_columns.length == 1)
+		  index_name = Persistence.rails_name_trunc('index_'+fk.from.rails_name+'_on_'+from_columns[0])
 		  [
 		    "    add_foreign_key :#{fk.from.rails_name}, :#{fk.to.rails_name}, :column => :#{from_columns[0]}, :primary_key => :#{to_columns[0]}, :on_delete => :cascade"
 		  ]+
 		  Array(
 		    # Index it non-uniquely only if it's not unique already:
 		    fk.jump_reference.to_role.unique ? nil :
-		      "    add_index :#{fk.from.rails_name}, [:#{from_columns[0]}], :unique => false"
+		      "    add_index :#{fk.from.rails_name}, [:#{from_columns[0]}], :unique => false, :name => :#{index_name}"
 		  )
 		else
 		  # This probably isn't going to work without Dr Nic's CPK gem:

data/lib/activefacts/generate/transform/surrogate.rb

@@ -128,7 +128,10 @@ module ActiveFacts
 
 	  irf.flatten!
 
-	  # Multi-part identifiers are only allowed if each part is a foreign key (i.e. it's a join table) and the object is not the target of a foreign key:
+	  # Multi-part identifiers are only allowed if:
+	  # * each part is a foreign key (i.e. it's a join table),
+	  # * there are no other columns (that might require updating) and
+	  # * the object is not the target of a foreign key:
 	  if irf.size >= 2
 	    if pk_fks.include?(nil)
 	      trace :transform_surrogate, "#{self.name} needs a surrogate because its multi-part key contains a non-table"
@@ -136,6 +139,9 @@ module ActiveFacts
 	    elsif references_to.size != 0
 	      trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect} but is also an FK target"
 	      return true
+	    elsif (references_from-identifying_refs_from).size > 0
+	      # There are other attributes to worry about
+	      return true
 	    else
 	      trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect}"
 	      return false

data/lib/activefacts/input/cql.rb

@@ -14,9 +14,13 @@ module ActiveFacts
     class CQL
       # Read the specified file
       def self.readfile(filename)
-        File.open(filename) {|file|
-          read(file, filename)
-        }
+	if File.basename(filename, '.cql') == "-"
+	  read(STDIN, "<standard input>")
+	else
+	  File.open(filename) {|file|
+	    read(file, filename)
+	  }
+	end
       rescue => e
         # Augment the exception message, but preserve the backtrace
         ne = StandardError.new("In #{filename} #{e.message.strip}")

data/lib/activefacts/input/orm.rb

@@ -72,9 +72,13 @@ module ActiveFacts
 
     private
       def self.readfile(filename, *options)
-        File.open(filename) {|file|
-          self.read(file, filename, *options)
-        }
+	if File.basename(filename, '.orm') == "-"
+	  self.read(STDIN, "<standard input>", options)
+	else
+	  File.open(filename) {|file|
+	    self.read(file, filename, *options)
+	  }
+	end
       end
 
       def self.read(file, filename = "stdin", *options)
@@ -378,7 +382,7 @@ module ActiveFacts
             rs2 = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs2, 0, :role => supertype_role)
             @constellation.RoleRef(rs2, 1, :role => subtype_role)
-            n = 'aeiouh'.include?(subtype_role.object_type.name.downcase[0]) ? 1 : 0
+            n = 'aeioh'.include?(subtype_role.object_type.name.downcase[0]) ? 1 : 0
             @constellation.Reading(inheritance_fact, 2+n, :role_sequence => rs2, :text => "{0} is a {1}", :is_negative => false)
             @constellation.Reading(inheritance_fact, 3-n, :role_sequence => rs2, :text => "{0} is an {1}", :is_negative => false)
           }
@@ -835,12 +839,12 @@ module ActiveFacts
           @constellation.Variable(query, query.all_variable.size, :object_type => ti.subtype)
         supertype_node = query.all_variable.detect{|jn| jn.object_type == ti.supertype } ||
           @constellation.Variable(query, query.all_variable.size, :object_type => ti.supertype)
+        step = @constellation.Step(:guid => :new, :fact_type => ti)
         rs = @constellation.RoleSequence(:new)
         @constellation.RoleRef(rs, 0, :role => ti.subtype_role)
-        sub_play = @constellation.Play(subtype_node, ti.subtype_role)
+        sub_play = @constellation.Play(:step => step, :variable => subtype_node, :role => ti.subtype_role)
         @constellation.RoleRef(rs, 1, :role => ti.supertype_role)
-        sup_play = @constellation.Play(supertype_node, ti.supertype_role)
-        step = @constellation.Step(sub_play, sup_play, :fact_type => ti)
+        sup_play = @constellation.Play(:step => step, :variable => supertype_node, :role => ti.supertype_role, :is_input => true)
         trace :query, "New subtyping step #{step.describe}"
         step
       end
@@ -972,11 +976,11 @@ module ActiveFacts
                     # There may be more than one supertyping level. Make the steps:
                     subtyping_steps = subtype_steps(query, subtype, end_point)
                     step = subtyping_steps[0]
-                    constrained_play = subtyping_steps[-1].input_play
+                    constrained_play = subtyping_steps[-1].all_play.detect{|p| p.role.object_type == end_point}
 
                     # Replace the constrained role and node with the supertype ones:
                     end_node = query.all_variable.detect{|jn| jn.object_type == end_point }
-                    projecting_play = step.output_play
+                    projecting_play = step.all_play.detect{|p| p.role.object_type == subtype}
                     end_role = step.fact_type.all_role.detect{|r| r.object_type == end_point }
                     role_node = query.all_variable.detect{|jn| jn.object_type == role_ref.role.object_type }
                   end
@@ -984,7 +988,7 @@ module ActiveFacts
 
                 raise "Internal error in #{constraint_type} #{name}: making illegal reference to variable, end role mismatch" if end_role.object_type != end_node.object_type
                 rr = @constellation.RoleRef(replacement_rs, replacement_rs.all_role_ref.size, :role => end_role)
-                projecting_play ||= (constrained_play = @constellation.Play(end_node, end_role))
+                projecting_play ||= (constrained_play = @constellation.Play(:variable => end_node, :role => end_role))
                 projecting_play.role_ref = rr   # Project this RoleRef
                 # projecting_play.variable.projection = rr.role   # REVISIT: The variable should project a role, not the Play a RoleRef
 
@@ -997,13 +1001,12 @@ module ActiveFacts
                     rs = @constellation.RoleSequence(:new)
                     # Detect the fact type over which we're stepping (may involve objectification)
                     raise "Internal error in #{constraint_type} #{name}: making illegal reference to variable, object type mismatch" if role_ref.role.object_type != role_node.object_type
+		    step = @constellation.Step(:guid => :new, :fact_type => joined_role.fact_type)
                     @constellation.RoleRef(rs, 0, :role => role_ref.role)
-                    role_play = @constellation.Play(role_node, role_ref.role)
+                    role_play = @constellation.Play(:step => step, :variable => role_node, :role => role_ref.role, :is_input => true)
                     raise "Internal error in #{constraint_type} #{name}: making illegal reference to variable, joined_role mismatch" if joined_role.object_type != variable.object_type
                     @constellation.RoleRef(rs, 1, :role => joined_role)
-                    join_play = @constellation.Play(variable, joined_role)
-
-                    step = @constellation.Step(role_play, join_play, :fact_type => joined_role.fact_type)
+                    join_play = @constellation.Play(:step => step, :variable => variable, :role => joined_role)
                     trace :query, "New step #{step.describe}"
                   end
                 else
@@ -1012,13 +1015,13 @@ module ActiveFacts
                     # Here we have an end join (step already created) but no sequence join
                     if variable
                       raise "Internal error in #{constraint_type} #{name}: making illegal step" if role_ref.role.object_type != role_node.object_type
-                      join_play = @constellation.Play(variable, query_role)
-                      role_play = @constellation.Play(role_node, role_ref.role)
-                      step = @constellation.Step(join_play, role_play, :fact_type => role_ref.role.fact_type)
+		      step = @constellation.Step(:guid => :new, :fact_type => role_ref.role.fact_type)
+                      join_play = @constellation.Play(:step => step, :variable => variable, :role => query_role, :is_input => true)
+                      role_play = @constellation.Play(:step => step, :variable => role_node, :role => role_ref.role)
                       roles -= [query_role, role_ref.role]
                       roles.each do |incidental_role|
                         jn = @constellation.Variable(query, query.all_variable.size, :object_type => incidental_role.object_type)
-                        play = @constellation.Play(jn, incidental_role, :step => step)
+                        play = @constellation.Play(:step => step, :variable => jn, :role => incidental_role, :step => step)
                       end
                     else
                       if role_sequence.all_role_ref.size > 1
@@ -1028,25 +1031,20 @@ module ActiveFacts
                         # There's no query in this role sequence, so we'd drop off the bottom without doing the right things. Why?
                         # Without this case, Supervision.orm omits "that runs Company" from the exclusion constraint, and I'm not sure why.
                         # I think the "then" code causes it to drop out the bottom without making the step (which is otherwise made in every case, see CompanyDirectorEmployee for example)
-                        role_play = @constellation.Play(role_node, role_ref.role)
-                        step = nil
+			step = @constellation.Step(:guid => :new, :fact_type => role_ref.role.fact_type)
+                        role_play = @constellation.Play(:step => step, :variable => role_node, :role => role_ref.role, :is_input => true)
                         role_ref.role.fact_type.all_role.each do |role|
                           next if role == role_play.role
                           next if role_sequence.all_role_ref.detect{|rr| rr.role == role}
                           jn = @constellation.Variable(query, query.all_variable.size, :object_type => role.object_type)
-                          play = @constellation.Play(jn, role)
-                          if step
-                            play.step = step  # Incidental role
-                          else
-                            step = @constellation.Step(role_play, play, :fact_type => role_ref.role.fact_type)
-                          end
+                          play = @constellation.Play(:step => step, :variable => jn, :role => role)
                         end
                       end
                     end
                   else
                     # Unary fact type, make a Step from and to the constrained_play
-                    play = @constellation.Play(constrained_play.variable, role_ref.role)
-                    step = @constellation.Step(play, play, :fact_type => role_ref.role.fact_type)
+                    step = @constellation.Step(:guid => :new, :fact_type => role_ref.role.fact_type)
+                    play = @constellation.Play(:step => step, :variable => constrained_play.variable, :role => role_ref.role, :is_input => true)
                   end
                 end
               end
@@ -1092,9 +1090,15 @@ module ActiveFacts
               @mandatory_constraints_by_rs.delete(mc_rs)
             end
 
-            next if role_sequences.compact.size != role_sequences.size  # Role sequence missing; includes a derived fact type role
+	    if role_sequences.compact.size != role_sequences.size  # Role sequence missing; includes a derived fact type role
+	      trace :orm, "skipped exclusion constraint #{id}, missing role sequence"
+	      next
+	    end
 
-            next unless make_queries('exclusion', name+(x_mandatory ? '/'+x_mandatory['Name'] : ''), role_sequences)
+	    unless make_queries('exclusion', name+(x_mandatory ? '/'+x_mandatory['Name'] : ''), role_sequences)
+	      trace :orm, "skipped exclusion constraint #{id}, can't make_queries"
+	      next
+	    end
 
             ec = @constellation.SetExclusionConstraint(id_of(x))
             ec.vocabulary = @vocabulary

data/lib/activefacts/mapping/rails.rb

@@ -5,6 +5,13 @@ require 'digest/sha1'
 
 module ActiveFacts
   module Persistence
+    def self.rails_name_trunc name
+      if name.length > 63
+	hash = Digest::SHA1.hexdigest name
+	name = name[0, 53] + '__' + hash[0, 8]
+      end
+      name
+    end
 
     def self.rails_plural_name name
       # Crunch spaces and pluralise the first part, all in snake_case
@@ -87,11 +94,7 @@ module ActiveFacts
       def rails_name
 	column_names = columns.map{|c| c.rails_name }
 	index_name = "index_#{on.rails_name+'_on_'+column_names*'_'}"
-	if index_name.length > 63
-	  hash = Digest::SHA1.hexdigest index_name
-	  index_name = index_name[0, 53] + '__' + hash[0, 8]
-	end
-	index_name
+	Persistence.rails_name_trunc index_name
       end
     end
 

data/lib/activefacts/persistence/reference.rb

@@ -304,7 +304,8 @@ module ActiveFacts
         when :supertype   # A subtype absorbs a reference to its supertype when separate, or all when partitioned
           # REVISIT: Or when partitioned
           raise hell unless role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-          if role.fact_type.assimilation  # assimilation == 'separate' or assimilation == 'partitioned'
+	  counterpart_role = (role.fact_type.all_role.to_a-[role])[0]
+          if role.fact_type.assimilation or counterpart_role.object_type.is_independent  # assimilation == 'separate' or assimilation == 'partitioned'
             trace :references, "supertype #{name} doesn't absorb a reference to separate subtype #{role.fact_type.subtype.name}"
           else
             r = ActiveFacts::Persistence::Reference.new(self, role)
@@ -314,7 +315,7 @@ module ActiveFacts
           end
 
         when :subtype    # This object is a supertype, which can absorb the subtype unless that's independent
-          if role.fact_type.assimilation
+          if role.fact_type.assimilation or is_independent
             ActiveFacts::Persistence::Reference.new(self, role).tabulate
             # If partitioned, the supertype is absorbed into *each* subtype; a reference to the supertype needs to know which
           else

data/lib/activefacts/version.rb

@@ -7,8 +7,8 @@
 module ActiveFacts
   module Version
     MAJOR = 1
-    MINOR = 2
-    PATCH = 1
+    MINOR = 3
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefacts
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Clifford Heath
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-12 00:00:00.000000000 Z
+date: 2015-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activefacts-api