dm-migrations 0.9.2 → 0.9.3

data/lib/sql/postgresql.rb

@@ -9,9 +9,6 @@ module SQL
       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"
@@ -37,19 +34,21 @@ module SQL
 
     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::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()"
+        query_column_constraints
+      end
+
+      def query_column_constraints
+        @adapter.query(
+          "SELECT * FROM information_schema.table_constraints WHERE table_name='#{@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()"
+          @adapter.query(
+            "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
@@ -61,6 +60,7 @@ module SQL
             end
           end
         end
+
       end
 
     end

data/lib/sql/sqlite3.rb

@@ -8,7 +8,7 @@ module SQL
     end
 
     def table(table_name)
-      SQL::Table.new(self, table_name)
+      SQL::Sqlite3::Table.new(self, table_name)
     end
 
     def recreate_database
@@ -21,13 +21,6 @@ module SQL
       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 = []

data/lib/sql/table_creator.rb

@@ -0,0 +1,55 @@
+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 = @adapter.class.type_map[type_class].merge(schema)
+        @adapter.property_schema_statement(schema)
+      end
+
+      def to_sql
+          type
+      end
+
+      def quoted_name
+        @adapter.send(:quote_column_name, name)
+      end
+    end
+
+  end
+
+end
+

data/lib/sql/table_modifier.rb

@@ -0,0 +1,53 @@
+module SQL
+  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.
+      # 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 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/spec/integration/migration_runner_spec.rb

@@ -1,78 +1,81 @@
 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 = []
+[:sqlite3, :mysql, :postgres].each do |adapter|
+  next unless eval("HAS_#{adapter.to_s.upcase}")
+  describe "Using Adapter #{adapter}, " do
+    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' 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"
+    describe 'migration runnner' do
+      # set up some 'global' setup and teardown tasks
+      before(:each) do
+        migration( 1, :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
+      after(:each) do
+        @@migrations = []
       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
+      describe '#migration' do
 
-    end
+        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
 
-    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 '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 '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)
+        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
-        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
+      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 expectation that migrate_up should be called
+          @@migrations.each do |m|
             m.should_receive(:perform_up)
-          else
-            m.should_not_receive(:perform_up)
           end
+          migrate_up!
         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)
+        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 expectation that migrate_up should be called
+          @@migrations.each do |m|
+            m.should_receive(:perform_down)
+          end
+          migrate_down!
         end
-        migrate_down!
-      end
 
+      end
     end
   end
 end

data/spec/integration/migration_spec.rb

@@ -1,136 +1,136 @@
 require 'pathname'
 require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
 
-if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
-  describe DataMapper::Migration, 'interface' do
-    before do
-      @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
-    end
+[:sqlite3, :mysql, :postgres].each do |adapter|
+  next unless eval("HAS_#{adapter.to_s.upcase}")
+  describe "Using Adapter #{adapter}, " do
+    describe DataMapper::Migration, 'interface' do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+      end
 
-    it "should have a postition attribute" do
-      @migration.should respond_to(:position)
-      @migration.should respond_to(:position=)
-      @migration.position.should == 1
-    end
+      it "should have a postition attribute" do
+        @migration.should respond_to(:position)
+        @migration.should respond_to(:position=)
+        @migration.position.should == 1
+      end
 
-    it "should have a name attribute" do
-      @migration.should respond_to(:name)
-      @migration.should respond_to(:name=)
-      @migration.name.should == :create_people_table
-    end
+      it "should have a name attribute" do
+        @migration.should respond_to(:name)
+        @migration.should respond_to(:name=)
+        @migration.name.should == :create_people_table
+      end
 
-    it "should have a :database option" do
-      DataMapper.setup(:other, "sqlite3://#{Dir.pwd}/migration_other.db")
+      it "should have a :database option" do
+        DataMapper.setup(:other, "sqlite3://#{Dir.pwd}/migration_other.db")
 
-      m = DataMapper::Migration.new(2, :create_dogs_table, :database => :other) {}
-      m.instance_variable_get(:@database).name.should == :other
-    end
+        m = DataMapper::Migration.new(2, :create_dogs_table, :database => :other) {}
+        m.instance_variable_get(:@database).name.should == :other
+      end
 
-    it "should use the default database by default" do
-      @migration.instance_variable_get(:@database).name.should == :default
-    end
+      it "should use the default database by default" do
+        @migration.instance_variable_get(:@database).name.should == :default
+      end
 
-    it "should have a verbose option" do
-      m = DataMapper::Migration.new(2, :create_dogs_table, :verbose => false) {}
-      m.instance_variable_get(:@verbose).should == false
-    end
+      it "should have a verbose option" do
+        m = DataMapper::Migration.new(2, :create_dogs_table, :verbose => false) {}
+        m.instance_variable_get(:@verbose).should == false
+      end
 
-    it "should be verbose by default" do
-      m = DataMapper::Migration.new(2, :create_dogs_table) {}
-      m.instance_variable_get(:@verbose).should == true
-    end
+      it "should be verbose by default" do
+        m = DataMapper::Migration.new(2, :create_dogs_table) {}
+        m.instance_variable_get(:@verbose).should == true
+      end
 
-    it "should be sortable, first by position, then name" do
-      m1 = DataMapper::Migration.new(1, :create_people_table) {}
-      m2 = DataMapper::Migration.new(2, :create_dogs_table) {}
-      m3 = DataMapper::Migration.new(2, :create_cats_table) {}
-      m4 = DataMapper::Migration.new(4, :create_birds_table) {}
+      it "should be sortable, first by position, then name" do
+        m1 = DataMapper::Migration.new(1, :create_people_table) {}
+        m2 = DataMapper::Migration.new(2, :create_dogs_table) {}
+        m3 = DataMapper::Migration.new(2, :create_cats_table) {}
+        m4 = DataMapper::Migration.new(4, :create_birds_table) {}
 
-      [m1, m2, m3, m4].sort.should == [m1, m3, m2, m4]
-    end
+        [m1, m2, m3, m4].sort.should == [m1, m3, m2, m4]
+      end
 
-    if HAS_SQLITE3
-      it "should extend with SQL::Sqlite3 when adapter is Sqlite3Adapter" do
-        DataMapper.setup(:sqlite3, "sqlite3::memory:")
-        migration = DataMapper::Migration.new(1, :sqlite3_adapter_test, :database => :sqlite3) { }
-        (class << migration.adapter; self; end).included_modules.should include(SQL::Sqlite3)
+      if HAS_SQLITE3
+        it "should extend with SQL::Sqlite3 when adapter is Sqlite3Adapter" do
+          migration = DataMapper::Migration.new(1, :sqlite3_adapter_test, :database => :sqlite3) { }
+          (class << migration.adapter; self; end).included_modules.should include(SQL::Sqlite3)
+        end
       end
-    end
 
-    if HAS_MYSQL
-      it "should extend with SQL::Mysql when adapter is MysqlAdapter" do
-        DataMapper.setup(:mysql, "mysql://localhost/migration_test")
-        migration = DataMapper::Migration.new(1, :mysql_adapter_test, :database => :mysql) { }
-        (class << migration.adapter; self; end).included_modules.should include(SQL::Mysql)
+      if HAS_MYSQL
+        it "should extend with SQL::Mysql when adapter is MysqlAdapter" do
+          migration = DataMapper::Migration.new(1, :mysql_adapter_test, :database => :mysql) { }
+          (class << migration.adapter; self; end).included_modules.should include(SQL::Mysql)
+        end
       end
-    end
 
-    if HAS_POSTGRES
-      it "should extend with SQL::Postgres when adapter is PostgresAdapter" do
-        DataMapper.setup(:postgres, "postgres://localhost/migration_test")
-        migration = DataMapper::Migration.new(1, :postgres_adapter_test, :database => :postgres) { }
-        (class << migration.adapter; self; end).included_modules.should include(SQL::Postgresql)
+      if HAS_POSTGRES
+        it "should extend with SQL::Postgres when adapter is PostgresAdapter" do
+          migration = DataMapper::Migration.new(1, :postgres_adapter_test, :database => :postgres) { }
+          (class << migration.adapter; self; end).included_modules.should include(SQL::Postgresql)
+        end
       end
     end
-  end
 
-  describe DataMapper::Migration, 'defining actions' do
-    before do
-      @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
-    end
+    describe DataMapper::Migration, 'defining actions' do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+      end
 
-    it "should have an #up method" do
-      @migration.should respond_to(:up)
-    end
+      it "should have an #up method" do
+        @migration.should respond_to(:up)
+      end
 
-    it "should save the block passed into the #up method in @up_action" do
-      action = lambda {}
-      @migration.up(&action)
+      it "should save the block passed into the #up method in @up_action" do
+        action = lambda {}
+        @migration.up(&action)
 
-      @migration.instance_variable_get(:@up_action).should == action
-    end
+        @migration.instance_variable_get(:@up_action).should == action
+      end
 
-    it "should have a #down method" do
-      @migration.should respond_to(:down)
-    end
+      it "should have a #down method" do
+        @migration.should respond_to(:down)
+      end
 
-    it "should save the block passed into the #down method in @down_action" do
-      action = lambda {}
-      @migration.down(&action)
+      it "should save the block passed into the #down method in @down_action" do
+        action = lambda {}
+        @migration.down(&action)
 
-      @migration.instance_variable_get(:@down_action).should == action
-    end
+        @migration.instance_variable_get(:@down_action).should == action
+      end
+
+      it "should make available an #execute method" do
+        @migration.should respond_to(:execute)
+      end
 
-    it "should make available an #execute method" do
-      @migration.should respond_to(:execute)
+      it "should run the sql passed into the #execute method"
+      # TODO: Find out how to stub the DataMapper::database.execute method
     end
 
-    it "should run the sql passed into the #execute method"
-    # TODO: Find out how to stub the DataMapper::database.execute method
-  end
+    describe DataMapper::Migration, "output" do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table) { }
+        @migration.stub!(:write) # so that we don't actually write anything to the console!
+      end
 
-  describe DataMapper::Migration, "output" do
-    before do
-      @migration = DataMapper::Migration.new(1, :create_people_table) { }
-      @migration.stub!(:write) # so that we don't actually write anything to the console!
-    end
+      it "should #say a string with an indent" do
+        @migration.should_receive(:write).with("   Foobar")
+        @migration.say("Foobar", 2)
+      end
 
-    it "should #say a string with an indent" do
-      @migration.should_receive(:write).with("   Foobar")
-      @migration.say("Foobar", 2)
-    end
+      it "should #say with a default indent of 4" do
+        @migration.should_receive(:write).with("     Foobar")
+        @migration.say("Foobar")
+      end
 
-    it "should #say with a default indent of 4" do
-      @migration.should_receive(:write).with("     Foobar")
-      @migration.say("Foobar")
-    end
+      it "should #say_with_time the running time of a block" do
+        @migration.should_receive(:write).with(/Block/)
+        @migration.should_receive(:write).with(/-> [\d]+/)
 
-    it "should #say_with_time the running time of a block" do
-      @migration.should_receive(:write).with(/Block/)
-      @migration.should_receive(:write).with(/-> [\d]+/)
+        @migration.say_with_time("Block"){ }
+      end
 
-      @migration.say_with_time("Block"){ }
     end
-
   end
 end