sequel_migration_builder 0.1.4 → 0.2.0

data/CHANGELOG

@@ -0,0 +1,9 @@
+CHANGELOG
+
+== 0.2.0
+
+* Switched to using the new style 'change' block in the generated
+  migrations, rather than 'up' or 'down'. This bumps the Sequel
+  requirement to at least 3.18.0.
+* Changes in indexes are properly handled - not just if the names
+  are different.

data/README.rdoc

@@ -3,6 +3,16 @@
 Builds sequel migrations based on the differences between an abstract
 representation of the desired schema and a database instance.
 
+This is quite a low-level library - it doesn't provide any functionality
+to write out migration files, nor does it provide a ruby DSL for defining
+your schema (see Schema format below).
+
+This library is also very, very new, so there WILL be bugs.
+
+== Install
+
+    sudo gem install sequel_migration_builder
+
 == Example
 
     require 'sequel/migration_builder'
@@ -38,7 +48,7 @@ as a hash. A sample YAML version might look like:
 
 == Requirements
 
-* Sequel 3.12.0 or higher
+* Sequel 3.18.0 or higher
 
 == TODO
 

data/Rakefile

@@ -10,7 +10,7 @@ begin
     gem.email = "roland.swingler@gmail.com"
     gem.homepage = "http://github.com/knaveofdiamonds/sequel_migration_builder"
     gem.authors = ["Roland Swingler"]
-    gem.add_dependency "sequel", ">= 3.12.0"
+    gem.add_dependency "sequel", ">= 3.18.0"
     gem.add_development_dependency "rspec", ">= 1.2.9"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/lib/sequel/migration_builder.rb

@@ -1,5 +1,6 @@
 require 'sequel/extensions/blank'
 require 'sequel/schema/db_column'
+require 'sequel/schema/db_index'
 require 'sequel/schema/db_schema_parser'
 require 'sequel/schema/alter_table_operations'
 
@@ -30,38 +31,23 @@ module Sequel
 
       add_line "Sequel.migration do"
       indent do
-        generate_up(tables)
-        generate_down(tables)
+        generate_migration_body(tables)
       end
       add_line "end\n"
 
       result.join("\n")
     end
 
-    # Generates the 'up' part of the migration.
+    # Generates the 'change' block of the migration.
     #
-    def generate_up(tables)
+    def generate_migration_body(tables)
       current_tables, new_tables = table_names(tables).partition do |table_name| 
         @db_table_names.include?(table_name)
       end
 
-      add_line "up do"
+      add_line "change do"
       create_new_tables(new_tables, tables)
-      alter_tables(current_tables, tables, :up)
-      add_line "end"
-      add_blank_line
-    end
-
-    # Generates the down part of the migration.
-    #
-    def generate_down(tables)
-      current_tables, new_tables = table_names(tables).partition do |table_name| 
-        @db_table_names.include?(table_name)
-      end
-
-      add_line "down do"
-      alter_tables(current_tables, tables, :down)
-      drop_new_tables(new_tables)
+      alter_tables(current_tables, tables)
       add_line "end"
     end
 
@@ -84,13 +70,13 @@ module Sequel
 
     # Generates any alter table statements for current tables.
     #
-    def alter_tables(current_table_names, tables, direction)
+    def alter_tables(current_table_names, tables)
       each_table(current_table_names, tables) do |table_name, table, last_table|
         hsh = table.dup
         hsh[:columns] = hsh[:columns].map {|c| Schema::DbColumn.build_from_hash(c) }
         operations = Schema::AlterTableOperations.build(@db_tables[table_name], hsh)
         unless operations.empty?
-          alter_table_statement table_name, operations, direction
+          alter_table_statement table_name, operations
           add_blank_line unless last_table
         end
       end
@@ -98,10 +84,10 @@ module Sequel
 
     # Generates an individual alter table statement.
     #
-    def alter_table_statement(table_name, operations, direction)
+    def alter_table_statement(table_name, operations)
       add_line "alter_table #{table_name.inspect} do"
       indent do
-        operations.map {|op| op.__send__(direction) }.compact.each {|op| add_line op }
+        operations.compact.each {|op| add_line op }
       end
       add_line "end"
     end
