ardm-migrations 1.2.0

data/lib/dm-migrations/migration.rb

@@ -0,0 +1,300 @@
+require 'dm-migrations/exceptions/duplicate_migration'
+require 'dm-migrations/sql'
+
+require 'benchmark'
+
+module DataMapper
+  class Migration
+    include SQL
+
+    # The position or version the migration belongs to
+    attr_reader :position
+
+    # The name of the migration
+    attr_reader :name
+
+    # The repository the migration operates on
+    attr_reader :repository
+
+    #
+    # Creates a new migration.
+    #
+    # @param [Symbol, String, Integer] position
+    #   The position or version the migration belongs to.
+    #
+    # @param [Symbol] name
+    #   The name of the migration.
+    #
+    # @param [Hash] options
+    #   Additional options for the migration.
+    #
+    # @option options [Boolean] :verbose (true)
+    #   Enables or disables verbose output.
+    #
+    # @option options [Symbol] :repository (:default)
+    #   The DataMapper repository the migration will operate on.
+    #
+    def initialize(position, name, options = {}, &block)
+      @position    = position
+      @name        = name
+      @options     = options
+      @verbose     = options.fetch(:verbose, true)
+      @up_action   = nil
+      @down_action = nil
+
+      @repository = if options.key?(:database)
+        warn 'Using the :database option with migrations is deprecated, use :repository instead'
+        options[:database]
+      else
+        options.fetch(:repository, :default)
+      end
+
+      instance_eval(&block)
+    end
+
+    #
+    # The repository the migration will operate on.
+    #
+    # @return [Symbol, nil]
+    #   The name of the DataMapper repository the migration will run against.
+    #
+    # @deprecated Use {#repository} instead.
+    #
+    # @since 1.0.1.
+    #
+    def database
+      warn "Using the DataMapper::Migration#database method is deprecated, use #repository instead"
+      @repository
+    end
+
+    #
+    # The adapter the migration will use.
+    #
+    # @return [DataMapper::Adapter]
+    #   The adapter the migration will operate on.
+    #
+    # @since 1.0.1
+    #
+    def adapter
+      setup! unless setup?
+
+      @adapter
+    end
+
+    # define the actions that should be performed on an up migration
+    def up(&block)
+      @up_action = block
+    end
+
+    # define the actions that should be performed on a down migration
+    def down(&block)
+      @down_action = block
+    end
+
+    # perform the migration by running the code in the #up block
+    def perform_up
+      result = nil
+
+      if needs_up?
+        # TODO: fix this so it only does transactions for databases that support create/drop
+        # database.transaction.commit do
+        if @up_action
+          say_with_time "== Performing Up Migration ##{position}: #{name}", 0 do
+            result = @up_action.call
+          end
+        end
+
+        update_migration_info(:up)
+        # end
+      end
+
+      result
+    end
+
+    # un-do the migration by running the code in the #down block
+    def perform_down
+      result = nil
+
+      if needs_down?
+        # TODO: fix this so it only does transactions for databases that support create/drop
+        # database.transaction.commit do
+        if @down_action
+          say_with_time "== Performing Down Migration ##{position}: #{name}", 0 do
+            result = @down_action.call
+          end
+        end
+
+        update_migration_info(:down)
+        # end
+      end
+
+      result
+    end
+
+    # execute raw SQL
+    def execute(sql, *bind_values)
+      say_with_time(sql) do
+        adapter.execute(sql, *bind_values)
+      end
+    end
+
+    def create_table(table_name, opts = {}, &block)
+      execute TableCreator.new(adapter, table_name, opts, &block).to_sql
+    end
+
+    def drop_table(table_name, opts = {})
+      execute "DROP TABLE #{adapter.send(:quote_name, table_name.to_s)}"
+    end
+
+    def modify_table(table_name, opts = {}, &block)
+      TableModifier.new(adapter, table_name, opts, &block).statements.each do |sql|
+        execute(sql)
+      end
+    end
+
+    def create_index(table_name, *columns_and_options)
+      if columns_and_options.last.is_a?(Hash)
+        opts = columns_and_options.pop
+      else
+        opts = {}
+      end
+      columns = columns_and_options.flatten
+
+      opts[:name] ||= "#{opts[:unique] ? 'unique_' : ''}index_#{table_name}_#{columns.join('_')}"
+
+      execute DataMapper::Ext::String.compress_lines(<<-SQL)
+        CREATE #{opts[:unique] ? 'UNIQUE ' : '' }INDEX #{quote_column_name(opts[:name])} ON
+        #{quote_table_name(table_name)} (#{columns.map { |c| quote_column_name(c) }.join(', ') })
+      SQL
+    end
+
+    # Orders migrations by position, so we know what order to run them in.
+    # First order by position, then by name, so at least the order is predictable.
+    def <=> other
+      if self.position == other.position
+        self.name.to_s <=> other.name.to_s
+      else
+        self.position <=> other.position
+      end
+    end
+
+    # Output some text. Optional indent level
+    def say(message, indent = 4)
+      write "#{" " * indent} #{message}"
+    end
+
+    # Time how long the block takes to run, and output it with the message.
+    def say_with_time(message, indent = 2)
+      say(message, indent)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      say("-> %.4fs" % time.real, indent)
+      result
+    end
+
+    # output the given text, but only if verbose mode is on
+    def write(text="")
+      puts text if @verbose
+    end
+
+    # Inserts or removes a row into the `migration_info` table, so we can mark this migration as run, or un-done
+    def update_migration_info(direction)
+      save, @verbose = @verbose, false
+
+      create_migration_info_table_if_needed
+
+      if direction.to_sym == :up
+        execute("INSERT INTO #{migration_info_table} (#{migration_name_column}) VALUES (#{quoted_name})")
+      elsif direction.to_sym == :down
+        execute("DELETE FROM #{migration_info_table} WHERE #{migration_name_column} = #{quoted_name}")
+      end
+      @verbose = save
+    end
+
+    def create_migration_info_table_if_needed
+      save, @verbose = @verbose, false
+      unless migration_info_table_exists?
+        execute("CREATE TABLE #{migration_info_table} (#{migration_name_column} VARCHAR(255) UNIQUE)")
+      end
+      @verbose = save
+    end
+
+    # Quote the name of the migration for use in SQL
+    def quoted_name
+      "'#{name}'"
+    end
+
+    def migration_info_table_exists?
+      adapter.storage_exists?('migration_info')
+    end
+
+    # Fetch the record for this migration out of the migration_info table
+    def migration_record
+      return [] unless migration_info_table_exists?
+      adapter.select("SELECT #{migration_name_column} FROM #{migration_info_table} WHERE #{migration_name_column} = #{quoted_name}")
+    end
+
+    # True if the migration needs to be run
+    def needs_up?
+      return true unless migration_info_table_exists?
+      migration_record.empty?
+    end
+
+    # True if the migration has already been run
+    def needs_down?
+      return false unless migration_info_table_exists?
+      ! migration_record.empty?
+    end
+
+    # Quoted table name, for the adapter
+    def migration_info_table
+      @migration_info_table ||= quote_table_name('migration_info')
+    end
+
+    # Quoted `migration_name` column, for the adapter
+    def migration_name_column
+      @migration_name_column ||= quote_column_name('migration_name')
+    end
+
+    def quote_table_name(table_name)
+      # TODO: Fix this for 1.9 - can't use this hack to access a private method
+      adapter.send(:quote_name, table_name.to_s)
+    end
+
+    def quote_column_name(column_name)
+      # TODO: Fix this for 1.9 - can't use this hack to access a private method
+      adapter.send(:quote_name, column_name.to_s)
+    end
+
+    protected
+
+    #
+    # Determines whether the migration has been setup.
+    #
+    # @return [Boolean]
+    #   Specifies whether the migration has been setup.
+    #
+    # @since 1.0.1
+    #
+    def setup?
+      !(@adapter.nil?)
+    end
+
+    #
+    # Sets up the migration.
+    #
+    # @since 1.0.1
+    #
+    def setup!
+      @adapter = DataMapper.repository(@repository).adapter
+
+      case @adapter.class.name
+      when /Sqlite/   then @adapter.extend(SQL::Sqlite)
+      when /Mysql/    then @adapter.extend(SQL::Mysql)
+      when /Postgres/ then @adapter.extend(SQL::Postgres)
+      else
+        raise(RuntimeError,"Unsupported Migration Adapter #{@adapter.class}",caller)
+      end
+    end
+  end
+end

data/lib/dm-migrations/migration_runner.rb

@@ -0,0 +1,85 @@
+require 'dm-migrations/migration'
+
+module DataMapper
+  module MigrationRunner
+    # Creates a new migration, and adds it to the list of migrations to be run.
+    # Migrations can be defined in any order, they will be sorted and run in the
+    # correct order.
+    #
+    # The order that migrations are run in is set by the first argument. It is not
+    # neccessary that this be unique; migrations with the same version number are
+    # expected to be able to be run in any order.
+    #
+    # The second argument is the name of the migration. This name is used internally
+    # to track if the migration has been run. It is required that this name be unique
+    # across all migrations.
+    #
+    # Addtionally, it accepts a number of options:
+    # * <tt>:database</tt> If you defined several DataMapper::database instances use this
+    #   to choose which one to run the migration gagainst. Defaults to <tt>:default</tt>.
+    #   Migrations are tracked individually per database.
+    # * <tt>:verbose</tt> true/false, defaults to true. Determines if the migration should
+    #   output its status messages when it runs.
+    #
+    # Example of a simple migration:
+    #
+    #   migration( 1, :create_people_table ) do
+    #     up do
+    #       create_table :people do
+    #         column :id,   Integer, :serial => true
+    #         column :name, String, :size => 50
+    #         column :age,  Integer
+    #       end
+    #     end
+    #     down do
+    #       drop_table :people
+    #     end
+    #   end
+    #
+    # Its recommended that you stick with raw SQL for migrations that manipulate data. If
+    # you write a migration using a model, then later change the model, there's a
+    # possibility the migration will no longer work. Using SQL will always work.
+    def migration( number, name, opts = {}, &block )
+      raise "Migration name conflict: '#{name}'" if migrations.map { |m| m.name }.include?(name.to_s)
+
+      migrations << DataMapper::Migration.new( number, name.to_s, opts, &block )
+    end
+
+    # Run all migrations that need to be run. In most cases, this would be called by a
+    # rake task as part of a larger project, but this provides the ability to run them
+    # in a script or test.
+    #
+    # has an optional argument 'level' which if supplied, only performs the migrations
+    # with a position less than or equal to the level.
+    def migrate_up!(level = nil)
+      migrations.sort.each do |migration|
+        if level.nil?
+          migration.perform_up()
+        else
+          migration.perform_up() if migration.position <= level.to_i
+        end
+      end
+    end
+
+    # Run all the down steps for the migrations that have already been run.
+    #
+    # has an optional argument 'level' which, if supplied, only performs the
+    # down migrations with a postion greater than the level.
+    def migrate_down!(level = nil)
+      migrations.sort.reverse.each do |migration|
+        if level.nil?
+          migration.perform_down()
+        else
+          migration.perform_down() if migration.position > level.to_i
+        end
+      end
+    end
+
+    def migrations
+      @@migrations ||= []
+    end
+
+  end
+end
+
+include DataMapper::MigrationRunner

data/lib/dm-migrations/sql/column.rb

@@ -0,0 +1,5 @@
+module SQL
+  class Column
+    attr_accessor :name, :type, :not_null, :default_value, :primary_key, :unique
+  end
+end

data/lib/dm-migrations/sql/mysql.rb

@@ -0,0 +1,61 @@
+require 'dm-migrations/sql/table'
+
+module SQL
+  module Mysql
+
+    def supports_schema_transactions?
+      false
+    end
+
+    def table(table_name)
+      SQL::Mysql::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      execute "DROP DATABASE #{schema_name}"
+      execute "CREATE DATABASE #{schema_name}"
+      execute "USE #{schema_name}"
+    end
+
+    def supports_serial?
+      true
+    end
+
+    def table_options(opts)
+      opt_engine    = opts[:storage_engine] || storage_engine
+      opt_char_set  = opts[:character_set] || character_set
+      opt_collation = opts[:collation] || collation
+
+      " ENGINE = #{opt_engine} CHARACTER SET #{opt_char_set} COLLATE #{opt_collation}"
+    end
+
+    def property_schema_statement(connection, schema)
+      if supports_serial? && schema[:serial]
+        statement = "#{schema[:quote_column_name]} SERIAL PRIMARY KEY"
+      else
+        super
+      end
+    end
+
+    def change_column_type_statement(name, column)
+      "ALTER TABLE #{quote_name(name)} MODIFY COLUMN #{column.to_sql}"
+    end
+
+    class Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.table_info(table_name).each do |col_struct|
+          @columns << SQL::Mysql::Column.new(col_struct)
+        end
+      end
+    end
+
+    class Column
+      def initialize(col_struct)
+        @name, @type, @default_value, @primary_key = col_struct.name, col_struct.type, col_struct.dflt_value, col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+  end
+end

data/lib/dm-migrations/sql/postgres.rb

@@ -0,0 +1,82 @@
+module SQL
+  module Postgres
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Postgres::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      execute 'DROP SCHEMA IF EXISTS test CASCADE'
+      execute 'CREATE SCHEMA test'
+      execute 'SET search_path TO test'
+    end
+
+    def supports_serial?
+      true
+    end
+
+    def property_schema_statement(connection, schema)
+      if supports_serial? && schema[:serial]
+        statement = "#{schema[:quote_column_name]} SERIAL PRIMARY KEY"
+      else
+        statement = super
+        if schema.has_key?(:sequence_name)
+          statement << " DEFAULT nextval('#{schema[:sequence_name]}') NOT NULL"
+        end
+        statement
+      end
+      statement
+    end
+
+    def table_options(opts)
+      ''
+    end
+
+    def change_column_type_statement(name, column)
+      "ALTER TABLE #{quote_name(name)} ALTER COLUMN #{column.to_sql}"
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @adapter, @name = adapter, table_name
+        @columns = []
+        adapter.query_table(table_name).each do |col_struct|
+          @columns << SQL::Postgres::Column.new(col_struct)
+        end
+
+        query_column_constraints
+      end
+
+      def query_column_constraints
+        @adapter.select(
+          "SELECT * FROM information_schema.table_constraints WHERE table_name='#{@name}' AND table_schema=current_schema()"
+        ).each do |table_constraint|
+          @adapter.select(
+            "SELECT * FROM information_schema.constraint_column_usage WHERE constraint_name='#{table_constraint.constraint_name}' AND table_schema=current_schema()"
+          ).each do |constrained_column|
+            @columns.each do |column|
+              if column.name == constrained_column.column_name
+                case table_constraint.constraint_type
+                when "UNIQUE"       then column.unique = true
+                when "PRIMARY KEY"  then column.primary_key = true
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        @name, @type, @default_value = col_struct.column_name, col_struct.data_type, col_struct.column_default
+
+        @not_null = col_struct.is_nullable != "YES"
+      end
+    end
+  end
+end

data/lib/dm-migrations/sql/sqlite.rb

