sequel_migration_builder 0.0.5 → 0.1.0

data/README.rdoc

@@ -21,6 +21,10 @@ as a hash. A sample YAML version might look like:
       primary_key: id
       table_options:
         engine: myisam
+      indexes:
+        foo_index_name:
+          columns: foo
+          unique: true
       columns:
         - name: id
           column_type: integer

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.1.0

data/lib/sequel/migration_builder.rb

@@ -114,6 +114,14 @@ module Sequel
         table[:columns].each do |c| 
           add_line Schema::DbColumn.build_from_hash(c).define_statement
         end
+        if table[:indexes]
+          add_blank_line
+          table[:indexes].each do |name, options|
+            opts = options.clone
+            columns = opts.delete(:columns)
+            add_line "index #{columns.inspect}, :name => #{name.to_sym.inspect}#{pretty_hash(opts)}"
+          end
+        end
         if table[:primary_key]
           add_blank_line
           add_line "primary_key #{table[:primary_key].inspect}"
@@ -139,7 +147,7 @@ module Sequel
     # Returns a string representing a hash as ':foo => :bar'
     # rather than '{:foo=.:bar}'
     def pretty_hash(hash)
-      ", " + hash.inspect.gsub(/^\{|\}$/,'').gsub("=>", " => ") if hash
+      ", " + hash.inspect.gsub(/^\{|\}$/,'').gsub("=>", " => ") if hash && ! hash.empty?
     end
 
     def table_names(tables)

data/lib/sequel/schema/alter_table_operations.rb

@@ -17,7 +17,24 @@ module Sequel
         end.flatten
 
         new_column_names = new_table[:columns].map {|c| c.name }
-        operations + (db_columns.keys - new_column_names).map {|column| DropColumn.new(column) }
+        operations += (db_columns.keys - new_column_names).map {|name| DropColumn.new(db_columns[name]) }
+
+        db_indexes = db_table[:indexes] || {}
+        new_indexes = new_table[:indexes] || {}
+
+        operations += (db_indexes.keys - new_indexes.keys).map do |index_name|
+          DropIndex.new(index_name, 
+                        db_indexes[index_name][:columns],
+                        db_indexes[index_name][:unique])
+        end
+
+        operations += (new_indexes.keys - db_indexes.keys).map do |index_name|
+          AddIndex.new(index_name, 
+                       new_indexes[index_name][:columns],
+                       new_indexes[index_name][:unique])
+        end
+
+        operations
       end
       
       # Returns an array of operations to change the current database
@@ -35,49 +52,55 @@ module Sequel
         result.map {|k| ChangeColumn.new(db_column, new_column, k) }
       end
 
+      # Base alter table operation class. Each operation will return
+      # Sequel::Migration statement(s) to alter the table.
+      class Operation
+        # Returns the statement for the up part of the migration
+        attr_reader :up
+        
+        # Returns the statement for the down part of the operation
+        attr_reader :down
+      end
+
       # Changes a column.
-      class ChangeColumn
+      class ChangeColumn < Operation
         def initialize(old_column, new_column, statement)
-          @old_column, @new_column = old_column, new_column
-          @statement_method = statement
-        end
-
-        def up
-          @new_column.__send__(@statement_method)
-        end
-
-        def down
-          @old_column.__send__(@statement_method)
+          @up = new_column.__send__(statement)
+          @down = old_column.__send__(statement)
         end
       end
 
       # Adds a column.
-      class AddColumn
+      class AddColumn < Operation
         def initialize(column)
-          @column = column
-        end
-
-        def up
-          @column.add_statement
-        end
-
-        def down
-          @column.drop_statement
+          @up = column.add_statement
+          @down = column.drop_statement
         end
       end
 
       # Drops a column.
-      class DropColumn
+      class DropColumn < Operation
         def initialize(column)
-          @column = column
+          @up = column.drop_statement
+          @down = column.add_statement
         end
+      end
 
-        def up
-          @column.drop_statement
+      # Adds an index.
+      class AddIndex < Operation
+        def initialize(name, columns, unique)
+          @up   = "add_index #{columns.inspect}, :name => #{name.inspect}"
+          @up << ", :unique => true" if unique
+          @down = "drop_index #{columns.inspect}, :name => #{name.inspect}"
         end
+      end
 
-        def down
-          @column.add_statement
+      # Drops an index.
+      class DropIndex < Operation
+        def initialize(name, columns, unique)
+          @up = "drop_index #{columns.inspect}, :name => #{name.inspect}"
+          @down = "add_index #{columns.inspect}, :name => #{name.inspect}"
+          @down << ", :unique => true" if unique
         end
       end
     end

data/lib/sequel/schema/db_column.rb

@@ -14,7 +14,7 @@ module Sequel
       INTEGER_TYPES = [:tinyint, :integer, :smallint, :mediumint, :bigint]
 
       # Database column types that hold fractional values.
-      DECIMAL_TYPES = [:decimal, :float, :bigdecimal]
+      DECIMAL_TYPES = [:decimal, :float, :double, :real]
 
       # All numeric database column types.
       NUMERIC_TYPES = INTEGER_TYPES + DECIMAL_TYPES
@@ -81,7 +81,7 @@ module Sequel
         }.select {|attribute, method| __send__(method, attribute, other) }.map {|a| a.first }.to_set
       end
 
-      # Returns true if this column is numeric
+      # Returns true if this column is numeric.
       #
       def numeric?
         NUMERIC_TYPES.include?(column_type)

data/lib/sequel/schema/db_schema_parser.rb

@@ -28,7 +28,10 @@ module Sequel
       #
       def parse_db_schema
         @db.tables.inject({}) do |result, table_name|
-          result[table_name] = {:columns => parse_table_schema(@db.schema(table_name))}
+          result[table_name] = {
+            :indexes => @db.indexes(table_name),
+            :columns => parse_table_schema(@db.schema(table_name))
+          }
           result
         end
       end

data/sequel_migration_builder.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sequel_migration_builder}
-  s.version = "0.0.5"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Roland Swingler"]
-  s.date = %q{2010-06-23}
+  s.date = %q{2010-07-02}
   s.description = %q{Build Sequel Migrations based on the differences between two schemas}
   s.email = %q{roland.swingler@gmail.com}
   s.extra_rdoc_files = [

data/spec/alter_table_operations_spec.rb

@@ -111,13 +111,15 @@ describe Sequel::Schema::AlterTableOperations::AddColumn do
   before(:each) { @mock_column = mock() }
 
   it "should ask the column for its add column statement on #up" do
-    @mock_column.should_receive(:add_statement)
-    Sequel::Schema::AlterTableOperations::AddColumn.new(@mock_column).up
+    @mock_column.should_receive(:add_statement).and_return("add")
+    @mock_column.should_receive(:drop_statement)
+    Sequel::Schema::AlterTableOperations::AddColumn.new(@mock_column).up.should == "add"
   end
 
   it "should ask the column for its drop column statement on #down" do
-    @mock_column.should_receive(:drop_statement)
-    Sequel::Schema::AlterTableOperations::AddColumn.new(@mock_column).down
+    @mock_column.should_receive(:add_statement)
+    @mock_column.should_receive(:drop_statement).and_return("drop")
+    Sequel::Schema::AlterTableOperations::AddColumn.new(@mock_column).down.should == "drop"
   end
 end
 
@@ -125,13 +127,15 @@ describe Sequel::Schema::AlterTableOperations::DropColumn do
   before(:each) { @mock_column = mock() }
 
   it "should ask the column for its drop column statement on #up" do
-    @mock_column.should_receive(:drop_statement)
-    Sequel::Schema::AlterTableOperations::DropColumn.new(@mock_column).up
+    @mock_column.should_receive(:add_statement)
+    @mock_column.should_receive(:drop_statement).and_return("drop")
+    Sequel::Schema::AlterTableOperations::DropColumn.new(@mock_column).up.should == "drop"
   end
 
   it "should ask the column for its add column statement on #down" do
-    @mock_column.should_receive(:add_statement)
-    Sequel::Schema::AlterTableOperations::DropColumn.new(@mock_column).down
+    @mock_column.should_receive(:drop_statement)
+    @mock_column.should_receive(:add_statement).and_return("add")
+    Sequel::Schema::AlterTableOperations::DropColumn.new(@mock_column).down.should == "add"
   end
 end
 
@@ -139,14 +143,41 @@ describe Sequel::Schema::AlterTableOperations::ChangeColumn do
   it "should ask the new column for statement on #up" do
     new = mock(:new)
     old = mock(:old)
-    new.should_receive(:change_type_statement)
-    Sequel::Schema::AlterTableOperations::ChangeColumn.new(old, new, :change_type_statement).up
+    old.should_receive(:change_type_statement)
+    new.should_receive(:change_type_statement).and_return("new")
+    Sequel::Schema::AlterTableOperations::ChangeColumn.new(old, new, :change_type_statement).up.should == "new"
   end
 
-  it "should ask the new column for statement on #down" do
+  it "should ask the old column for statement on #down" do
     new = mock(:new)
     old = mock(:old)
-    old.should_receive(:change_type_statement)
+    old.should_receive(:change_type_statement).and_return("old")
+    new.should_receive(:change_type_statement)
     Sequel::Schema::AlterTableOperations::ChangeColumn.new(old, new, :change_type_statement).down
   end
 end
+
+
+describe Sequel::Schema::AlterTableOperations::AddIndex do
+  it "should add the index on #up" do
+    Sequel::Schema::AlterTableOperations::AddIndex.new(:foo_index, :foo, true).up.
+      should == "add_index :foo, :name => :foo_index, :unique => true"
+  end
+
+  it "should drop the index on #down" do
+    Sequel::Schema::AlterTableOperations::AddIndex.new(:foo_index, :foo, true).down.
+      should == "drop_index :foo, :name => :foo_index"
+  end
+end
+
+describe Sequel::Schema::AlterTableOperations::DropIndex do
+  it "should add the index on #down" do
+    Sequel::Schema::AlterTableOperations::DropIndex.new(:foo_index, :foo, true).down.
+      should == "add_index :foo, :name => :foo_index, :unique => true"
+  end
+
+  it "should drop the index on #up" do
+    Sequel::Schema::AlterTableOperations::DropIndex.new(:foo_index, :foo, true).up.
+      should == "drop_index :foo, :name => :foo_index"
+  end
+end

data/spec/db_schema_parser_spec.rb

@@ -114,6 +114,7 @@ describe "Sequel::Schema::DbSchemaParser#parse_db_schema" do
     mock_db = mock(:db)
     mock_db.should_receive(:tables).at_least(:once).and_return([:table1])
     mock_db.should_receive(:schema).with(:table1).and_return([])
+    mock_db.should_receive(:indexes).with(:table1)
 
     @parser = Sequel::Schema::DbSchemaParser.for_db(mock_db)
     @parser.parse_db_schema.keys.should == [:table1]

data/spec/migration_builder_spec.rb

@@ -107,13 +107,35 @@ END
       should == expected.strip
   end
 
+  it "should add indexes to the create_table statement" do
+    mock_db = mock(:database)
+    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    table = {
+      :indexes => {:foo_index => {:columns => :foo, :unique => true}},
+      :columns => [{:name => :foo, :column_type => :integer}]
+    }
+
+    expected = <<-END
+create_table :example_table do
+  integer :foo, :null => false
+
+  index :foo, :name => :foo_index, :unique => true
+end
+END
+
+    Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n").
+      should == expected.strip
+  end
+  
   context "when a table needs to be altered" do
     before :each do
       @tables = { :example_table =>
-        {:columns => [{:name => :foo, :column_type => :integer}, {:name => :bar, :column_type => :varchar}]}
+        { :indexes => {:foo_index => {:columns => :foo, :unique => true}},
+          :columns => [{:name => :foo, :column_type => :integer}, {:name => :bar, :column_type => :varchar}]}
       }
       @mock_db = mock(:database)
       @mock_db.should_receive(:tables).at_least(:once).and_return([:example_table])
+      @mock_db.should_receive(:indexes).with(:example_table).and_return({})
       @mock_db.should_receive(:schema).with(:example_table).and_return([[:foo, {:type => :integer, :db_type => "smallint(5) unsigned", :allow_null => true, :ruby_default => 10}]])
 
     end
@@ -125,6 +147,7 @@ up do
     set_column_type :foo, :integer, :default => nil
     set_column_allow_null :foo, false
     add_column :bar, :varchar, :null => false
+    add_index :foo, :name => :foo_index, :unique => true
   end
 end
 END
@@ -138,6 +161,7 @@ down do
     set_column_type :foo, :smallint, :default => 10, :unsigned => true
     set_column_allow_null :foo, true
     drop_column :bar
+    drop_index :foo, :name => :foo_index
   end
 end
 END

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 5
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors: 
 - Roland Swingler
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-23 00:00:00 +01:00
+date: 2010-07-02 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency