sbf-dm-migrations 1.3.0.beta

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

@@ -0,0 +1,105 @@
+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 = []
+
+      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(&: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}
+
+        %i(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
+
+        schema[:allow_nil] = !schema[:not_null] unless schema.key?(:allow_nil)
+
+        if type_class.is_a?(String)
+          schema[:primitive] = type_class
+        else
+          primitive = type_class.respond_to?(:dump_as) ? type_class.dump_as : type_class
+          options   = @adapter.class.type_by_property_class(type_class) || @adapter.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
+
+      private def quoted_name
+        @adapter.send(:quote_name, name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module SQL
+  class TableModifier
+    extend DataMapper::Property::Lookup
+
+    attr_accessor :table_name, :opts, :statements, :adapter
+
+    def initialize(adapter, table_name, opts = {}, &block)
+      @adapter = adapter
+      @table_name = table_name.to_s
+      @opts = opts
+
+      @statements = []
+
+      instance_eval(&block)
+    end
+
+    def add_column(name, type, opts = {})
+      column = SQL::TableCreator::Column.new(@adapter, name, type, opts)
+      @statements << "ALTER TABLE #{quoted_table_name} ADD COLUMN #{column.to_sql}"
+    end
+
+    def drop_column(name)
+      # raise NotImplemented for SQLite3. Can't ALTER TABLE, need to copy table.
+      # We'd have to inspect it, and we can't, since we aren't executing any queries yet.
+      # TODO instead of building the SQL queries when executing the block, create AddColumn,
+      # AlterColumn and DropColumn objects that get #to_sql'd
+      if name.is_a?(Array)
+        name.each { |n| drop_column(n) }
+      else
+        @statements << "ALTER TABLE #{quoted_table_name} DROP COLUMN #{quote_column_name(name)}"
+      end
+    end
+    alias_method :drop_columns, :drop_column
+
+    def rename_column(name, new_name, _opts = {})
+      # raise NotImplemented for SQLite3
+      @statements << @adapter.rename_column_type_statement(table_name, name, new_name)
+    end
+
+    def change_column(name, type, opts = {})
+      column = SQL::TableCreator::Column.new(@adapter, name, type, opts)
+      @statements << @adapter.change_column_type_statement(table_name, column)
+    end
+
+    def quote_column_name(name)
+      @adapter.send(:quote_name, name.to_s)
+    end
+
+    def quoted_table_name
+      @adapter.send(:quote_name, table_name)
+    end
+
+    def to_sql
+      @statements.join(';')
+    end
+  end
+end

data/lib/dm-migrations/sql.rb

@@ -0,0 +1,7 @@
+require 'dm-migrations/sql/table_creator'
+require 'dm-migrations/sql/table_modifier'
+require 'dm-migrations/sql/sqlite'
+require 'dm-migrations/sql/mysql'
+require 'dm-migrations/sql/postgres'
+require 'dm-migrations/sql/sqlserver'
+require 'dm-migrations/sql/oracle'

data/lib/dm-migrations/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Migrations
+    VERSION = '1.3.0.beta'.freeze
+  end
+end

data/lib/dm-migrations.rb

@@ -0,0 +1,3 @@
+require 'dm-core'
+require 'dm-migrations/migration'
+require 'dm-migrations/auto_migration'

data/lib/spec/example/migration_example_group.rb

@@ -0,0 +1,69 @@
+require_relative '../matchers/migration_matchers'
+
+require 'rspec'
+
+module Spec
+  module Example
+    class MigrationExampleGroup < RSpec::Core::ExampleGroup
+      include Spec::Matchers::Migration
+
+      before(:all) do
+        run_prereq_migrations if this_migration.adapter.supports_schema_transactions?
+      end
+
+      before(:each) do
+        if this_migration.adapter.supports_schema_transactions?
+          this_migration.adapter.begin_transaction
+        else
+          run_prereq_migrations
+        end
+      end
+
+      after(:each) do
+        this_migration.adapter.rollback_transaction if this_migration.adapter.supports_schema_transactions?
+      end
+
+      after(:all) do
+        this_migration.adapter.recreate_database
+      end
+
+      def run_prereq_migrations
+        # 'running n-1 migrations'
+        all_databases.each do |db|
+          db.adapter.recreate_database
+        end
+        @@migrations.sort.each do |migration|
+          break if migration.name.to_s == migration_name.to_s
+
+          migration.perform_up
+        end
+      end
+
+      def run_migration
+        this_migration.perform_up
+      end
+
+      def migration_name
+        @migration_name ||= self.class.instance_variable_get('@description_text').to_s
+      end
+
+      def all_databases
+        @@migrations.map(&:database).uniq
+      end
+
+      def this_migration
+        @@migrations.select { |m| m.name.to_s == migration_name }.first
+      end
+
+      def select(sql)
+        this_migration.adapter.select(sql)
+      end
+
+      def table(table_name)
+        this_migration.adapter.table(table_name)
+      end
+
+      Spec::Example::MigrationExampleGroup.register
+    end
+  end
+end

data/lib/spec/matchers/migration_matchers.rb

@@ -0,0 +1,96 @@
+module Spec
+  module Matchers
+    module Migration
+      def have_table(table_name)
+        HaveTableMatcher.new(table_name)
+      end
+
+      def have_column(column_name)
+        HaveColumnMatcher.new(column_name)
+      end
+
+      def permit_null
+        NullableColumnMatcher.new
+      end
+
+      def be_primary_key
+        PrimaryKeyMatcher.new
+      end
+
+      class HaveTableMatcher
+        attr_accessor :table_name, :repository
+
+        def initialize(table_name)
+          @table_name = table_name
+        end
+
+        def matches?(repository)
+          repository.adapter.storage_exists?(table_name)
+        end
+
+        def failure_message
+          %(expected #{repository} to have table '#{table_name}')
+        end
+
+        def negative_failure_message
+          %(expected #{repository} to not have table '#{table_name}')
+        end
+      end
+
+      class HaveColumnMatcher
+        attr_accessor :table, :column_name
+
+        def initialize(column_name)
+          @column_name = column_name
+        end
+
+        def matches?(table)
+          @table = table
+          table.columns.map(&:name).include?(column_name.to_s)
+        end
+
+        def failure_message
+          %(expected #{table} to have column '#{column_name}')
+        end
+
+        def negative_failure_message
+          %(expected #{table} to not have column '#{column_name}')
+        end
+      end
+
+      class NullableColumnMatcher
+        attr_accessor :column
+
+        def matches?(column)
+          @column = column
+          !column.not_null
+        end
+
+        def failure_message
+          %(expected #{column.name} to permit NULL)
+        end
+
+        def negative_failure_message
+          %(expected #{column.name} to be NOT NULL)
+        end
+      end
+
+      class PrimaryKeyMatcher
+        attr_accessor :column
+
+        def matches?(column)
+          @column = column
+          column.primary_key
+        end
+
+        def failure_message
+          %(expected #{column.name} to be PRIMARY KEY)
+        end
+
+        def negative_failure_message
+          %(expected #{column.name} to not be PRIMARY KEY)
+        end
+      end
+    end
+  end
+end