activefacts-generators 1.7.1

data/lib/activefacts/generators/rails/schema.rb

@@ -0,0 +1,217 @@
+#
+#       ActiveFacts Generators.
+#       Generate a Rails-friendly schema.rb from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2012 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/rmap'
+require 'activefacts/generators/traits/rails'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    module Rails
+      # Generate a Rails-friendly schema for the vocabulary
+      # Invoke as
+      #   afgen --rails/schema[=options] <file>.cql
+      class SchemaRb
+      private
+	include RMap
+
+	def initialize(vocabulary, *options)
+	  @vocabulary = vocabulary
+	  @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+	  help if options.include? "help"
+	  @exclude_fks = options.include? "exclude_fks"
+	  @include_comments = options.include? "include_comments"
+	  @closed_world = options.include? "closed_world"
+	end
+
+	def help
+	  @helping = true
+	  warn %Q{Options for --rails/schema:
+	exclude_fks		Don't generate foreign key definitions for use with Rails 4 or the foreigner gem
+	include_comments	Generate a comment for each column showing the absorption path
+	closed_world		Set this if your DBMS only allows one null in a unique index (MS SQL)
+}
+	end
+
+	def warn *a
+	  $stderr.puts *a
+	end
+
+	def puts s
+	  @out.puts s
+	end
+
+      public
+
+	# We sort the columns here, not in the rmap layer, because it affects
+	# the ordering of columns in an index :-(.
+	def sorted_columns table, pk, fk_columns
+	  table.columns.sort_by do |column|
+	    [ # Emit columns alphabetically, but PK first, then FKs, then others
+	      case
+	      when i = pk.index(column)
+		i
+	      when fk_columns.include?(column)
+		pk.size+1
+	      else
+		pk.size+2
+	      end,
+	      column.rails_name
+	    ]
+	  end
+	end
+
+	def generate_column table, pk, column
+	  name = column.rails_name
+	  type, params, constraints = *column.type
+	  length = params[:length]
+	  length &&= length.to_i
+	  scale = params[:scale]
+	  scale &&= scale.to_i
+	  rails_type, length = *column.rails_type
+ 
+	  length_name = rails_type == 'decimal' ? 'precision' : 'limit'
+	  length_option = length ? ", :#{length_name} => #{length}" : ''
+	  scale_option = scale ? ", :scale => #{scale}" : ''
+
+	  comment = column.comment
+	  null_option = ", :null => #{!column.is_mandatory}"
+	  if pk.size == 1 && pk[0] == column
+	    case rails_type
+	    when 'serial'
+	      rails_type = "primary_key"
+	    when 'uuid'
+	      rails_type = "uuid, :default => 'gen_random_uuid()', :primary_key => true"
+	    end
+	  else
+	    case rails_type
+	    when 'serial'
+	      rails_type = 'integer'	    # An integer foreign key
+	    end
+	  end
+
+	  (@include_comments ? ["    \# #{comment}"] : []) +
+	  [
+	    %Q{    t.column "#{name}", :#{rails_type}#{length_option}#{scale_option}#{null_option}}
+	  ]
+	end
+
+	def generate_columns table, pk, fk_columns
+	  sc = sorted_columns(table, pk, fk_columns)
+	  lines = sc.map do |column|
+	    generate_column table, pk, column
+	  end
+	  lines.flatten
+	end
+
+	def generate_table table, foreign_keys
+	  ar_table_name = table.rails_name
+
+	  pk = table.identifier_columns
+	  if pk[0].is_auto_assigned
+	    identity_column = pk[0]
+	    warn "Warning: redundant column(s) after #{identity_column.name} in primary key of #{ar_table_name}" if pk.size > 1
+	  end
+
+	  # Get the list of references that give rise to foreign keys:
+	  fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
+
+	  # Get the list of columns that embody the foreign keys:
+	  fk_columns = table.columns.select do |column|
+	    column.references[0].is_simple_reference
+	  end
+
+	  # Detect if this table is a join table.
+	  # Join tables have multi-part primary keys that are made up only of foreign keys
+	  is_join_table = pk.length > 1 and
+	    !pk.detect do |pk_column|
+	      !fk_columns.include?(pk_column)
+	    end
+	  warn "Warning: #{table.name} has a multi-part primary key" if pk.length > 1 and !is_join_table
+
+	  puts %Q{  create_table "#{ar_table_name}", :id => false, :force => true do |t|}
+
+	  columns = generate_columns table, pk, fk_columns
+
+	  unless @exclude_fks
+	    table.foreign_keys.each do |fk|
+	      from_columns = fk.from_columns.map{|column| column.rails_name}
+	      to_columns = fk.to_columns.map{|column| column.rails_name}
+
+	      foreign_keys.concat(
+		if (from_columns.length == 1)
+		  index_name = RMap.rails_name_trunc('index_'+fk.from.rails_name+'_on_'+from_columns[0])
+		  [
+		    "    add_foreign_key :#{fk.from.rails_name}, :#{fk.to.rails_name}, :column => :#{from_columns[0]}, :primary_key => :#{to_columns[0]}, :on_delete => :cascade"
+		  ]+
+		  Array(
+		    # Index it non-uniquely only if it's not unique already:
+		    fk.jump_reference.to_role.unique ? nil :
+		      "    add_index :#{fk.from.rails_name}, [:#{from_columns[0]}], :unique => false, :name => :#{index_name}"
+		  )
+		else
+		  # This probably isn't going to work without Dr Nic's CPK gem:
+		  [
+		    "    add_foreign_key :#{fk.to.rails_name}, :#{fk.from.rails_name}, :column => [:#{from_columns.join(':, ')}], :primary_key => [:#{to_columns.join(':, ')}], :on_delete => :cascade"
+		  ]
+		end
+	      )
+	    end
+	  end
+
+	  indices = table.indices
+	  index_text = []
+	  indices.each do |index|
+	    next if index.is_primary && index.columns.size == 1	  # We've handled this already
+
+	    index_name = index.rails_name
+
+	    unique = !index.columns.detect{|column| !column.is_mandatory} and !@closed_world
+	    index_text << %Q{  add_index "#{ar_table_name}", ["#{index.columns.map{|c| c.rails_name}*'", "'}"], :name => :#{index_name}#{
+	      unique ? ", :unique => true" : ''
+	    }}
+	  end
+
+	  puts columns.join("\n")
+	  puts "  end\n\n"
+
+	  puts index_text.join("\n")
+	  puts "\n" unless index_text.empty?
+	end
+
+	def generate(out = $>)      #:nodoc:
+	  return if @helping
+	  @out = out
+
+	  foreign_keys = []
+
+	  # If we get index names that need to be truncated, add a counter to ensure uniqueness
+	  dup_id = 0
+
+	  puts "#\n# schema.rb auto-generated using ActiveFacts for #{@vocabulary.name} on #{Date.today}\n#\n\n"
+	  puts "ActiveRecord::Base.logger = Logger.new(STDOUT)\n"
+	  puts "ActiveRecord::Schema.define(:version => #{Time.now.strftime('%Y%m%d%H%M%S')}) do"
+	  puts "  enable_extension 'pgcrypto' unless extension_enabled?('pgcrypto')\n"
+
+	  @vocabulary.tables.each do |table|
+	    generate_table table, foreign_keys
+	  end
+
+	  unless @exclude_fks
+	    puts '  unless ENV["EXCLUDE_FKS"]'
+	    puts foreign_keys.join("\n")
+	    puts '  end'
+	  end
+	  puts "end"
+	end
+
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('rails/schema', ActiveFacts::Generators::Rails::SchemaRb)

