activefacts 0.8.16 → 0.8.18

data/lib/activefacts/mapping/rails.rb

@@ -0,0 +1,122 @@
+require 'activefacts/vocabulary'
+require 'activefacts/persistence'
+require 'active_support'
+require 'digest/sha1'
+
+module ActiveFacts
+
+  module Persistence
+    # Return ActiveRecord type and (modified?) length for the passed base type
+    def self.rails_type(type, length)
+      rails_type = case type
+	when /^Auto ?Counter$/
+	  'integer'	    # REVISIT: Need to detect surrogate ID fields and handle them correctly
+
+	when /^Unsigned ?Integer$/,
+	  /^Integer$/,
+	  /^Signed ?Integer$/,
+	  /^Unsigned ?Small ?Integer$/,
+	  /^Signed ?Small ?Integer$/,
+	  /^Unsigned ?Tiny ?Integer$/
+	  length = nil
+	  'integer'
+
+	when /^Decimal$/
+	  'decimal'
+
+	when /^Fixed ?Length ?Text$/, /^Char$/
+	  'string'
+	when /^Variable ?Length ?Text$/, /^String$/
+	  'string'
+	when /^Large ?Length ?Text$/, /^Text$/
+	  'text'
+
+	when /^Date ?And ?Time$/, /^Date ?Time$/
+	  'datetime'
+	when /^Date$/
+	  'datetime'
+	when /^Time$/
+	  'time'
+	when /^Auto ?Time ?Stamp$/
+	  'timestamp'
+
+	when /^Money$/
+	  'decimal'
+	when /^Picture ?Raw ?Data$/, /^Image$/, /^Variable ?Length ?Raw ?Data$/, /^Blob$/
+	  'binary'
+	when /^BIT$/
+	  'boolean'
+	else type # raise "ActiveRecord type unknown for standard type #{type}"
+	end
+      [rails_type, length]
+    end
+
+    def self.rails_plural_name name
+      # Crunch spaces and pluralise the first part, all in snake_case
+      name.pop if name.is_a?(Array) and name.last == []
+      name = name[0]*'_' if name.is_a?(Array) and name.size == 1
+      if name.is_a?(Array)
+	name = ActiveSupport::Inflector.tableize((name[0]*'_').gsub(/\s+/, '_')) +
+	  '_' +
+	  ActiveSupport::Inflector.underscore((name[1..-1].flatten*'_').gsub(/\s+/, '_'))
+      else
+	ActiveSupport::Inflector.tableize(name.gsub(/\s+/, '_'))
+      end
+    end
+
+    def self.rails_singular_name name
+      # Crunch spaces and convert to snake_case
+      name = name.flatten*'_' if name.is_a?(Array)
+      ActiveSupport::Inflector.underscore(name.gsub(/\s+/, '_'))
+    end
+
+    class Column
+      def rails_name
+	Persistence::rails_singular_name(name('_'))
+      end
+    end
+
+    class Index
+      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
+      end
+    end
+
+    class ForeignKey
+      def rails_from_association_name
+	Persistence::rails_singular_name(to_name.join('_'))
+      end
+
+      def rails_to_association
+	jump = jump_reference
+	if jump.is_one_to_one
+	  [ "has_one", Persistence::rails_singular_name(from_name)]
+	else
+	  [ "has_many", Persistence::rails_plural_name(from_name)]
+	end
+      end
+    end
+  end
+
+  module Metamodel
+    class ObjectType
+      def rails_name
+	Persistence::rails_plural_name(name)
+      end
+
+      def rails_singular_name
+	Persistence::rails_singular_name(name)
+      end
+
+      def rails_class_name
+	ActiveSupport::Inflector.camelize(name.gsub(/\s+/, '_'))
+      end
+    end
+  end
+end

data/lib/activefacts/persistence/columns.rb

@@ -55,18 +55,18 @@ module ActiveFacts
       end
 
       # A Column name is a sequence of names (derived from the to_roles of the References)