@@ -109,30 +95,44 @@ module Sequel
     # Generates an individual create_table statement.
     #
     def create_table_statement(table_name, table)
+      normalize_primary_key(table)
       add_line "create_table #{table_name.inspect}#{pretty_hash(table[:table_options])} do"
       indent do
-        table[:primary_key] = [table[:primary_key]] if table[:primary_key].kind_of?(Symbol)
-        table[:columns].each do |c| 
-          column = Schema::DbColumn.build_from_hash(c)
-          if table[:primary_key] && table[:primary_key].size == 1 && table[:primary_key].first == column.name
-            column.single_primary_key = true
-          end
-          add_line column.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
+        output_columns(table[:columns], table[:primary_key])
+        output_indexes(table[:indexes])
+        output_composite_primary_key(table[:primary_key])
+      end
+      add_line "end"
+    end
+
+    def normalize_primary_key(table)
+      table[:primary_key] = [table[:primary_key]] if table[:primary_key].kind_of?(Symbol)
+    end
+
+    def output_columns(columns, primary_key)
+      columns.each do |c| 
+        column = Schema::DbColumn.build_from_hash(c)
+        if primary_key && primary_key.size == 1 && primary_key.first == column.name
+          column.single_primary_key = true
         end
-        if table[:primary_key] && table[:primary_key].size > 1
-          add_blank_line
-          add_line "primary_key #{table[:primary_key].inspect}"
+        add_line column.define_statement
+      end
+    end
+
+    def output_indexes(indexes)
+      if indexes
+        add_blank_line
+        Schema::DbIndex.build_from_hash(indexes).each do |idx|
+          add_line idx.define_statement
         end
       end
-      add_line "end"
+    end
+
+    def output_composite_primary_key(primary_key)
+      if primary_key && primary_key.size > 1
+        add_blank_line
+        add_line "primary_key #{primary_key.inspect}"
+      end
     end
 
     private

data/lib/sequel/schema/alter_table_operations.rb

@@ -1,60 +1,48 @@
 module Sequel
   module Schema
-    module AlterTableOperations
-      
+    class AlterTableOperations
       # Returns an array of operations to change the current database
       # table to be like the defined table.
       #
       def self.build(db_table, new_table)
+        new.build(db_table, new_table)
+      end
+
+      def build(db_table, new_table)
         db_columns = db_table[:columns].inject({}) {|hsh, column| hsh[column.name] = column; hsh }
+        new_column_names = new_table[:columns].map {|c| c.name }
+        dropped_columns = db_columns.keys - new_column_names
 
         operations = new_table[:columns].map do |column|
           if db_columns[column.name]
             build_column_operations db_columns[column.name], column
           else
-            AddColumn.new(column)
+            column.add_statement
           end
         end.flatten
 
-        new_column_names = new_table[:columns].map {|c| c.name }
-        dropped_columns = db_columns.keys - new_column_names
-
         operations += dropped_columns.map do |name| 
-          DropColumn.new(db_columns[name])
+          db_columns[name].drop_statement
         end
 
-        db_indexes = db_table[:indexes] || {}
-        new_indexes = new_table[:indexes] || {}
-
-        operations += (db_indexes.keys - new_indexes.keys).map do |index_name|
-          dropped_column = db_indexes[index_name][:columns].size == 1 && dropped_columns.include?(db_indexes[index_name][:columns].first)
-
-          DropIndex.new(index_name, 
-                        db_indexes[index_name][:columns],
-                        db_indexes[index_name][:unique],
-                        ! dropped_column)
+        db_indexes = Schema::DbIndex.build_from_hash(db_table[:indexes] || {})
+        new_indexes = Schema::DbIndex.build_from_hash(new_table[:indexes] || {})
+        
+        operations += (db_indexes - new_indexes).map do |index|
+          index.drop_statement unless index.columns.all? {|c| dropped_columns.include?(c) }
         end
