convergence 1.0.6 → 1.1.0

data/lib/convergence/sql_generator/sqlite_generator.rb

@@ -0,0 +1,178 @@
+require 'convergence/sql_generator'
+
+# SQLite's ALTER TABLE support is intentionally limited: it can add/drop columns
+# and create/drop indexes, but it cannot change a column's type/null/default,
+# nor add/remove a foreign key or primary key on an existing table. Doing any of
+# those requires SQLite's official "rebuild the table" procedure (create a new
+# table, copy the data over, drop the old one, rename), which this adapter does
+# not implement yet -- it raises NotImplementedError instead of generating SQL
+# that SQLite would reject.
+class SQLGenerator::SqliteGenerator < SQLGenerator
+  UNSUPPORTED_TYPES = [:enum, :set].freeze
+
+  attr_reader :original_table
+
+  def generate(to_table, delta, original_table, safe_migration: false)
+    @original_table = original_table
+    sqls = []
+    sqls << change_table_sql(to_table, delta)
+    sqls << (safe_migration ? [] : drop_table_sqls(delta))
+    sqls << create_table_sqls(delta)
+    sqls.reject!(&:empty?)
+    sqls.join("\n")
+  end
+
+  private
+
+  def change_table_sql(to_table, delta)
+    change_table = delta[:change_table]
+    results = []
+    change_table.each do |table_name, table_delta|
+      unless table_delta[:remove_foreign_key].empty?
+        fail unsupported_alter_error(table_name, 'removing a foreign key')
+      end
+      unless table_delta[:add_foreign_key].empty?
+        fail unsupported_alter_error(table_name, 'adding a foreign key')
+      end
+      unless table_delta[:change_column].empty?
+        columns = table_delta[:change_column].keys.join(', ')
+        fail unsupported_alter_error(table_name, "changing column(s) #{columns} (type/null/default/primary key)")
+      end
+      table_delta[:remove_index].each do |index_name, _index|
+        results << alter_remove_index_sql(index_name)
+      end
+      unless table_delta[:remove_column].empty?
+        results << alter_remove_columns_sql(table_name, table_delta[:remove_column].values)
+      end
+      unless table_delta[:add_column].empty?
+        results << alter_add_columns_sql(table_name, table_delta[:add_column].values)
+      end
+      table_delta[:add_index].each do |_index_name, index|
+        results << alter_add_index_sql(table_name, index)
+      end
+      # SQLite has no table-level options comparable to MySQL's engine/comment/
+      # charset, so any detected change_table_option diff is silently ignored.
+    end
+    results << '' unless results.empty?
+    results
+  end
+
+  def unsupported_alter_error(table_name, action)
+    NotImplementedError.new(
+      "SQLite adapter does not support #{action} on an existing table (`#{table_name}`) via ALTER TABLE. " \
+      'This requires rebuilding the table (create new, copy data, drop old, rename), which is not supported yet.'
+    )
+  end
+
+  def alter_add_columns_sql(table_name, columns)
+    columns.map { |column| %(ALTER TABLE "#{table_name}" ADD COLUMN #{create_column_sql(column)};) }.join("\n")
+  end
+
+  def alter_remove_columns_sql(table_name, columns)
+    columns.map { |column| %(ALTER TABLE "#{table_name}" DROP COLUMN "#{column.column_name}";) }.join("\n")
+  end
+
+  def alter_remove_index_sql(index_name)
+    %(DROP INDEX "#{index_name}";)
+  end
+
+  def alter_add_index_sql(table_name, index)
+    sql = 'CREATE'
+    sql += ' UNIQUE' if index.options[:unique]
+    sql += %( INDEX "#{index.index_name}" ON "#{table_name}" (#{quoted_index_columns(index).join(',')});)
+    sql
+  end
+
+  def create_table_sqls(delta)
+    delta[:add_table].map do |table_name, table|
+      column_sql = (create_table_column_sql(table) << create_table_constraint_sql(table))
+        .flatten
+        .reject(&:empty?)
+        .join(",\n  ")
+      sql = <<-SQL
+CREATE TABLE "#{table_name}" (
+  #{column_sql}
+);
+      SQL
+      index_sqls = table.indexes.values.map { |index| alter_add_index_sql(table_name, index) }
+      ([sql.strip] + index_sqls).join("\n")
+    end
+  end
+
+  def drop_table_sqls(delta)
+    delta[:remove_table].map do |table_name, _|
+      %(DROP TABLE "#{table_name}";)
+    end
+  end
+
+  def create_table_column_sql(table)
+    table.columns.values.map do |column|
+      create_column_sql(column)
+    end
+  end
+
+  def create_column_sql(column)
+    fail NotImplementedError.new("#{column.type} is not supported on the SQLite adapter yet") if UNSUPPORTED_TYPES.include?(column.type)
+    return %("#{column.column_name}" INTEGER PRIMARY KEY AUTOINCREMENT) if auto_increment?(column)
+    sql = %("#{column.column_name}")
+    sql += " #{sqlite_column_type(column)}"
+    if column.options[:primary_key]
+      sql += ' PRIMARY KEY'
+    end
+    sql += ' NOT NULL' unless column.options[:null]
+    if column.options[:default]
+      sql += " DEFAULT #{quote_default_expression(column.options[:default])}"
+    end
+    sql
+  end
+
+  def sqlite_column_type(column)
+    type = column.type.to_s
+    if column.type == :decimal && column.options[:precision] && column.options[:scale]
+      "#{type}(#{column.options[:precision]}, #{column.options[:scale]})"
+    elsif column.options[:limit] && !column.options[:limit].to_s.empty?
+      "#{type}(#{column.options[:limit]})"
+    else
+      type
+    end
+  end
+
+  def auto_increment?(column)
+    extra = column.options[:extra]
+    !extra.nil? && extra.to_s.upcase.include?('AUTO_INCREMENT')
+  end
+
+  # A single-column INTEGER PRIMARY KEY AUTOINCREMENT already declares itself as
+  # the primary key inline, so it must not also appear in a table-level
+  # PRIMARY KEY (...) clause.
+  def create_table_constraint_sql(table)
+    pkeys = table.columns.reject { |_k, v| auto_increment?(v) }.select { |_k, v| v.options[:primary_key] }
+    foreign_keys = table.foreign_keys.values
+    results = []
+    unless pkeys.empty?
+      results << %(PRIMARY KEY (#{pkeys.keys.map { |v| %("#{v}") }.join(',')}))
+    end
+    results << foreign_keys.map { |fk| foreign_key_constraint_sql(fk) }
+    results
+  end
+
+  def foreign_key_constraint_sql(foreign_key)
+    sql = %(CONSTRAINT "#{foreign_key.key_name}" FOREIGN KEY )
+    sql += "(#{[foreign_key.from_columns].flatten.map { |v| %("#{v}") }.join(',')}) "
+    sql += %(REFERENCES "#{foreign_key.to_table}" )
+    sql += "(#{[foreign_key.to_columns].flatten.map { |v| %("#{v}") }.join(',')})"
+    sql
+  end
+
+  def quoted_index_columns(index)
+    [index.index_columns].flatten.map { |v| %("#{v}") }
+  end
+
+  def quote_default_expression(value)
+    if value.is_a?(Proc)
+      value.call
+    else
+      %('#{value.to_s.gsub("'", "''")}')
+    end
+  end
+end

data/lib/convergence/version.rb

@@ -1,3 +1,3 @@
 module Convergence
-  VERSION = '1.0.6'
+  VERSION = '1.1.0'
 end

data/spec/config/spec_database.yml

@@ -5,3 +5,15 @@ mysql:
   port: 3306
   username: root
   password: root
+
+postgresql:
+  adapter: postgresql
+  database: convergence_test_db
+  host: 127.0.0.1
+  port: 5432
+  username: postgres
+  password: postgres
+
+sqlite3:
+  adapter: sqlite3
+  database: sqlite_test_db.sqlite3

data/spec/convergence/config_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'convergence/config'
+require 'tempfile'
+
+describe Convergence::Config do
+  describe '#initialize' do
+    it 'sets the known attributes' do
+      config = Convergence::Config.new(
+        adapter: 'mysql2',
+        database: 'my_db',
+        host: '127.0.0.1',
+        port: 3306,
+        username: 'root',
+        password: 'secret'
+      )
+      expect(config.adapter).to eq('mysql2')
+      expect(config.database).to eq('my_db')
+      expect(config.host).to eq('127.0.0.1')
+      expect(config.port).to eq(3306)
+      expect(config.username).to eq('root')
+      expect(config.password).to eq('secret')
+    end
+
+    it 'ignores unknown attributes instead of raising' do
+      expect { Convergence::Config.new(adapter: 'mysql2', unknown_key: 'value') }.not_to raise_error
+    end
+
+    it 'ignores nil-valued attributes' do
+      config = Convergence::Config.new(adapter: 'mysql2', database: nil)
+      expect(config.database).to be_nil
+    end
+
+    context 'when the adapter is mysql/mysql2' do
+      it 'builds a nested MySQL SSL config object' do
+        config = Convergence::Config.new(adapter: 'mysql2', sslca: '/path/to/ca.pem', sslverify: true)
+        expect(config.mysql).to be_a(Convergence::Config::MySQL)
+        expect(config.mysql.ssl_options).to eq(sslca: '/path/to/ca.pem', sslverify: true)
+      end
+
+      it 'omits unset SSL options from ssl_options' do
+        config = Convergence::Config.new(adapter: 'mysql2')
+        expect(config.mysql.ssl_options).to eq({})
+      end
+    end
+
+    context 'when the adapter is not mysql/mysql2' do
+      it 'does not build a MySQL SSL config object' do
+        config = Convergence::Config.new(adapter: 'postgresql')
+        expect(config.mysql).to be_nil
+      end
+    end
+  end
+
+  describe '.load' do
+    it 'parses attributes from a YAML file' do
+      Tempfile.create(['database', '.yml']) do |file|
+        file.write("adapter: mysql2\ndatabase: my_db\nhost: 127.0.0.1\n")
+        file.flush
+        config = Convergence::Config.load(file.path)
+        expect(config.adapter).to eq('mysql2')
+        expect(config.database).to eq('my_db')
+        expect(config.host).to eq('127.0.0.1')
+      end
+    end
+
+    it 'evaluates ERB before parsing the YAML' do
+      Tempfile.create(['database', '.yml']) do |file|
+        file.write("adapter: mysql2\ndatabase: <%= 'interpolated_' + 'db' %>\n")
+        file.flush
+        config = Convergence::Config.load(file.path)
+        expect(config.database).to eq('interpolated_db')
+      end
+    end
+  end
+end

data/spec/convergence/diff_spec.rb

@@ -104,6 +104,7 @@ describe Convergence::DSL do
         let(:table_to) do
           Convergence::Table.new('table1').tap do |t|
             t.int('id')
+            t.varchar('name', limit: 200, null: false)
           end
         end
 
@@ -135,130 +136,209 @@ describe Convergence::DSL do
   end
 
   describe '#diff_table' do
-    let(:table_from) do
-      Convergence::Table.new('table1').tap do |t|
-        t.int('id', primary_key: true)
-        t.varchar('name', limit: 200, null: false)
+    subject(:results) { Convergence::Diff.new(**diff_options).diff_table(table_from, table_to) }
+    let(:diff_options) { {} }
+
+    context 'change auto_increment table option' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.table_options = { auto_increment: 1 }
+        end
+      end
+      let(:table_to) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.table_options = { auto_increment: 5000 }
+        end
+      end
+
+      it 'detects the auto_increment change by default' do
+        expect(results[:change_table_option][:auto_increment]).to eq(5000)
+      end
+
+      context 'when ignore_auto_increment is enabled' do
+        let(:diff_options) { { ignore_auto_increment: true } }
 
-        t.index('name')
-        t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
+        it 'ignores the auto_increment change' do
+          expect(results[:change_table_option]).not_to have_key(:auto_increment)
+        end
       end
     end
 
     context 'change column options' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+          t.datetime('created_at', default: -> { "CURRENT_TIMESTAMP" })
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true, unsigned: true)
-
-          t.index('name')
+          t.varchar('name', limit: 300, null: true, unsigned: true)     # option changed
+          t.datetime('created_at', default: -> { "CURRENT_TIMESTAMP" }) # option[:default] not changed
         end
       end
 
       it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
         expect(results[:change_column]['name']).not_to be_nil
         expect(results[:change_column]['name'][:limit]).to eq('300')
         expect(results[:change_column]['name'][:null]).to eq('true')
         expect(results[:change_column]['name'][:unsigned]).to eq('true')
+        expect(results[:change_column]['created_at']).to be_nil
+      end
+    end
+
+    context 'change enum/set column values' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.enum('status', values: %w(Active Inactive))
+        end
+      end
+
+      context 'when values are identical' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id', primary_key: true)
+            t.enum('status', values: %w(Active Inactive))
+          end
+        end
+
+        it 'does not detect a change' do
+          expect(results[:change_column]['status']).to be_nil
+        end
+      end
+
+      context 'when only the letter case differs' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id', primary_key: true)
+            t.enum('status', values: %w(active inactive))
+          end
+        end
+
+        it 'detects the change since values are case-sensitive' do
+          expect(results[:change_column]['status']).not_to be_nil
+          expect(results[:change_column]['status'][:values]).to eq('["active", "inactive"]')
+        end
       end
     end
 
     context 'change column order' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
           t.int('id', primary_key: true)
-
-          t.index('name')
         end
       end
 
       it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:change_column]['name']).not_to be_nil
+        expect(results[:change_column]['name']).to be_nil
         expect(results[:change_column]['id']).not_to be_nil
         expect(results[:change_column]['id'][:after]).to eq('name')
       end
     end
 
     context 'remove index' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+
+          t.index('name')
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:remove_index].values.first.index_columns).to eq(['name'])
-      end
+      it { expect(results[:remove_index].values.first.index_columns).to eq(['name']) }
     end
 
     context 'add index' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
 
-          t.index('id')
           t.index('name')
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:add_index].values.first.index_columns).to eq(['id'])
-      end
+      it { expect(results[:add_index].values.first.index_columns).to eq(['name']) }
     end
 
     context 'remove foreign key' do