@@ -0,0 +1,51 @@
+require 'dm-migrations/sql/table'
+
+require 'fileutils'
+
+module SQL
+  module Sqlite
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Sqlite::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      DataMapper.logger.info "Dropping #{@uri.path}"
+      FileUtils.rm_f(@uri.path)
+      # do nothing, sqlite will automatically create the database file
+    end
+
+    def table_options(opts)
+      ''
+    end
+
+    def supports_serial?
+      true
+    end
+
+    def change_column_type_statement(*args)
+      raise NotImplementedError
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.table_info(table_name).each do |col_struct|
+          @columns << SQL::Sqlite::Column.new(col_struct)
+        end
+      end
+    end
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        @name, @type, @default_value, @primary_key = col_struct.name, col_struct.type, col_struct.dflt_value, col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+  end
+end

data/lib/dm-migrations/sql/table.rb

@@ -0,0 +1,15 @@
+require 'dm-migrations/sql/column'
+
+module SQL
+  class Table
+    attr_accessor :name, :columns
+
+    def to_s
+      name
+    end
+
+    def column(column_name)
+      @columns.select { |c| c.name == column_name.to_s }.first
+    end
+  end
+end

data/lib/dm-migrations/sql/table_creator.rb

@@ -0,0 +1,109 @@
+require 'dm-core'
+
+module SQL
+  class TableCreator
+
+    extend DataMapper::Property::Lookup
+
+    attr_accessor :table_name, :opts
+
+    def initialize(adapter, table_name, opts = {}, &block)
+      @adapter = adapter
+      @table_name = table_name.to_s
+      @opts = opts
+
+      @columns = []
+
+      self.instance_eval &block
+    end
+
+    def quoted_table_name
+      @adapter.send(:quote_name, table_name)
+    end
+
+    def column(name, type, opts = {})
+      @columns << Column.new(@adapter, name, type, opts)
+    end
+
+    def to_sql
+      "CREATE TABLE #{quoted_table_name} (#{@columns.map{ |c| c.to_sql }.join(', ')})#{@adapter.table_options(@opts)}"
+    end
+
+    # A helper for using the native NOW() SQL function in a default
+    def now
+      SqlExpr.new('NOW()')
+    end
+
+    # A helper for using the native UUID() SQL function in a default
+    def uuid
+      SqlExpr.new('UUID()')
+    end
+
+    class SqlExpr
+      attr_accessor :sql
+      def initialize(sql)
+        @sql = sql
+      end
+
+      def to_s
+        @sql.to_s
+      end
+    end
+
+    class Column
+      attr_accessor :name, :type
+
+      def initialize(adapter, name, type, opts = {})
+        @adapter = adapter
+        @name = name.to_s
+        @opts = opts
+        @type = build_type(type)
+      end
+
+      def to_sql
+        type
+      end
+
+      private
+
+      def build_type(type_class)
+        schema = { :name => @name, :quote_column_name => quoted_name }
+
+        [ :nullable, :nullable? ].each do |option|
+          next if (value = schema.delete(option)).nil?
+          warn "#{option.inspect} is deprecated, use :allow_nil instead"
+          schema[:allow_nil] = value unless schema.key?(:allow_nil)
+        end
+
+        unless schema.key?(:allow_nil)
+          schema[:allow_nil] = !schema[:not_null]
+        end
+
+        if type_class.kind_of?(String)
+          schema[:primitive] = type_class
+        else
+          type_map  = @adapter.class.type_map
+          primitive = type_class.respond_to?(:primitive) ? type_class.primitive : type_class
+          options   = (type_map[type_class] || type_map[primitive])
+
+          schema.update(type_class.options) if type_class.respond_to?(:options)
+          schema.update(options)
+
+          schema.delete(:length) if type_class == DataMapper::Property::Text
+        end
+
+        schema.update(@opts)
+
+        schema[:length] = schema.delete(:size) if schema.key?(:size)
+
+        @adapter.send(:with_connection) do |connection|
+          @adapter.property_schema_statement(connection, schema)
+        end
+      end
+
+      def quoted_name
+        @adapter.send(:quote_name, name)
+      end
+    end
+  end
+end