activefacts-generators 1.8.3 → 1.9.0

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

@@ -82,8 +82,8 @@ module ActiveFacts
               /^Signed ?Small ?Integer$/,
               /^Unsigned ?Tiny ?Integer$/
               s = case
-		when length == nil
-		  'int'
+                when length == nil
+                  'int'
                 when length <= 8
                   'tinyint'
                 when length <= 16
@@ -168,7 +168,7 @@ module ActiveFacts
                   "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
                 end
                 }"
-	      # Emit IDENTITY for auto-assigned columns, unless it's assigned at assert:
+              # Emit IDENTITY for auto-assigned columns, unless it's assigned at assert:
               identity = column == identity_column && column.references[-1].to.transaction_phase != 'assert' ? " IDENTITY" : ""
               null = (column.is_mandatory ? "NOT " : "") + "NULL"
               check = check_clause(name, constraints)

data/lib/activefacts/generators/stats.rb

@@ -21,47 +21,47 @@ module ActiveFacts
 
     public
       def generate(out = $>)
-	constellation = @vocabulary.constellation
-	object_types = constellation.ObjectType.values
-	fact_types = constellation.FactType.values
+        constellation = @vocabulary.constellation
+        object_types = constellation.ObjectType.values
+        fact_types = constellation.FactType.values
 
-	# All metamodel object types:
-	object_count = 0
-	populated_object_type_count = 0
-	fact_types_processed = {}
-	fact_count = 0
-	role_played_count = 0
-	constellation.vocabulary.object_type.map do |object_type_name, object_type|
-	  objects = constellation.send(object_type_name)
-	  next unless objects.size > 0
-	  puts "\t#{object_type_name}: #{objects.size} instances (which play #{object_type.all_role.size} roles)"
-	  populated_object_type_count += 1
-	  object_count += objects.size
+        # All metamodel object types:
+        object_count = 0
+        populated_object_type_count = 0
+        fact_types_processed = {}
+        fact_count = 0
+        role_played_count = 0
+        constellation.vocabulary.object_type.map do |object_type_name, object_type|
+          objects = constellation.send(object_type_name)
+          next unless objects.size > 0
+          puts "\t#{object_type_name}: #{objects.size} instances (which play #{object_type.all_role.size} roles)"
+          populated_object_type_count += 1
+          object_count += objects.size
 
-	  #puts "#{object_type_name} has #{object_type.all_role.size} roles"
-	  object_type.all_role.each do |name, role|
-	    next unless role.unique
-	    next if fact_types_processed[role.fact_type]
-	    next if role.fact_type.is_a?(ActiveFacts::API::TypeInheritanceFactType)
-	    role_population_count =
-	      objects.values.inject(0) do |count, object|
-		count += 1 if object.send(role.name) != nil
-		count
-	      end
-	    puts "\t\t#{object_type_name}.#{role.name} has #{role_population_count} instances" if role_population_count > 0
-	    fact_count += role_population_count
-	    role_played_count += role_population_count*role.fact_type.all_role.size
+          #puts "#{object_type_name} has #{object_type.all_role.size} roles"
+          object_type.all_role.each do |name, role|
+            next unless role.unique
+            next if fact_types_processed[role.fact_type]
+            next if role.fact_type.is_a?(ActiveFacts::API::TypeInheritanceFactType)
+            role_population_count =
+              objects.values.inject(0) do |count, object|
+                count += 1 if object.send(role.name) != nil
+                count
+              end
+            puts "\t\t#{object_type_name}.#{role.name} has #{role_population_count} instances" if role_population_count > 0
+            fact_count += role_population_count
+            role_played_count += role_population_count*role.fact_type.all_role.size
 
-	    fact_types_processed[role.fact_type] = true
-	  end
+            fact_types_processed[role.fact_type] = true
+          end
 
-	end
-	puts "#{@vocabulary.name} has"
-	puts "\t#{object_types.size} object types"
-	puts "\t#{fact_types.size} fact types"
-	puts "\tcompiles to #{object_count} objects in total, of #{populated_object_type_count} metamodel types"
-	puts "\tcompiles to #{fact_count} facts in total, of #{fact_types_processed.size} metamodel fact types"
-	puts "\tcompiles to #{role_played_count} role instances in total"
+        end
+        puts "#{@vocabulary.name} has"
+        puts "\t#{object_types.size} object types"
+        puts "\t#{fact_types.size} fact types"
+        puts "\tcompiles to #{object_count} objects in total, of #{populated_object_type_count} metamodel types"
+        puts "\tcompiles to #{fact_count} facts in total, of #{fact_types_processed.size} metamodel fact types"
+        puts "\tcompiles to #{role_played_count} role instances in total"
       end
     end
   end

data/lib/activefacts/generators/traits/datavault.rb