-
-        operations += (new_indexes.keys - db_indexes.keys).map do |index_name|
-          if new_indexes[index_name][:columns].kind_of?(Symbol)
-            dropped_column = dropped_columns.include?(new_indexes[index_name][:columns])
-          else
-            dropped_column = new_indexes[index_name][:columns].size == 1 && dropped_columns.include?(new_indexes[index_name][:columns].first)
-          end
-
-          AddIndex.new(index_name, 
-                       new_indexes[index_name][:columns],
-                       new_indexes[index_name][:unique],
-                       ! dropped_column)
+        
+        operations += (new_indexes - db_indexes).map do |index|
+          index.add_statement          
         end
-
-        operations
+        
+        operations        
       end
       
       # Returns an array of operations to change the current database
       # column to be like the defined column.
       #
-      def self.build_column_operations(db_column, new_column)
+      def build_column_operations(db_column, new_column)
         result = []
         
         diffs = db_column.diff(new_column)
@@ -63,63 +51,7 @@ module Sequel
         result << :change_default_statement if diffs.include?(:default) && result.empty?
         result << :change_null_statement    if diffs.include?(:null)
         
-        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 < Operation
-        def initialize(old_column, new_column, statement)
-          @up = new_column.__send__(statement)
-          @down = old_column.__send__(statement)
-        end
-      end
-
-      # Adds a column.
-      class AddColumn < Operation
-        def initialize(column)
-          @up = column.add_statement
-          @down = column.drop_statement
-        end
-      end
-
-      # Drops a column.
-      class DropColumn < Operation
-        def initialize(column)
-          @up = column.drop_statement
-          @down = column.add_statement
-        end
-      end
-
-      # Adds an index.
-      class AddIndex < Operation
-        def initialize(name, columns, unique, include_drop_index=true)
-          @up   = "add_index #{columns.inspect}, :name => #{name.inspect}"
-          @up << ", :unique => true" if unique
-          if include_drop_index
-            @down = "drop_index #{columns.inspect}, :name => #{name.inspect}"
-          end
-        end
-      end
-
-      # Drops an index.
-      class DropIndex < Operation
-        def initialize(name, columns, unique, include_drop_index=true)
-          if include_drop_index
-            @up = "drop_index #{columns.inspect}, :name => #{name.inspect}"
-          end
-          @down = "add_index #{columns.inspect}, :name => #{name.inspect}"
-          @down << ", :unique => true" if unique
-        end
+        result.map {|statement| new_column.__send__(statement) }
       end
     end
   end

data/lib/sequel/schema/db_index.rb

@@ -0,0 +1,78 @@
+module Sequel
+  module Schema
+    class DbIndex
+      attr_accessor :name
+      attr_reader :columns
+
+      # Builds an Array of DbIndexes from the index hash returned by
+      # Sequel::Database#indexes
+      def self.build_from_hash(definitions)
+        definitions.map {|name,attrs| new(name, attrs[:columns], attrs[:unique]) }
+      end
+
+      # Creates a new DbIndex definition.
+      #
+      # columns may be a single column name as a symbol, or an array
+      # of column symbol names.
+      #
+      # Indexes are not unique by default.
+      def initialize(name, columns, unique=false)
+        @name = name.to_sym
+        @columns = columns.kind_of?(Array) ? columns.clone : [columns]
+        @unique = unique
+      end
+
+      # Returns true if this index is unique
+      def unique?
+        !! @unique
+      end
+
+      # Returns true if this index has more than one column.
+      def multi_column?
+        @columns.size > 1
+      end
+
+      # Returns the sequel migration statement to define an index in a
+      # create_table block.
+      def define_statement
+        base_add_statement('index')
+      end
+
+      # Returns the sequel migration statement to add an index in an
+      # alter_table block.
+      def add_statement
+        base_add_statement('add_index')
+      end
+
+      # Returns the sequel migration statement to remove an index in an
+      # alter_table block.
+      def drop_statement
+        "drop_index #{columns_for_statement.inspect}, :name => #{name.inspect}"
+      end
+
+      # Indexes are equal if all their attributes are equal.
+      def ==(other)
+        other.kind_of?(self.class) &&
+          @name == other.name && @columns == other.columns && @unique == other.unique?
+      end
+      alias :eql? :==
+      
+      def hash # :nodoc:
+        @name.hash
+      end
+
+      private
+
+      def columns_for_statement
+        return columns.first unless multi_column?
+        columns
+      end
+      
+      def base_add_statement(keyword)
+        parts = ["#{keyword} #{columns_for_statement.inspect}, :name => #{name.inspect}"]
+        parts << ":unique => #{@unique.inspect}" if unique?
+        parts.join(", ")
+      end
+    end
+  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.1.4"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Roland Swingler"]
-  s.date = %q{2010-08-13}
+  s.date = %q{2011-01-13}
   s.description = %q{Build Sequel Migrations based on the differences between two schemas}
   s.email = %q{roland.swingler@gmail.com}
   s.extra_rdoc_files = [
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
      ".gitignore",
+     "CHANGELOG",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -26,10 +27,12 @@ Gem::Specification.new do |s|
      "lib/sequel/migration_builder.rb",
      "lib/sequel/schema/alter_table_operations.rb",
      "lib/sequel/schema/db_column.rb",
+     "lib/sequel/schema/db_index.rb",
      "lib/sequel/schema/db_schema_parser.rb",
      "sequel_migration_builder.gemspec",
      "spec/alter_table_operations_spec.rb",
      "spec/db_column_spec.rb",
+     "spec/db_index_spec.rb",
      "spec/db_schema_parser_spec.rb",
      "spec/migration_builder_spec.rb",
      "spec/spec.opts",
@@ -38,11 +41,12 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/knaveofdiamonds/sequel_migration_builder}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Build Sequel Migrations based on the differences between two schemas}
   s.test_files = [
     "spec/alter_table_operations_spec.rb",
      "spec/db_column_spec.rb",
+     "spec/db_index_spec.rb",
      "spec/db_schema_parser_spec.rb",
      "spec/migration_builder_spec.rb",
      "spec/spec_helper.rb"
@@ -52,15 +56,15 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<sequel>, [">= 3.12.0"])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sequel>, [">= 3.18.0"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
     else
-      s.add_dependency(%q<sequel>, [">= 3.12.0"])
+      s.add_dependency(%q<sequel>, [">= 3.18.0"])
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
     end
   else
-    s.add_dependency(%q<sequel>, [">= 3.12.0"])
+    s.add_dependency(%q<sequel>, [">= 3.18.0"])
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
   end
 end

data/spec/alter_table_operations_spec.rb

@@ -4,69 +4,73 @@ def build_column(hash)
   Sequel::Schema::DbColumn.build_from_hash(hash)
 end
 
-describe "Sequel::Schema::AlterTableOperations.build_column_operations" do
+describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
+  before :each do
+    @subject = Sequel::Schema::AlterTableOperations.new
+  end
+
   it "should return an empty Array if there are no differences between column definitions" do
     a = build_column(:name => :foo, :column_type => :integer)
     b = build_column(:name => :foo, :column_type => :integer)
 
-    Sequel::Schema::AlterTableOperations.build_column_operations(a,b).should == []
+    @subject.build_column_operations(a,b).should == []
   end
 
   it "should return a ChangeColumn operation if the types are different" do
     a = build_column(:name => :foo, :column_type => :integer)
     b = build_column(:name => :foo, :column_type => :smallint)
-    ops = Sequel::Schema::AlterTableOperations.build_column_operations(a,b)
+    ops = @subject.build_column_operations(a,b)
 
-    ops.first.up.should == "set_column_type :foo, :smallint, :default => nil"
+    ops.first.should == "set_column_type :foo, :smallint, :default => nil"
   end
 
   it "should return a ChangeColumn operation if the sizes are different" do
     a = build_column(:name => :foo, :column_type => :char, :size => 20)
     b = build_column(:name => :foo, :column_type => :char, :size => 10)
-    ops = Sequel::Schema::AlterTableOperations.build_column_operations(a,b)
+    ops = @subject.build_column_operations(a,b)
 
-    ops.first.up.should == "set_column_type :foo, :char, :default => nil, :size => 10"
+    ops.first.should == "set_column_type :foo, :char, :default => nil, :size => 10"
   end
 
   it "should return a ChangeColumn operation if the unsigned value is different" do
     a = build_column(:name => :foo, :column_type => :integer, :unsigned => true)
     b = build_column(:name => :foo, :column_type => :integer, :unsigned => false)
-    ops = Sequel::Schema::AlterTableOperations.build_column_operations(a,b)
+    ops = @subject.build_column_operations(a,b)
 
-    ops.first.up.should == "set_column_type :foo, :integer, :default => nil, :unsigned => false"
+    ops.first.should == "set_column_type :foo, :integer, :default => nil, :unsigned => false"
   end
 
   it "should return a ChangeColumn operation to set the null value if the null value is different" do
     a = build_column(:name => :foo, :column_type => :integer, :null => true)
     b = build_column(:name => :foo, :column_type => :integer, :null => false)
-    ops = Sequel::Schema::AlterTableOperations.build_column_operations(a,b)
+    ops = @subject.build_column_operations(a,b)
 
-    ops.first.up.should == "set_column_allow_null :foo, false"
+    ops.first.should == "set_column_allow_null :foo, false"
   end
 
   it "should return a ChangeColumn operation to set the default if the default value is different" do
     a = build_column(:name => :foo, :column_type => :integer, :default => 1)
     b = build_column(:name => :foo, :column_type => :integer, :default => 2)
-    ops = Sequel::Schema::AlterTableOperations.build_column_operations(a,b)
+    ops = @subject.build_column_operations(a,b)
 
-    ops.first.up.should == "set_column_default :foo, 2"
+    ops.first.should == "set_column_default :foo, 2"
   end
 
   it "should only return 1 operation if the default and other values are different" do
     a = build_column(:name => :foo, :column_type => :integer, :default => 1)
     b = build_column(:name => :foo, :column_type => :smallint, :default => 2)
-    ops = Sequel::Schema::AlterTableOperations.build_column_operations(a,b)
+    ops = @subject.build_column_operations(a,b)
 
     ops.size.should == 1
-    ops.first.up.should == "set_column_type :foo, :smallint, :default => 2"
+    ops.first.should == "set_column_type :foo, :smallint, :default => 2"
   end
 
   it "should return a ChangeColumn operation if the elements are different" do
     a = build_column(:name => :foo, :column_type => :enum, :elements => ["A"])
     b = build_column(:name => :foo, :column_type => :enum, :elements => ["A", "B"])
-    ops = Sequel::Schema::AlterTableOperations.build_column_operations(a,b)
+    ops = @subject.build_column_operations(a,b)
 
-    ops.first.up.should == "set_column_type :foo, :enum, :default => nil, :elements => [\"A\", \"B\"]"
+    ops.first.should == "set_column_type :foo, :enum, :default => nil, :elements => [\"A\", \"B\"]"
   end
 end
 
@@ -89,7 +93,7 @@ describe "Sequel::Schema::AlterTableOperations.build" do
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
     ops.size.should == 1
-    ops.first.should be_kind_of(Sequel::Schema::AlterTableOperations::AddColumn)
+    ops.first.should =~ /add_column/
   end
 
   it "should return a drop column operation if the column has been removed" do
@@ -100,7 +104,7 @@ describe "Sequel::Schema::AlterTableOperations.build" do
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
     ops.size.should == 1
-    ops.first.should be_kind_of(Sequel::Schema::AlterTableOperations::DropColumn)
+    ops.first.should =~ /drop_column/
   end
 
   it "should return a change column operation if columns are different" do
@@ -111,105 +115,16 @@ describe "Sequel::Schema::AlterTableOperations.build" do
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
     ops.size.should == 1
-    ops.first.should be_kind_of(Sequel::Schema::AlterTableOperations::ChangeColumn)
+    ops.first.should =~ /set_column/
   end
 
-  it "should not output a drop index statement in #up if the index's column is also removed" do
+  it "should not output a drop index statement in #change if the index's column is also removed" do
     table_a = {:name => :example_table,
       :indexes => {:foo_idx => {:columns => [:foo]}},
       :columns => [build_column(:name => :foo, :column_type => :integer)]}
     table_b = {:name => :example_table, :indexes => {}, :columns => []}
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
-    ops.last.should be_kind_of(Sequel::Schema::AlterTableOperations::DropIndex)
-    ops.last.up.should be_nil
-    ops.last.down.should == "add_index [:foo], :name => :foo_idx"
-  end
-
-  it "should not output a drop index statement in #down if the index's column is also added" do
-    table_a = {:name => :example_table,
-      :indexes => {},
-      :columns => [build_column(:name => :foo, :column_type => :integer)]}
-    table_b = {:name => :example_table, :indexes => {:foo_idx => {:columns => [:foo]}}, :columns => []}
-    ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
-
-    ops.last.should be_kind_of(Sequel::Schema::AlterTableOperations::AddIndex)
-    ops.last.up.should  == "add_index [:foo], :name => :foo_idx"
-    ops.last.down.should be_nil
-  end
-end
-
-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).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(:add_statement)
-    @mock_column.should_receive(:drop_statement).and_return("drop")
-    Sequel::Schema::AlterTableOperations::AddColumn.new(@mock_column).down.should == "drop"
-  end
-end
-
-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(: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(:drop_statement)
-    @mock_column.should_receive(:add_statement).and_return("add")
-    Sequel::Schema::AlterTableOperations::DropColumn.new(@mock_column).down.should == "add"
-  end
-end
-
-describe Sequel::Schema::AlterTableOperations::ChangeColumn do
-  it "should ask the new column for statement on #up" do
-    new = mock(:new)
-    old = mock(:old)
-    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 old column for statement on #down" do
-    new = mock(:new)
-    old = mock(:old)
-    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"
+    ops.last.should be_nil
   end
 end

data/spec/db_index_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Sequel::Schema::DbIndex do
+  it "should have a name" do
+    Sequel::Schema::DbIndex.new('foo_index', :foo).name.should == :foo_index
+  end
+
+  it "can have columns" do
+    Sequel::Schema::DbIndex.new('foo_index', [:foo, :bar]).columns.should == [:foo, :bar]
+  end
+
+  it "converts a single column symbol to a 1 element array of columns" do
+    Sequel::Schema::DbIndex.new('foo_index', :foo).columns.should == [:foo]
+  end
+
+  it "is not unique by default" do
+    Sequel::Schema::DbIndex.new('foo_index', :foo).should_not be_unique
+  end
+
+  it "can be unique" do
+    Sequel::Schema::DbIndex.new('foo_index', :foo, true).should be_unique
+  end
+
+  it "should respond to multi_column?" do
+    Sequel::Schema::DbIndex.new('foo_index', :foo, true).should_not be_multi_column
+    Sequel::Schema::DbIndex.new('foo_index', [:foo, :bar], true).should be_multi_column
+  end
+
+  it "should be equal when compared with ==" do
+    i1 = Sequel::Schema::DbIndex.new('foo_idx', :foo, true)
+
+    i1.should == Sequel::Schema::DbIndex.new('foo_idx', :foo, true)
+    i1.should == Sequel::Schema::DbIndex.new('foo_idx', [:foo], true)
+    i1.should_not == Sequel::Schema::DbIndex.new('foo_idx', :foo, false)
+    i1.should_not == Sequel::Schema::DbIndex.new('foo', :foo, true)
+    i1.should_not == Sequel::Schema::DbIndex.new('foo_idx', :bar, true)
+  end
+
+  it "should be equal when compared with eql?" do
+    i1 = Sequel::Schema::DbIndex.new('foo_idx', :foo, true)
+
+    i1.hash.should == Sequel::Schema::DbIndex.new('foo_idx', :foo, true).hash
+    i1.should be_eql(Sequel::Schema::DbIndex.new('foo_idx', :foo, true))
+  end
+  
+  it "can be built from a hash returned by Sequel::Database#indexes" do
+    hsh = {:foo_idx => {:columns => [:foo], :unique => true}}
+    Sequel::Schema::DbIndex.build_from_hash(hsh).should ==
+      [Sequel::Schema::DbIndex.new(:foo_idx, :foo, true)]
+  end
+
+  it "should have a define statement" do
+    Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).define_statement.should ==
+      "index :foo, :name => :foo_idx, :unique => true"
+  end
+
+  it "should have a define statement for multiple columns" do
+    Sequel::Schema::DbIndex.new(:foo_idx, [:foo, :bar], true).define_statement.should ==
+      "index [:foo, :bar], :name => :foo_idx, :unique => true"
+  end
+
+  it "should not output the unique value if it is false" do
+    Sequel::Schema::DbIndex.new(:foo_idx, :foo).define_statement.should ==
+      "index :foo, :name => :foo_idx"
+  end
+
+  it "should have an add_index statement" do
+    Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).add_statement.should ==
+      "add_index :foo, :name => :foo_idx, :unique => true"
+  end
+
+  it "should have an drop_index statement" do
+    Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).drop_statement.should ==
+      "drop_index :foo, :name => :foo_idx"
+  end
+end

data/spec/migration_builder_spec.rb

@@ -16,15 +16,11 @@ describe Sequel::MigrationBuilder do
 
     expected = <<-END
 Sequel.migration do
-  up do
+  change do
     create_table :example_table do
       integer :foo, :null => false
     end
   end
-
-  down do
-    drop_table :example_table
-  end
 end
 END
     
@@ -45,7 +41,7 @@ END
 
     expected = <<-END
 Sequel.migration do
-  up do
+  change do
     create_table :example_table do
       integer :foo, :null => false
       varchar :bar, :null => false
@@ -55,11 +51,6 @@ Sequel.migration do
       integer :foo
     end
   end
-
-  down do
-    drop_table :example_table_2
-    drop_table :example_table
-  end
 end
 END
     
@@ -140,7 +131,7 @@ END
 
     it "should return an alter table statement with column changes for #generate_up" do
       expected = <<-END
-up do
+change do
   alter_table :example_table do
     set_column_type :foo, :integer, :default => nil
     set_column_allow_null :foo, false
@@ -149,21 +140,8 @@ up do
   end
 end
 END
-      Sequel::MigrationBuilder.new(@mock_db).generate_up(@tables).join("\n").should == expected
-    end
-
-    it "should return an alter table statement with column changes for #generate_down" do
-      expected = <<-END
-down do
-  alter_table :example_table 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
-      Sequel::MigrationBuilder.new(@mock_db).generate_down(@tables).join("\n").should == expected.strip
+      Sequel::MigrationBuilder.new(@mock_db).
+        generate_migration_body(@tables).join("\n").should == expected.strip
     end
   end
 
@@ -173,7 +151,7 @@ END
     mock_db.should_receive(:tables).at_least(:once).and_return([:example_table])
     
     expected = <<-END
-up do
+change do
   drop_table :example_table
 end
 END

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_migration_builder
 version: !ruby/object:Gem::Version 
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 4
-  version: 0.1.4
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Roland Swingler
@@ -14,30 +15,34 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-13 00:00:00 +01:00
+date: 2011-01-13 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sequel
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 79
         segments: 
         - 3
-        - 12
+        - 18
         - 0
-        version: 3.12.0
+        version: 3.18.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 13
         segments: 
         - 1
         - 2
@@ -57,6 +62,7 @@ extra_rdoc_files:
 files: 
 - .document
 - .gitignore
+- CHANGELOG
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -64,10 +70,12 @@ files:
 - lib/sequel/migration_builder.rb
 - lib/sequel/schema/alter_table_operations.rb
 - lib/sequel/schema/db_column.rb
+- lib/sequel/schema/db_index.rb
 - lib/sequel/schema/db_schema_parser.rb
 - sequel_migration_builder.gemspec
 - spec/alter_table_operations_spec.rb
 - spec/db_column_spec.rb
+- spec/db_index_spec.rb
 - spec/db_schema_parser_spec.rb
 - spec/migration_builder_spec.rb
 - spec/spec.opts
@@ -82,29 +90,34 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Build Sequel Migrations based on the differences between two schemas
 test_files: 
 - spec/alter_table_operations_spec.rb
 - spec/db_column_spec.rb
+- spec/db_index_spec.rb
 - spec/db_schema_parser_spec.rb
 - spec/migration_builder_spec.rb
 - spec/spec_helper.rb