-      let(:table_to) do
+      let(:table_from) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
 
-          t.index('name')
+          t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
         end
       end
-
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:remove_foreign_key].values.first.from_columns).to eq(['id'])
+      let(:table_to) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
       end
+
+      it { expect(results[:remove_foreign_key].values.first.from_columns).to eq(['id']) }
     end
 
     context 'add foreign key' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
 
-          t.index('name')
           t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
-          t.foreign_key('id2', reference: 'ref_tables2', reference_column: 'ref_id2')
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:add_foreign_key].values.first.from_columns).to eq(['id2'])
-      end
+      it { expect(results[:add_foreign_key].values.first.from_columns).to eq(['id']) }
     end
 
     context 'change table options' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1', engine: 'MyISAM').tap do |t|
-          t.varchar('name', limit: 300, null: true)
           t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:change_table_option][:engine]).to eq('MyISAM')
-      end
+      it { expect(results[:change_table_option][:engine]).to eq('MyISAM') }
     end
   end
 end

data/spec/convergence/dsl_spec.rb

@@ -89,4 +89,30 @@ describe Convergence::DSL do
       end
     end
   end
+
+  describe '#parse_dsl' do
+    let(:dsl_with_execute) do
+      <<-DSL
+      create_table "users" do |t|
+        t.int "id", primary_key: true, extra: "auto_increment"
+      end
+
+      execute "CREATE OR REPLACE VIEW active_users AS SELECT * FROM users"
+      execute "GRANT SELECT ON users TO readonly"
+      DSL
+    end
+
+    subject { Convergence::DSL.parse_dsl(dsl_with_execute, '') }
+
+    it 'should be able to parse tables' do
+      expect(subject.tables['users']).not_to be_nil
+    end
+
+    it 'should be able to collect raw sql statements in order' do
+      expect(subject.raw_sqls).to eq([
+        'CREATE OR REPLACE VIEW active_users AS SELECT * FROM users',
+        'GRANT SELECT ON users TO readonly'
+      ])
+    end
+  end
 end

