convergence 0.0.1

data/lib/convergence/command/apply.rb

@@ -0,0 +1,51 @@
+require 'benchmark'
+
+class Convergence::Command::Apply < Convergence::Command
+  def validate!
+    fail ArgumentError.new('--config required') if @config.nil?
+    fail ArgumentError.new('--input required') unless @opts[:input]
+  end
+
+  def execute
+    validate!
+    input_tables = Convergence::DSL.parse(File.open(@opts[:input]).read)
+    current_tables = dumper.dump
+    execute_sql(input_tables, current_tables)
+  end
+
+  def execute_sql(input_tables, current_tables)
+    sql = generate_sql(input_tables, current_tables)
+    unless sql.strip.empty?
+      sql = <<-SQL
+SET FOREIGN_KEY_CHECKS=0;
+      #{sql}
+SET FOREIGN_KEY_CHECKS=1;
+      SQL
+    end
+    sql.split(';').each do |q2|
+      q = q2.strip
+      unless q.empty?
+        begin
+          q = q + ';'
+          time = Benchmark.realtime { connector.client.query(q) }
+          logger.output q
+          logger.output "  --> #{time}s"
+        rescue => e
+          logger.output 'Invalid Query Exception >>>'
+          logger.output q
+          logger.output '<<<'
+          throw e
+        end
+      end
+    end
+  end
+
+  def generate_sql(input_tables, current_tables)
+    current_tables_with_full_option =
+      Convergence::DefaultParameter.append_database_default_parameter(current_tables, database_adapter)
+    input_tables_with_full_option =
+      Convergence::DefaultParameter.append_database_default_parameter(input_tables, database_adapter)
+    delta = Convergence::Diff.new.diff(current_tables_with_full_option, input_tables_with_full_option)
+    sql_generator.generate(input_tables_with_full_option, delta)
+  end
+end

data/lib/convergence/command/diff.rb

@@ -0,0 +1,26 @@
+class Convergence::Command::Diff < Convergence::Command
+  def validate!
+    unless @opts[:diff].size == 2
+      fail ArgumentError.new('diff required two arguments')
+    end
+  end
+
+  def execute
+    validate!
+    from = Convergence::DefaultParameter.remove_database_default_parameter(from_tables, database_adapter)
+    to = Convergence::DefaultParameter.remove_database_default_parameter(to_tables, database_adapter)
+    msg = Convergence::PrettyDiff.new(from, to).output
+    logger.output(msg)
+    msg
+  end
+
+  private
+
+  def from_tables
+    Convergence::DSL.parse(File.open(@opts[:diff][0]).read)
+  end
+
+  def to_tables
+    Convergence::DSL.parse(File.open(@opts[:diff][1]).read)
+  end
+end

data/lib/convergence/command/dryrun.rb

@@ -0,0 +1,39 @@
+class Convergence::Command::Dryrun < Convergence::Command
+  def validate!
+    fail ArgumentError.new('--config required') if @config.nil?
+    fail ArgumentError.new('--input required') unless @opts[:input]
+  end
+
+  def execute
+    validate!
+    input_tables = Convergence::DSL.parse(File.open(@opts[:input]).read)
+    current_tables = dumper.dump
+    # -- maybe it's redundant output
+    # output_diff(input_tables, current_tables)
+    output_sql(input_tables, current_tables)
+  end
+
+  def output_diff(input_tables, current_tables)
+    input_tables_without_default_parameter =
+      Convergence::DefaultParameter.remove_database_default_parameter(input_tables, database_adapter)
+    current_tables_without_default_parameter =
+      Convergence::DefaultParameter.remove_database_default_parameter(current_tables, database_adapter)
+
+    msg = Convergence::PrettyDiff
+      .new(current_tables_without_default_parameter, input_tables_without_default_parameter)
+      .output
+    logger.output(msg)
+    msg
+  end
+
+  def output_sql(input_tables, current_tables)
+    msg = Convergence::Command::Apply
+      .new(@opts, config: @config)
+      .generate_sql(input_tables, current_tables)
+      .split("\n")
+      .map { |v| '# ' + v }
+      .join("\n")
+    logger.output(msg)
+    msg
+  end
+end

