activefacts 0.8.16 → 0.8.18

data/lib/activefacts/generate/records.rb

@@ -43,3 +43,4 @@ module ActiveFacts
   end
 end
 
+ActiveFacts::Registry.generator('records', ActiveFacts::Generate::RECORDS)

data/lib/activefacts/generate/ruby.rb

@@ -4,8 +4,10 @@
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
+require 'activefacts'
 require 'activefacts/vocabulary'
-require 'activefacts/generate/oo'
+require 'activefacts/generate/helpers/oo'
+require 'activefacts/mapping/rails'
 
 module ActiveFacts
   module Generate
@@ -15,25 +17,29 @@ module ActiveFacts
     # Options are comma or space separated:
     # * help list available options
     # * sql Emit the sql mapping for tables/columns (REVISIT: not functional at present)
-    class RUBY < OO
+    class RUBY < Helpers::OO
     private
 
       def set_option(option)
-        @sql ||= false
+        @mapping = false
         case option
         when 'help', '?'
           $stderr.puts "Usage:\t\tafgen --ruby[=option,option] input_file.cql\n"+
-              "options:\tsql\tEmit data to enable mappings to SQL"
+              "\t\tmapping={sql|rails}\tEmit data to enable mappings to SQL or to Rails"
           exit 0
-        when 'sql'; @sql = true
+        when /mapping=(.*)/
+          @mapping = $1
+          @vocabulary.tables
         else super
         end
       end
 
       def vocabulary_start(vocabulary)
         puts "require 'activefacts/api'\n"
-        if @sql
+        if @mapping
           require 'activefacts/persistence'
+        end
+        if @mapping == 'sql'
           puts "require 'activefacts/persistence'\n"
           @tables = vocabulary.tables
         end
@@ -44,6 +50,15 @@ module ActiveFacts
         puts "end"
       end
 
+      def emit_mapping o
+        case @mapping
+        when 'sql'
+          puts "    table"
+        when 'rails'
+          puts "    table :#{o.rails_name}"
+        end
+      end
+
       def value_type_dump(o)
         length = (l = o.length) && l > 0 ? ":length => #{l}" : nil
         scale = (s = o.scale) && s > 0 ? ":scale => #{s}" : nil
@@ -69,9 +84,7 @@ module ActiveFacts
 
         puts "  class #{name} < #{ruby_type_name}\n" +
              "    value_type #{params}\n"
-        if @sql and o.is_table
-          puts "    table"
-        end
+        emit_mapping o if o.is_table
         puts "    restrict #{o.value_constraint.all_allowed_range_sorted.map{|ar| ar.to_s}*", "}\n" if o.value_constraint
         puts "    \# REVISIT: #{o.name} is in units of #{o.unit.name}\n" if o.unit
         roles_dump(o)
@@ -85,9 +98,7 @@ module ActiveFacts
         puts "  class #{o.name.gsub(/ /,'')} < #{ primary_supertype.name.gsub(/ /,'') }"
         puts "    identified_by #{identified_by(o, pi)}" if pi
         puts "    supertypes "+secondary_supertypes.map{|st| st.name.gsub(/ /,'')}*", " if secondary_supertypes.size > 0
-        if @sql and o.is_table
-          puts "    table"
-        end
+        emit_mapping(o) if o.is_table
         fact_roles_dump(o.fact_type) if o.fact_type
         roles_dump(o)
         puts "  end\n\n"
@@ -99,9 +110,7 @@ module ActiveFacts
 
         # We want to name the absorption role only when it's absorbed along its single identifying role.
         puts "    identified_by #{identified_by(o, pi)}"
-        if @sql and o.is_table
-          puts "    table"
-        end
+        emit_mapping o if o.is_table
         fact_roles_dump(o.fact_type) if o.fact_type
         roles_dump(o)
         puts "  end\n\n"
@@ -125,7 +134,7 @@ module ActiveFacts
           "\n" +
           secondary_supertypes.map{|sst| "    supertype :#{sst.name.gsub(/ /,'_')}"}*"\n" +
           (pi ? "    identified_by #{identified_by(o, pi)}" : "")
-        puts "    table" if @sql and o.is_table
+        emit_mapping o if o.is_table
         fact_roles_dump(fact_type)
         roles_dump(o)
         puts "  end\n\n"
@@ -144,25 +153,35 @@ module ActiveFacts
       end
 
       def binary_dump(role, role_name, role_player, mandatory = nil, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
+        ruby_role_name = ":"+role_name.gsub(/ /,'_')
+
         # Find whether we need the name of the other role player, and whether it's defined yet:
-        if role_name.camelcase == role_player.name.gsub(/ /,'').sub(/^[a-z]/) {|i| i.upcase}
-          # Don't use Class name if implied by rolename
-          role_reference = nil
-        else
+        implied_role_name = role_player.name.gsub(/ /,'').sub(/^[a-z]/) {|i| i.upcase}
+        if role_name.camelcase != implied_role_name
+          # Only use Class name if it's not implied by the rolename
           role_reference = ":class => "+object_type_reference(role_player)
         end
+
         other_role_name = ":counterpart => :"+other_role_name.gsub(/ /,'_') if other_role_name
 
-        line = "    #{one_to_one ? "one_to_one" : "has_one" } " +
-                [ ":"+role_name.gsub(/ /,'_'),
-                  role_reference,
-                  mandatory ? ":mandatory => true" : nil,
-                  readings,
-                  other_role_name,
-                  (vr = role.role_value_constraint) ? ":restrict => #{vr}" : nil
-                ].compact*", "+"  "
-        line += " "*(48-line.length) if line.length < 48
-        line += "\# See #{role_player.name.gsub(/ /,'')}.#{other_method_name}" if other_method_name
+        if vr = role.role_value_constraint
+          value_restriction = ":restrict => #{vr}"
+        end
+
+        options = [
+            ruby_role_name,
+            role_reference,
+            mandatory ? ":mandatory => true" : nil,
+            readings,
+            other_role_name,
+            value_restriction
+          ].compact
+
+        line = "    #{one_to_one ? "one_to_one" : "has_one" } #{options*', '}  "
+        if other_method_name
+          line += " "*(48-line.length) if line.length < 48
+          line += "\# See #{role_player.name.gsub(/ /,'')}.#{other_method_name}"
+        end
         puts line
         #puts "    \# REVISIT: #{other_role_name} has values restricted to #{role.role_value_constraint}\n" if role.role_value_constraint
       end
@@ -178,3 +197,5 @@ module ActiveFacts
     end
   end
 end
+
+ActiveFacts::Registry.generator('ruby', ActiveFacts::Generate::RUBY)

data/lib/activefacts/generate/sql/mysql.rb

@@ -9,7 +9,7 @@ require 'activefacts/persistence'
 
 module ActiveFacts
   module Generate
-    class SQL #:nodoc:
+    module SQL #:nodoc:
       # Generate SQL for MySQL for an ActiveFacts vocabulary.
       # Invoke as
       #   afgen --sql/mysql[=options] <file>.cql
@@ -165,7 +165,7 @@ module ActiveFacts
             puts "CREATE TABLE #{escape table.name.gsub(' ','')} ("
 
             pk = table.identifier_columns
-            identity_column = pk[0] if pk.size == 1 && pk[0].is_auto_assigned
+            identity_column = pk[0] if pk[0].is_auto_assigned
 
             fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
             fk_columns = table.columns.select do |column|
@@ -245,7 +245,7 @@ module ActiveFacts
 
       private
         def sql_value(value)
-          value.is_a_string ? sql_string(value.literal) : value.literal
+          value.is_literal_string ? sql_string(value.literal) : value.literal
         end
 
         def sql_string(str)
@@ -276,3 +276,5 @@ module ActiveFacts
     end
   end
 end
+
+ActiveFacts::Registry.generator('sql/mysql', ActiveFacts::Generate::SQL::MYSQL)

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

@@ -9,7 +9,7 @@ require 'activefacts/persistence'
 
 module ActiveFacts
   module Generate
-    class SQL #:nodoc:
+    module SQL #:nodoc:
       # Generate SQL for SQL Server for an ActiveFacts vocabulary.
       # Invoke as
       #   afgen --sql/server[=options] <file>.cql
@@ -84,7 +84,7 @@ module ActiveFacts
                 when length <= 8
                   'tinyint'
                 when length <= 16
-                  'shortint'
+                  'smallint'
                 when length <= 32
                   'int'
                 else
@@ -112,6 +112,8 @@ module ActiveFacts
             when /^Auto ?Time ?Stamp$/
               'timestamp'
 
+            when /^Guid$/
+              'uniqueidentifier'
             when /^Money$/
               'decimal'
             when /^Picture ?Raw ?Data$/, /^Image$/
@@ -137,7 +139,7 @@ module ActiveFacts
             puts "CREATE TABLE #{escape table.name.gsub(' ',@underscore)} ("
 
             pk = table.identifier_columns
-            identity_column = pk[0] if pk.size == 1 && pk[0].is_auto_assigned
+            identity_column = pk[0] if pk[0].is_auto_assigned
 
             fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
             fk_columns = table.columns.select do |column|
@@ -235,7 +237,7 @@ CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.c
 
       private
         def sql_value(value)
-          value.is_a_string ? sql_string(value.literal) : value.literal
+          value.is_literal_string ? sql_string(value.literal) : value.literal
         end
 
         def sql_string(str)
@@ -266,3 +268,5 @@ CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.c
     end
   end
 end
+
+ActiveFacts::Registry.generator('sql/server', ActiveFacts::Generate::SQL::SERVER)

data/lib/activefacts/generate/text.rb

@@ -24,3 +24,4 @@ module ActiveFacts
   end
 end
 
+ActiveFacts::Registry.generator('text', ActiveFacts::Generate::TEXT)

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

@@ -0,0 +1,209 @@
+#
+#       ActiveFacts Schema Transform
+#       Transform a loaded ActiveFacts vocabulary to suit ActiveRecord
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/vocabulary'
+require 'activefacts/persistence'
+
+module ActiveFacts
+  module Metamodel
+    class ObjectType
+
+      def 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, :guid => :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, :guid => :new, :supertype => auto_counter)
+
+	# Create a fact type
+	identifying_fact_type = constellation.FactType(:guid => :new)
+	my_role = constellation.Role(:guid => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
+	@injected_surrogate_role = my_role
+	id_role = constellation.Role(:guid => :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(
+	    :guid => :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(
+	    :guid => :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
+
+    class ValueType
+      def needs_surrogate
+	supertype_names = supertypes_transitive.map(&:name)
+	!(supertype_names.include?('Auto Counter') or supertype_names.include?('Guid') or supertype_names.include?('ID'))
+      end
+
+      def inject_surrogate
+	debug :transform_surrogate, "Adding surrogate ID to Value Type #{name}"
+	add_surrogate('Auto Counter', 'ID')
+      end
+    end
+
+    class EntityType
+      def 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 }
+	  raise "failed to find #{name} identifying reference for #{rr.role.object_type.name} in #{references_from.inspect}" unless r
+	  r
+	end
+      end
+
+      def needs_surrogate
+
+	# A recursive proc to replace any reference to an Entity Type by its identifying references:
+	debug :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
+	    debug :transform_surrogate_expansion, "recursing to handle absorption of #{object.name} into #{absorbed_into.name}"
+	    [substitute_identifying_refs.call(absorbed_into)]
+	  else
+	    irf = object.identifying_refs_from
+	    debug :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
+
+		debug :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)
+
+	debug :transform_surrogate, "Does #{name} need a surrogate? it's identified by #{irf.inspect}" do
+
+	  pk_fks = 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) and the object is not the target of a foreign key:
+	  if irf.size >= 2
+	    if pk_fks.include?(nil)
+	      debug :transform_surrogate, "#{self.name} needs a surrogate because its multi-part key contains a non-table"
+	      return true
+	    elsif references_to.size != 0
+	      debug :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect} but is also an FK target"
+	      return true
+	    else
+	      debug :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.needs_surrogate
+	    debug :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 inject_surrogate
+	debug :transform_surrogate, "Injecting a surrogate key into #{self.name}"
+
+	# Disable the preferred identifier:
+	pi = preferred_identifier
+	debug :transform_surrogate, "pi for #{name} was '#{pi.describe}'"
+	pi.is_preferred_identifier = false
+	@preferred_identifier = nil   # Kill the cache
+
+	add_surrogate
+
+	debug :transform_surrogate, "pi for #{name} is now '#{preferred_identifier.describe}'"
+      end
+
+    end
+  end
+
+  module Persistence
+    class Column
+      def is_injected_surrogate
+	references.size == 1 and
+	  references[0].from_role == references[0].from.injected_surrogate_role
+      end
+    end
+  end
+
+  module Generate #:nodoc:
+    module Transform #:nodoc:
+      class Surrogate
+	def initialize(vocabulary, *options)
+	  @vocabulary = vocabulary
+	end
+
+	def generate(out = $stdout)
+	  @out = out
+	  injections = 
+	    @vocabulary.tables.select do |table|
+	      table.needs_surrogate
+	    end
+	  injections.each do |table|
+	    table.inject_surrogate
+	  end
+
+	  @vocabulary.decide_tables
+	end
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('transform/surrogate', ActiveFacts::Generate::Transform::Surrogate)