ridgepole 0.7.3.beta → 0.7.3.beta2

data/gemfiles/activerecord_5.2.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "mysql2", "~> 0.4.4"
 gem "activerecord", "~> 5.2.0"
+gem "mysql2", "~> 0.4.4"
 
 gemspec path: "../"

data/lib/ridgepole/cli/config.rb

@@ -1,54 +1,54 @@
 require 'erb'
 require 'yaml'
 
-class Ridgepole::Config
-  class << self
-    def load(config, env = 'development')
-      if config =~ /\Aenv:(.+)\z/
-        config = ENV.fetch($1)
+module Ridgepole
+  class Config
+    class << self
+      def load(config, env = 'development')
+        config = ENV.fetch(Regexp.last_match(1)) if config =~ /\Aenv:(.+)\z/
+
+        parsed_config = if File.exist?(config)
+                          parse_config_file(config)
+                        elsif (expanded = File.expand_path(config)) && File.exist?(expanded)
+                          parse_config_file(expanded)
+                        else
+                          YAML.safe_load(ERB.new(config).result, [], [], true)
+                        end
+
+        unless parsed_config.is_a?(Hash)
+          parsed_config = parse_database_url(config)
+        end
+
+        if parsed_config.key?(env.to_s)
+          parsed_config.fetch(env.to_s)
+        else
+          parsed_config
+        end
       end
 
-      if File.exist?(config)
-        parsed_config = parse_config_file(config)
-      elsif (expanded = File.expand_path(config)) and File.exist?(expanded)
-        parsed_config = parse_config_file(expanded)
-      else
-        parsed_config = YAML.load(ERB.new(config).result)
-      end
+      private
 
-      unless parsed_config.kind_of?(Hash)
-        parsed_config = parse_database_url(config)
+      def parse_config_file(path)
+        yaml = ERB.new(File.read(path)).result
+        YAML.safe_load(yaml, [], [], true)
       end
 
-      if parsed_config.has_key?(env.to_s)
-        parsed_config.fetch(env.to_s)
-      else
-        parsed_config
+      def parse_database_url(config)
+        uri = URI.parse(config)
+
+        if [uri.scheme, uri.user, uri.host, uri.path].any? { |i| i.nil? || i.empty? }
+          raise "Invalid config: #{config.inspect}"
+        end
+
+        {
+          'adapter'  => uri.scheme,
+          'username' => uri.user,
+          'password' => uri.password,
+          'host'     => uri.host,
+          'port'     => uri.port,
+          'database' => uri.path.sub(%r{\A/}, '')
+        }
       end
     end
-
-    private
-
-    def parse_config_file(path)
-      yaml = ERB.new(File.read(path)).result
-      YAML.load(yaml)
-    end
-
-    def parse_database_url(config)
-      uri = URI.parse(config)
-
-      if [uri.scheme, uri.user, uri.host, uri.path].any? {|i| i.nil? or i.empty? }
-        raise "Invalid config: #{config.inspect}"
-      end
-
-      {
-        'adapter'  => uri.scheme,
-        'username' => uri.user,
-        'password' => uri.password,
-        'host'     => uri.host,
-        'port'     => uri.port,
-        'database' => uri.path.sub(%r|\A/|, ''),
-      }
-     end
-   end # of class methods
+  end
 end

data/lib/ridgepole/client.rb

@@ -1,84 +1,86 @@
-class Ridgepole::Client
-  def initialize(conn_spec, options = {})
-    @options = options
+module Ridgepole
+  class Client
+    def initialize(conn_spec, options = {})
+      @options = options
 
-    ActiveRecord::Base.establish_connection(conn_spec)
+      ActiveRecord::Base.establish_connection(conn_spec)
 
-    # XXX: If the required processing in class method?
-    if not @options.has_key?(:index_removed_drop_column) and Ridgepole::DefaultsLimit.adapter == :postgresql
-      @options[:index_removed_drop_column] = true
-    end
+      # XXX: If the required processing in class method?
+      if !@options.key?(:index_removed_drop_column) && (Ridgepole::DefaultsLimit.adapter == :postgresql)
+        @options[:index_removed_drop_column] = true
+      end
 
-    Ridgepole::ExecuteExpander.expand_execute(ActiveRecord::Base.connection)
-    @dumper = Ridgepole::Dumper.new(@options)
-    @parser = Ridgepole::DSLParser.new(@options)
-    @diff = Ridgepole::Diff.new(@options)
+      Ridgepole::ExecuteExpander.expand_execute(ActiveRecord::Base.connection)
+      @dumper = Ridgepole::Dumper.new(@options)
+      @parser = Ridgepole::DSLParser.new(@options)
+      @diff = Ridgepole::Diff.new(@options)
 
-    if @options[:mysql_use_alter]
-      require 'ridgepole/ext/abstract_mysql_adapter/use_alter_index'
-    end
+      if @options[:mysql_use_alter]
+        require 'ridgepole/ext/abstract_mysql_adapter/use_alter_index'
+      end
 
-    if @options[:mysql_dump_auto_increment]
-      require 'ridgepole/ext/abstract_mysql_adapter/dump_auto_increment'
+      if @options[:mysql_dump_auto_increment]
+        require 'ridgepole/ext/abstract_mysql_adapter/dump_auto_increment'
+      end
     end
-  end
-
-  def dump(&block)
-    logger = Ridgepole::Logger.instance
-    logger.verbose_info('# Load tables')
-    @dumper.dump(&block)
-  end
 
-  def diff(dsl, opts = {})
-    logger = Ridgepole::Logger.instance
-
-    logger.verbose_info('# Parse DSL')
-    expected_definition, expected_execute = @parser.parse(dsl, opts)
-    expected_definition.each do |table, definition|
-      definition[:options][:options] ||= @options[:table_options] if @options[:table_options]
+    def dump(&block)
+      logger = Ridgepole::Logger.instance
+      logger.verbose_info('# Load tables')
+      @dumper.dump(&block)
     end
-    logger.verbose_info('# Load tables')
-    current_definition, _current_execute = @parser.parse(@dumper.dump, opts)
-    logger.verbose_info('# Compare definitions')
-    @diff.diff(current_definition, expected_definition, :execute => expected_execute)
-  end
 
-  class << self
-    def diff(dsl_or_config1, dsl_or_config2, options = {})
+    def diff(dsl, opts = {})
       logger = Ridgepole::Logger.instance
 
-      logger.verbose_info('# Parse DSL1')
-      definition1, _execute1 = load_definition(dsl_or_config1, options)
-      logger.verbose_info('# Parse DSL2')
-      definition2, _execute2 = load_definition(dsl_or_config2, options)
-
+      logger.verbose_info('# Parse DSL')
+      expected_definition, expected_execute = @parser.parse(dsl, opts)
+      expected_definition.each do |_table, definition|
+        definition[:options][:options] ||= @options[:table_options] if @options[:table_options]
+      end
+      logger.verbose_info('# Load tables')
+      current_definition, _current_execute = @parser.parse(@dumper.dump, opts)
       logger.verbose_info('# Compare definitions')
-      diff = Ridgepole::Diff.new(options)
-      diff.diff(definition1, definition2)
+      @diff.diff(current_definition, expected_definition, execute: expected_execute)
     end
 
-    def dump(conn_spec, options = {}, &block)
-      client = self.new(conn_spec, options)
-      client.dump(&block)
-    end
+    class << self
+      def diff(dsl_or_config1, dsl_or_config2, options = {})
+        logger = Ridgepole::Logger.instance
 
-    private
+        logger.verbose_info('# Parse DSL1')
+        definition1, _execute1 = load_definition(dsl_or_config1, options)
+        logger.verbose_info('# Parse DSL2')
+        definition2, _execute2 = load_definition(dsl_or_config2, options)
 
-    def load_definition(dsl_or_config, options = {})
-      parse_opts = {}
+        logger.verbose_info('# Compare definitions')
+        diff = Ridgepole::Diff.new(options)
+        diff.diff(definition1, definition2)
+      end
 
-      case dsl_or_config
-      when Hash
-        dsl_or_config = dump(dsl_or_config, options)
-      when File
-        file = dsl_or_config
-        parse_opts[:path] = file.path
-        dsl_or_config = file.read
-        file.close
+      def dump(conn_spec, options = {}, &block)
+        client = new(conn_spec, options)
+        client.dump(&block)
       end
 
-      parser = Ridgepole::DSLParser.new(options)
-      parser.parse(dsl_or_config, parse_opts)
+      private
+
+      def load_definition(dsl_or_config, options = {})
+        parse_opts = {}
+
+        case dsl_or_config
+        when Hash
+          dsl_or_config = dump(dsl_or_config, options)
+        when File
+          file = dsl_or_config
+          parse_opts[:path] = file.path
+          dsl_or_config = file.read
+          file.close
+        end
+
+        parser = Ridgepole::DSLParser.new(options)
+        parser.parse(dsl_or_config, parse_opts)
+      end
     end
-  end # of class methods
+  end
 end

data/lib/ridgepole/default_limit.rb

@@ -1,28 +1,30 @@
-class Ridgepole::DefaultsLimit
-  DEFAULTS_LIMITS = {
-    :mysql2 => {
-      :boolean => 1,
-      :integer => 4,
-      :bigint  => 8,
-      :float   => 24,
-      :string  => 255,
-      :text    => 65535,
-      :binary  => 65535,
-    }
-  }
+module Ridgepole
+  class DefaultsLimit
+    DEFAULTS_LIMITS = {
+      mysql2: {
+        boolean: 1,
+        integer: 4,
+        bigint: 8,
+        float: 24,
+        string: 255,
+        text: 65_535,
+        binary: 65_535
+      }
+    }.freeze
 
-  class << self
-    def default_limit(column_type, options)
-      defaults = DEFAULTS_LIMITS[adapter] || {}
-      option_key = :"default_#{column_type}_limit"
-      default_limit = options[option_key] || defaults[column_type] || 0
-      default_limit.zero? ? nil : default_limit
-    end
+    class << self
+      def default_limit(column_type, options)
+        defaults = DEFAULTS_LIMITS[adapter] || {}
+        option_key = :"default_#{column_type}_limit"
+        default_limit = options[option_key] || defaults[column_type] || 0
+        default_limit.zero? ? nil : default_limit
+      end
 
-    def adapter
-      ActiveRecord::Base.connection_config.fetch(:adapter).to_sym
-    rescue ActiveRecord::ConnectionNotEstablished
-      nil
+      def adapter
+        ActiveRecord::Base.connection_config.fetch(:adapter).to_sym
+      rescue ActiveRecord::ConnectionNotEstablished
+        nil
+      end
     end
-  end # of class methods
+  end
 end

data/lib/ridgepole/delta.rb

@@ -1,515 +1,513 @@
-class Ridgepole::Delta
-  SCRIPT_NAME = '<Schema>'
+module Ridgepole
+  class Delta
+    SCRIPT_NAME = '<Schema>'.freeze
 
-  def initialize(delta, options = {})
-    @delta = delta
-    @options = options
-    @logger = Ridgepole::Logger.instance
-  end
+    def initialize(delta, options = {})
+      @delta = delta
+      @options = options
+      @logger = Ridgepole::Logger.instance
+    end
+
+    def migrate(options = {})
+      log_file = @options[:log_file]
+
+      if log_file
+        result = ActiveRecord::Migration.record_time do
+          migrate0(options)
+        end
 
-  def migrate(options = {})
-    if log_file = @options[:log_file]
-      result = ActiveRecord::Migration.record_time do
+        File.open(log_file, 'wb') { |f| f.puts JSON.pretty_generate(result) }
+        result
+      else
         migrate0(options)
       end
-
-      open(log_file, 'wb') {|f| f.puts JSON.pretty_generate(result) }
-      result
-    else
-      migrate0(options)
     end
-  end
 
-  def script
-    buf = StringIO.new
-    pre_buf_for_fk = StringIO.new
-    post_buf_for_fk = StringIO.new
+    def script
+      buf = StringIO.new
+      pre_buf_for_fk = StringIO.new
+      post_buf_for_fk = StringIO.new
 
-    (@delta[:add] || {}).each do |table_name, attrs|
-      append_create_table(table_name, attrs, buf, post_buf_for_fk)
-    end
+      (@delta[:add] || {}).each do |table_name, attrs|
+        append_create_table(table_name, attrs, buf, post_buf_for_fk)
+      end
 
-    (@delta[:rename] || {}).each do |table_name, attrs|
-      append_rename_table(table_name, attrs, buf)
-    end
+      (@delta[:rename] || {}).each do |table_name, attrs|
+        append_rename_table(table_name, attrs, buf)
+      end
 
-    (@delta[:change] || {}).each do |table_name, attrs|
-      append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)
-    end
+      (@delta[:change] || {}).each do |table_name, attrs|
+        append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)
+      end
 
-    (@delta[:delete] || {}).each do |table_name, attrs|
-      append_drop_table(table_name, attrs, buf)
-    end
+      (@delta[:delete] || {}).each do |table_name, attrs|
+        append_drop_table(table_name, attrs, buf)
+      end
 
-    [
-      pre_buf_for_fk,
-      buf,
-      post_buf_for_fk,
-    ].map {|b| b.string.strip }.join("\n\n").strip
-  end
+      [
+        pre_buf_for_fk,
+        buf,
+        post_buf_for_fk
+      ].map { |b| b.string.strip }.join("\n\n").strip
+    end
 
-  def differ?
-    not script.empty? or not delta_execute.empty?
-  end
+    def differ?
+      !script.empty? || !delta_execute.empty?
+    end
 
-  private
+    private
 
-  def migrate0(options = {})
-    migrated = false
-    out = nil
+    def migrate0(options = {})
+      migrated = false
+      out = nil
 
-    if options[:noop]
-      disable_logging_orig = ActiveRecord::Migration.disable_logging
+      if options[:noop]
+        disable_logging_orig = ActiveRecord::Migration.disable_logging
 
-      begin
-        ActiveRecord::Migration.disable_logging = true
-        buf = StringIO.new
+        begin
+          ActiveRecord::Migration.disable_logging = true
+          buf = StringIO.new
 
-        callback = proc do |sql, name|
-          buf.puts sql if sql =~ /\A(CREATE|ALTER|DROP|RENAME)\b/i
-        end
+          callback = proc do |sql, _name|
+            buf.puts sql if sql =~ /\A(CREATE|ALTER|DROP|RENAME)\b/i
+          end
 
-        eval_script_block = proc do
-          Ridgepole::ExecuteExpander.without_operation(callback) do
-            migrated = eval_script(script, options.merge(:out => buf))
+          eval_script_block = proc do
+            Ridgepole::ExecuteExpander.without_operation(callback) do
+              migrated = eval_script(script, options.merge(out: buf))
+            end
           end
-        end
 
-        if options[:alter_extra]
-          Ridgepole::ExecuteExpander.with_alter_extra(options[:alter_extra]) do
+          if options[:alter_extra]
+            Ridgepole::ExecuteExpander.with_alter_extra(options[:alter_extra]) do
+              eval_script_block.call
+            end
+          else
             eval_script_block.call
           end