@@ -1,6 +1,6 @@
 #
-#	ActiveFacts Schema Transform
-#	Transform a loaded ActiveFacts vocabulary to suit ActiveRecord
+#       ActiveFacts Schema Transform
+#       Transform a loaded ActiveFacts vocabulary to suit ActiveRecord
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
@@ -12,230 +12,230 @@ module ActiveFacts
 
       module ObjectType
 
-	def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
-	  # Find or assert the surrogate value type
-	  auto_counter = vocabulary.valid_value_type_name(type_name) ||
-	    constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
-
-	  # Create a subtype to identify this entity type:
-	  vt_name = self.name + ' '+suffix
-	  my_id = @vocabulary.valid_value_type_name(vt_name) ||
-	    constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
-
-	  # Create a fact type
-	  identifying_fact_type = constellation.FactType(:concept => :new)
-	  my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
-	  self.injected_surrogate_role = my_role
-	  id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
-
-	  # Create a reading (which needs a RoleSequence)
-	  reading = constellation.Reading(
-	    :fact_type => identifying_fact_type,
-	    :ordinal => 0,
-	    :role_sequence => [:new],
-	    :text => "{0} has {1}"
-	  )
-	  constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
-	  constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
-
-	  # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
-	  one_id = constellation.PresenceConstraint(
-	      :concept => :new,
-	      :vocabulary => vocabulary,
-	      :name => self.name+'HasOne'+suffix,
-	      :role_sequence => [:new],
-	      :is_mandatory => true,
-	      :min_frequency => 1,
-	      :max_frequency => 1,
-	      :is_preferred_identifier => false
-	    )
-	  @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
-
-	  one_me = constellation.PresenceConstraint(
-	      :concept => :new,
-	      :vocabulary => vocabulary,
-	      :name => self.name+suffix+'IsOfOne'+self.name,
-	      :role_sequence => [:new],
-	      :is_mandatory => false,
-	      :min_frequency => 0,
-	      :max_frequency => 1,
-	      :is_preferred_identifier => true
-	    )
-	  @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
-	end
+        def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
+          # Find or assert the surrogate value type
+          auto_counter = vocabulary.valid_value_type_name(type_name) ||
+            constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
+
+          # Create a subtype to identify this entity type:
+          vt_name = self.name + ' '+suffix
+          my_id = @vocabulary.valid_value_type_name(vt_name) ||
+            constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
+
+          # Create a fact type
+          identifying_fact_type = constellation.FactType(:concept => :new)
+          my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
+          self.injected_surrogate_role = my_role
+          id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
+
+          # Create a reading (which needs a RoleSequence)
+          reading = constellation.Reading(
+            :fact_type => identifying_fact_type,
+            :ordinal => 0,
+            :role_sequence => [:new],
+            :text => "{0} has {1}"
+          )
+          constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
+          constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
+
+          # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
+          one_id = constellation.PresenceConstraint(
+              :concept => :new,
+              :vocabulary => vocabulary,
+              :name => self.name+'HasOne'+suffix,
+              :role_sequence => [:new],
+              :is_mandatory => true,
+              :min_frequency => 1,
+              :max_frequency => 1,
+              :is_preferred_identifier => false
+            )
+          @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
+
+          one_me = constellation.PresenceConstraint(
+              :concept => :new,
+              :vocabulary => vocabulary,
+              :name => self.name+suffix+'IsOfOne'+self.name,
+              :role_sequence => [:new],
+              :is_mandatory => false,
+              :min_frequency => 0,
+              :max_frequency => 1,
+              :is_preferred_identifier => true
+            )
+          @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
+        end
       end
 
       module ValueType
-	def dv_needs_surrogate
-	  !is_auto_assigned
-	end
-
-	def dv_inject_surrogate
-	  trace :transform_surrogate, "Adding surrogate ID to Value Type #{name}"
-	  add_surrogate('Auto Counter', 'ID')
-	end
+        def dv_needs_surrogate
+          !is_auto_assigned
+        end
+
+        def dv_inject_surrogate
+          trace :transform_surrogate, "Adding surrogate ID to Value Type #{name}"
+          add_surrogate('Auto Counter', 'ID')
+        end
       end
 
       module EntityType