-      # joined by a joiner string (pass nil to get the original array of names)
+      # appended by a separator string (pass nil to get the original array of names)
       # The names to use is derived from the to_names of each Reference,
       # modified by these rules:
       # * A reference after the first one which is not a TypeInheritance but where the _from_ object plays the sole role in the preferred identifier of the _to_ entity is ignored,
       # * A reference (after a name has been retained) which is a TypeInheritance retains the names of the subtype,
       # * If the names retained so far end in XYZ and the to_names start with XYZ, remove the duplication
       # * If we have retained the name of an entity, and this reference is the sole identifying role of an entity, and the identifying object has a name that is prefixed by the name of the object it identifies, remove the prefix and use just the suffix.
-      def name(joiner = "")
-        self.class.name(@references, joiner)
+      def name(separator = "")
+        self.class.name(@references, separator)
       end
 
-      def self.name(refs, joiner = "")
+      def self.name(refs, separator = "")
         last_names = []
         names = refs.
           inject([]) do |a, ref|
@@ -82,7 +82,7 @@ module ActiveFacts
               next a
             end
 
-            names = ref.to_names
+            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)
@@ -131,17 +131,23 @@ module ActiveFacts
           }
 
         name_array = names.map{|n| n.sub(/^[a-z]/){|s| s.upcase}}
-        joiner ? name_array * joiner : name_array
+        separator ? name_array * separator : name_array
       end
 
       # Is this column mandatory or nullable?
       def is_mandatory
-        !@references.detect{|ref| !ref.is_mandatory}
+        # Uncomment the following line for CWA unaries (not nullable, just T/F)
+        # @references[-1].is_unary ||
+          !@references.detect{|ref| !ref.is_mandatory || ref.is_unary }
       end
 
-      # Is this column an auto-assigned value type?
+      # This column is auto-assigned if it's an auto-assigned value type and is not a foreign key
       def is_auto_assigned
-        (to = references[-1].to) && to.is_auto_assigned
+        last_table_ref = references.reverse.detect{|r| r.from && r.from.is_table}
+        (to = references[-1].to) &&
+          to.is_auto_assigned &&
+          references[0].from.identifier_columns.size == 1 &&
+          references[0].from == last_table_ref.from
       end
 
       # What's the underlying SQL data type of this column?
@@ -168,7 +174,7 @@ module ActiveFacts
         return [vt.name, params, constraints]
       end
 
-      # The comment is the readings from the References expressed as a join
+      # 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.is_mandatory ? "" : "maybe ") +
@@ -186,9 +192,10 @@ module ActiveFacts
       def columns(excluded_supertypes)  #:nodoc:
         kind = ""
         cols = 
-          if is_unary && !(@to && @to.fact_type)
+          if is_unary
             kind = "unary "
-            [Column.new()]
+            [Column.new()] +
+              ((@to && @to.fact_type) ?  @to.all_columns(excluded_supertypes) : [])
           elsif is_self_value
             kind = "self-role "
             [Column.new()]
@@ -218,7 +225,7 @@ module ActiveFacts
     class ObjectType
       # The array of columns for this ObjectType's table
       def columns
-        @columns
+        @columns || populate_columns
       end
 
       def populate_columns  #:nodoc:
@@ -229,12 +236,16 @@ module ActiveFacts
 
     # The ValueType class is defined in the metamodel; full documentation is not generated.
     # This section shows the features relevant to relational Persistence.
-    class ValueType < ObjectType
+    class ValueType < DomainObjectType
       # The identifier_columns for a ValueType can only ever be the self-value role that was injected
       def identifier_columns
         debug :columns, "Identifier Columns for #{name}" do
           raise "Illegal call to identifier_columns for absorbed ValueType #{name}" unless is_table
-          columns.select{|column| column.references[0] == self_value_reference}
+          if isr = injected_surrogate_role
+            columns.select{|column| column.references[0].from_role == isr }
+          else
+            columns.select{|column| column.references[0] == self_value_reference}
+          end
         end
       end
 