-        else
-          eval_script_block.call
-        end
 
-        out = buf.string.strip
-      ensure
-        ActiveRecord::Migration.disable_logging = disable_logging_orig
-      end
-    elsif options[:external_script]
-      Ridgepole::ExecuteExpander.with_script(options[:external_script], Ridgepole::Logger.instance) do
-        migrated = eval_script(script, options)
-      end
-    elsif options[:alter_extra]
-      Ridgepole::ExecuteExpander.with_alter_extra(options[:alter_extra]) do
+          out = buf.string.strip
+        ensure
+          ActiveRecord::Migration.disable_logging = disable_logging_orig
+        end
+      elsif options[:external_script]
+        Ridgepole::ExecuteExpander.with_script(options[:external_script], Ridgepole::Logger.instance) do
+          migrated = eval_script(script, options)
+        end
+      elsif options[:alter_extra]
+        Ridgepole::ExecuteExpander.with_alter_extra(options[:alter_extra]) do
+          migrated = eval_script(script, options)
+        end
+      else
         migrated = eval_script(script, options)
       end
-    else
-      migrated = eval_script(script, options)
+
+      [migrated, out]
     end
 
-    [migrated, out]
-  end
+    def eval_script(script, options = {})
+      execute_count = 0
 
-  def eval_script(script, options = {})
-    execute_count = 0
+      begin
+        with_pre_post_query(options) do
+          unless script.empty?
+            ActiveRecord::Schema.new.instance_eval(script, SCRIPT_NAME, 1)
+          end
 
-    begin
-      with_pre_post_query(options) do
-        unless script.empty?
-          ActiveRecord::Schema.new.instance_eval(script, SCRIPT_NAME, 1)
+          execute_count = execute_sqls(options)
         end
-
-        execute_count = execute_sqls(options)
+      rescue StandardError => e
+        raise_exception(script, e)
       end
-    rescue => e
-      raise_exception(script, e)
+
+      !script.empty? || execute_count.nonzero?
     end
 
-    not script.empty? or execute_count.nonzero?
-  end
+    def execute_sqls(options = {})
+      es = @delta[:execute] || []
+      out = options[:out] || $stdout
+      execute_count = 0
 
-  def execute_sqls(options = {})
-    es = @delta[:execute] || []
-    out = options[:out] || $stdout
-    execute_count = 0
+      es.each do |exec|
+        sql, cond = exec.values_at(:sql, :condition)
+        executable = false
 
-    es.each do |exec|
-      sql, cond = exec.values_at(:sql, :condition)
-      executable = false
+        begin
+          executable = cond.nil? || cond.call(ActiveRecord::Base.connection)
+        rescue StandardError => e
+          errmsg = "[WARN] `#{sql}` is not executed: #{e.message}"
 
-      begin
-        executable = cond.nil? || cond.call(ActiveRecord::Base.connection)
-      rescue => e
-        errmsg = "[WARN] `#{sql}` is not executed: #{e.message}"
+          errmsg = ([errmsg] + e.backtrace).join("\n\tfrom ") if @options[:debug]
 
-        if @options[:debug]
-          errmsg = ([errmsg] + e.backtrace).join("\n\tfrom ")
+          Ridgepole::Logger.instance.warn(errmsg)
+
+          executable = false
         end
 
-        Ridgepole::Logger.instance.warn(errmsg)
+        next unless executable
 
-        executable = false
-      end
-
-      next unless executable
+        if options[:noop]
+          out.puts(sql.strip_heredoc)
+        else
+          @logger.info(sql.strip_heredoc)
+          ActiveRecord::Base.connection.execute(sql)
+        end
 
-      if options[:noop]
-        out.puts(sql.strip_heredoc)
-      else
-        @logger.info(sql.strip_heredoc)
-        ActiveRecord::Base.connection.execute(sql)
+        execute_count += 1
       end
 
-      execute_count += 1
+      execute_count
     end
 
-    return execute_count
-  end
-
-  def with_pre_post_query(options = {})
-    out = options[:out] || $stdout
+    def with_pre_post_query(options = {})
+      out = options[:out] || $stdout
 
-    if (pre_query = @options[:pre_query])
-      if options[:noop]
-        out.puts(pre_query)
-      else
-        ActiveRecord::Base.connection.execute(pre_query)
+      if (pre_query = @options[:pre_query])
+        if options[:noop]
+          out.puts(pre_query)
+        else
+          ActiveRecord::Base.connection.execute(pre_query)
+        end
       end
-    end
 
-    retval = yield
+      retval = yield
 
-    if (post_query = @options[:post_query])
-      if options[:noop]
-        out.puts(post_query)
-      else
-        ActiveRecord::Base.connection.execute(post_query)
+      if (post_query = @options[:post_query])
+        if options[:noop]
+          out.puts(post_query)
+        else
+          ActiveRecord::Base.connection.execute(post_query)
+        end
       end
+
+      retval
     end
 