-	def dv_identifying_refs_from
-	  pi = preferred_identifier
-	  rrs = pi.role_sequence.all_role_ref
-
-  #	  REVISIT: This is actually a ref to us, not from
-  #	  if absorbed_via
-  #	    return [absorbed_via]
-  #	  end
-
-	  rrs.map do |rr|
-	    r = references_from.detect{|ref| rr.role == ref.to_role }
-	    unless r
-	      debugger
-	      raise "failed to find #{name} identifying reference for #{rr.role.object_type.name} in #{references_from.inspect}"
-	    end
-	    r
-	  end
-	end
-
-	def dv_needs_surrogate
-
-	  # A recursive proc to replace any reference to an Entity Type by its identifying references:
-	  trace :transform_surrogate_expansion, "Expanding key for #{name}"
-	  substitute_identifying_refs = proc do |object|
-	    if ref = object.absorbed_via
-	      # This shouldn't be necessary, but see the absorbed_via comment above.
-	      absorbed_into = ref.from
-	      trace :transform_surrogate_expansion, "recursing to handle absorption of #{object.name} into #{absorbed_into.name}"
-	      [substitute_identifying_refs.call(absorbed_into)]
-	    else
-	      irf = object.dv_identifying_refs_from
-	      trace :transform_surrogate_expansion, "Iterating for #{object.name} over #{irf.inspect}" do
-		irf.each_with_index do |ref, i|
-		  next if ref.is_unary
-		  next if ref.to_role.object_type.kind_of?(ActiveFacts::Metamodel::ValueType)
-		  recurse_to = ref.to_role.object_type
-
-		  trace :transform_surrogate_expansion, "#{i}: recursing to expand #{recurse_to.name} key in #{ref}" do
-		    irf[i] = substitute_identifying_refs.call(recurse_to)
-		  end
-		end
-	      end
-	      irf
-	    end
-	  end
-	  irf = substitute_identifying_refs.call(self)
-
-	  trace :transform_surrogate, "Does #{name} need a surrogate? it's identified by #{irf.inspect}" do
-
-	    pk_fks = dv_identifying_refs_from.map do |ref|
-	      ref.to && ref.to.is_table ? ref.to : nil
-	    end
-
-	    irf.flatten!
-
-	    # 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"
-		return true
-	      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-dv_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
-	      end
-	      return true
-	    end
-
-	    # Single-part key. It must be an Auto Counter, or we will add a surrogate
-
-	    identifying_type = irf[0].to
-	    if identifying_type.dv_needs_surrogate
-	      trace :transform_surrogate, "#{self.name} needs a surrogate because #{irf[0].to.name} is not an AutoCounter, but #{identifying_type.supertypes_transitive.map(&:name).inspect}"
-	      return true
-	    end
-
-	    false
-	  end
-	end
-
-	def dv_inject_surrogate
-	  trace :transform_surrogate, "Injecting a surrogate key into #{self.name}"
-
-	  # Disable the preferred identifier:
-	  pi = preferred_identifier
-	  trace :transform_surrogate, "pi for #{name} was '#{pi.describe}'"
-	  pi.is_preferred_identifier = false
-	  @preferred_identifier = nil	# Kill the cache
-
-	  dv_add_surrogate
-
-	  trace :transform_surrogate, "pi for #{name} is now '#{preferred_identifier.describe}'"
-	end
-
-	def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
-	 # Find or assert the surrogate value type
-	 auto_counter = vocabulary.valid_value_type_name(type_name) ||
-	   constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
-
-	 # Create a subtype to identify this entity type:
-	 vt_name = self.name + ' '+suffix
-	 my_id = @vocabulary.valid_value_type_name(vt_name) ||
-	   constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
-
-	 # Create a fact type
-	 identifying_fact_type = constellation.FactType(:concept => :new)
-	 my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
-	 @injected_surrogate_role = my_role
-	 id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
-
-	 # Create a reading (which needs a RoleSequence)
-	 reading = constellation.Reading(
-	   :fact_type => identifying_fact_type,
-	   :ordinal => 0,
-	   :role_sequence => [:new],
-	   :text => "{0} has {1}"
-	 )
-	 constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
-	 constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
-
-	 # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
-	 one_id = constellation.PresenceConstraint(
-	     :concept => :new,
-	     :vocabulary => vocabulary,
-	     :name => self.name+'HasOne'+suffix,
-	     :role_sequence => [:new],
-	     :is_mandatory => true,
-	     :min_frequency => 1,
-	     :max_frequency => 1,
-	     :is_preferred_identifier => false
-	   )
-	 @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
-
-	 one_me = constellation.PresenceConstraint(
-	     :concept => :new,
-	     :vocabulary => vocabulary,
-	     :name => self.name+suffix+'IsOfOne'+self.name,
-	     :role_sequence => [:new],
-	     :is_mandatory => false,
-	     :min_frequency => 0,
-	     :max_frequency => 1,
-	     :is_preferred_identifier => true
-	   )
-	 @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
-
-	 return my_id
-	end
+        def dv_identifying_refs_from
+          pi = preferred_identifier
+          rrs = pi.role_sequence.all_role_ref
+
+  #       REVISIT: This is actually a ref to us, not from
+  #       if absorbed_via
+  #         return [absorbed_via]
+  #       end
+
+          rrs.map do |rr|
+            r = references_from.detect{|ref| rr.role == ref.to_role }
+            unless r
+              debugger
+              raise "failed to find #{name} identifying reference for #{rr.role.object_type.name} in #{references_from.inspect}"
+            end
+            r
+          end
+        end
+
+        def dv_needs_surrogate
+
+          # A recursive proc to replace any reference to an Entity Type by its identifying references:
+          trace :transform_surrogate_expansion, "Expanding key for #{name}"
+          substitute_identifying_refs = proc do |object|
+            if ref = object.absorbed_via
+              # This shouldn't be necessary, but see the absorbed_via comment above.
+              absorbed_into = ref.from
+              trace :transform_surrogate_expansion, "recursing to handle absorption of #{object.name} into #{absorbed_into.name}"
+              [substitute_identifying_refs.call(absorbed_into)]
+            else
+              irf = object.dv_identifying_refs_from
+              trace :transform_surrogate_expansion, "Iterating for #{object.name} over #{irf.inspect}" do
+                irf.each_with_index do |ref, i|
+                  next if ref.is_unary
+                  next if ref.to_role.object_type.kind_of?(ActiveFacts::Metamodel::ValueType)
+                  recurse_to = ref.to_role.object_type
+
+                  trace :transform_surrogate_expansion, "#{i}: recursing to expand #{recurse_to.name} key in #{ref}" do
+                    irf[i] = substitute_identifying_refs.call(recurse_to)
+                  end
+                end
+              end
+              irf
+            end
+          end
+          irf = substitute_identifying_refs.call(self)
+
+          trace :transform_surrogate, "Does #{name} need a surrogate? it's identified by #{irf.inspect}" do
+
+            pk_fks = dv_identifying_refs_from.map do |ref|
+              ref.to && ref.to.is_table ? ref.to : nil
+            end
+
+            irf.flatten!
+
+            # 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"
+                return true
+              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-dv_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
+              end
+              return true
+            end
+
+            # Single-part key. It must be an Auto Counter, or we will add a surrogate
+
+            identifying_type = irf[0].to
+            if identifying_type.dv_needs_surrogate
+              trace :transform_surrogate, "#{self.name} needs a surrogate because #{irf[0].to.name} is not an AutoCounter, but #{identifying_type.supertypes_transitive.map(&:name).inspect}"
+              return true
+            end
+
+            false
+          end
+        end
+
+        def dv_inject_surrogate
+          trace :transform_surrogate, "Injecting a surrogate key into #{self.name}"
+
+          # Disable the preferred identifier:
+          pi = preferred_identifier
+          trace :transform_surrogate, "pi for #{name} was '#{pi.describe}'"
+          pi.is_preferred_identifier = false
+          @preferred_identifier = nil   # Kill the cache
+
+          dv_add_surrogate
+
+          trace :transform_surrogate, "pi for #{name} is now '#{preferred_identifier.describe}'"
+        end
+
+        def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
+         # Find or assert the surrogate value type
+         auto_counter = vocabulary.valid_value_type_name(type_name) ||
+           constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
+
+         # Create a subtype to identify this entity type:
+         vt_name = self.name + ' '+suffix
+         my_id = @vocabulary.valid_value_type_name(vt_name) ||
+           constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
+
+         # Create a fact type
+         identifying_fact_type = constellation.FactType(:concept => :new)
+         my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
+         @injected_surrogate_role = my_role
+         id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
+
+         # Create a reading (which needs a RoleSequence)
+         reading = constellation.Reading(
+           :fact_type => identifying_fact_type,
+           :ordinal => 0,
+           :role_sequence => [:new],
+           :text => "{0} has {1}"
+         )
+         constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
+         constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
+
+         # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
+         one_id = constellation.PresenceConstraint(
+             :concept => :new,
+             :vocabulary => vocabulary,
+             :name => self.name+'HasOne'+suffix,
+             :role_sequence => [:new],
+             :is_mandatory => true,
+             :min_frequency => 1,
+             :max_frequency => 1,
+             :is_preferred_identifier => false
+           )
+         @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
+
+         one_me = constellation.PresenceConstraint(
+             :concept => :new,
+             :vocabulary => vocabulary,
+             :name => self.name+suffix+'IsOfOne'+self.name,
+             :role_sequence => [:new],
+             :is_mandatory => false,
+             :min_frequency => 0,
+             :max_frequency => 1,
+             :is_preferred_identifier => true
+           )
+         @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
+
+         return my_id
+        end
 
       end
 
-      include ActiveFacts::TraitInjector	# Must be last in this module, after all submodules have been defined
+      include ActiveFacts::TraitInjector        # Must be last in this module, after all submodules have been defined
     end
   end
 end