1147

pending completion

Build # 1147

Build Type

Pull #258

travis-ci

Committed by

web-flow

Commit Message

Suppress deprecation warnings of `Psych.safe_load` args in Ruby 2.6

The interface of `Psych.safe_load` will change from Ruby 2.6.
https://github.com/ruby/ruby/commit/1c92766bf

This PR suppresses the following wargnins in Ruby 2.6.0-dev.

```console
warning: Passing whitelist_classes with the 2nd argument of
Psych.safe_load is deprecated. Use keyword argument like
Psych.safe_load(yaml, whitelist_classes: ...) instead.
warning: Passing whitelist_symbols with the 3rd argument of
Psych.safe_load is deprecated. Use keyword argument like
Psych.safe_load(yaml, whitelist_symbols: ...) instead.
warning: Passing aliases with the 4th argument of Psych.safe_load is
deprecated. Use keyword argument like Psych.safe_load(yaml, aliases:
...) instead.
warning: Passing filename with the 5th argument of Psych.safe_load is
deprecated. Use keyword argument like Psych.safe_load(yaml, filename:
...) instead.
```

```console
% ruby -v
ruby 2.6.0dev (2018-10-21 trunk 65252) [x86_64-darwin17]
```

Pull Request Pull Request #258: Suppress deprecation warnings of `Psych.safe_load` args in Ruby 2.6

Run Details

5 of 5 new or added lines in 1 file covered. (100.0%)

1111 of 1146 relevant lines covered (96.95%)

16374.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.58

/lib/ridgepole/delta.rb

module Ridgepole
  class Delta
    SCRIPT_NAME = '<Schema>'.freeze

    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

        File.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

      (@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[: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

      [
        pre_buf_for_fk,
        buf,
        post_buf_for_fk
      ].map { |b| b.string.strip }.join("\n\n").strip
    end

    def differ?
      !script.empty? || !delta_execute.empty?
    end

    private

    def migrate0(options = {})
      migrated = false
      out = nil

      if options[:noop]
        disable_logging_orig = ActiveRecord::Migration.disable_logging

        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

          eval_script_block = proc do
            Ridgepole::ExecuteExpander.without_operation(callback) do
              migrated = eval_script(script, options.merge(out: buf))
            end
          end

          if options[:alter_extra]
            Ridgepole::ExecuteExpander.with_alter_extra(options[:alter_extra]) do
              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
          migrated = eval_script(script, options)
        end
      else
        migrated = eval_script(script, options)
      end

      [migrated, out]
    end

    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

          execute_count = execute_sqls(options)
        end
      rescue StandardError => e
        raise_exception(script, e)
      end

      !script.empty? || execute_count.nonzero?
    end

    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

        begin
          executable = cond.nil? || cond.call(ActiveRecord::Base.connection)
        rescue StandardError => e
          errmsg = "[WARN] `#{sql}` is not executed: #{e.message}"

          errmsg = ([errmsg] + e.backtrace).join("\n\tfrom ") if @options[:debug]

          Ridgepole::Logger.instance.warn(errmsg)

          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

        execute_count += 1
      end

      execute_count
    end

    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)
        end
      end

      retval = yield

      if (post_query = @options[:post_query])
        if options[:noop]
          out.puts(post_query)
        else
          ActiveRecord::Base.connection.execute(post_query)
        end
      end

      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)

      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

      if err_num > 0
        from = err_num - 6
        from = 0 if from < 0
        to = err_num + 4
        errmsg = errmsg.slice(from..to)
      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 }

      if line && (m = rgx.match(line))
        m[1].to_i
      else
        0
      end
    end

    def append_create_table(table_name, attrs, buf, post_buf_for_fk)
      options = attrs[:options] || {}
      definition = attrs[:definition] || {}
      indices = attrs[:indices] || {}

      buf.puts(<<-RUBY)
