activefacts-rmap 1.8.1 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf33b3400b5c538ad43e3db107ca862a29f5b1f5
-  data.tar.gz: 3eb0d4cfa5be71a688a8a41cb138601fd76f6e3d
+  metadata.gz: 41a6ef1c77d0e5d8085c6564a4cdf9e4715094ba
+  data.tar.gz: 59989842387ccc9f7bc701cd9be100279ef8af92
 SHA512:
-  metadata.gz: d5358ddf562d53888ce4b9213a85e845d43b6b1947692bb8b2661b9ed30214b7c9fc2617ca589aaf674fde0715f584fdc8cba27ed4b1ece4ad68ddce60bd275a
-  data.tar.gz: 1c6170b95730f6b6c0ad08249953ea9dd2c63ea78aedabbb240b6190289d7f27d5074d11280eba6418c248e20f1f90b088ba2f75722941e55d444027f2181208
+  metadata.gz: c14280f747f47d489475e8499c1b1fb40f6dabfd593c424e7494f62bb39677dc04c2f2022443c39595a51439be01c501634ad07312040b453f98f0fc29e6083a
+  data.tar.gz: b82c172e59dbad9b14078be5a2410d96ca8fac4e2e6777e01f63ce1e3ea592a71f9f6a901d7ae6ff7311f8ecf987c45de080834f928e47ea8b6ffed45173c39a

data/Gemfile

@@ -2,7 +2,9 @@ source 'https://rubygems.org'
 
 gemspec
 