data/lib/convergence/command/export.rb

@@ -0,0 +1,15 @@
+class Convergence::Command::Export < Convergence::Command
+  def validate!
+    if @config.nil?
+      fail ArgumentError.new('--config required')
+    end
+  end
+
+  def execute
+    validate!
+    tables = Convergence::DefaultParameter.remove_database_default_parameter(dumper.dump, database_adapter)
+    msg = Convergence::Dumper.new.dump_dsl(tables)
+    logger.output(msg)
+    msg
+  end
+end

data/lib/convergence/config.rb

@@ -0,0 +1,17 @@
+require 'erb'
+require 'yaml'
+
+class Convergence::Config
+  attr_accessor :adapter, :database, :host, :port, :username, :password
+
+  def initialize(attributes)
+    attributes.each do |k, v|
+      instance_variable_set("@#{k}", v) unless v.nil?
+    end
+  end
+
+  def self.load(yaml_path)
+    setting = YAML.load(ERB.new(File.read(yaml_path)).result)
+    new(setting)
+  end
+end

data/lib/convergence/database_connector.rb

@@ -0,0 +1,25 @@
+class Convergence::DatabaseConnector
+  attr_reader :connector
+
+  def initialize(config)
+    @connector =
+      case config.adapter
+      when 'mysql'
+        Convergence::DatabaseConnector::MysqlConnector.new(config)
+      else
+        fail NotImplementedError.new("#{config.adapter} not supported yet")
+      end
+  end
+
+  def client
+    @connector.client
+  end
+
+  def schema_client
+    @connector.schema_client
+  end
+
+  def config
+    @connector.config
+  end
+end

data/lib/convergence/database_connector/mysql_connector.rb

@@ -0,0 +1,27 @@
+class Convergence::DatabaseConnector::MysqlConnector
+  attr_reader :config
+
+  def initialize(config)
+    @config = config
+  end
+
+  def client(database_name = @config.database)
+    @mysql ||= Mysql2::Client.new(
+      host: @config.host,
+      port: @config.port,
+      username: @config.username,
+      password: @config.password,
+      database: database_name
+    )
+  end
+
+  def schema_client
+    @schema_mysql ||= Mysql2::Client.new(
+      host: @config.host,
+      port: @config.port,
+      username: @config.username,
+      password: @config.password,
+      database: 'information_schema'
+    )
+  end
+end

data/lib/convergence/default_parameter.rb

@@ -0,0 +1,32 @@
+class Convergence::DefaultParameter
+  def initialize(adapter)
+    case adapter.downcase
+    when 'mysql'
+      @parameter_klass = Convergence::DefaultParameter::MysqlDefaultParameter.new
+    else
+      fail NotImplementedError.new("unknown adapter #{config.adapter}.")
+    end
+  end
+
+  def remove_default_parameter(table)
+    @parameter_klass.remove_default_parameter(table)
+  end
+
+  def append_default_parameter(table)
+    @parameter_klass.append_default_parameter(table)
+  end
+
+  def self.remove_database_default_parameter(tables, adapter)
+    values = tables.values.map do |table|
+      { table.table_name => Convergence::DefaultParameter.new(adapter).remove_default_parameter(table) }
+    end
+    values.reduce { |a, e| a.merge(e) }
+  end
+
+  def self.append_database_default_parameter(tables, adapter)
+    values = tables.values.map do |table|
+      { table.table_name => Convergence::DefaultParameter.new(adapter).append_default_parameter(table) }
+    end
+    values.reduce { |a, e| a.merge(e) }
+  end
+end

data/lib/convergence/default_parameter/mysql_default_parameter.rb