data/spec/convergence/dumper/mysql_schema_dumper_spec.rb

@@ -37,14 +37,17 @@ describe Convergence::Dumper::MysqlSchemaDumper do
         expect(papers.columns['title1']).not_to be_nil
         expect(papers.columns['title2']).not_to be_nil
         expect(papers.columns['description']).not_to be_nil
+        expect(papers.columns['edition_number']).not_to be_nil
+        expect(papers.columns['published_at']).not_to be_nil
       end
 
       it 'should be dump columns in the correct order' do
         papers = subject['papers']
-        expect(papers.columns.keys).to eq(%w(id slug title1 title2 description))
+        expect(papers.columns.keys)
+          .to eq(%w(id slug title1 title2 description edition_number published_at))
       end
 
-      describe 'table options' do
+      describe 'table column options' do
         it 'should be dump primary key' do
           expect(subject['papers'].columns['id'].options[:primary_key]).to be_truthy
         end
@@ -69,6 +72,13 @@ describe Convergence::Dumper::MysqlSchemaDumper do
         it 'should be dump unsigned definition' do
           expect(subject['authors'].columns['age'].options[:unsigned]).to be_truthy
         end
+
+        it 'should be dump default' do
+          expect(subject['papers'].columns['edition_number'].options[:default]).to eq "0"
+          expect(subject['papers'].columns['published_at'].options[:default])
+            .to be_a(Proc)
+            .and have_attributes(call: "CURRENT_TIMESTAMP")
+        end
       end
     end
 
@@ -96,6 +106,19 @@ describe Convergence::Dumper::MysqlSchemaDumper do
       end
     end
 
+    describe 'enum/set columns' do
+      it 'should be dump enum values' do
+        expect(subject['enum_set_samples'].columns['status'].options[:values])
+          .to eq(%w(active inactive pending))
+        expect(subject['enum_set_samples'].columns['status'].options[:default]).to eq('active')
+      end
+
+      it 'should be dump set values, including values containing quotes' do
+        expect(subject['enum_set_samples'].columns['flags'].options[:values])
+          .to eq(['a', 'b', "it's tricky"])
+      end
+    end
+
     describe 'foreign keys' do
       it do
         foreign_key = subject['paper_authors'].foreign_keys['paper_authors_author_id_fk']