-    return retval
-  end
+    def raise_exception(script, org)
+      lines = script.each_line
+      digit_number = (lines.count + 1).to_s.length
+      err_num = detect_error_line(org)
 
-  def raise_exception(script, org)
-    lines = script.each_line
-    digit_number = (lines.count + 1).to_s.length
-    err_num = detect_error_line(org)
+      errmsg = lines.with_index.map do |l, i|
+        line_num = i + 1
+        prefix = line_num == err_num ? '* ' : '  '
+        format("#{prefix}%*d: #{l}", digit_number, line_num)
+      end
 
-    errmsg = lines.with_index.map {|l, i|
-      line_num = i + 1
-      prefix = (line_num == err_num) ? '* ' : '  '
-      "#{prefix}%*d: #{l}" % [digit_number, line_num]
-    }
+      if err_num > 0
+        from = err_num - 6
+        from = 0 if from < 0
+        to = err_num + 4
+        errmsg = errmsg.slice(from..to)
+      end
 
-    if err_num > 0
-      from = err_num - 6
-      from = 0 if from < 0
-      to = err_num + 4
-      errmsg = errmsg.slice(from..to)
+      e = RuntimeError.new(org.message + "\n" + errmsg.join)
+      e.set_backtrace(org.backtrace)
+      raise e
     end
 
-    e = RuntimeError.new(org.message + "\n" + errmsg.join)
-    e.set_backtrace(org.backtrace)
-    raise e
-  end
+    def detect_error_line(exception)
+      rgx = /\A#{Regexp.escape(SCRIPT_NAME)}:(\d+):/
+      line = exception.backtrace.find { |i| i =~ rgx }
 
-  def detect_error_line(e)
-    rgx = /\A#{Regexp.escape(SCRIPT_NAME)}:(\d+):/
-    line = e.backtrace.find {|i| i =~ rgx }
-
-    if line and (m = rgx.match(line))
-      m[1].to_i
-    else
-      0
+      if line && (m = rgx.match(line))
+        m[1].to_i
+      else
+        0
+      end
     end
-  end
 
-  def append_create_table(table_name, attrs, buf, post_buf_for_fk)
-    options = attrs[:options] || {}
-    definition = attrs[:definition] || {}
-    indices = attrs[:indices] || {}
+    def append_create_table(table_name, attrs, buf, post_buf_for_fk)
+      options = attrs[:options] || {}
+      definition = attrs[:definition] || {}
+      indices = attrs[:indices] || {}
 
-    buf.puts(<<-EOS)
+      buf.puts(<<-RUBY)
 create_table(#{table_name.inspect}, #{inspect_options_include_default_proc(options)}) do |t|
-    EOS
+    RUBY
 
-    definition.each do |column_name, column_attrs|
-      column_type = column_attrs.fetch(:type)
-      column_options = column_attrs[:options] || {}
-      normalize_limit(column_type, column_options)
+      definition.each do |column_name, column_attrs|
+        column_type = column_attrs.fetch(:type)
+        column_options = column_attrs[:options] || {}
+        normalize_limit(column_type, column_options)
 
-      buf.puts(<<-EOS)
+        buf.puts(<<-RUBY)
   t.column(#{column_name.inspect}, :#{column_type.to_s.inspect}, #{inspect_options_include_default_proc(column_options)})
-      EOS
-    end
+      RUBY
+      end
 
-    if @options[:create_table_with_index] and not indices.empty?
-      indices.each do |index_name, index_attrs|
-        append_add_index(table_name, index_name, index_attrs, buf, true)
+      if @options[:create_table_with_index] && !indices.empty?
+        indices.each do |index_name, index_attrs|
+          append_add_index(table_name, index_name, index_attrs, buf, true)
+        end
       end
-    end
 
-    buf.puts(<<-EOS)
-end
-    EOS
+      buf.puts(<<-RUBY)
+  end
+      RUBY
 
-    if not @options[:create_table_with_index] and not indices.empty?
-      append_change_table(table_name, buf) do
-        indices.each do |index_name, index_attrs|
-          append_add_index(table_name, index_name, index_attrs, buf)
+      if !(@options[:create_table_with_index]) && !indices.empty?
+        append_change_table(table_name, buf) do
+          indices.each do |index_name, index_attrs|
+            append_add_index(table_name, index_name, index_attrs, buf)
+          end
         end
       end
-    end
 
-    unless (foreign_keys = attrs[:foreign_keys] || {}).empty?
-      foreign_keys.each do |_, foreign_key_attrs|
-        append_add_foreign_key(table_name, foreign_key_attrs, post_buf_for_fk, @options)
+      unless (foreign_keys = attrs[:foreign_keys] || {}).empty?
+        foreign_keys.each do |_, foreign_key_attrs|
+          append_add_foreign_key(table_name, foreign_key_attrs, post_buf_for_fk, @options)
+        end
       end
-    end
 
-    buf.puts
-    post_buf_for_fk.puts
-  end
+      buf.puts
+      post_buf_for_fk.puts
+    end
 
-  def append_rename_table(to_table_name, from_table_name, buf)
-    buf.puts(<<-EOS)
+    def append_rename_table(to_table_name, from_table_name, buf)
+      buf.puts(<<-RUBY)
 rename_table(#{from_table_name.inspect}, #{to_table_name.inspect})
-    EOS
+    RUBY
 
-    buf.puts
-  end
+      buf.puts
+    end
 
-  def append_drop_table(table_name, attrs, buf)
-    buf.puts(<<-EOS)
+    def append_drop_table(table_name, _attrs, buf)
+      buf.puts(<<-RUBY)
 drop_table(#{table_name.inspect})
-    EOS
+    RUBY
 
-    buf.puts
-  end
+      buf.puts
+    end
 
-  def append_change_table_options(table_name, table_options, buf)
-    # XXX: MySQL only
-    buf.puts(<<-EOS)
+    def append_change_table_options(table_name, table_options, buf)
+      # XXX: MySQL only
+      buf.puts(<<-RUBY)
 execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{table_options}"
-    EOS
-
-    buf.puts
-  end
+    RUBY
 
-  def append_change_table_comment(table_name, table_comment, buf)
-    comment_literal = "COMMENT=#{ActiveRecord::Base.connection.quote(table_comment)}"
-    append_change_table_options(table_name, comment_literal, buf)
-  end
-
-  def append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)
-    definition = attrs[:definition] || {}
-    primary_key_definition = attrs[:primary_key_definition] || {}
-    indices = attrs[:indices] || {}
-    foreign_keys = attrs[:foreign_keys] || {}
-    table_options = attrs[:table_options]
-    table_comment = attrs[:table_comment]
-
-    if not definition.empty? or not indices.empty? or not primary_key_definition.empty?
-      append_change_table(table_name, buf) do
-        append_delete_indices(table_name, indices, buf)
-        append_change_definition(table_name, definition, buf)
-        append_change_definition(table_name, primary_key_definition, buf)
-        append_add_indices(table_name, indices, buf)
-      end
+      buf.puts
     end
 
-    unless foreign_keys.empty?
-      append_change_foreign_keys(table_name, foreign_keys, pre_buf_for_fk, post_buf_for_fk, @options)
+    def append_change_table_comment(table_name, table_comment, buf)
+      comment_literal = "COMMENT=#{ActiveRecord::Base.connection.quote(table_comment)}"
+      append_change_table_options(table_name, comment_literal, buf)
     end
 
-    if table_options
-      append_change_table_options(table_name, table_options, buf)
-    end
+    def append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)
+      definition = attrs[:definition] || {}
+      primary_key_definition = attrs[:primary_key_definition] || {}
+      indices = attrs[:indices] || {}
+      foreign_keys = attrs[:foreign_keys] || {}
+      table_options = attrs[:table_options]
+      table_comment = attrs[:table_comment]
 
-    if table_comment
-      append_change_table_comment(table_name, table_comment, buf)
-    end
+      if !definition.empty? || !indices.empty? || !primary_key_definition.empty?
+        append_change_table(table_name, buf) do
+          append_delete_indices(table_name, indices, buf)
+          append_change_definition(table_name, definition, buf)
+          append_change_definition(table_name, primary_key_definition, buf)
+          append_add_indices(table_name, indices, buf)
+        end
+      end
 
-    buf.puts
-    pre_buf_for_fk.puts
-    post_buf_for_fk.puts
-  end
+      unless foreign_keys.empty?
+        append_change_foreign_keys(table_name, foreign_keys, pre_buf_for_fk, post_buf_for_fk, @options)
+      end
 
-  def append_change_table(table_name, buf)
-    buf.puts "change_table(#{table_name.inspect}, {:bulk => true}) do |t|" if @options[:bulk_change]
-    yield
-    buf.puts 'end' if @options[:bulk_change]
-  end
+      append_change_table_options(table_name, table_options, buf) if table_options
 
-  def append_change_definition(table_name, delta, buf)
-    (delta[:add] || {}).each do |column_name, attrs|
-      append_add_column(table_name, column_name, attrs, buf)
-    end
+      append_change_table_comment(table_name, table_comment, buf) if table_comment
 
-    (delta[:rename] || {}).each do |column_name, attrs|
-      append_rename_column(table_name, column_name, attrs, buf)
+      buf.puts
+      pre_buf_for_fk.puts
+      post_buf_for_fk.puts
     end
 
-    (delta[:change] || {}).each do |column_name, attrs|
-      append_change_column(table_name, column_name, attrs, buf)
+    def append_change_table(table_name, buf)
+      buf.puts "change_table(#{table_name.inspect}, {:bulk => true}) do |t|" if @options[:bulk_change]
+      yield
+      buf.puts 'end' if @options[:bulk_change]
     end
 
-    (delta[:delete] || {}).each do |column_name, attrs|
-      append_remove_column(table_name, column_name, attrs, buf)
+    def append_change_definition(table_name, delta, buf)
+      (delta[:add] || {}).each do |column_name, attrs|
+        append_add_column(table_name, column_name, attrs, buf)
+      end
+
+      (delta[:rename] || {}).each do |column_name, attrs|
+        append_rename_column(table_name, column_name, attrs, buf)
+      end
+
+      (delta[:change] || {}).each do |column_name, attrs|
+        append_change_column(table_name, column_name, attrs, buf)
+      end
+
+      (delta[:delete] || {}).each do |column_name, attrs|
+        append_remove_column(table_name, column_name, attrs, buf)
+      end
     end
-  end
 
-  def append_add_column(table_name, column_name, attrs, buf)
-    type = attrs.fetch(:type)
-    options = attrs[:options] || {}
-    normalize_limit(type, options)
+    def append_add_column(table_name, column_name, attrs, buf)
+      type = attrs.fetch(:type)
+      options = attrs[:options] || {}
+      normalize_limit(type, options)
 
-    if @options[:bulk_change]
-      buf.puts(<<-EOS)
+      if @options[:bulk_change]
+        buf.puts(<<-RUBY)
   t.column(#{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
-      EOS
-    else
-      buf.puts(<<-EOS)
+      RUBY
+      else
+        buf.puts(<<-RUBY)
 add_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
-      EOS
+      RUBY
+      end
     end
-  end
 
-  def append_rename_column(table_name, to_column_name, from_column_name, buf)
-    if @options[:bulk_change]
-      buf.puts(<<-EOS)
+    def append_rename_column(table_name, to_column_name, from_column_name, buf)
+      if @options[:bulk_change]
+        buf.puts(<<-RUBY)
   t.rename(#{from_column_name.inspect}, #{to_column_name.inspect})
-      EOS
-    else
-      buf.puts(<<-EOS)
+      RUBY
+      else
+        buf.puts(<<-RUBY)
 rename_column(#{table_name.inspect}, #{from_column_name.inspect}, #{to_column_name.inspect})
-      EOS
+      RUBY
+      end
     end
-  end
 
-  def append_change_column(table_name, column_name, attrs, buf)
-    type = attrs.fetch(:type)
-    options = attrs[:options] || {}
+    def append_change_column(table_name, column_name, attrs, buf)
+      type = attrs.fetch(:type)
+      options = attrs[:options] || {}
 
-    # Fix for https://github.com/rails/rails/commit/7f0567b43b73b1bd1a16bfac9cd32fcbf1321b51
-    if Ridgepole::ConnectionAdapters.mysql? and ActiveRecord::VERSION::STRING !~ /\A5\.0\./
-      options[:comment] = nil unless options.has_key?(:comment)
-    end
+      # Fix for https://github.com/rails/rails/commit/7f0567b43b73b1bd1a16bfac9cd32fcbf1321b51
+      if Ridgepole::ConnectionAdapters.mysql? && ActiveRecord::VERSION::STRING !~ /\A5\.0\./
+        options[:comment] = nil unless options.key?(:comment)
+      end
 
-    if @options[:bulk_change]
-      buf.puts(<<-EOS)
+      if @options[:bulk_change]
+        buf.puts(<<-RUBY)
   t.change(#{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
-      EOS
-    else
-      buf.puts(<<-EOS)
+      RUBY
+      else
+        buf.puts(<<-RUBY)
 change_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
-      EOS
+      RUBY
+      end
     end
-  end
 
-  def append_remove_column(table_name, column_name, attrs, buf)
-    if @options[:bulk_change]
-      buf.puts(<<-EOS)
+    def append_remove_column(table_name, column_name, _attrs, buf)
+      if @options[:bulk_change]
+        buf.puts(<<-RUBY)
   t.remove(#{column_name.inspect})
-      EOS
-    else
-      buf.puts(<<-EOS)
+      RUBY
+      else
+        buf.puts(<<-RUBY)
 remove_column(#{table_name.inspect}, #{column_name.inspect})
-      EOS
+      RUBY
+      end
     end
-  end
 
-  def append_add_indices(table_name, delta, buf)
-    (delta[:add] || {}).each do |index_name, attrs|
-      append_add_index(table_name, index_name, attrs, buf)
+    def append_add_indices(table_name, delta, buf)
+      (delta[:add] || {}).each do |index_name, attrs|
+        append_add_index(table_name, index_name, attrs, buf)
+      end
     end
-  end
 
-  def append_delete_indices(table_name, delta, buf)
-    (delta[:delete] || {}).each do |index_name, attrs|
-      append_remove_index(table_name, index_name, attrs, buf)
+    def append_delete_indices(table_name, delta, buf)
+      (delta[:delete] || {}).each do |index_name, attrs|
+        append_remove_index(table_name, index_name, attrs, buf)
+      end
     end
-  end
 
-  def append_add_index(table_name, index_name, attrs, buf, force_bulk_change = false)
-    column_name = attrs.fetch(:column_name)
-    options = attrs[:options] || {}
+    def append_add_index(table_name, _index_name, attrs, buf, force_bulk_change = false)
+      column_name = attrs.fetch(:column_name)
+      options = attrs[:options] || {}
 
-    if force_bulk_change or @options[:bulk_change]
-      buf.puts(<<-EOS)
+      if force_bulk_change || @options[:bulk_change]
+        buf.puts(<<-RUBY)
   t.index(#{column_name.inspect}, #{options.inspect})
-      EOS
-    else
-      buf.puts(<<-EOS)
+      RUBY
+      else
+        buf.puts(<<-RUBY)
 add_index(#{table_name.inspect}, #{column_name.inspect}, #{options.inspect})
-      EOS
+      RUBY
+      end
     end
-  end
 
-  def append_remove_index(table_name, index_name, attrs, buf)
-    column_name = attrs.fetch(:column_name)
-    options = attrs[:options] || {}
-    target = options[:name] ? {:name => options[:name]} : column_name
+    def append_remove_index(table_name, _index_name, attrs, buf)
+      column_name = attrs.fetch(:column_name)
+      options = attrs[:options] || {}
+      target = options[:name] ? { name: options[:name] } : column_name
 
-    if @options[:bulk_change]
-      buf.puts(<<-EOS)
+      if @options[:bulk_change]
+        buf.puts(<<-RUBY)
   t.remove_index(#{target.inspect})
-      EOS
-    else
-      buf.puts(<<-EOS)
+      RUBY
+      else
+        buf.puts(<<-RUBY)
 remove_index(#{table_name.inspect}, #{target.inspect})
-      EOS
+      RUBY
+      end
     end
-  end
 
-  def append_change_foreign_keys(table_name, delta, pre_buf_for_fk, post_buf_for_fk, options)
-    (delta[:delete] || {}).each do |_, attrs|
-      append_remove_foreign_key(table_name, attrs, pre_buf_for_fk, options)
-    end
+    def append_change_foreign_keys(table_name, delta, pre_buf_for_fk, post_buf_for_fk, options)
+      (delta[:delete] || {}).each do |_, attrs|
+        append_remove_foreign_key(table_name, attrs, pre_buf_for_fk, options)
+      end
 
-    (delta[:add] || {}).each do |_, attrs|
-      append_add_foreign_key(table_name, attrs, post_buf_for_fk, options)
+      (delta[:add] || {}).each do |_, attrs|
+        append_add_foreign_key(table_name, attrs, post_buf_for_fk, options)
+      end
     end
-  end
 
-  def append_add_foreign_key(table_name, attrs, buf, options)
-    to_table = attrs.fetch(:to_table)
-    attrs_options = attrs[:options] || {}
+    def append_add_foreign_key(table_name, attrs, buf, _options)
+      to_table = attrs.fetch(:to_table)
+      attrs_options = attrs[:options] || {}
 
-    buf.puts(<<-EOS)
+      buf.puts(<<-RUBY)
 add_foreign_key(#{table_name.inspect}, #{to_table.inspect}, #{attrs_options.inspect})
-    EOS
-  end
+    RUBY
+    end
 
-  def append_remove_foreign_key(table_name, attrs, buf, options)
-    attrs_options = attrs[:options] || {}
-    fk_name = attrs_options[:name]
+    def append_remove_foreign_key(table_name, attrs, buf, _options)
+      attrs_options = attrs[:options] || {}
+      fk_name = attrs_options[:name]
 
-    if fk_name
-      target = {:name => fk_name}
-    else
-      target = attrs.fetch(:to_table)
-    end
+      target = if fk_name
+                 { name: fk_name }
+               else
+                 attrs.fetch(:to_table)
+               end
 
-    buf.puts(<<-EOS)
+      buf.puts(<<-RUBY)
 remove_foreign_key(#{table_name.inspect}, #{target.inspect})
-    EOS
-  end
+    RUBY
+    end
 
-  def delta_execute
-    @delta[:execute] || []
-  end
+    def delta_execute
+      @delta[:execute] || []
+    end
 
-  def normalize_limit(column_type, column_options)
-    default_limit = Ridgepole::DefaultsLimit.default_limit(column_type, @options)
-    column_options[:limit] ||= default_limit if default_limit
-  end
+    def normalize_limit(column_type, column_options)
+      default_limit = Ridgepole::DefaultsLimit.default_limit(column_type, @options)
+      column_options[:limit] ||= default_limit if default_limit
+    end
+
+    def inspect_options_include_default_proc(options)
+      options = options.dup
 
-  def inspect_options_include_default_proc(options)
-    options = options.dup
-
-    if options[:default].kind_of?(Proc)
-      proc_default = options.delete(:default)
-      proc_default = ":default=>proc{#{proc_default.call.inspect}}"
-      options_inspect = options.inspect
-      options_inspect.sub!(/\}\z/, '')
-      options_inspect << ', ' if options_inspect !~ /\{\z/
-      options_inspect << proc_default << '}'
-      options_inspect
-    else
-      options.inspect
+      if options[:default].is_a?(Proc)
+        proc_default = options.delete(:default)
+        proc_default = ":default=>proc{#{proc_default.call.inspect}}"
+        options_inspect = options.inspect
+        options_inspect.sub!(/\}\z/, '')
+        options_inspect << ', ' if options_inspect !~ /\{\z/
+        options_inspect << proc_default << '}'
+        options_inspect
+      else
+        options.inspect
+      end
     end
   end
 end