@@ -0,0 +1,159 @@
+class Convergence::DefaultParameter::MysqlDefaultParameter
+  DEFAULT_TABLE_PARAMETERS = {
+    engine: 'InnoDB',
+    row_format: 'Compact',
+    default_charset: 'utf8'
+  }
+  DEFAULT_COLLATE_NAME = {
+    'big5' => 'big5_chinese_ci',
+    'dec8' => 'dec8_swedish_ci',
+    'cp850' => 'cp850_general_ci',
+    'hp8' => ' hp8_english_ci',
+    'koi8r' => ' koi8r_general_ci',
+    'latin1' => 'latin1_swedish_ci',
+    'latin2' => 'latin2_general_ci',
+    'swe7' => 'swe7_swedish_ci',
+    'ascii' => 'ascii_general_ci',
+    'ujis' => 'ujis_japanese_ci',
+    'sjis' => 'sjis_japanese_ci',
+    'hebrew' => 'hebrew_general_ci',
+    'tis620' => 'tis620_thai_ci',
+    'euckr' => 'euckr_korean_ci',
+    'koi8u' => 'koi8u_general_ci',
+    'gb2312' => 'gb2312_chinese_ci',
+    'greek' => ' greek_general_ci',
+    'cp1250' => 'cp1250_general_ci',
+    'gbk' => 'gbk_chinese_ci',
+    'latin5' => 'latin5_turkish_ci',
+    'armscii8' => 'armscii8_general_ci',
+    'utf8' => 'utf8_general_ci',
+    'ucs2' => 'ucs2_general_ci',
+    'cp866' => 'cp866_general_ci',
+    'keybcs2' => 'keybcs2_general_ci',
+    'macce' => 'macce_general_ci',
+    'macroman' => 'macroman_general_ci',
+    'cp852' => 'cp852_general_ci',
+    'latin7' => 'latin7_general_ci',
+    'utf8mb4' => 'utf8mb4_general_ci',
+    'cp1251' => 'cp1251_general_ci',
+    'utf16' => 'utf16_general_ci',
+    'utf16le' => 'utf16le_general_ci',
+    'cp1256' => 'cp1256_general_ci',
+    'cp1257' => 'cp1257_general_ci',
+    'utf32' =>  'utf32_general_ci',
+    'binary' => 'binary',
+    'geostd8' => 'eostd8_general_ci',
+    'cp932' => 'cp932_japanese_ci',
+    'eucjpms' => 'ucjpms_japanese_ci'
+  }
+  DEFAULT_COLUMN_PARAMETERS = {
+    null: false
+  }
+  TEXT_TYPE = [:varchar, :char, :tiny_text, :text, :mediumtext, :longtext]
+  DEFAULT_COLUMN_TYPE_PARAMETERS = {
+    tinyint: {
+      limit: 3
+    },
+    smallint: {
+      limit: 5
+    },
+    mediumint: {
+      limit: 8
+    },
+    int: {
+      limit: 11
+    },
+    bigint: {
+      limit: 19
+    },
+    varchar: {
+      limit: 255
+    }
+  }
+  DEFAULT_INDEX_PARAMETERS = { type: 'BTREE' }
+
+  def initialize
+  end
+
+  def remove_default_parameter(table)
+    remove_column_default_parameter(table)
+    remove_table_default_parameter(table)
+    remove_index_default_parameter(table)
+    table
+  end
+
+  def append_default_parameter(table)
+    append_column_default_parameter(table)
+    append_table_default_parameter(table)
+    append_index_default_parameter(table)
+    table
+  end
+
+  private
+
+  def remove_column_default_parameter(table)
+    table.columns.each do |_column_name, column|
+      type = column.type
+      parameters = DEFAULT_COLUMN_PARAMETERS.merge(DEFAULT_COLUMN_TYPE_PARAMETERS[type] || {})
+      if TEXT_TYPE.include?(type)
+        character_set = table.table_options[:default_charset] || DEFAULT_TABLE_PARAMETERS[:default_charset]
+        parameters = parameters.merge(
+          character_set: character_set,
+          collate: table.table_options[:collate] || DEFAULT_COLLATE_NAME[character_set.downcase])
+      end
+      parameters.each do |k, v|
+        if !column.options[k].nil? && column.options[k].to_s.downcase == v.to_s.downcase
+          column.options.delete(k)
+        end
+      end
+    end
+  end
+
+  def remove_table_default_parameter(table)
+    table.table_options.each do |k, v|
+      if !DEFAULT_TABLE_PARAMETERS[k].nil? && DEFAULT_TABLE_PARAMETERS[k].downcase == v.to_s.downcase
+        table.table_options.delete(k)
+      end
+    end
+  end
+
+  def remove_index_default_parameter(table)
+    table.indexes.each do |_, va|
+      va.options.each do |k, v|
+        if !DEFAULT_INDEX_PARAMETERS[k].nil? && DEFAULT_INDEX_PARAMETERS[k].downcase == v.to_s.downcase
+          va.options.delete(k)
+        end
+      end
+    end
+  end
+
+  def append_column_default_parameter(table)
+    table.columns.each do |_column_name, column|
+      type = column.type
+      parameters = DEFAULT_COLUMN_PARAMETERS
+        .merge(DEFAULT_COLUMN_TYPE_PARAMETERS[type] || {})
+        .merge(column.options)
+      if TEXT_TYPE.include?(type)
+        character_set = table.table_options[:default_charset] || DEFAULT_TABLE_PARAMETERS[:default_charset]
+        parameters = parameters.merge(
+          character_set: character_set,
+          collate: table.table_options[:collate] || DEFAULT_COLLATE_NAME[character_set.downcase])
+      end
+      column.options = parameters
+    end
+  end
+
+  def append_table_default_parameter(table)
+    table.table_options = DEFAULT_TABLE_PARAMETERS.merge(table.table_options)
+    if table.table_options[:collate].nil?
+      table.table_options.merge!(collate: DEFAULT_COLLATE_NAME[table.table_options[:default_charset].downcase])
+    end
+  end
+
+  def append_index_default_parameter(table)
+    table.indexes.each do |_column_name, column|
+      parameters = DEFAULT_INDEX_PARAMETERS.merge(column.options)
+      column.options = parameters
+    end
+  end
+end

