activefacts-generators 1.8.3 → 1.9.0

data/lib/activefacts/generators/help.rb

@@ -14,22 +14,22 @@ module ActiveFacts
     class HELP
     private
       def initialize(vocabulary, *options)
-	generators = $:.
-	  map{|path|
+        generators = $:.
+          map{|path|
             Dir[path+"/activefacts/generators/**/*.rb"].
-	      reject{|p|
-		p =~ %r{/(transform|helpers)/}
-	      }.
-	      map{|p|
+              reject{|p|
+                p =~ %r{/(transform|helpers)/}
+              }.
+              map{|p|
                 p.sub(%r{.*/activefacts/generators/}, '').sub(/\.rb/,'')
               }
           }
-	transformers = $:.
-	  map{|path|
+        transformers = $:.
+          map{|path|
             Dir[path+"/activefacts/generators/transform/**/*.rb"].
-	      map{|p|
+              map{|p|
                 p.sub(%r{.*/activefacts/generators/}, '').sub(/\.rb/,'')
-	      }
+              }
           }
 
         puts %Q{

data/lib/activefacts/generators/helpers/inject.rb

@@ -5,11 +5,11 @@ module ActiveFacts
     def self.included other
       overlap = Metamodel.constants & other.constants
       overlap.each do |const|
-	mix_into = Metamodel.const_get(const)
-	mix_in = other.const_get(const)
-	mix_into.instance_exec {
-	  include(mix_in)
-	}
+        mix_into = Metamodel.const_get(const)
+        mix_in = other.const_get(const)
+        mix_into.instance_exec {
+          include(mix_in)
+        }
       end
     end
   end

data/lib/activefacts/generators/helpers/oo.rb

@@ -47,7 +47,7 @@ module ActiveFacts
                 !role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
             }.
             sort_by{|role|
-	      other_role = role.fact_type.all_role.select{|r2| r2 != role}[0] || role
+              other_role = role.fact_type.all_role.select{|r2| r2 != role}[0] || role
               other_role.preferred_role_name(o) + ':' + role.preferred_role_name(other_role.object_type)
             }.each{|role| 
               role_dump(role)
@@ -59,7 +59,7 @@ module ActiveFacts
           if fact_type.all_role.size == 1
             unary_dump(role, role.preferred_role_name)
             return
-	  end
+          end
           return if role.fact_type.entity_type
 
           if fact_type.all_role.size != 2
@@ -91,8 +91,8 @@ module ActiveFacts
           other_role_method = one_to_one ? role_method : "all_"+role_method
           # puts "---"+role.role_name if role.role_name
           if other_role_name != other_player.oo_default_role_name and
-	      role_method == role.object_type.oo_default_role_name
-	    # debugger
+              role_method == role.object_type.oo_default_role_name
+            # debugger
             other_role_method += "_as_#{other_role_name}"
           end
 
@@ -119,7 +119,7 @@ puts b
               role_name = role.preferred_role_name(fact_type.entity_type)
               one_to_one = role.is_unique
               as = role_name != role.object_type.oo_default_role_name ? "_as_#{role_name}" : ""
-#	      debugger if as != ''
+#             debugger if as != ''
               raise "Fact #{fact_type.describe} type is not objectified" unless fact_type.entity_type
               other_role_method = (one_to_one ? "" : "all_") + 
                 fact_type.entity_type.oo_default_role_name +

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

@@ -71,24 +71,24 @@ module ActiveFacts
         end
 
         def value_type_fork(o)
-	  if o.name == "_ImplicitBooleanValueType"
-	    # do nothing
-	  elsif
-	      !o.supertype                      # No supertype, i.e. a base type
-	      o.all_role.size == 0 &&           # No roles
-	      !o.is_independent &&              # not independent
-	      !o.value_constraint &&		# No value constraints
-	      o.concept.all_context_note_as_relevant_concept.size == 0 &&	# No context notes
-	      o.all_instance.size == 0          # No instances
-	    data_type_dump(o)
-	  else
-	    super_type_name = o.supertype ? o.supertype.name : o.name
-	    length = (l = o.length) && l > 0 ? "#{l}" : nil
-	    scale = (s = o.scale) && s > 0 ? "#{s}" : nil
-	    facets = { :length => length, :scale => scale }
-	    value_type_dump(o, super_type_name, facets)
-	  end
-	end
+          if o.name == "_ImplicitBooleanValueType"
+            # do nothing
+          elsif
+              !o.supertype                      # No supertype, i.e. a base type
+              o.all_role.size == 0 &&           # No roles
+              !o.is_independent &&              # not independent
+              !o.value_constraint &&            # No value constraints
+              o.concept.all_context_note_as_relevant_concept.size == 0 &&       # No context notes
+              o.all_instance.size == 0          # No instances
+            data_type_dump(o)
+          else
+            super_type_name = o.supertype ? o.supertype.name : o.name
+            length = (l = o.length) && l > 0 ? "#{l}" : nil
+            scale = (s = o.scale) && s > 0 ? "#{s}" : nil
+            facets = { :length => length, :scale => scale }
+            value_type_dump(o, super_type_name, facets)
+          end
+        end
 
         def value_types_dump
           done_banner = false
@@ -100,7 +100,7 @@ module ActiveFacts
 
               value_type_chain_dump(o)
 #              @object_types_dumped[o] = true
-	      o.ordered_dumped!
+              o.ordered_dumped!
             }
           value_type_end if done_banner
         end
@@ -129,18 +129,18 @@ module ActiveFacts
             count_this_pass = 0
             skipped_this_pass = 0
             sorted.each{|o|
-		next if o.ordered_dumped	    # Already done
+                next if o.ordered_dumped            # Already done
 
-		trace :ordered, "Panicing to dump #{panic.name}" if panic
+                trace :ordered, "Panicing to dump #{panic.name}" if panic
                 # Can we do this yet?
-		remaining_precursors = Array(@precursors[o])-[o]
+                remaining_precursors = Array(@precursors[o])-[o]
                 if (o != panic and                  # We don't *have* to do it (panic mode)
                     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
+                  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
+                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
@@ -168,24 +168,24 @@ module ActiveFacts
 =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
+                  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.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"
+                    (
+                      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:
@@ -211,8 +211,8 @@ module ActiveFacts
           # which will be attached to the uniqueness constraint on this object in the binary FT that
           # attaches that identifying role.
           identifying_role_refs =
-	    (o.fact_type && o.fact_type.all_role.size == 1 ? o.fact_type.preferred_reading : pi).
-	      role_sequence.all_role_ref_in_order
+            (o.fact_type && o.fact_type.all_role.size == 1 ? o.fact_type.preferred_reading : pi).
+              role_sequence.all_role_ref_in_order
 
           # We need to get the adjectives for the roles from the identifying fact's preferred readings:
           identifying_facts = ([o.fact_type]+identifying_role_refs.map{|rr| rr.role.fact_type }).compact.uniq
@@ -326,7 +326,7 @@ module ActiveFacts
 
           # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
           # These will come up as un-handled constraints:
-	  # Dump this fact type only if it contains a presence constraint we've missed:
+          # Dump this fact type only if it contains a presence constraint we've missed:
           pcs = @presence_constraints_by_fact[f]
           pcs && pcs.size > 0 && !pcs.detect{|c| !c.ordered_dumped }
         end
@@ -338,7 +338,7 @@ module ActiveFacts
           return if skip_fact_type(fact_type)
 
           if (et = fact_type.entity_type) &&
-	      fact_type.all_role.size > 1 &&
+              fact_type.all_role.size > 1 &&
               (pi = et.preferred_identifier) &&
               pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type != fact_type }
             # trace "Dumping objectified FT #{et.name} as an entity, non-fact PI"
@@ -423,11 +423,11 @@ module ActiveFacts
         def fact_type_key(fact_type)
           role_names =
             if (pr = fact_type.preferred_reading)
-              pr.role_sequence.
-                all_role_ref.
-                sort_by{|role_ref| role_ref.ordinal}.
+              role_refs = pr.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
+              role_refs.
                 map{|role_ref| [ role_ref.leading_adjective, role_ref.role.object_type.name, role_ref.trailing_adjective ].compact*"-" } +
-                [pr.text]
+                [pr.text] +
+                role_refs.map{|role_ref| [role_ref.role.is_mandatory ? 0 : 1] }
             else
               fact_type.all_role.map{|role| role.object_type.name }
             end
@@ -490,10 +490,10 @@ module ActiveFacts
         def constraints_dump
           heading = false
           @vocabulary.
-	      all_constraint.
-	      reject{|c| c.ordered_dumped}.
-	      sort_by{ |c| constraint_sort_key(c) }.
-	      each do |c|
+              all_constraint.
+              reject{|c| c.ordered_dumped}.
+              sort_by{ |c| constraint_sort_key(c) }.
+              each do |c|
             # Skip some PresenceConstraints:
             if c.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
               # Skip uniqueness constraints that cover all roles of a fact type, they're implicit
@@ -550,7 +550,7 @@ module ActiveFacts
           trace "Should override data_type_dump"
         end
 
-	def value_type_dump(o, super_type_name, facets)
+        def value_type_dump(o, super_type_name, facets)
           trace "Should override value_type_dump"
         end
 

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

@@ -43,10 +43,10 @@ module ActiveFacts
         def generate(out = $>)
           @out = out
           
-      	  @all_object_type =
-      	    @vocabulary.
-      	      all_object_type.
-      	      sort_by{|o| o.name.gsub(/ /,'').downcase}
+          @all_object_type =
+            @vocabulary.
+              all_object_type.
+              sort_by{|o| o.name.gsub(/ /,'').downcase}
           
           vocabulary_start
 
@@ -65,133 +65,133 @@ module ActiveFacts
             # 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+/, '')
+                  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
           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+/, '')
+                  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_toc
-      	  if @gen_bootstrap
+          if @gen_bootstrap
             puts '<div class="col-md-3 glossary-sidebar">'
           else
-        	  puts '<div class="glossary-sidebar">'
+                  puts '<div class="glossary-sidebar">'
           end
-      	  puts '<h1 style="visibility: hidden">X</h1>'
+          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
+          @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-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
+          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
+            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)
@@ -211,54 +211,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'
+            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) +
+                    (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)
+                  value_sub_types(o)
             relevant_facts_and_constraints(o)
-        	  values(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(
@@ -267,14 +267,14 @@ module ActiveFacts
               map{|r| r.fact_type}.
               uniq.
               reject do |ft|
-            		ft.is_a?(ActiveFacts::Metamodel::LinkFactType)
-      	      end.
+                        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::TypeInheritance) ? 0 : 1, text]
+                      }.
+                      map{|ft, text| text}.
+                      join "\n"
           )
         end
 
@@ -291,11 +291,11 @@ module ActiveFacts
         def expand_reading(reading, include_rolenames = true)
           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')
-      		}
-	      end
+              if role_name_def
+                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,
             {:class => 'copula'}
@@ -303,52 +303,52 @@ 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 +
+          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) +
+            (unless ft.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+              fact_type_constraints(ft)
+            else
+              ''
+            end) +
                   "</ul>"
         end
 
@@ -360,13 +360,13 @@ 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"
+                    div(
+                      element(
+                        reading.expand_with_final_presence_constraint { |*a| role_ref(*a) },
+                        {:class => 'copula'}
+                      ),
+                      'glossary-constraint'
+                    )+"\n"
                   end.compact*''
         end
 
@@ -378,7 +378,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
@@ -400,59 +400,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>"
 
                 puts "  <dd>"
                 relevant_facts_and_constraints(o)
-            	  entities(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