@@ -243,7 +254,12 @@ module ActiveFacts
       def reference_columns(excluded_supertypes)  #:nodoc:
         debug :columns, "Reference Columns for #{name}" do
           if is_table
-            [ActiveFacts::Persistence::Column.new(self_value_reference)]
+            if isr = injected_surrogate_role
+              ref_from = references_from.detect{|ref| ref.from_role == isr}
+              [ActiveFacts::Persistence::Column.new(ref_from)]
+            else
+              [ActiveFacts::Persistence::Column.new(self_value_reference)]
+            end
           else
             [ActiveFacts::Persistence::Column.new]
           end
@@ -278,7 +294,7 @@ module ActiveFacts
 
     # The EntityType class is defined in the metamodel; full documentation is not generated.
     # This section shows the features relevant to relational Persistence.
-    class EntityType < ObjectType
+    class EntityType < DomainObjectType
       # The identifier_columns for an EntityType are the columns that result from the identifying roles
       def identifier_columns
         debug :columns, "Identifier Columns for #{name}" do
@@ -318,7 +334,7 @@ module ActiveFacts
             # REVISIT: Should index references by to_role:
             ref = references_from.detect {|ref| ref.to_role == role_ref.role}
 
-            raise "reference for role #{role.describe} not found on #{name} in #{references_from.size} references:\n\t#{references_from.map(&:to_s)*"\n\t"}" unless ref
+            raise "reference for role #{role_ref.describe} not found on #{name} in #{references_from.size} references:\n\t#{references_from.map(&:to_s)*"\n\t"}" unless ref
 
             ref.columns({})
           end.flatten

data/lib/activefacts/persistence/foreignkey.rb

@@ -14,7 +14,7 @@ module ActiveFacts
       def to; @to; end
 
       # What reference created the FK?
-      def reference; @fk_ref; end
+      def references; @references; end
 
       # What columns in the *from* table form the FK
       def from_columns; @from_columns; end
@@ -22,10 +22,71 @@ module ActiveFacts
       # What columns in the *to* table form the identifier
       def to_columns; @to_columns; end
 
-      def initialize(from, to, fk_ref, from_columns, to_columns) #:nodoc:
-        @from, @to, @fk_ref, @from_columns, @to_columns =
-          from, to, fk_ref, from_columns, to_columns
+      def initialize(from, to, references, from_columns, to_columns) #:nodoc:
+        @from, @to, @references, @from_columns, @to_columns =
+          from, to, references, from_columns, to_columns
       end
+
+      def describe
+	"foreign key from #{from.name}(#{from_columns.map{|c| c.name}*', '}) to #{to.name}(#{to_columns.map{|c| c.name}*', '})"
+      end
+
+      def verbalised_path
+	# REVISIT: This should be a proper join path verbalisation:
+	references.map do |r|
+	  (r.fact_type.entity_type ? r.fact_type.entity_type.name + ' (in which ' : '') +
+	    r.fact_type.default_reading +
+	    (r.fact_type.entity_type ? ')' : '')
+	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]
+      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] : []
+      end
+
+      def jump_reference
+	@references.detect(&:fk_jump)
+      end
+
+      def to_name
+	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)
+      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
+
+	# 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
+
+	[
+	  @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
   end
 
@@ -43,87 +104,84 @@ module ActiveFacts
               # REVISIT: Disabled, as this should never happen.
               # next array if ref.to.absorbed_via != ref.fact_type
             end
+	    ref.fk_jump = true
             array << [ref]
-          elsif ref.is_absorbing
-            ref.to.all_absorbed_foreign_key_reference_path.each{|aref|
-              array << aref.insert(0, ref)
-            }
+          elsif ref.is_absorbing or (ref.to && !ref.to.is_table)
+	    debug :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 ||= []
+      end
+
       # Return an array of all the foreign keys from this table
       def foreign_keys
-        fk_ref_paths = all_absorbed_foreign_key_reference_path
 
         # Get the ForeignKey object for each absorbed reference path
-        fk_ref_paths.map do |fk_ref_path|
-          debug :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
-            }
-            debug :fk, "from_columns = #{from_columns.map { |column| column.name }*", "}"
-
-            absorption_path = []
-            to = fk_ref_path.last.to
-            # REVISIT: There should be a better way to find where it's absorbed (especially since this fails for absorbed subtypes having their own identification!)
-            while (r = to.absorbed_via)
-              absorption_path << r
-              to = r.to == to ? r.from : r.to
-            end
-            raise "REVISIT: #{fk_ref_path.inspect} is bad" unless to and to.columns
+	@foreign_keys ||= 
+	  begin
+	    fk_ref_paths = all_absorbed_foreign_key_reference_path
+	    fk_ref_paths.map do |fk_ref_path|
+	      debug :fk, "\nFK: " + fk_ref_path.map{|fk_ref| fk_ref.reading }*" and " do
 
-            unless absorption_path.empty?
-              debug :fk, "Reference target #{fk_ref_path.last.to.name} is absorbed into #{to.name} via:" do
-                debug :fk, "#{absorption_path.map(&:reading)*" and "}"
-              end
-            end
+		from_columns = (columns||all_columns({})).select{|column|
+		  column.references[0...fk_ref_path.size] == fk_ref_path
+		}
+		debug :fk, "from_columns = #{from_columns.map { |column| column.name }*", "}"
 
-            debug :fk, "Looking at absorption depth of #{absorption_path.size} in #{to.name} for to_columns for #{from_columns.map(&:name)*", "}:"
-            to_supertypes = to.supertypes_transitive
-            to_columns = from_columns.map do |from_column|
-              debug :fk, "\tLooking for counterpart of #{from_column.name}: #{from_column.comment}" do
-                target_path = absorption_path + from_column.references[fk_ref_path.size..-1]
-                debug :fk, "\tcounterpart MUST MATCH #{target_path.map(&:reading)*" and "}"
-                c = to.columns.detect do |column|
-                  debug :fk, "Considering #{column.references.map(&:reading) * " and "}"
-                  debug :fk, "exact match: #{column.name}: #{column.comment}" if column.references == target_path
-                  # Column may be inherited into "to", in which case target_path is too long.
-                  cr = column.references
-                  allowed_type = fk_ref_path.last.to
-                  #debug :fk, "Check for absorption, need #{allowed_type.name}" if cr != target_path
-                  cr == target_path or
-                    cr == target_path[-cr.size..-1] &&
-                    !target_path[0...-cr.size].detect do |ref|
-                      ft = ref.fact_type
-                      next true if allowed_type.absorbed_via != ref   # Problems if it doesn't match
-                      allowed_type = ref.from
-                      false
-                    end
-                end
-                raise "REVISIT: Failed to find conterpart column for #{from_column.name}" unless c
-                c
-              end
-            end
-            debug :fk, "to_columns in #{to.name}: #{to_columns.map { |column| column ? column.name : "OOPS!" }*", "}"
+		# Figure out absorption on the target end:
+		to = fk_ref_path.last.to
+		if to.absorbed_via
+		  debug :fk, "Reference target #{fk_ref_path.last.to.name} is absorbed via:" do
+		    while (r = to.absorbed_via)
+		      m = r.reversed
+		      debug :fk, "#{m.reading}"
+		      fk_ref_path << m
+		      to = m.from == to ? m.to : m.from
+		    end
+		    debug :fk, "Absorption ends at #{to.name}"
+		  end
+		end
 
-            # Put the column pairs in a defined order, sorting key pairs by to-name:
-            froms, tos = from_columns.zip(to_columns).sort_by { |pair|
-              pair[1].name(nil)
-            }.transpose
+		# 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::Persistence::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
 
-            ActiveFacts::Persistence::ForeignKey.new(self, to, fk_ref_path[-1], froms, tos)
-          end
-        end.
-        sort_by do |fk|
-          # Put the foreign keys in a defined order:
-          [ fk.to.name,
-            fk.to_columns.map{|col| col.name(nil).sort},
-            fk.from_columns.map{|col| col.name(nil).sort}
-          ]
-        end
       end
     end
   end