data/lib/convergence/diff.rb

@@ -0,0 +1,148 @@
+require 'diff/lcs'
+
+class Convergence::Diff
+  def diff(from_database, to_database)
+    delta = {}
+    from_database = {} if from_database.nil?
+    delta[:add_table] = scan_add_table(from_database, to_database)
+    delta[:remove_table] = scan_remove_table(from_database, to_database)
+    delta[:change_table] = scan_change_table(from_database, to_database)
+    delta
+  end
+
+  def diff_table(from_table, to_table)
+    from = from_table.dup
+    to = to_table.dup
+    delta = {}
+    delta[:add_column] = scan_add_column(from, to)
+    delta[:remove_column] = scan_remove_column(from, to)
+    delta[:change_column] = scan_change_column(from, to)
+    scan_change_order_column(from, to, delta)
+    delta[:remove_index] = scan_change_index(to, from)
+    delta[:add_index] = scan_change_index(from, to)
+    delta[:remove_foreign_key] = scan_change_foreign_key(to, from)
+    delta[:add_foreign_key] = scan_change_foreign_key(from, to)
+    delta[:change_table_option] = scan_change_table_option(from, to)
+    delta
+  end
+
+  private
+
+  def scan_add_table(from, to)
+    to.reject { |table_name, _| from.map { |k, _| k }.include?(table_name) }
+  end
+
+  def scan_remove_table(from, to)
+    from.reject { |table_name, _| to.map { |k, _| k }.include?(table_name) }
+  end
+
+  def scan_change_table(from, to)
+    delta = {}
+    target_tables = from.map { |name, _| name } & to.map { |name, _| name }
+    target_tables.each do |target_table|
+      from_table = from.find { |name, _| name == target_table }[1]
+      to_table = to.find { |name, _| name == target_table }[1]
+      diff = diff_table(from_table, to_table)
+      unless diff.values.all?(&:empty?)
+        delta[target_table] = diff
+      end
+    end
+    delta
+  end
+
+  def scan_add_column(from, to)
+    to.columns.reject { |column_name, _| from.columns.keys.include?(column_name) }
+  end
+
+  def scan_remove_column(from, to)
+    from.columns.reject { |column_name, _| to.columns.keys.include?(column_name) }
+  end
+
+  def scan_change_column(from, to)
+    change_columns = from
+      .columns
+      .map do |column_name, from_column|
+        to_column = to.columns[column_name]
+        if to_column
+          to_column_option_with_type = (from_column.options.map { |k, _v| { k => nil } }.reduce { |a, e| a.merge(e) } || {})
+            .merge(to_column.options)
+            .merge(type: to_column.type)
+            .map { |k, v| [k, v.to_s.downcase] }
+            .to_a
+          from_column_option_with_type = from_column
+            .options
+            .merge(type: from_column.type)
+            .map { |k, v| [k, v.to_s.downcase] }
+            .to_a
+          { column_name => Hash[(to_column_option_with_type - from_column_option_with_type)] }
+        end
+      end
+    change_columns
+      .compact
+      .reduce { |a, e| a.merge(e) }
+      .reject { |_k, v| v.empty? }
+  end
+
+  def scan_change_order_column(from, to, delta)
+    from_columns = from.columns.keys
+    to_columns = to.columns.keys
+    order_changed_columns = Diff::LCS.diff(from_columns, to_columns)
+      .flatten
+      .select(&:adding?)
+      .map(&:element)
+    order_changed_columns.each do |column|
+      before_column_index = to_columns.index { |v| v == column } - 1
+      before_column = if before_column_index < 0
+                        nil
+                      else
+                        to_columns[before_column_index]
+                      end
+      if delta[:add_column][column]
+        delta[:add_column][column].options.merge!(after: before_column)
+      else
+        delta[:change_column][column] = {} if delta[:change_column][column].nil?
+        delta[:change_column][column].merge!(after: before_column)
+      end
+    end
+  end
+
+  def scan_change_index(from, to)
+    delta = {}
+    to.indexes.each do |name, index|
+      candidate_index = from.indexes.find { |from_name, _| from_name == name }
+      if candidate_index.nil? || candidate_index[1].options != index.options
+        delta[name] = index
+      end
+    end
+    delta
+  end
+
+  def scan_change_foreign_key(from, to)
+    delta = {}
+    to.foreign_keys.each do |name, fk|
+      candidate_foreign_keys = from.foreign_keys.find { |from_name, _| from_name == name }
+      target_fk = candidate_foreign_keys[1] rescue nil
+      if candidate_foreign_keys.nil?
+        delta[name] = fk
+      elsif !target_fk.nil?
+        if target_fk.from_columns != fk.from_columns ||
+          target_fk.key_name != fk.key_name ||
+          target_fk.options != fk.options ||
+          target_fk.to_columns != fk.to_columns ||
+          target_fk.to_table != fk.to_table
+          delta[name] = fk
+        end
+      end
+    end
+    delta
+  end
+
+  def scan_change_table_option(from, to)
+    change_options = (from.table_options.map { |k, _v| { k => nil } }.reduce { |a, e| a.merge(e) } || {})
+      .merge(to.table_options)
+      .reject do |k, v|
+        !from.table_options[k].nil? && from.table_options[k].to_s.downcase == v.to_s.downcase
+      end
+    Hash[change_options]
+  end
+end