dm-migrations 0.9.2

data/lib/spec/matchers/migration_matchers.rb

@@ -0,0 +1,107 @@
+
+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 { |c| c.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

data/lib/sql.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/sql/sqlite3'
+require File.dirname(__FILE__) + '/sql/mysql'
+require File.dirname(__FILE__) + '/sql/postgresql'
+
+module SQL
+
+  class TableCreator
+    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_table_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(', ')})"
+    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 build_type(type_class)
+        schema = {:name => @name, :quote_column_name => quoted_name}.merge(@opts)
+        schema.merge!(@adapter.class.type_map[type_class])
+        @adapter.property_schema_statement(schema)
+      end
+
+      def to_sql
+          type
+      end
+
+      def quoted_name
+        @adapter.send(:quote_column_name, name)
+      end
+    end
+
+  end
+
+  class TableModifier
+    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 = []
+
+      self.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.
+      # Just write the sql yourself.
+      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 drop_columns drop_column
+
+    def rename_column(name, new_name, opts = {})
+      # raise NotImplemented for SQLite3
+      @statements << "ALTER TABLE #{quoted_table_name} RENAME COLUMN #{quote_column_name(name)} TO #{quote_column_name(new_name)}"
+    end
+
+    def change_column(name, type, opts = {})
+      # raise NotImplemented for SQLite3
+      @statements << "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quote_column_name(name)} TYPE #{type}"
+    end
+
+    def quote_column_name(name)
+      @adapter.send(:quote_column_name, name.to_s)
+    end
+
+    def quoted_table_name
+      @adapter.send(:quote_table_name, table_name)
+    end
+
+  end
+
+
+end

data/lib/sql/column.rb

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

data/lib/sql/mysql.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/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 #{db_name}"
+      execute "CREATE DATABASE #{db_name}"
+      execute "USE #{db_name}"
+    end
+
+    def supports_serial?
+      true
+    end
+
+    # TODO: move to dm-more/dm-migrations
+    def property_schema_statement(schema)
+      if supports_serial? && schema[:serial]
+        statement = "#{schema[:quote_column_name]} serial PRIMARY KEY"
+      else
+        super
+      end
+    end
+
+    class Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.query_table(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/sql/postgresql.rb

@@ -0,0 +1,78 @@
+module SQL
+  module Postgresql
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Postgresql::Table.new(self, table_name)
+    end
+
+    def drop_database
+    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(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
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.query_table(table_name).each do |col_struct|
+          @columns << SQL::Postgresql::Column.new(col_struct)
+        end
+
+        puts "+=+++++++++++++++++++++++++++++++++++++++"
+        # detect column constraints
+        adapter.query(
+          "SELECT * FROM information_schema.table_constraints WHERE table_name='#{table_name}' AND table_schema=current_schema()"
+        ).each do |table_constraint|
+          puts table_constraint.inspect
+          adapter.query(
+            "SELECT * FROM information_schema.constraint_column_usage WHERE table_name='#{table_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/sql/sqlite3.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/table'
+
+module SQL
+  module Sqlite3
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      DataMapper.logger.info "Dropping #{@uri.path}"
+      system "rm #{@uri.path}"
+      # do nothing, sqlite will automatically create the database file
+    end
+
+    def supports_serial?
+      true
+    end
+
+    # TODO: move to dm-more/dm-migrations
+    def property_schema_statement(schema)
+      statement = super
+      statement << ' PRIMARY KEY AUTOINCREMENT' if supports_serial? && schema[:serial]
+      statement
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.query_table(table_name).each do |col_struct|
+          @columns << SQL::Sqlite3::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/sql/table.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/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/spec/integration/migration_runner_spec.rb

@@ -0,0 +1,78 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
+  describe 'empty migration runner' do
+    it "should return an empty array if no migrations have been defined" do
+      migrations.should be_kind_of(Array)
+      migrations.should have(0).item
+    end
+  end
+  describe 'migration runnner' do
+    # set up some 'global' setup and teardown tasks
+    before(:each) do
+      migration( 1, :create_people_table) { }
+    end
+
+    after(:each) do
+      @@migrations = []
+    end
+
+    describe '#migration' do
+
+      it 'should create a new migration object, and add it to the list of migrations' do
+        @@migrations.should be_kind_of(Array)
+        @@migrations.should have(1).item
+        @@migrations.first.name.should == "create_people_table"
+      end
+
+      it 'should allow multiple migrations to be added' do
+        migration( 2, :add_dob_to_people) { }
+        migration( 2, :add_favorite_pet_to_people) { }
+        migration( 3, :add_something_else_to_people) { }
+        @@migrations.should have(4).items
+      end
+
+      it 'should raise an error on adding with a duplicated name' do
+        lambda { migration( 1, :create_people_table) { } }.should raise_error(RuntimeError, /Migration name conflict/)
+      end
+
+    end
+
+    describe '#migrate_up! and #migrate_down!' do
+      before(:each) do
+        migration( 2, :add_dob_to_people) { }
+        migration( 2, :add_favorite_pet_to_people) { }
+        migration( 3, :add_something_else_to_people) { }
+      end
+
+      it 'calling migrate_up! should migrate up all the migrations' do
+        # add our expection that migrate_up should be called
+        @@migrations.each do |m|
+          m.should_receive(:perform_up)
+        end
+        migrate_up!
+      end
+
+      it 'calling migrate_up! with an arguement should only migrate to that level' do
+        @@migrations.each do |m|
+          if m.position <= 2
+            m.should_receive(:perform_up)
+          else
+            m.should_not_receive(:perform_up)
+          end
+        end
+        migrate_up!(2)
+      end
+
+      it 'calling migrate_down! should migrate down all the migrations' do
+        # add our expection that migrate_up should be called
+        @@migrations.each do |m|
+          m.should_receive(:perform_down)
+        end
+        migrate_down!
+      end
+
+    end
+  end
+end