data/lib/activefacts/generators/ruby.rb

@@ -0,0 +1,134 @@
+#
+#       ActiveFacts Generators.
+#       Generate Ruby classes for the ActiveFacts API from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/generators/helpers/oo'
+require 'activefacts/generators/traits/ruby'
+# require 'activefacts/generators/traits/rails'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+
+    # Generate Ruby module containing classes for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --ruby[=options] <file>.cql
+    # 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 < Helpers::OO
+    private
+
+      def set_option(option)
+        @mapping = false
+        case option
+        when 'help', '?'
+          $stderr.puts "Usage:\t\tafgen --ruby[=option,option] input_file.cql\n"+
+              "\t\tmapping={sql|rails}\tEmit data to enable mappings to SQL or to Rails"
+          exit 0
+        when /mapping=(.*)/
+          @mapping = $1
+          @vocabulary.tables
+        else super
+        end
+      end
+
+      def vocabulary_start
+        puts @vocabulary.prelude
+      end
+
+      def vocabulary_end
+        puts @vocabulary.finale
+      end
+
+      def emit_mapping o
+	return
+        case @mapping
+        when 'sql'
+          puts "    table"
+        when 'rails'
+          puts "    table :#{o.rails_name}"
+        end
+      end
+
+      def data_type_dump(o)
+	value_type_dump(o, o.name, {}) if o.all_role.size > 0
+      end
+
+      def value_type_dump(o, super_type_name, facets)
+	puts o.ruby_definition
+      end
+
+      def subtype_dump(o, supertypes, pi = nil)
+        primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
+        secondary_supertypes = o.supertypes-[primary_supertype]
+
+        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
+        emit_mapping(o) if @mapping && o.is_table
+        fact_roles_dump(o.fact_type) if o.fact_type
+        roles_dump(o)
+        puts "  end\n\n"
+        pi.ordered_dumped! if pi
+      end
+
+      def non_subtype_dump(o, pi)
+        puts "  class #{o.name.gsub(/ /,'')}"
+
+        # We want to name the absorption role only when it's absorbed along its single identifying role.
+        puts "    identified_by #{identified_by(o, pi)}"
+        emit_mapping o if @mapping && o.is_table
+        fact_roles_dump(o.fact_type) if o.fact_type
+        roles_dump(o)
+        puts "  end\n\n"
+        pi.ordered_dumped!
+      end
+
+      # Dump one fact type.
+      def fact_type_dump(fact_type, name)
+        return if skip_fact_type(fact_type)
+        o = fact_type.entity_type
+
+        primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
+        secondary_supertypes = o.supertypes-[primary_supertype]
+
+        # Get the preferred identifier, but don't emit it unless it's different from the primary supertype's:
+        pi = o.preferred_identifier
+        pi = nil if pi && primary_supertype && primary_supertype.preferred_identifier == pi
+
+        puts "  class #{name.gsub(/ /,'')}" +
+          (primary_supertype ? " < "+primary_supertype.name.gsub(/ /,'') : "") +
+          "\n" +
+          secondary_supertypes.map{|sst| "    supertype :#{sst.name.gsub(/ /,'_')}"}*"\n" +
+          (pi ? "    identified_by #{identified_by(o, pi)}" : "")
+        emit_mapping o if @mapping && o.is_table
+        fact_roles_dump(fact_type)
+        roles_dump(o)
+        puts "  end\n\n"
+
+        fact_type.ordered_dumped!
+      end
+
+      def identified_by_roles_and_facts(entity_type, identifying_role_refs, identifying_facts)
+        identifying_role_refs.map{|role_ref|
+            ":"+role_ref.role.preferred_role_name(entity_type)
+          }*", "
+      end
+
+      def unary_dump(role, role_name)
+        puts "    maybe :"+role_name
+      end
+
+      def binary_dump(role, role_name, role_player, mandatory = nil, one_to_one = nil, readings = nil, counterpart_role_name = nil, counterpart_method_name = nil)
+	puts role.as_binary(role_name, role_player, mandatory, one_to_one, readings, counterpart_role_name, counterpart_method_name)
+      end
+
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('ruby', ActiveFacts::Generators::RUBY)

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