-if ENV['PWD'] =~ %r{\A#{ENV['HOME']}/work}
-  $stderr.puts "Using work area gems for #{File.basename(File.dirname(__FILE__))} from activefacts-rmap"
-  gem 'activefacts-metamodel', path: '/Users/cjh/work/activefacts/metamodel'
+this_file = File.absolute_path(__FILE__)
+if this_file =~ %r{\A#{ENV['HOME']}}i
+  dir = File.dirname(File.dirname(this_file))
+  $stderr.puts "Using work area gems in #{dir} from activefacts-rmap"
+  gem 'activefacts-metamodel', path: dir+'/metamodel'
 end

data/activefacts-rmap.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", ">= 1.10", "~> 1.10.6"
+  spec.add_development_dependency "bundler", ">= 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 

data/lib/activefacts/rmap/columns.rb

@@ -68,69 +68,73 @@ module ActiveFacts
 
       def self.name(refs, separator = "")
         last_names = []
-        names = refs.
-          inject([]) do |a, ref|
-
-            # Skip any object after the first which is identified by this reference
-            if ref != refs[0] and
-                !ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
-                ref.to and
-                ref.to.is_a?(ActiveFacts::Metamodel::EntityType) and
-                (role_ref = ref.to.preferred_identifier.role_sequence.all_role_ref.single) and
-                role_ref.role == ref.from_role
-              trace :columns, "Skipping #{ref}, identifies non-initial object"
-              next a
-            end
+        name_array = nil
+        trace :columns, "Building column name from #{refs.inspect}" do
+          names = refs.
+            inject([]) do |a, ref|
+
+              # Skip any object after the first which is identified by this reference
+              if ref != refs[0] and
+                  !ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
+                  ref.to and
+                  ref.to.is_a?(ActiveFacts::Metamodel::EntityType) and
+                  (role_ref = ref.to.preferred_identifier.role_sequence.all_role_ref.single) and
+                  role_ref.role == ref.from_role
+                trace :columns, "Skipping #{ref}, identifies non-initial object"
+                next a
+              end
 
-            names = ref.to_names(ref != refs.last)
+              names = ref.to_names(ref != refs.last)
 
-            # When traversing type inheritances, keep the subtype name, not the supertype names as well:
-            if a.size > 0 && ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-              if ref.to != ref.fact_type.subtype  # Did we already have the subtype?
-                trace :columns, "Skipping supertype #{ref}"
-                next a
+              # When traversing type inheritances, keep the subtype name, not the supertype names as well:
+              if a.size > 0 && ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+                if ref.to != ref.fact_type.subtype  # Did we already have the subtype?
+                  trace :columns, "Skipping supertype #{ref}"
+                  next a
+                end
+                trace :columns, "Eliding supertype in #{ref}"
+                last_names.size.times { a.pop }   # Remove the last names added
+              elsif last_names.last && last_names.last == names[0][0...last_names.last.size] 
+                # When Xyz is followed by XyzID, truncate that to just ID
+                trace :columns, "truncating repeated #{last_names.last} in #{names[0]}"
+                names[0] = names[0][last_names.last.size..-1]
+                names.shift if names[0] == ''
+              elsif last_names.last == names[0]
+                # Same, but where an underscore split up the words
+                trace :columns, "truncating repeated name in #{names.inspect}"
+                names.shift
               end
-              trace :columns, "Eliding supertype in #{ref}"
-              last_names.size.times { a.pop }   # Remove the last names added
-            elsif last_names.last && last_names.last == names[0][0...last_names.last.size] 
-              # When Xyz is followed by XyzID, truncate that to just ID
-              trace :columns, "truncating repeated #{last_names.last} in #{names[0]}"
-              names[0] = names[0][last_names.last.size..-1]
-              names.shift if names[0] == ''
-            elsif last_names.last == names[0]
-              # Same, but where an underscore split up the words
-              trace :columns, "truncating repeated name in #{names.inspect}"
-              names.shift
-            end
 
-            # If the reference is to the single identifying role of the object_type making the reference,
-            # strip the object_type name from the start of the reference role
-            if a.size > 0 and
-                (et = ref.from).is_a?(ActiveFacts::Metamodel::EntityType) and
-                # This instead of the next 2 would apply to all identifying roles, but breaks some examples:
-                # (role_ref = et.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == ref.to_role}) and
-                (role_ref = et.preferred_identifier.role_sequence.all_role_ref.single) and
-                role_ref.role == ref.to_role and
-                names[0][0...et.name.size].downcase == et.name.downcase
-
-              trace :columns, "truncating transitive identifying role #{names.inspect}"
-              names[0] = names[0][et.name.size..-1]
-              names.shift if names[0] == ""
-            end
+              # If the reference is to the single identifying role of the object_type making the reference,
+              # strip the object_type name from the start of the reference role
+              if a.size > 0 and
+                  (et = ref.from).is_a?(ActiveFacts::Metamodel::EntityType) and
+                  # This instead of the next 2 would apply to all identifying roles, but breaks some examples:
+                  # (role_ref = et.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == ref.to_role}) and
+                  (role_ref = et.preferred_identifier.role_sequence.all_role_ref.single) and
+                  role_ref.role == ref.to_role and
+                  names[0][0...et.name.size].downcase == et.name.downcase
+
+                trace :columns, "truncating transitive identifying role #{names.inspect}"
+                names[0] = names[0][et.name.size..-1]
+                names.shift if names[0] == ""
+              end
 
-            last_names = names
+              last_names = names
 
-            a += names
-            a
-          end.elide_repeated_subsequences { |a, b|
-            if a.is_a?(Array)
-              a.map{|e| e.downcase} == b.map{|e| e.downcase}
-            else
-              a.downcase == b.downcase
-            end
-          }
+              a += names
+              a
+            end.elide_repeated_subsequences { |a, b|
+              if a.is_a?(Array)
+                a.map{|e| e.downcase} == b.map{|e| e.downcase}
+              else
+                a.downcase == b.downcase
+              end
+            }
 
-        name_array = names.map{|n| n.sub(/^[a-z]/){|s| s.upcase}}
+          name_array = names.map{|n| n.sub(/^[a-z]/){|s| s.upcase}}
+          trace :columns, "column name is #{name_array*'.'}"
+        end
         separator ? name_array * separator : name_array
       end
 
@@ -163,21 +167,21 @@ module ActiveFacts
         end
 
         vt = references[-1].is_self_value ? references[-1].from : references[-1].to
-	begin
+        begin
           params[:length] ||= vt.length if vt.length.to_i != 0
           params[:scale] ||= vt.scale if vt.scale.to_i != 0
           constraints << vt.value_constraint if vt.value_constraint
-	  last_vt = vt
+          last_vt = vt
           vt = vt.supertype
         end while vt
-	params[:underlying_type] = last_vt
+        params[:underlying_type] = last_vt
         return [last_vt.name, params, constraints]
       end
 
       # The comment is the readings from the References expressed as a series of steps (not a full verbalisation)
       def comment
         @references.map do |ref|
-	  ref.verbalised_path
+          ref.verbalised_path
         end.compact * " and "
       end
 
@@ -192,34 +196,34 @@ module ActiveFacts
         cols = 
           if is_unary
             kind = "unary "
-	    objectified_unary_columns =
-	      ((@to && @to.fact_type) ?  @to.all_columns(excluded_supertypes) : [])
+            objectified_unary_columns =
+              ((@to && @to.fact_type) ?  @to.all_columns(excluded_supertypes) : [])
 
 =begin
-	    # This code omits the unary if it's objectified and that plays a mandatory role
-	    first_mandatory_column = nil
-	    if (@to && @to.fact_type)
-	      trace :unary_col, "Deciding whether to skip unary column for #{inspect}" do
-		first_mandatory_column =
-		  objectified_unary_columns.detect do |col|	# Detect a mandatory column for the unary
-		    trace :unary_col, "checking column #{col.name}" do
-		      !col.references.detect do |ref|
-			trace :unary_col, "#{ref} is mandatory=#{ref.is_mandatory.inspect}"
-			!ref.is_mandatory
-		      end
-		    end
-		  end
-		if is_from_objectified_fact && first_mandatory_column
-		  trace :unary_col, "Skipping unary column for #{inspect} because #{first_mandatory_column.name} is mandatory"
-		end
-	      end
-	    end
-
-            (is_from_objectified_fact && first_mandatory_column ? [] : [Column.new()]) +	  # The unary itself, unless its objectified
+            # This code omits the unary if it's objectified and that plays a mandatory role
+            first_mandatory_column = nil
+            if (@to && @to.fact_type)
+              trace :unary_col, "Deciding whether to skip unary column for #{inspect}" do
+                first_mandatory_column =
+                  objectified_unary_columns.detect do |col|     # Detect a mandatory column for the unary
+                    trace :unary_col, "checking column #{col.name}" do
+                      !col.references.detect do |ref|
+                        trace :unary_col, "#{ref} is mandatory=#{ref.is_mandatory.inspect}"
+                        !ref.is_mandatory
+                      end
+                    end
+                  end
+                if is_from_objectified_fact && first_mandatory_column
+                  trace :unary_col, "Skipping unary column for #{inspect} because #{first_mandatory_column.name} is mandatory"
+                end
+              end
+            end
+
+            (is_from_objectified_fact && first_mandatory_column ? [] : [Column.new()]) +          # The unary itself, unless its objectified
 =end
 
-            [Column.new()] +	  # The unary itself
-	      objectified_unary_columns
+            [Column.new()] +      # The unary itself
+              objectified_unary_columns
           elsif is_self_value
             kind = "self-role "
             [Column.new()]
@@ -258,7 +262,7 @@ module ActiveFacts
       end
 
       def wipe_columns
-	@columns = nil
+        @columns = nil
       end
     end
 
@@ -327,7 +331,7 @@ module ActiveFacts
       def identifier_columns
         trace :columns, "Identifier Columns for #{name}" do
           if absorbed_via and
-            # If this is a subtype that has its own identification, use that.
+            # If this is a subtype that has its own identification, use that instead
             (all_type_inheritance_as_subtype.size == 0 ||
               all_type_inheritance_as_subtype.detect{|ti| ti.provides_identification })
             return absorbed_via.from.identifier_columns

data/lib/activefacts/rmap/foreignkey.rb

@@ -28,62 +28,62 @@ module ActiveFacts
       end
 
       def describe
-	"foreign key from #{from.name}(#{from_columns.map{|c| c.name}*', '}) to #{to.name}(#{to_columns.map{|c| c.name}*', '})"
+        "foreign key from #{from.name}(#{from_columns.map{|c| c.name}*', '}) to #{to.name}(#{to_columns.map{|c| c.name}*', '})"
       end
 
       def verbalised_path reverse = false
-	# REVISIT: This should be a proper join path verbalisation:
-	refs = reverse ? references.reverse : references
-	refs.map do |r|
-	  r.verbalised_path reverse
-	end * ' and '
+        # REVISIT: This should be a proper join path verbalisation:
+        refs = reverse ? references.reverse : references
+        refs.map do |r|
+          r.verbalised_path reverse
+        end * ' and '
       end
 
       # Which references are absorbed into the "from" table?
       def precursor_references
-	fk_jump = @references.detect(&:fk_jump)
-	jump_index = @references.index(fk_jump)
-	@references[0, jump_index]
+        fk_jump = @references.detect(&:fk_jump)
+        jump_index = @references.index(fk_jump)
+        @references[0, jump_index]
       end
 
       # Which references are absorbed into the "to" table?
       def following_references
-	fk_jump = @references.detect(&:fk_jump)
-	jump_index = @references.index(fk_jump)
-	fk_jump != @references.last ? @references[jump_index+1..-1] : []
+        fk_jump = @references.detect(&:fk_jump)
+        jump_index = @references.index(fk_jump)
+        fk_jump != @references.last ? @references[jump_index+1..-1] : []
       end
 
       def jump_reference
-	@references.detect(&:fk_jump)
+        @references.detect(&:fk_jump)
       end
 
       def to_name
-	p = precursor_references
-	f = following_references
-	j = jump_reference
+        p = precursor_references
+        f = following_references
+        j = jump_reference
 
-	@references.last.to_names +
-	  (p.empty? && f.empty? ? [] : ['via'] + p.map{|r| r.to_names}.flatten + f.map{|r| r.from_names}.flatten)
+        @references.last.to_names +
+          (p.empty? && f.empty? ? [] : ['via'] + p.map{|r| r.to_names}.flatten + f.map{|r| r.from_names}.flatten)
       end
 
       # The from_name is the role name of the table with the FK, viewed from the other end
       # When there are no precursor_references or following_references, it's the jump_reference.from_names
       # REVISIT: I'm still working out what to do with precursor_references and following_references
       def from_name
-	p = precursor_references
-	f = following_references
-	j = jump_reference
+        p = precursor_references
+        f = following_references
+        j = jump_reference
 
-	# pluralise unless j.is_one_to_one
+        # pluralise unless j.is_one_to_one
 
-	# REVISIT: references[0].from_names is where the FK lives; but the object of interest may be an absorbed subclass which we should use here instead:
-	# REVISIT: Should crunch superclasses in subtype traversals
-	# REVISIT: Need to add "_as_rolename" where rolename is not to.name
+        # REVISIT: references[0].from_names is where the FK lives; but the object of interest may be an absorbed subclass which we should use here instead:
+        # REVISIT: Should crunch superclasses in subtype traversals
+        # REVISIT: Need to add "_as_rolename" where rolename is not to.name
 
-	[
-	  @references[0].from_names,
-	  (p.empty? && f.empty? ? [] : ['via'] + p.map{|r| r.to_names}.flatten + f.map{|r| r.from_names}.flatten)
-	]
+        [
+          @references[0].from_names,
+          (p.empty? && f.empty? ? [] : ['via'] + p.map{|r| r.to_names}.flatten + f.map{|r| r.from_names}.flatten)
+        ]
       end
 
     end
@@ -103,83 +103,83 @@ module ActiveFacts
               # REVISIT: Disabled, as this should never happen.
               # next array if ref.to.absorbed_via != ref.fact_type
             end
-	    ref.fk_jump = true
+            ref.fk_jump = true
             array << [ref]
           elsif ref.is_absorbing or (ref.to && !ref.to.is_table)
-	    trace :fk, "getting fks absorbed into #{name} via #{ref}" do
-	      ref.to.all_absorbed_foreign_key_reference_path.each do |aref|
-		array << aref.insert(0, ref)
-	      end
-	    end
+            trace :fk, "getting fks absorbed into #{name} via #{ref}" do
+              ref.to.all_absorbed_foreign_key_reference_path.each do |aref|
+                array << aref.insert(0, ref)
+              end
+            end
           end
           array
         end
       end
 
       def foreign_keys_to
-	@foreign_keys_to ||= []
+        @foreign_keys_to ||= []
       end
 
       # Return an array of all the foreign keys from this table
       def foreign_keys
 
         # Get the ForeignKey object for each absorbed reference path
-	@foreign_keys ||=
-	  begin
-	    fk_ref_paths = all_absorbed_foreign_key_reference_path
-	    fk_ref_paths.map do |fk_ref_path|
-	      trace :fk, "\nFK: " + fk_ref_path.map{|fk_ref| fk_ref.reading }*" and " do
-
-		from_columns = (columns||all_columns({})).select{|column|
-		  column.references[0...fk_ref_path.size] == fk_ref_path
-		}
-		trace :fk, "from_columns = #{from_columns.map { |column| column.name }*", "}"
-
-		# Figure out absorption on the target end:
-		to = fk_ref_path.last.to
-		if to.absorbed_via
-		  trace :fk, "Reference target #{fk_ref_path.last.to.name} is absorbed via:" do
-		    while (r = to.absorbed_via)
-		      m = r.reversed
-		      trace :fk, "#{m.reading}"
-		      fk_ref_path << m
-		      to = m.from == to ? m.to : m.from
-		    end
-		    trace :fk, "Absorption ends at #{to.name}"
-		  end
-		end
-
-		# REVISIT: This test may no longer be necessary
-		raise "REVISIT: #{fk_ref_path.inspect} is bad" unless to and to.columns
-
-		# REVISIT: This fails for absorbed subtypes having their own identification.
-		# Check the CompanyDirectorEmployee model for example, EmployeeManagerNr -> Person (should reference EmployeeNr)
-		# Need to use the absorbed identifier_columns of the subtype,
-		# not the columns of the supertype that absorbs it.
-		# But in general, that isn't going to work because in most DBMS
-		# there's no suitable uniquen index on the subtype's identifier_columns
-
-		to_columns = fk_ref_path[-1].to.identifier_columns
-
-		# Put the column pairs in the correct order. They MUST be in the order they appear in the primary key
-		froms, tos = from_columns.zip(to_columns).sort_by { |pair|
-		  to_columns.index(pair[1])
-		}.transpose
-
-		fk = ActiveFacts::RMap::ForeignKey.new(self, to, fk_ref_path, froms, tos)
-		to.foreign_keys_to << fk
-		fk
-	      end
-	    end.
-	    sort_by do |fk|
-	      # Put the foreign keys in a defined order:
-#	      debugger if !fk.to_columns || fk.to_columns.include?(nil) || !fk.from_columns || fk.from_columns.include?(nil)
-	      [ fk.to.name,
-		fk.to_columns.map{|col| col.name(nil).sort},
-		fk.from_columns.map{|col| col.name(nil).sort}
-	      ]
-	    end
-	  end
+        @foreign_keys ||=
+          begin
+            fk_ref_paths = all_absorbed_foreign_key_reference_path
+            fk_ref_paths.map do |fk_ref_path|
+              trace :fk, "\nFK: " + fk_ref_path.map{|fk_ref| fk_ref.reading }*" and " do
+
+                from_columns = (columns||all_columns({})).select{|column|
+                  column.references[0...fk_ref_path.size] == fk_ref_path
+                }
+                trace :fk, "from_columns = #{from_columns.map { |column| column.name }*", "}"
+
+                # Figure out absorption on the target end:
+                to = fk_ref_path.last.to
+                if to.absorbed_via
+                  trace :fk, "Reference target #{fk_ref_path.last.to.name} is absorbed via:" do
+                    while (r = to.absorbed_via)
+                      m = r.reversed
+                      trace :fk, "#{m.reading}"
+                      fk_ref_path << m
+                      to = m.from == to ? m.to : m.from
+                    end
+                    trace :fk, "Absorption ends at #{to.name}"
+                  end
+                end
+
+                # REVISIT: This test may no longer be necessary
+                raise "REVISIT: #{fk_ref_path.inspect} is bad" unless to and to.columns
+
+                # REVISIT: This fails for absorbed subtypes having their own identification.
+                # Check the CompanyDirectorEmployee model for example, EmployeeManagerNr -> Person (should reference EmployeeNr)
+                # Need to use the absorbed identifier_columns of the subtype,
+                # not the columns of the supertype that absorbs it.
+                # But in general, that isn't going to work because in most DBMS
+                # there's no suitable uniquen index on the subtype's identifier_columns
+
+                to_columns = fk_ref_path[-1].to.identifier_columns
+
+                # Put the column pairs in the correct order. They MUST be in the order they appear in the primary key
+                froms, tos = from_columns.zip(to_columns).sort_by { |pair|
+                  to_columns.index(pair[1])
+                }.transpose
+
+                fk = ActiveFacts::RMap::ForeignKey.new(self, to, fk_ref_path, froms, tos)
+                to.foreign_keys_to << fk
+                fk
+              end
+            end.
+            sort_by do |fk|
+              # Put the foreign keys in a defined order:
+#             debugger if !fk.to_columns || fk.to_columns.include?(nil) || !fk.from_columns || fk.from_columns.include?(nil)
+              [ fk.to.name,
+                fk.to_columns.map{|col| col.name(nil).sort},
+                fk.from_columns.map{|col| col.name(nil).sort}
+              ]
+            end
+          end
 
       end
     end

data/lib/activefacts/rmap/index.rb

@@ -69,13 +69,13 @@ module ActiveFacts
       end
 
       def to_s  #:nodoc:
-	if @uniqueness_constraint
-	  name = @uniqueness_constraint.name
-	  preferred = @uniqueness_constraint.is_preferred_identifier ? " (preferred)" : ""
-	else
-	  name = "#{@on.name}IsUnique"
-	  preferred = !@on.injected_surrogate_role ? " (preferred)" : ""
-	end
+        if @uniqueness_constraint
+          name = @uniqueness_constraint.name
+          preferred = @uniqueness_constraint.is_preferred_identifier ? " (preferred)" : ""
+        else
+          name = "#{@on.name}IsUnique"
+          preferred = !@on.injected_surrogate_role ? " (preferred)" : ""
+        end
         colnames = @columns.map(&:name)*", "
         "Index #{name} on #{@on.name} over #{@over.name}(#{colnames})#{preferred}"
       end
@@ -85,26 +85,26 @@ module ActiveFacts
   module Metamodel    #:nodoc:
     class EntityType
       def self_index
-	nil
+        nil
       end
     end
 
     class ValueType
       def self_index
-	ActiveFacts::RMap::Index.new(
-	  nil,	  # The implied uniqueness constraint is not created
-	  self,	  # ValueType being indexed
-	  self,	  # Absorbed object being indexed
-	  columns.select{|c| c.references[0].is_self_value},
-	  injected_surrogate_role ? false : true
-	)
+        ActiveFacts::RMap::Index.new(
+          nil,    # The implied uniqueness constraint is not created
+          self,   # ValueType being indexed
+          self,   # Absorbed object being indexed
+          columns.select{|c| c.references[0].is_self_value},
+          injected_surrogate_role ? false : true
+        )
       end
     end
 
     class ObjectType
       # An array of each Index for this table
       def indices
-	@indices || populate_indices
+        @indices || populate_indices
       end
 
       def clear_indices     #:nodoc:
@@ -146,7 +146,7 @@ module ActiveFacts
                 # trace :index2, "Considering #{ref_path.map(&:to_s)*" and "} yielding columns #{all_column_by_ref_path[ref_path].map{|c| c.name('.')}*", "}"
                 ref.to_role.all_role_ref.each do |role_ref|
                   all_pcs = role_ref.role_sequence.all_presence_constraint
-		  # puts "pcs over #{ref_path.map{|r| r.to_names}.flatten*'.'}: #{role_ref.role_sequence.all_presence_constraint.map(&:describe)*"; "}" if all_pcs.size > 0
+                  # puts "pcs over #{ref_path.map{|r| r.to_names}.flatten*'.'}: #{role_ref.role_sequence.all_presence_constraint.map(&:describe)*"; "}" if all_pcs.size > 0
                   pcs = all_pcs.
                     reject do |pc|
                       !pc.max_frequency or      # No maximum freq; cannot be a uniqueness constraint
@@ -179,12 +179,12 @@ module ActiveFacts
             over = columns[0].references[absorption_level].from
 
             # Absorption through a one-to-one forms a UC that we don't need to enforce using an index:
-	    if over != self and
+            if over != self and
               over.absorbed_via == columns[0].references[absorption_level-1] and
               (rr = uc.role_sequence.all_role_ref.single) and
               over.absorbed_via.fact_type.all_role.include?(rr.role)
-	      next nil
-	    end
+              next nil
+            end
 
             index = ActiveFacts::RMap::Index.new(
               uc,
@@ -202,9 +202,9 @@ module ActiveFacts
             index.columns.map(&:name)+['', index.over.name]
           end
         end
-	si = self_index
-	@indices.unshift(si) if si
-	@indices
+        si = self_index
+        @indices.unshift(si) if si
+        @indices
       end
 
     end

data/lib/activefacts/rmap/reference.rb

@@ -74,9 +74,9 @@ module ActiveFacts
 
       # Is this Reference covered by a mandatory constraint (implicitly or explicitly)
       def is_mandatory
-	!is_unary &&
-	  (!@from_role ||        # All phantom roles of fact types are mandatory
-	    @from_role.is_mandatory)
+        !is_unary &&
+          (!@from_role ||        # All phantom roles of fact types are mandatory
+            @from_role.is_mandatory)
       end
 
       # Is this Reference from a unary Role?
@@ -177,6 +177,7 @@ module ActiveFacts
         # Flip the reference
         @to, @from = @from, @to
         @to_role, @from_role = @from_role, @to_role
+        trace :references, "Mirror #{self.inspect} absorbs #{@to.name}" if @to.absorbed_via == self
         self
       end
 
@@ -212,23 +213,23 @@ module ActiveFacts
       end
 
       def verbalised_path reverse = false
-	return "#{from.name} Value" if is_self_value
-	objectified = fact_type.entity_type 
-	f =	# Switch to the Link Fact Type if we're traversing an objectification
-	  (to_role && to_role.link_fact_type) ||
-	  (from_role && from_role.link_fact_type) ||
-	  fact_type
-
-	start_role =
-	  if objectified
-	    target = reverse ? to : from
-	    [to_role, from_role, f.all_role[0]].compact.detect{|role| role.object_type == target}
-	  else
-	    reverse ? to_role : from_role
-	  end
-	reading = f.reading_preferably_starting_with_role(start_role)
-	(is_mandatory || is_unary ? '' : 'maybe ') +
-	  reading.expand
+        return "#{from.name} Value" if is_self_value
+        objectified = fact_type.entity_type 
+        f =     # Switch to the Link Fact Type if we're traversing an objectification
+          (to_role && to_role.link_fact_type) ||
+          (from_role && from_role.link_fact_type) ||
+          fact_type
+
+        start_role =
+          if objectified
+            target = reverse ? to : from
+            [to_role, from_role, f.all_role_in_order[0]].compact.detect{|role| role.object_type == target}
+          else
+            reverse ? to_role : from_role
+          end
+        reading = f.reading_preferably_starting_with_role(start_role)
+        (is_mandatory || is_unary ? '' : 'maybe ') +
+          reading.expand
       end
 
       def inspect #:nodoc:
@@ -294,11 +295,8 @@ module ActiveFacts
         all_role.each do |role|
           # It's possible that this role is in an implicit or derived fact type. Skip it if so.
           next if role.fact_type.is_a?(LinkFactType) or
-	    # REVISIT: dafuq? Is this looking for a constraint over a derivation? This looks wrong.
-            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].play or
-	    # This is not yet actually set, and wouldn't handle constraint derivations anyhow:
-	    role.variable_as_projection
-          
+            # REVISIT: dafuq? Is this looking for a constraint over a derivation? This looks wrong.
+            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].play
           populate_reference role
         end
       end
@@ -324,13 +322,13 @@ module ActiveFacts
         when :supertype   # A subtype absorbs a reference to its supertype when separate, or all when partitioned
           # REVISIT: Or when partitioned
           raise "Internal error, expected TypeInheritance" unless role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-	  counterpart_role = (role.fact_type.all_role.to_a-[role])[0]
+          counterpart_role = (role.fact_type.all_role.to_a-[role])[0]
           if role.fact_type.assimilation or counterpart_role.object_type.is_separate
             trace :references, "supertype #{name} doesn't absorb a reference to separate subtype #{role.fact_type.subtype.name}"
           else
             r = ActiveFacts::RMap::Reference.new(self, role)
             r.to.absorbed_via = r
-            trace :references, "supertype #{name} absorbs subtype #{r.to.name}"
+            trace :references, "Supertype #{name} absorbs subtype #{r.to.name}"
             r.tabulate
           end
 
@@ -384,7 +382,7 @@ module ActiveFacts
             r.tabulate
           end
         else
-	  # REVISIT: Should we implicitly objectify this fact type here and add a spanning UC?
+          # REVISIT: Should we implicitly objectify this fact type here and add a spanning UC?
           raise "Role #{role.object_type.name} in '#{role.fact_type.default_reading}' lacks a uniqueness constraint"
         end
       end

data/lib/activefacts/rmap/tables.rb

@@ -45,16 +45,6 @@ module ActiveFacts
 
         @is_table
       end
-
-      # Is this ValueType auto-assigned either at assert or on first save to the database?
-      def is_auto_assigned
-        type = self
-	while type
-	  return true if type.name =~ /^Auto/ || type.transaction_phase
-	  type = type.supertype
-	end
-	false
-      end
     end
 
     class EntityType < DomainObjectType
@@ -150,7 +140,7 @@ module ActiveFacts
                 (rr = c.role_sequence.all_role_ref.single) and
                 rr.role == self
             end
-	# REVISIT: check mapping pragmas, e.g. by to_1.concept.all_concept_annotation.detect{|ca| ca.mapping_annotation == 'separate'}
+        # REVISIT: check mapping pragmas, e.g. by to_1.concept.all_concept_annotation.detect{|ca| ca.mapping_annotation == 'separate'}
 
         if fact_type.entity_type
           # This is a role in an objectified fact type
@@ -259,10 +249,10 @@ module ActiveFacts
                   pi_ref = nil
                   if pi_roles.size == 1 and
                     object_type.references_to.detect do |ref|
-		      if ref.from_role == first_pi_role and ref.from.is_a?(EntityType) # and ref.is_mandatory # REVISIT
-			pi_ref = ref
-		      end
-		    end
+                      if ref.from_role == first_pi_role and ref.from.is_a?(EntityType) # and ref.is_mandatory # REVISIT
+                        pi_ref = ref
+                      end
+                    end
 
                     trace :absorption, "#{object_type.name} is fully absorbed along its sole reference path into entity type #{pi_ref.from.name}"
                     object_type.definitely_not_table
@@ -275,16 +265,16 @@ module ActiveFacts
                       pi_roles.include?(ref.to_role)
                     }
                   trace :absorption, "#{object_type.name} has #{non_identifying_refs_from.size} non-identifying functional roles" do
-		    non_identifying_refs_from.each do |ref|
-		      trace :absorption, "#{ref.inspect}"
-		    end
-		  end
+                    non_identifying_refs_from.each do |ref|
+                      trace :absorption, "#{ref.inspect}"
+                    end
+                  end
 
-		  trace :absorption, "#{object_type.name} has #{object_type.references_to.size} references to it:" do
-		    object_type.references_to.each do |ref|
-		      trace :absorption, ref.inspect
-		    end
-		  end if object_type.references_to.size > 1
+                  trace :absorption, "#{object_type.name} has #{object_type.references_to.size} references to it:" do
+                    object_type.references_to.each do |ref|
+                      trace :absorption, ref.inspect
+                    end
+                  end if object_type.references_to.size > 1
 
                   if object_type.references_to.size > 1 and
                       non_identifying_refs_from.size > 0
@@ -298,7 +288,7 @@ module ActiveFacts
                       non_identifying_refs_from.reject do |ref|
                         !ref.to or ref.to.absorbed_via == ref
                       end +
-		      object_type.references_to
+                      object_type.references_to
                     ).reject do |ref|
                       next true if !ref.to.is_table or !ref.is_one_to_one
 
@@ -314,12 +304,12 @@ module ActiveFacts
                   # If this object can be fully absorbed, do that (might require flipping some references)
                   if absorption_paths.size > 0
                     trace :absorption, "#{object_type.name} is fully absorbed through #{absorption_paths.inspect}" do
-		      absorption_paths.each do |ref|
-			flip = object_type == ref.from
-			ref.flip if flip
-			trace :absorption, "#{object_type.name} is FULLY ABSORBED via {ref}#{flip ? ' (flipped)' : ''}"
-		      end
-		    end
+                      absorption_paths.each do |ref|
+                        flip = object_type == ref.from
+                        ref.flip if flip
+                        trace :absorption, "#{object_type.name} is FULLY ABSORBED via {ref}#{flip ? ' (flipped)' : ''}"
+                      end
+                    end
                     object_type.definitely_not_table
                     next object_type
                   end

data/lib/activefacts/rmap/version.rb

@@ -1,5 +1,5 @@
 module Activefacts
   module RMap
-    VERSION = "1.8.1"
+    VERSION = "1.8.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefacts-rmap
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.8.2
 platform: ruby
 authors:
 - Clifford Heath
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-04 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.10'
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.10.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.10'
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.10.6
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -121,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Relational mapping for ActiveFacts