create_table(#{table_name.inspect}, #{inspect_options_include_default_proc(options)}) do |t|
    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)

        buf.puts(<<-RUBY)
  t.column(#{column_name.inspect}, :#{column_type.to_s.inspect}, #{inspect_options_include_default_proc(column_options)})
      RUBY
      end

      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

      buf.puts(<<-RUBY)
  end
      RUBY

      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

      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

      buf.puts
      post_buf_for_fk.puts
    end

    def append_rename_table(to_table_name, from_table_name, buf)
      buf.puts(<<-RUBY)
rename_table(#{from_table_name.inspect}, #{to_table_name.inspect})
    RUBY

      buf.puts
    end

    def append_drop_table(table_name, _attrs, buf)
      buf.puts(<<-RUBY)
drop_table(#{table_name.inspect})
    RUBY

      buf.puts
    end

    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}"
    RUBY

      buf.puts
    end

    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 !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

      unless foreign_keys.empty?
        append_change_foreign_keys(table_name, foreign_keys, pre_buf_for_fk, post_buf_for_fk, @options)
      end

      append_change_table_options(table_name, table_options, buf) if table_options

      append_change_table_comment(table_name, table_comment, buf) if table_comment

      buf.puts
      pre_buf_for_fk.puts
      post_buf_for_fk.puts
    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

    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

    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(<<-RUBY)
  t.column(#{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
      RUBY
      else
        buf.puts(<<-RUBY)
add_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
      RUBY
      end
    end

    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})
      RUBY
      else
        buf.puts(<<-RUBY)
rename_column(#{table_name.inspect}, #{from_column_name.inspect}, #{to_column_name.inspect})
      RUBY
      end
    end

    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? && ActiveRecord::VERSION::STRING !~ /\A5\.0\./
        options[:comment] = nil unless options.key?(:comment)
      end

      if @options[:bulk_change]
        buf.puts(<<-RUBY)
  t.change(#{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
      RUBY
      else
        buf.puts(<<-RUBY)
change_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
      RUBY
      end
    end

    def append_remove_column(table_name, column_name, _attrs, buf)
      if @options[:bulk_change]
        buf.puts(<<-RUBY)
  t.remove(#{column_name.inspect})
      RUBY
      else
        buf.puts(<<-RUBY)
remove_column(#{table_name.inspect}, #{column_name.inspect})
      RUBY
      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)
      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)
      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] || {}

      if force_bulk_change || @options[:bulk_change]
        buf.puts(<<-RUBY)
  t.index(#{column_name.inspect}, #{options.inspect})
      RUBY
      else
        buf.puts(<<-RUBY)
add_index(#{table_name.inspect}, #{column_name.inspect}, #{options.inspect})
      RUBY
      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

      if @options[:bulk_change]
        buf.puts(<<-RUBY)
  t.remove_index(#{target.inspect})
      RUBY
      else
        buf.puts(<<-RUBY)
remove_index(#{table_name.inspect}, #{target.inspect})
      RUBY
      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

      (delta[:add] || {}).each do |_, attrs|
        append_add_foreign_key(table_name, attrs, post_buf_for_fk, options)
      end
    end

    def append_add_foreign_key(table_name, attrs, buf, _options)
      to_table = attrs.fetch(:to_table)
      attrs_options = attrs[:options] || {}

      buf.puts(<<-RUBY)
add_foreign_key(#{table_name.inspect}, #{to_table.inspect}, #{attrs_options.inspect})
    RUBY
    end

    def append_remove_foreign_key(table_name, attrs, buf, _options)
      attrs_options = attrs[:options] || {}
      fk_name = attrs_options[:name]

      target = if fk_name
                 { name: fk_name }
               else
                 attrs.fetch(:to_table)
               end

      buf.puts(<<-RUBY)
remove_foreign_key(#{table_name.inspect}, #{target.inspect})
    RUBY
    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 inspect_options_include_default_proc(options)
      options = options.dup

      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

1	module Ridgepole	36✔
2	class Delta	36✔
3	SCRIPT_NAME = '<Schema>'.freeze	36✔
4
5	def initialize(delta, options = {})	36✔
6	@delta = delta	9,740✔
7	@options = options	9,740✔
8	@logger = Ridgepole::Logger.instance	9,740✔
9	end
10
11	def migrate(options = {})	36✔
12	log_file = @options[:log_file]	8,864✔
13
14	if log_file	8,864✔
15	result = ActiveRecord::Migration.record_time do	24✔
16	migrate0(options)	24✔
17	end
18
19	File.open(log_file, 'wb') { \|f\| f.puts JSON.pretty_generate(result) }	48✔
20	result	24✔
21	else
22	migrate0(options)	8,840✔
23	end
24	end
25
26	def script	36✔
27	buf = StringIO.new	14,536✔
28	pre_buf_for_fk = StringIO.new	14,536✔
29	post_buf_for_fk = StringIO.new	14,536✔
30
31	(@delta[:add] \|\| {}).each do \|table_name, attrs\|	14,536✔
32	append_create_table(table_name, attrs, buf, post_buf_for_fk)	16,028✔
33	end
34
35	(@delta[:rename] \|\| {}).each do \|table_name, attrs\|	14,536✔
36	append_rename_table(table_name, attrs, buf)	240✔
37	end
38
39	(@delta[:change] \|\| {}).each do \|table_name, attrs\|	14,536✔
40	append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)	10,392✔
41	end
42
43	(@delta[:delete] \|\| {}).each do \|table_name, attrs\|	14,536✔
44	append_drop_table(table_name, attrs, buf)	960✔
45	end
46
47	[
48	pre_buf_for_fk,
49	buf,
50	post_buf_for_fk
51	].map { \|b\| b.string.strip }.join("\n\n").strip	58,144✔
52	end
53
54	def differ?	36✔
55	!script.empty? \|\| !delta_execute.empty?	4,984✔
56	end
57
58	private	36✔
59
60	def migrate0(options = {})	36✔
61	migrated = false	8,864✔
62	out = nil	8,864✔
63
64	if options[:noop]	8,864✔
65	disable_logging_orig = ActiveRecord::Migration.disable_logging	348✔
66
67	begin	348✔
68	ActiveRecord::Migration.disable_logging = true	348✔
69	buf = StringIO.new	348✔
70
71	callback = proc do \|sql, _name\|	348✔
72	buf.puts sql if sql =~ /\A(CREATE\|ALTER\|DROP\|RENAME)\b/i	3,024✔
73	end
74
75	eval_script_block = proc do	348✔
76	Ridgepole::ExecuteExpander.without_operation(callback) do	348✔
77	migrated = eval_script(script, options.merge(out: buf))	348✔
78	end
79	end
80
81	if options[:alter_extra]	348✔
82	Ridgepole::ExecuteExpander.with_alter_extra(options[:alter_extra]) do	×
83	eval_script_block.call	×
84	end
85	else
86	eval_script_block.call	348✔
87	end
88
89	out = buf.string.strip	348✔
90	ensure
91	ActiveRecord::Migration.disable_logging = disable_logging_orig	348✔
92	end
93	elsif options[:external_script]	8,516✔
94	Ridgepole::ExecuteExpander.with_script(options[:external_script], Ridgepole::Logger.instance) do	48✔
95	migrated = eval_script(script, options)	48✔
96	end
97	elsif options[:alter_extra]	8,468✔
98	Ridgepole::ExecuteExpander.with_alter_extra(options[:alter_extra]) do	24✔
99	migrated = eval_script(script, options)	24✔
100	end
101	else
102	migrated = eval_script(script, options)	8,444✔
103	end
104
105	[migrated, out]	8,816✔
106	end
107
108	def eval_script(script, options = {})	36✔
109	execute_count = 0	8,864✔
110
111	begin	8,864✔
112	with_pre_post_query(options) do	8,864✔
113	unless script.empty?	8,864✔
114	ActiveRecord::Schema.new.instance_eval(script, SCRIPT_NAME, 1)	8,248✔
115	end
116
117	execute_count = execute_sqls(options)	8,816✔
118	end
119	rescue StandardError => e
120	raise_exception(script, e)	48✔
121	end
122
123	!script.empty? \|\| execute_count.nonzero?	8,816✔
124	end
125
126	def execute_sqls(options = {})	36✔
127	es = @delta[:execute] \|\| []	8,816✔
128	out = options[:out] \|\| $stdout	8,816✔
129	execute_count = 0	8,816✔
130
131	es.each do \|exec\|	8,816✔
132	sql, cond = exec.values_at(:sql, :condition)	144✔
133	executable = false	144✔
134
135	begin	144✔
136	executable = cond.nil? \|\| cond.call(ActiveRecord::Base.connection)	144✔
137	rescue StandardError => e
138	errmsg = "[WARN] `#{sql}` is not executed: #{e.message}"	×
139
140	errmsg = ([errmsg] + e.backtrace).join("\n\tfrom ") if @options[:debug]	×
141
142	Ridgepole::Logger.instance.warn(errmsg)	×
143
144	executable = false	×
145	end
146
147	next unless executable	144✔
148
149	if options[:noop]	48✔
150	out.puts(sql.strip_heredoc)	24✔
151	else
152	@logger.info(sql.strip_heredoc)	24✔
153	ActiveRecord::Base.connection.execute(sql)	24✔
154	end
155
156	execute_count += 1	48✔
157	end
158
159	execute_count	8,816✔
160	end
161
162	def with_pre_post_query(options = {})	36✔
163	out = options[:out] \|\| $stdout	8,864✔
164
165	if (pre_query = @options[:pre_query])	8,864✔
166	if options[:noop]	24✔
167	out.puts(pre_query)	×
168	else
169	ActiveRecord::Base.connection.execute(pre_query)	24✔
170	end
171	end
172
173	retval = yield	8,864✔
174
175	if (post_query = @options[:post_query])	8,816✔
176	if options[:noop]	24✔
177	out.puts(post_query)	×
178	else
179	ActiveRecord::Base.connection.execute(post_query)	24✔
180	end
181	end
182
183	retval	8,816✔
184	end
185
186	def raise_exception(script, org)	36✔
187	lines = script.each_line	48✔
188	digit_number = (lines.count + 1).to_s.length	48✔
189	err_num = detect_error_line(org)	48✔
190
191	errmsg = lines.with_index.map do \|l, i\|	48✔
192	line_num = i + 1	1,704✔
193	prefix = line_num == err_num ? '* ' : ' '	1,704✔
194	format("#{prefix}%*d: #{l}", digit_number, line_num)	1,704✔
195	end
196
197	if err_num > 0	48✔
198	from = err_num - 6	48✔
199	from = 0 if from < 0	48✔
200	to = err_num + 4	48✔
201	errmsg = errmsg.slice(from..to)	48✔
202	end
203
204	e = RuntimeError.new(org.message + "\n" + errmsg.join)	48✔
205	e.set_backtrace(org.backtrace)	48✔
206	raise e	48✔
207	end
208
209	def detect_error_line(exception)	36✔
210	rgx = /\A#{Regexp.escape(SCRIPT_NAME)}:(\d+):/	48✔
211	line = exception.backtrace.find { \|i\| i =~ rgx }	888✔
212
213	if line && (m = rgx.match(line))	48✔
214	m[1].to_i	48✔
215	else
216	0	×
217	end
218	end
219
220	def append_create_table(table_name, attrs, buf, post_buf_for_fk)	36✔
221	options = attrs[:options] \|\| {}	16,028✔
222	definition = attrs[:definition] \|\| {}	16,028✔
223	indices = attrs[:indices] \|\| {}	16,028✔
224
225	buf.puts(<<-RUBY)	16,028✔
226	create_table(#{table_name.inspect}, #{inspect_options_include_default_proc(options)}) do \|t\|
227	RUBY
228
229	definition.each do \|column_name, column_attrs\|	16,028✔
230	column_type = column_attrs.fetch(:type)	47,748✔
231	column_options = column_attrs[:options] \|\| {}	47,748✔
232	normalize_limit(column_type, column_options)	47,748✔
233
234	buf.puts(<<-RUBY)	47,748✔
235	t.column(#{column_name.inspect}, :#{column_type.to_s.inspect}, #{inspect_options_include_default_proc(column_options)})
236	RUBY
237	end
238
239	if @options[:create_table_with_index] && !indices.empty?	16,028✔
240	indices.each do \|index_name, index_attrs\|	120✔
241	append_add_index(table_name, index_name, index_attrs, buf, true)	240✔
242	end
243	end
244
245	buf.puts(<<-RUBY)	16,028✔
246	end
247	RUBY
248
249	if !(@options[:create_table_with_index]) && !indices.empty?	16,028✔
250	append_change_table(table_name, buf) do	10,828✔
251	indices.each do \|index_name, index_attrs\|	10,828✔
252	append_add_index(table_name, index_name, index_attrs, buf)	13,556✔
253	end
254	end
255	end
256
257	unless (foreign_keys = attrs[:foreign_keys] \|\| {}).empty?	16,028✔
258	foreign_keys.each do \|_, foreign_key_attrs\|	756✔
259	append_add_foreign_key(table_name, foreign_key_attrs, post_buf_for_fk, @options)	756✔
260	end
261	end
262
263	buf.puts	16,028✔
264	post_buf_for_fk.puts	16,028✔
265	end
266
267	def append_rename_table(to_table_name, from_table_name, buf)	36✔
268	buf.puts(<<-RUBY)	240✔
269	rename_table(#{from_table_name.inspect}, #{to_table_name.inspect})
270	RUBY
271
272	buf.puts	240✔
273	end
274
275	def append_drop_table(table_name, _attrs, buf)	36✔
276	buf.puts(<<-RUBY)	960✔
277	drop_table(#{table_name.inspect})
278	RUBY
279
280	buf.puts	960✔
281	end
282
283	def append_change_table_options(table_name, table_options, buf)	36✔
284	# XXX: MySQL only
285	buf.puts(<<-RUBY)	96✔
286	execute "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{table_options}"
287	RUBY
288
289	buf.puts	96✔
290	end
291
292	def append_change_table_comment(table_name, table_comment, buf)	36✔
293	comment_literal = "COMMENT=#{ActiveRecord::Base.connection.quote(table_comment)}"	48✔
294	append_change_table_options(table_name, comment_literal, buf)	48✔
295	end
296
297	def append_change(table_name, attrs, buf, pre_buf_for_fk, post_buf_for_fk)	36✔
298	definition = attrs[:definition] \|\| {}	10,392✔
299	primary_key_definition = attrs[:primary_key_definition] \|\| {}	10,392✔
300	indices = attrs[:indices] \|\| {}	10,392✔
301	foreign_keys = attrs[:foreign_keys] \|\| {}	10,392✔
302	table_options = attrs[:table_options]	10,392✔
303	table_comment = attrs[:table_comment]	10,392✔
304
305	if !definition.empty? \|\| !indices.empty? \|\| !primary_key_definition.empty?	10,392✔
306	append_change_table(table_name, buf) do	8,828✔
307	append_delete_indices(table_name, indices, buf)	8,828✔
308	append_change_definition(table_name, definition, buf)	8,828✔
309	append_change_definition(table_name, primary_key_definition, buf)	8,828✔
310	append_add_indices(table_name, indices, buf)	8,828✔
311	end
312	end
313
314	unless foreign_keys.empty?	10,392✔
315	append_change_foreign_keys(table_name, foreign_keys, pre_buf_for_fk, post_buf_for_fk, @options)	1,580✔
316	end
317
318	append_change_table_options(table_name, table_options, buf) if table_options	10,392✔
319
320	append_change_table_comment(table_name, table_comment, buf) if table_comment	10,392✔
321
322	buf.puts	10,392✔
323	pre_buf_for_fk.puts	10,392✔
324	post_buf_for_fk.puts	10,392✔
325	end
326
327	def append_change_table(table_name, buf)	36✔
328	buf.puts "change_table(#{table_name.inspect}, {:bulk => true}) do \|t\|" if @options[:bulk_change]	19,656✔
329	yield	19,656✔
330	buf.puts 'end' if @options[:bulk_change]	19,656✔
331	end
332
333	def append_change_definition(table_name, delta, buf)	36✔
334	(delta[:add] \|\| {}).each do \|column_name, attrs\|	17,656✔
335	append_add_column(table_name, column_name, attrs, buf)	3,220✔
336	end
337
338	(delta[:rename] \|\| {}).each do \|column_name, attrs\|	17,656✔
339	append_rename_column(table_name, column_name, attrs, buf)	480✔
340	end
341
342	(delta[:change] \|\| {}).each do \|column_name, attrs\|	17,656✔
343	append_change_column(table_name, column_name, attrs, buf)	2,664✔
344	end
345
346	(delta[:delete] \|\| {}).each do \|column_name, attrs\|	17,656✔
347	append_remove_column(table_name, column_name, attrs, buf)	5,040✔
348	end
349	end
350
351	def append_add_column(table_name, column_name, attrs, buf)	36✔
352	type = attrs.fetch(:type)	3,220✔
353	options = attrs[:options] \|\| {}	3,220✔
354	normalize_limit(type, options)	3,220✔
355
356	if @options[:bulk_change]	3,220✔
357	buf.puts(<<-RUBY)	324✔
358	t.column(#{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
359	RUBY
360	else
361	buf.puts(<<-RUBY)	2,896✔
362	add_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
363	RUBY
364	end
365	end
366
367	def append_rename_column(table_name, to_column_name, from_column_name, buf)	36✔
368	if @options[:bulk_change]	480✔
369	buf.puts(<<-RUBY)	288✔
370	t.rename(#{from_column_name.inspect}, #{to_column_name.inspect})
371	RUBY
372	else
373	buf.puts(<<-RUBY)	192✔
374	rename_column(#{table_name.inspect}, #{from_column_name.inspect}, #{to_column_name.inspect})
375	RUBY
376	end
377	end
378
379	def append_change_column(table_name, column_name, attrs, buf)	36✔
380	type = attrs.fetch(:type)	2,664✔
381	options = attrs[:options] \|\| {}	2,664✔
382
383	# Fix for https://github.com/rails/rails/commit/7f0567b43b73b1bd1a16bfac9cd32fcbf1321b51
384	if Ridgepole::ConnectionAdapters.mysql? && ActiveRecord::VERSION::STRING !~ /\A5\.0\./	2,664✔
385	options[:comment] = nil unless options.key?(:comment)	1,632✔
386	end
387
388	if @options[:bulk_change]	2,664✔
389	buf.puts(<<-RUBY)	288✔
390	t.change(#{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
391	RUBY
392	else
393	buf.puts(<<-RUBY)	2,376✔
394	change_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{inspect_options_include_default_proc(options)})
395	RUBY
396	end
397	end
398
399	def append_remove_column(table_name, column_name, _attrs, buf)	36✔
400	if @options[:bulk_change]	5,040✔
401	buf.puts(<<-RUBY)	1,764✔
402	t.remove(#{column_name.inspect})
403	RUBY
404	else
405	buf.puts(<<-RUBY)	3,276✔
406	remove_column(#{table_name.inspect}, #{column_name.inspect})
407	RUBY
408	end
409	end
410
411	def append_add_indices(table_name, delta, buf)	36✔
412	(delta[:add] \|\| {}).each do \|index_name, attrs\|	8,828✔
413	append_add_index(table_name, index_name, attrs, buf)	2,488✔
414	end
415	end
416
417	def append_delete_indices(table_name, delta, buf)	36✔
418	(delta[:delete] \|\| {}).each do \|index_name, attrs\|	8,828✔
419	append_remove_index(table_name, index_name, attrs, buf)	1,980✔
420	end
421	end
422
423	def append_add_index(table_name, _index_name, attrs, buf, force_bulk_change = false)	36✔
424	column_name = attrs.fetch(:column_name)	16,284✔
425	options = attrs[:options] \|\| {}	16,284✔
426
427	if force_bulk_change \|\| @options[:bulk_change]	16,284✔
428	buf.puts(<<-RUBY)	1,248✔
429	t.index(#{column_name.inspect}, #{options.inspect})
430	RUBY
431	else
432	buf.puts(<<-RUBY)	15,036✔
433	add_index(#{table_name.inspect}, #{column_name.inspect}, #{options.inspect})
434	RUBY
435	end
436	end
437
438	def append_remove_index(table_name, _index_name, attrs, buf)	36✔
439	column_name = attrs.fetch(:column_name)	1,980✔
440	options = attrs[:options] \|\| {}	1,980✔
441	target = options[:name] ? { name: options[:name] } : column_name	1,980✔
442
443	if @options[:bulk_change]	1,980✔
444	buf.puts(<<-RUBY)	648✔
445	t.remove_index(#{target.inspect})
446	RUBY
447	else
448	buf.puts(<<-RUBY)	1,332✔
449	remove_index(#{table_name.inspect}, #{target.inspect})
450	RUBY
451	end
452	end
453
454	def append_change_foreign_keys(table_name, delta, pre_buf_for_fk, post_buf_for_fk, options)	36✔
455	(delta[:delete] \|\| {}).each do \|_, attrs\|	1,580✔
456	append_remove_foreign_key(table_name, attrs, pre_buf_for_fk, options)	1,040✔
457	end
458
459	(delta[:add] \|\| {}).each do \|_, attrs\|	1,580✔
460	append_add_foreign_key(table_name, attrs, post_buf_for_fk, options)	876✔
461	end
462	end
463
464	def append_add_foreign_key(table_name, attrs, buf, _options)	36✔
465	to_table = attrs.fetch(:to_table)	1,632✔
466	attrs_options = attrs[:options] \|\| {}	1,632✔
467
468	buf.puts(<<-RUBY)	1,632✔
469	add_foreign_key(#{table_name.inspect}, #{to_table.inspect}, #{attrs_options.inspect})
470	RUBY
471	end
472
473	def append_remove_foreign_key(table_name, attrs, buf, _options)	36✔
474	attrs_options = attrs[:options] \|\| {}	1,040✔
475	fk_name = attrs_options[:name]	1,040✔
476
477	target = if fk_name	1,040✔
478	{ name: fk_name }	656✔
479	else
480	attrs.fetch(:to_table)	384✔
481	end
482
483	buf.puts(<<-RUBY)	1,040✔
484	remove_foreign_key(#{table_name.inspect}, #{target.inspect})
485	RUBY
486	end
487
488	def delta_execute	36✔
489	@delta[:execute] \|\| []	1,168✔
490	end
491
492	def normalize_limit(column_type, column_options)	36✔
493	default_limit = Ridgepole::DefaultsLimit.default_limit(column_type, @options)	50,968✔
494	column_options[:limit] \|\|= default_limit if default_limit	50,968✔
495	end
496
497	def inspect_options_include_default_proc(options)	36✔
498	options = options.dup	69,660✔
499
500	if options[:default].is_a?(Proc)	69,660✔
501	proc_default = options.delete(:default)	312✔
502	proc_default = ":default=>proc{#{proc_default.call.inspect}}"	312✔
503	options_inspect = options.inspect	312✔
504	options_inspect.sub!(/\}\z/, '')	312✔
505	options_inspect << ', ' if options_inspect !~ /\{\z/	312✔
506	options_inspect << proc_default << '}'	312✔
507	options_inspect	312✔
508	else
509	options.inspect	69,348✔
510	end
511	end
512	end
513	end

winebarrel / ridgepole / 1147

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous