sequel_migration_builder 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Roland Swingler
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,55 @@
+= Sequel Migration Builder
+
+Builds sequel migrations based on the differences between an abstract
+representation of the desired schema and a database instance.
+
+== Example
+
+    require 'sequel/migration_builder'
+
+    desired_schema = { ... } # see below
+    builder = Sequel::MigrationBuilder.new(DB)
+    migration_code = builder.generate_migration(desired_schema)
+    File.write("001_some_migration.rb", migration_code)
+
+== Schema format
+
+The schema is an abstract representation of the tables in your database,
+as a hash. A sample YAML version might look like:
+
+    example_table:
+      primary_key: id
+      columns:
+        - name: id
+          column_type: integer
+        - name: foo
+          column_type: varchar
+          default: "bar"
+          null: true
+          size: 30
+     another_table:
+       ...
+
+== Requirements
+
+* Sequel 3.12.0 or higher
+
+== TODO
+
+* Dropping tables when they are removed from the schema
+* Automigrate functionality
+* Dealing with renames in some way (even if just logging that they would be possible).
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Roland Swingler. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sequel_migration_builder"
+    gem.summary = "Build Sequel Migrations based on the differences between two schemas"
+    gem.description = "Build Sequel Migrations based on the differences between two schemas"
+    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_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sequel_migration_builder #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/sequel/migration_builder.rb

@@ -0,0 +1,140 @@
+require 'sequel/schema/db_column'
+require 'sequel/schema/db_schema_parser'
+require 'sequel/schema/alter_table_operations'
+
+module Sequel
+  # Generates a Sequel migration to bring a database inline with an
+  # abstract schema.
+  #
+  class MigrationBuilder
+    INDENT_SPACES = '  '
+
+    # Creates a migration builder for the given database.
+    #
+    def initialize(db)
+      @db = db
+      @db_tables = Schema::DbSchemaParser.for_db(db).parse_db_schema
+      @db_table_names = @db.tables
+      @indent = 0
+      @result = []
+    end
+
+    # Generates a string of ruby code to define a sequel
+    # migration, based on the differences between the database schema
+    # of this MigrationBuilder and the tables passed.
+    #
+    def generate_migration(tables)
+      return if tables.empty? && @db_tables.empty?
+      result.clear
+
+      add_line "Sequel.migration do"
+      indent do
+        generate_up(tables)
+        generate_down(tables)
+      end
+      add_line "end\n"
+
+      result.join("\n")
+    end
+
+    # Generates the 'up' part of the migration.
+    #
+    def generate_up(tables)
+      current_tables, new_tables = table_names(tables).partition do |table_name| 
+        @db_table_names.include?(table_name)
+      end
+
+      add_line "up 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)
+      indent do
+        new_tables.reverse.each {|table_name| add_line "drop_table #{table_name.inspect}" }
+      end
+      add_line "end"
+    end
+
+    # Generates any create table statements for new tables.
+    #
+    def create_new_tables(new_tables, tables)
+      i = 0
+      new_tables.each do |table_name|
+        i += 1
+        indent { create_table_statement table_name, tables[table_name] }
+        add_blank_line unless i == tables.size
+      end
+    end
+
+    # Generates any alter table statements for current tables.
+    #
+    def alter_tables(current_tables, tables, direction)
+      i = 0
+      indent do
+        current_tables.each do |table_name|
+          i += 1
+          hsh = tables[table_name].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?
+            add_line "alter_table #{table_name.inspect} do"
+            indent do
+              operations.each {|op| add_line op.__send__(direction) }
+            end
+            add_line "end"
+            add_blank_line unless i == tables.size
+          end
+        end
+      end
+    end
+
+    # Generates an individual create_table statement.
+    #
+    def create_table_statement(table_name, table)
+      add_line "create_table #{table_name.inspect} do"
+      indent do
+        table[:columns].map {|c| Schema::DbColumn.build_from_hash(c) }.each do |column|
+          add_line column.define_statement
+        end
+        if table[:primary_key]
+          add_blank_line
+          add_line "primary_key #{table[:primary_key].inspect}"
+        end
+      end
+      add_line "end"
+    end
+
+    private
+
+    attr_reader :result
+
+    def table_names(tables)
+      tables.keys.map {|n| n.to_s }.sort.map {|n| n.to_sym }
+    end
+
+    def indent
+      @indent += 1
+      yield
+      @indent -= 1
+    end
+
+    def add_line(line)
+      @result << (INDENT_SPACES * @indent + line)
+    end
+
+    def add_blank_line
+      @result << ''
+    end
+  end
+end

data/lib/sequel/schema/alter_table_operations.rb

@@ -0,0 +1,85 @@
+module Sequel
+  module Schema
+    module 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)
+        db_columns = db_table[:columns].inject({}) {|hsh, column| hsh[column.name] = column; hsh }
+
+        operations = new_table[:columns].map do |column|
+          if db_columns[column.name]
+            build_column_operations db_columns[column.name], column
+          else
+            AddColumn.new(column)
+          end
+        end.flatten
+
+        new_column_names = new_table[:columns].map {|c| c.name }
+        operations + (db_columns.keys - new_column_names).map {|column| DropColumn.new(column) }
+      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)
+        result = []
+        
+        diffs = db_column.diff(new_column)
+        result << :change_type_statement    if [:column_type, :size, :unsigned].any? {|sym| diffs.include?(sym) }
+        # only need to explicitly set the default if we're not changing the column type.
+        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
+
+      # Changes a column.
+      class ChangeColumn
+        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)
+        end
+      end
+
+      # Adds a column.
+      class AddColumn
+        def initialize(column)
+          @column = column
+        end
+
+        def up
+          @column.add_statement
+        end
+
+        def down
+          @column.drop_statement
+        end
+      end
+
+      # Drops a column.
+      class DropColumn
+        def initialize(column)
+          @column = column
+        end
+
+        def up
+          @column.drop_statement
+        end
+
+        def down
+          @column.add_statement
+        end
+      end
+    end
+  end
+end

data/lib/sequel/schema/db_column.rb

@@ -0,0 +1,96 @@
+module Sequel
+  module Schema
+    DbColumn = Struct.new(:name, :column_type, :null, :default, :unsigned, :size, :elements)
+
+    # A column in a database table.
+    #
+    # Responsible for generating all migration method calls used by
+    # migration operations.
+    #
+    class DbColumn
+      # Builds a DbColumn from a Hash of attribute values. Keys 
+      # can be strings or symbols.
+      #
+      def self.build_from_hash(attrs={})
+        new *members.map {|key| attrs[key] || attrs[key.to_sym] }
+      end
+
+      # Returns a Sequel migration statement to define a column in a
+      # create_table block.
+      #
+      def define_statement
+        ["#{column_type} #{name.inspect}", options].compact.join(", ")
+      end
+
+      # Returns a Sequel migration statement to remove the column.
+      #
+      def drop_statement
+        "drop_column #{name.inspect}"
+      end
+
+      # Returns a Sequel migration statement to add the column to a
+      # table in an alter_table block.
+      #
+      def add_statement
+        ["add_column #{name.inspect}", column_type.inspect, options].compact.join(", ")
+      end
+      
+      # Returns a Sequel migration statement to change whether a column
+      # allows null values.
+      #
+      def change_null_statement
+        "set_column_allow_null #{name.inspect}, #{(!!null).inspect}"
+      end
+
+      # Returns a Sequel migration statement to change a column's default
+      # value.
+      # 
+      def change_default_statement
+        "set_column_default #{name.inspect}, #{default.inspect}"
+      end
+
+      # Returns a Sequel migration statement to change the type of an
+      # existing column. Null changes must be handled separately.
+      #
+      def change_type_statement
+        ["set_column_type #{name.inspect}", column_type.inspect, change_options].compact.join(", ")
+      end
+
+      # Returns an Array of attributes that are different between this
+      # and another column.
+      #
+      def diff(other)
+        result = []
+        each_pair {|key, value| result << key if other[key] != value }
+        result
+      end
+
+      private
+
+      def change_options
+        opts = []
+
+        opts << ":default => #{default.inspect}"
+        # seems odd, but we only want to output if unsigned is a true
+        # boolean, not if it is nil.
+        opts << ":unsigned => #{unsigned.inspect}" if unsigned == true || unsigned == false
+        opts << ":size => #{size.inspect}"         if size
+        opts << ":elements => #{elements.inspect}" if elements
+
+        opts.join(", ") unless opts.empty?
+      end
+
+      def options
+        opts = []
+
+        opts << ":null => false"                   unless null == true
+        opts << ":default => #{default.inspect}"   if default
+        opts << ":unsigned => true"                if unsigned
+        opts << ":size => #{size.inspect}"         if size
+        opts << ":elements => #{elements.inspect}" if elements
+
+        opts.join(", ") unless opts.empty?
+      end
+    end
+  end
+end

data/lib/sequel/schema/db_schema_parser.rb

@@ -0,0 +1,94 @@
+module Sequel
+  module Schema
+    # Builds an abstract representation of a database schema.
+    #
+    # Sample usage:
+    #
+    #     parser = DbSchemaParser.for_db( sequel_db_connection )
+    #     parser.parse_db_schema 
+    #     # => Returns an array of table definitions
+    #
+    class DbSchemaParser
+      # Returns an appropriate schema parser for the database
+      # connection.
+      #
+      def self.for_db(db)
+        self.new(db)
+      end
+
+      # Parses the schema from a Sequel Database connection.
+      #
+      # Returns a hash of table representations.
+      #
+      # Example:
+      #
+      #    builder.parse_db_schema(db)
+      #    # => {:table1 => { :columns => [ DbColumns ... ] }
+      #          :table2 => { ... } }
+      #
+      def parse_db_schema
+        result = {}
+        @db.tables.each do |table_name|
+          result[table_name] = {:columns => parse_table_schema(@db.schema(table_name))}
+        end
+        result
+      end
+
+      # Extracts an array of hashes representing the columns in the
+      # table, given an Array of Arrays returned by DB.schema(:table).
+      #
+      def parse_table_schema(db_schema)
+        db_schema.map do |column|
+          attrs = { 
+            :name        => column.first,
+            :default     => column.last[:ruby_default],
+            :null        => column.last[:allow_null],
+            :column_type => parse_type(column.last[:db_type]),
+            :unsigned    => column.last[:db_type].include?(" unsigned") 
+          }
+          attrs[:size]     = extract_size(column) if column.last[:type] == :string
+          attrs[:elements] = extract_enum_elements(column) if attrs[:column_type] == :enum
+          
+          DbColumn.build_from_hash(attrs)
+        end
+      end
+
+      protected
+
+      # Creates a new schema parser for the given database
+      # connection. Use for_db instead.
+      #
+      def initialize(db)
+        @db = db
+      end
+
+      # Returns a type symbol for a given db_type string, suitable for
+      # use in a Sequel migration.
+      #
+      # Examples:
+      #
+      #    parse_type("int(11)")     # => :integer
+      #    parse_type("varchar(20)") # => :varchar
+      #
+      def parse_type(type)
+        case type
+        when /^int/          then :integer
+        when /^tinyint\(1\)/ then :boolean
+        when /^([^(]+)/      then $1.to_sym
+        end
+      end
+
+      private
+
+      def extract_size(column)
+        match = column.last[:db_type].match(/\((\d+)\)/)
+        match[1].to_i if match[1]
+      end
+
+      def extract_enum_elements(column)
+        match = column.last[:db_type].match(/\(([^)]+)\)/)
+        eval('[' + match[1] + ']') if match[1]
+      end
+    end
+  end
+end

data/sequel_migration_builder.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sequel_migration_builder}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roland Swingler"]
+  s.date = %q{2010-06-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 = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/sequel/migration_builder.rb",
+     "lib/sequel/schema/alter_table_operations.rb",
+     "lib/sequel/schema/db_column.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_schema_parser_spec.rb",
+     "spec/migration_builder_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  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.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_schema_parser_spec.rb",
+     "spec/migration_builder_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    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"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<sequel>, [">= 3.12.0"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<sequel>, [">= 3.12.0"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/spec/alter_table_operations_spec.rb

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+def build_column(hash)
+  Sequel::Schema::DbColumn.build_from_hash(hash)
+end
+
+describe "Sequel::Schema::AlterTableOperations.build_column_operations" do
+  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 == []
+  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.first.up.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.first.up.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.first.up.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.first.up.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.first.up.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.size.should == 1
+    ops.first.up.should == "set_column_type :foo, :smallint, :default => 2"
+  end
+end
+
+describe "Sequel::Schema::AlterTableOperations.build" do
+  it "should return an empty array if nothing is different" do
+    table_a = {:name => :example_table,
+      :columns => [build_column(:name => :foo, :column_type => :integer)]}
+    table_b = {:name => :example_table,
+      :columns => [build_column(:name => :foo, :column_type => :integer)]}
+    ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
+
+    ops.should == []
+  end
+
+  it "should return an add column operation if the column is new" do
+    table_a = {:name => :example_table,
+      :columns => []}
+    table_b = {:name => :example_table,
+      :columns => [build_column(:name => :foo, :column_type => :integer)]}
+    ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
+
+    ops.size.should == 1
+    ops.first.should be_kind_of(Sequel::Schema::AlterTableOperations::AddColumn)
+  end
+
+  it "should return a drop column operation if the column has been removed" do
+    table_a = {:name => :example_table,
+      :columns => [build_column(:name => :foo, :column_type => :integer)]}
+    table_b = {:name => :example_table,
+      :columns => []}
+    ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
+
+    ops.size.should == 1
+    ops.first.should be_kind_of(Sequel::Schema::AlterTableOperations::DropColumn)
+  end
+
+  it "should return a change column operation if columns are different" do
+    table_a = {:name => :example_table,
+      :columns => [build_column(:name => :foo, :column_type => :integer)]}
+    table_b = {:name => :example_table,
+      :columns => [build_column(:name => :foo, :column_type => :smallint)]}
+    ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
+
+    ops.size.should == 1
+    ops.first.should be_kind_of(Sequel::Schema::AlterTableOperations::ChangeColumn)
+  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)
+    Sequel::Schema::AlterTableOperations::AddColumn.new(@mock_column).up
+  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
+  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(:drop_statement)
+    Sequel::Schema::AlterTableOperations::DropColumn.new(@mock_column).up
+  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
+  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)
+    new.should_receive(:change_type_statement)
+    Sequel::Schema::AlterTableOperations::ChangeColumn.new(old, new, :change_type_statement).up
+  end
+
+  it "should ask the new column for statement on #down" do
+    new = mock(:new)
+    old = mock(:old)
+    old.should_receive(:change_type_statement)
+    Sequel::Schema::AlterTableOperations::ChangeColumn.new(old, new, :change_type_statement).down
+  end
+end

data/spec/db_column_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Sequel::Schema::DbColumn do
+
+  before :each do
+    @column = Sequel::Schema::DbColumn.new(:foo, :integer, false, 10, true, 10, nil)
+  end
+
+  it "should return a #define_statement" do
+    @column.define_statement.should == "integer :foo, :null => false, :default => 10, :unsigned => true, :size => 10"
+  end
+  
+  it "should return a #drop_statement" do
+    @column.drop_statement.should == "drop_column :foo"
+  end
+
+  it "should return an #add_statement" do
+    @column.add_statement.should == "add_column :foo, :integer, :null => false, :default => 10, :unsigned => true, :size => 10"
+  end
+
+  it "should return a #change_null statement" do
+    @column.change_null_statement.should == "set_column_allow_null :foo, false"
+  end
+
+  it "should return a #change_default statement" do
+    @column.change_default_statement.should == "set_column_default :foo, 10"
+  end
+
+  it "should return a #change_type statement" do
+    @column.change_type_statement.should == "set_column_type :foo, :integer, :default => 10, :unsigned => true, :size => 10"
+  end
+
+  it "should be diffable with another DbColumn" do
+    other = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, 10, nil)
+    @column.diff(other).should == [:column_type]
+
+    other = Sequel::Schema::DbColumn.new(:foo, :integer, true, 11, true, 10, nil)
+    @column.diff(other).should == [:null, :default]
+  end
+
+  it "should be buildable from a Hash" do
+    Sequel::Schema::DbColumn.build_from_hash(:name => "foo", 
+                                       :column_type => "integer").column_type.should == "integer"
+    Sequel::Schema::DbColumn.build_from_hash('name' => "foo", 
+                                       'column_type' => "integer").name.should == "foo"
+  end
+end

data/spec/db_schema_parser_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe "Sequel::Schema::DbSchemaParser.for_db" do
+  it "should return a DbSchemaParser" do
+    Sequel::Schema::DbSchemaParser.for_db(stub(:database)).should \
+      be_kind_of(Sequel::Schema::DbSchemaParser)
+  end
+end
+
+describe "A hash in the array returned by Sequel::Schema::DbSchemaParser#parse_table_schema" do
+  before :each do
+    @parser = Sequel::Schema::DbSchemaParser.for_db(stub(:database))
+    @schema = [[:example_column, 
+                { :type => :integer, 
+                  :default => "1", 
+                  :ruby_default => 1, 
+                  :primary_key => false, 
+                  :db_type => "int(11)", 
+                  :allow_null => true   }]]
+  end
+
+  it "should contain the :name of the column" do
+    @parser.parse_table_schema(@schema).first.name.should == :example_column
+  end
+  
+  it "should contain the ruby_default as the :default" do
+    @parser.parse_table_schema(@schema).first.default.should == 1
+  end
+  
+  it "should contain whether the column can be :null" do
+    @parser.parse_table_schema(@schema).first.null.should == true
+  end
+  
+  it "should contain a type of :integer given a int column" do
+    set_db_type "int(11)"
+    @parser.parse_table_schema(@schema).first.column_type.should == :integer
+  end
+
+  it "should contain a type of :boolean given a tinyint(1) column" do
+    set_db_type "tinyint(1)"
+    @parser.parse_table_schema(@schema).first.column_type.should == :boolean
+  end
+
+  it "should contain a type of :tinyint given a tinyint column" do
+    set_db_type "tinyint(4)"
+    @parser.parse_table_schema(@schema).first.column_type.should == :tinyint
+  end
+
+  it "should contain a type of :smallint given a smallint column" do
+    set_db_type "smallint(5)"
+    @parser.parse_table_schema(@schema).first.column_type.should == :smallint
+  end
+
+  it "should contain a type of :mediumint given a mediumint column" do
+    set_db_type "mediumint(5)"
+    @parser.parse_table_schema(@schema).first.column_type.should == :mediumint
+  end
+
+  it "should contain a type of :bigint given a bigint column" do
+    set_db_type "bigint(10)"
+    @parser.parse_table_schema(@schema).first.column_type.should == :bigint
+  end
+
+  it "should contain a :size attribute for text-like columns" do
+    set_db_type "varchar(20)", :string
+    @parser.parse_table_schema(@schema).first.size.should == 20
+  end
+
+  it "should contain :unsigned false if a numeric column is not unsigned" do
+    set_db_type "int(10)"
+    @parser.parse_table_schema(@schema).first.unsigned.should == false
+  end
+
+  it "should contain :unsigned true if a numeric column is unsigned" do
+    set_db_type "int(10) unsigned"
+    @parser.parse_table_schema(@schema).first.unsigned.should == true
+  end
+
+  it "should contain the elements of an enum column" do
+    set_db_type "enum('foo','bar')"
+    @parser.parse_table_schema(@schema).first.elements.should == ['foo', 'bar']
+  end
+  
+  def set_db_type(type, ruby_type=nil)
+    @schema.first.last.merge!(:db_type => type)
+    @schema.first.last.merge!(:type => ruby_type) if ruby_type
+  end
+end
+
+describe "Sequel::Schema::DbSchemaParser#parse_db_schema" do
+  it "should extract a list of table definitions from a database" 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([])
+
+    @parser = Sequel::Schema::DbSchemaParser.for_db(mock_db)
+    @parser.parse_db_schema.keys.should == [:table1]
+  end
+end

data/spec/migration_builder_spec.rb

@@ -0,0 +1,143 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Sequel::MigrationBuilder do
+  
+  it "should return nil if the table hash is empty and the database has no tables" do
+    mock_db = mock(:database)
+    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    Sequel::MigrationBuilder.new(mock_db).generate_migration({}).should be_nil
+  end
+
+  it "should produce a simple migration string given a database connection and a hash of tables" do
+    tables = {}
+    tables[:example_table] = {
+      :columns => [{:name => :foo, :column_type => :integer}]
+    }
+
+    expected = <<-END
+Sequel.migration do
+  up do
+    create_table :example_table do
+      integer :foo, :null => false
+    end
+  end
+
+  down do
+    drop_table :example_table
+  end
+end
+END
+    
+    mock_db = mock(:database)
+    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    Sequel::MigrationBuilder.new(mock_db).generate_migration(tables).should == expected
+  end
+
+  it "should produce statements for multiple new tables" do
+    tables = {}
+    tables[:example_table] = {
+      :columns => [{:name => :foo, :column_type => :integer}, {:name => :bar, :column_type => :varchar}]
+    }
+
+    tables[:example_table_2] = {
+      :columns => [{:name => :foo, :column_type => :integer, :null => true}]
+    }
+
+    expected = <<-END
+Sequel.migration do
+  up do
+    create_table :example_table do
+      integer :foo, :null => false
+      varchar :bar, :null => false
+    end
+
+    create_table :example_table_2 do
+      integer :foo
+    end
+  end
+
+  down do
+    drop_table :example_table_2
+    drop_table :example_table
+  end
+end
+END
+    
+    mock_db = mock(:database)
+    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    Sequel::MigrationBuilder.new(mock_db).generate_migration(tables).should == expected
+  end
+
+  it "should add the primary key of the table" do
+    mock_db = mock(:database)
+    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    table = {
+      :primary_key => :foo,
+      :columns => [{:name => :foo, :column_type => :integer}, {:name => :bar, :column_type => :varchar}]
+    }
+
+    expected = <<-END
+create_table :example_table do
+  integer :foo, :null => false
+  varchar :bar, :null => false
+
+  primary_key :foo
+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}]}
+      }
+      @mock_db = mock(:database)
+      @mock_db.should_receive(:tables).at_least(:once).and_return([:example_table])
+      @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
+
+    it "should return an alter table statement with column changes for #generate_up" do
+      expected = <<-END
+up do
+  alter_table :example_table do
+    set_column_type :foo, :integer, :default => nil
+    set_column_allow_null :foo, false
+    add_column :bar, :varchar, :null => false
+  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
+  end
+end
+END
+      Sequel::MigrationBuilder.new(@mock_db).generate_down(@tables).join("\n").should == expected.strip
+    end
+  end
+
+  it "should drop the table if the table exists in the database but not the table hash" do
+    pending # Deal with in a later version.
+    mock_db = mock(:database)
+    mock_db.should_receive(:tables).at_least(:once).and_return([:example_table])
+    
+    expected = <<-END
+up do
+  drop_table :example_table
+end
+END
+    Sequel::MigrationBuilder.new(mock_db).generate_up({}).join("\n").should == expected
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sequel/migration_builder'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: sequel_migration_builder
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Roland Swingler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-13 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 12
+        - 0
+        version: 3.12.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+description: Build Sequel Migrations based on the differences between two schemas
+email: roland.swingler@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/sequel/migration_builder.rb
+- lib/sequel/schema/alter_table_operations.rb
+- lib/sequel/schema/db_column.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_schema_parser_spec.rb
+- spec/migration_builder_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/knaveofdiamonds/sequel_migration_builder
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+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_schema_parser_spec.rb
+- spec/migration_builder_spec.rb
+- spec/spec_helper.rb