@@ -0,0 +1,281 @@
+#
+#       ActiveFacts Generators.
+#       Generate SQL for MySQL from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2009 Daniel Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/rmap'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    module SQL #:nodoc:
+      # Generate SQL for MySQL for an ActiveFacts vocabulary.
+      # Invoke as
+      #   afgen --sql/mysql[=options] <file>.cql
+      # Options are comma or space separated:
+      # * delay_fks Leave all foreign keys until the end, not just those that contain forward-references
+      class MYSQL
+      private
+        include RMap
+        ColumnNameMax = 63
+        DefaultCharColLength = 63
+
+        RESERVED_WORDS = %w{
+          ACCESSIBLE ADD ALL ALTER ANALYZE AND AS ASC ASENSITIVE
+          BEFORE BETWEEN BIGINT BINARY BLOB BOTH BY CALL CASCADE
+          CASE CHANGE CHAR CHARACTER CHECK COLLATE COLUMN CONNECTION
+          CONDITION CONSTRAINT CONTINUE CONVERT CREATE CROSS
+          CURRENT_DATE CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER
+          CURSOR DATABASE DATABASES DAY_HOUR DAY_MICROSECOND
+          DAY_MINUTE DAY_SECOND DEC DECIMAL DECLARE DEFAULT DELAYED
+          DELETE DESC DESCRIBE DETERMINISTIC DISTINCT DISTINCTROW
+          DIV DOUBLE DROP DUAL EACH ELSE ELSEIF ENCLOSED ESCAPED
+          EXISTS EXIT EXPLAIN FALSE FETCH FLOAT FLOAT4 FLOAT8 FOR
+          FORCE FOREIGN FROM FULLTEXT GRANT GROUP HAVING HIGH_PRIORITY
+          HOUR_MICROSECOND HOUR_MINUTE HOUR_SECOND IF IGNORE IN
+          INDEX INFILE INNER INOUT INSENSITIVE INSERT INT INT1 INT2
+          INT3 INT4 INT8 INTEGER INTERVAL INTO IS ITERATE JOIN KEY
+          KEYS KILL LEADING LEAVE LEFT LIKE LIMIT LINEAR LINES LOAD
+          LOCALTIME LOCALTIMESTAMP LOCK LONG LONGBLOB LONGTEXT LOOP
+          LOW_PRIORITY MASTER_SSL_VERIFY_SERVER_CERT MATCH MEDIUMBLOB
+          MEDIUMINT MEDIUMTEXT MIDDLEINT MINUTE_MICROSECOND
+          MINUTE_SECOND MOD MODIFIES NATURAL NOT NO_WRITE_TO_BINLOG
+          NULL NUMERIC ON OPTIMIZE OPTION OPTIONALLY OR ORDER OUT
+          OUTER OUTFILE PRECISION PRIMARY PROCEDURE PURGE RANGE
+          READ READ_ONLY READS READ_WRITE READ_WRITE REAL REFERENCES
+          REGEXP RELEASE RENAME REPEAT REPLACE REQUIRE RESTRICT
+          RETURN REVOKE RIGHT RLIKE SCHEMA SCHEMAS SECOND_MICROSECOND
+          SELECT SENSITIVE SEPARATOR SET SHOW SMALLINT SPATIAL
+          SPECIFIC SQL SQL_BIG_RESULT SQL_CALC_FOUND_ROWS SQLEXCEPTION
+          SQL_SMALL_RESULT SQLSTATE SQLWARNING SSL STARTING
+          STRAIGHT_JOIN TABLE TERMINATED THEN TINYBLOB TINYINT
+          TINYTEXT TO TRAILING TRIGGER TRUE UNDO UNION UNIQUE UNLOCK
+          UNSIGNED UPDATE UPGRADE USAGE USE USING UTC_DATE UTC_TIME
+          UTC_TIMESTAMP VALUES VARBINARY VARCHAR VARCHARACTER VARYING
+          WHEN WHERE WHILE WITH WRITE XOR YEAR_MONTH ZEROFILL
+        }.inject({}){ |h,w| h[w] = true; h }
+
+        def initialize(vocabulary, *options)
+          @vocabulary = vocabulary
+          @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+          @delay_fks = options.include? "delay_fks"
+        end
+
+        def puts s
+          @out.puts s
+        end
+
+        def go s
+          puts s + ";\n\n"
+        end
+
+        def escape s
+          # Escape SQL keywords and non-identifiers
+          s = s[0...120]
+          if s =~ /[^A-Za-z0-9_]/ || RESERVED_WORDS[s.upcase]
+            "`#{s}`"
+          else
+            s
+          end
+        end
+
+        # Return SQL type and (modified?) length for the passed base type
+        def normalise_type(type, length)
+          sql_type = case type
+            when /^Auto ?Counter$/
+              'int'
+
+            when /^Signed ?Integer$/,
+              /^Signed ?Small ?Integer$/
+              s = case
+                when length <= 8
+                  'tinyint'
+                when length <= 16
+                  'shortint'
+                when length <= 32
+                  'int'
+                else 'bigint'
+                end
+              length = nil
+              s
+
+            when /^Unsigned ?Integer$/,
+              /^Unsigned ?Small ?Integer$/,
+              /^Unsigned ?Tiny ?Integer$/
+              s = case
+                when length <= 8
+                  'tinyint unsigned'
+                when length <= 16
+                  'shortint unsigned'
+                when length <= 32
+                  'int unsigned'
+                else 'bigint'
+                end
+              length = nil
+              s
+
+            when /^Decimal$/
+                'decimal'
+
+            when /^Fixed ?Length ?Text$/, /^Char$/
+                length ||= DefaultCharColLength
+                "char"
+            when /^Variable ?Length ?Text$/, /^String$/
+                length ||= DefaultCharColLength
+                "varchar"
+            # There are several large length text types; If you need to store more than 65k chars, look at using MEDIUMTEXT or LONGTEXT
+            # CQL does not yet allow you to specify a length for LargeLengthText.
+            when /^Large ?Length ?Text$/, /^Text$/
+              'text'
+
+            when /^Date ?And ?Time$/, /^Date ?Time$/
+              'datetime'
+            when /^Date$/
+              'date'
+            when /^Time$/
+              'time'
+            when /^Auto ?Time ?Stamp$/
+              'timestamp'
+
+            when /^Money$/
+              'decimal'
+            # Warning: Max 65 kbytes. To use larger types, try MediumBlob (16mb) or LongBlob (4gb)
+            when /^Picture ?Raw ?Data$/, /^Image$/
+              'blob'
+            when /^Variable ?Length ?Raw ?Data$/, /^Blob$/
+              'blob'
+            # Assuming you only want a boolean out of this. Should we specify length instead?
+            when /^BIT$/
+              'bit'
+            else type # raise "SQL type unknown for standard type #{type}"
+            end
+          [sql_type, length]
+        end
+
+      public
+        def generate(out = $>)      #:nodoc:
+          @out = out
+          #go "CREATE SCHEMA #{@vocabulary.name}"
+
+          tables_emitted = {}
+          delayed_foreign_keys = []
+
+          @vocabulary.tables.each do |table|
+            puts "CREATE TABLE #{escape table.name.gsub(' ','')} ("
+
+            pk = table.identifier_columns
+            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|
+              column.references[0].is_simple_reference
+            end
+
+            # We sort the columns here, not in the rmap layer, because it affects
+            # the ordering of columns in an index :-(.
+            columns = table.columns.sort_by { |column| column.name(nil) }.map do |column|
+              name = escape column.name("")
+              padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
+              type, params, constraints = column.type
+              constraints = [] if (fk_columns.include?(column))  # Don't enforce VT constraints on FK columns
+              length = params[:length]
+              length &&= length.to_i
+              scale = params[:scale]
+              scale &&= scale.to_i
+              type, length = normalise_type(type, length)
+              sql_type = "#{type}#{
+                if !length
+                  ""
+                else
+                  "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
+                end
+                }"
+              identity = column == identity_column ? " AUTO_INCREMENT" : ""
+              null = (column.is_mandatory ? "NOT " : "") + "NULL"
+              check = check_clause(name, constraints)
+              comment = column.comment
+              [ "-- #{comment}", "#{name}#{padding}#{sql_type}#{identity} #{null}#{check}" ]
+            end.flatten
+
+            pk_def = (pk.detect{|column| !column.is_mandatory} ? "UNIQUE(" : "PRIMARY KEY(") +
+                pk.map{|column| escape column.name("")}*", " +
+                ")"
+
+            inline_fks = []
+            table.foreign_keys.each do |fk|
+              fk_text = "FOREIGN KEY (" +
+                fk.from_columns.map{|column| column.name}*", " +
+                ") REFERENCES #{escape fk.to.name.gsub(' ','')} (" +
+                fk.to_columns.map{|column| column.name}*", " +
+                ")"
+              if !@delay_fks and              # We don't want to delay all Fks
+                (tables_emitted[fk.to] or     # The target table has been emitted
+                fk.to == table && !fk.to_columns.detect{|column| !column.is_mandatory})   # The reference columns already have the required indexes
+                inline_fks << fk_text
+              else
+                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name.gsub(' ','')}\n\tADD " + fk_text)
+              end
+            end
+
+            indices = table.indices
+            inline_indices = []
+            delayed_indices = []
+            indices.each do |index|
+              next if index.over == table && index.is_primary   # Already did the primary keys
+              abbreviated_column_names = index.abbreviated_column_names*""
+              column_names = index.column_names
+              column_name_list = column_names.map{|n| escape(n)}*", "
+              inline_indices << "UNIQUE(#{column_name_list})"
+            end
+
+            tables_emitted[table] = true
+
+            puts("\t" + (columns + [pk_def] + inline_indices + inline_fks)*",\n\t")
+            go ")"
+            delayed_indices.each {|index_text|
+              go index_text
+            }
+          end
+
+          delayed_foreign_keys.each do |fk|
+            go fk
+          end
+        end
+
+      private
+        def sql_value(value)
+          value.is_literal_string ? sql_string(value.literal) : value.literal
+        end
+
+        def sql_string(str)
+          "'" + str.gsub(/'/,"''") + "'"
+        end
+
+        def check_clause(column_name, constraints)
+          return "" if constraints.empty?
+          # REVISIT: Merge all constraints (later; now just use the first)
+          " CHECK(" +
+            constraints[0].all_allowed_range_sorted.map do |ar|
+              vr = ar.value_range
+              min = vr.minimum_bound
+              max = vr.maximum_bound
+              if (min && max && max.value.literal == min.value.literal)
+                "#{column_name} = #{sql_value(min.value)}"
+              else
+                inequalities = [
+                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{sql_value(min.value)}",
+                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{sql_value(max.value)}"
+                ].compact
+                inequalities.size > 1 ? "(" + inequalities*" AND " + ")" : inequalities[0]
+              end
+            end*" OR " +
+          ")"
+        end
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('sql/mysql', ActiveFacts::Generators::SQL::MYSQL)