rubocop 0.29.1 → 0.30.0

data/spec/rubocop/cop/style/multiline_block_layout_spec.rb

@@ -1,199 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::MultilineBlockLayout do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for missing newline in do/end block w/o params' do
-    inspect_source(cop,
-                   ['test do foo',
-                    'end'
-                   ])
-    expect(cop.messages)
-      .to eq(['Block body expression is on the same line as the block start.'])
-  end
-
-  it 'registers an offense for missing newline in {} block w/o params' do
-    inspect_source(cop,
-                   ['test { foo',
-                    '}'
-                   ])
-    expect(cop.messages)
-      .to eq(['Block body expression is on the same line as the block start.'])
-  end
-
-  it 'registers an offense for missing newline in do/end block with params' do
-    inspect_source(cop,
-                   ['test do |x| foo',
-                    'end'
-                   ])
-    expect(cop.messages)
-      .to eq(['Block body expression is on the same line as the block start.'])
-  end
-
-  it 'registers an offense for missing newline in {} block with params' do
-    inspect_source(cop,
-                   ['test { |x| foo',
-                    '}'
-                   ])
-    expect(cop.messages)
-      .to eq(['Block body expression is on the same line as the block start.'])
-  end
-
-  it 'does not register an offense for one-line do/end blocks' do
-    inspect_source(cop, 'test do foo end')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for one-line {} blocks' do
-    inspect_source(cop, 'test { foo }')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register offenses when there is a newline for do/end block' do
-    inspect_source(cop,
-                   ['test do',
-                    '  foo',
-                    'end'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not error out when the block is empty' do
-    inspect_source(cop,
-                   ['test do |x|',
-                    'end'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register offenses when there is a newline for {} block' do
-    inspect_source(cop,
-                   ['test {',
-                    '  foo',
-                    '}'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers offenses for lambdas as expected' do
-    inspect_source(cop,
-                   ['-> (x) do foo',
-                    '  bar',
-                    'end'
-                   ])
-    expect(cop.messages)
-      .to eq(['Block body expression is on the same line as the block start.'])
-  end
-
-  it 'registers an offense for line-break before arguments' do
-    inspect_source(cop,
-                   ['test do',
-                    '  |x| play_with(x)',
-                    'end'])
-    expect(cop.messages)
-      .to eq(['Block argument expression is not on the same line as the ' \
-              'block start.'])
-  end
-
-  it 'registers an offense for line-break before arguments with empty block' do
-    inspect_source(cop,
-                   ['test do',
-                    '  |x|',
-                    'end'])
-    expect(cop.messages)
-      .to eq(['Block argument expression is not on the same line as the ' \
-              'block start.'])
-  end
-
-  it 'registers an offense for line-break within arguments' do
-    inspect_source(cop,
-                   ['test do |x,',
-                    '  y|',
-                    'end'])
-    expect(cop.messages)
-      .to eq(['Block argument expression is not on the same line as the ' \
-              'block start.'])
-  end
-
-  it 'auto-corrects a do/end block with params that is missing newlines' do
-    src = ['test do |foo| bar',
-           'end']
-
-    new_source = autocorrect_source(cop, src)
-
-    expect(new_source).to eq(['test do |foo| ',
-                              '  bar',
-                              'end'].join("\n"))
-  end
-
-  it 'auto-corrects a do/end block with a mult-line body' do
-    src = ['test do |foo| bar',
-           '  test',
-           'end']
-
-    new_source = autocorrect_source(cop, src)
-
-    expect(new_source).to eq(['test do |foo| ',
-                              '  bar',
-                              '  test',
-                              'end'].join("\n"))
-  end
-
-  it 'auto-corrects a {} block with params that is missing newlines' do
-    src = ['test { |foo| bar',
-           '}']
-
-    new_source = autocorrect_source(cop, src)
-
-    expect(new_source).to eq(['test { |foo| ',
-                              '  bar',
-                              '}'].join("\n"))
-  end
-
-  it 'autocorrects in more complex case with lambda and assignment, and '\
-     'aligns the next line two spaces out from the start of the block' do
-    src = ['x = -> (y) { foo',
-           '  bar',
-           '}']
-
-    new_source = autocorrect_source(cop, src)
-
-    expect(new_source).to eq(['x = -> (y) { ',
-                              '      foo',
-                              '  bar',
-                              '}'].join("\n"))
-  end
-
-  it 'auto-corrects a line-break before arguments' do
-    new_source = autocorrect_source(cop,
-                                    ['test do',
-                                     '  |x| play_with(x)',
-                                     'end'])
-
-    expect(new_source).to eq(['test do |x|',
-                              '  play_with(x)',
-                              'end'].join("\n"))
-  end
-
-  it 'auto-corrects a line-break before arguments with empty block' do
-    new_source = autocorrect_source(cop,
-                                    ['test do',
-                                     '  |x|',
-                                     'end'])
-
-    expect(new_source).to eq(['test do |x|',
-                              'end'].join("\n"))
-  end
-
-  it 'auto-corrects a line-break within arguments' do
-    new_source = autocorrect_source(cop,
-                                    ['test do |x,',
-                                     '  y| play_with(x, y)',
-                                     'end'])
-    expect(new_source).to eq(['test do |x, y|',
-                              '  play_with(x, y)',
-                              'end'].join("\n"))
-  end
-end

data/spec/rubocop/cop/style/multiline_if_then_spec.rb

@@ -1,134 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::MultilineIfThen do
-  subject(:cop) { described_class.new }
-
-  # if
-
-  it 'does not get confused by empty elsif branch' do
-    inspect_source(cop, ['if cond',
-                         'elsif cond',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for then in multiline if' do
-    inspect_source(cop, ['if cond then',
-                         'end',
-                         "if cond then\t",
-                         'end',
-                         'if cond then  ',
-                         'end',
-                         'if cond',
-                         'then',
-                         'end',
-                         'if cond then # bad',
-                         'end'])
-    expect(cop.offenses.map(&:line)).to eq([1, 3, 5, 8, 10])
-    expect(cop.highlights).to eq(['then'] * 5)
-    expect(cop.messages).to eq(['Do not use `then` for multi-line `if`.'] * 5)
-  end
-
-  it 'registers an offense for then in multiline elsif' do
-    inspect_source(cop, ['if cond1',
-                         '  a',
-                         'elsif cond2 then',
-                         '  b',
-                         'end'])
-    expect(cop.offenses.map(&:line)).to eq([3])
-    expect(cop.highlights).to eq(['then'])
-    expect(cop.messages).to eq(['Do not use `then` for multi-line `elsif`.'])
-  end
-
-  it 'accepts multiline if without then' do
-    inspect_source(cop, ['if cond',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts table style if/then/elsif/ends' do
-    inspect_source(cop,
-                   ['if    @io == $stdout then str << "$stdout"',
-                    'elsif @io == $stdin  then str << "$stdin"',
-                    'elsif @io == $stderr then str << "$stderr"',
-                    'else                      str << @io.class.to_s',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not get confused by a then in a when' do
-    inspect_source(cop,
-                   ['if a',
-                    '  case b',
-                    '  when c then',
-                    '  end',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not get confused by a commented-out then' do
-    inspect_source(cop,
-                   ['if a # then',
-                    '  b',
-                    'end',
-                    'if c # then',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not raise an error for an implicit match if' do
-    expect do
-      inspect_source(cop,
-                     ['if //',
-                      'end'])
-    end.not_to raise_error
-  end
-
-  # unless
-
-  it 'registers an offense for then in multiline unless' do
-    inspect_source(cop, ['unless cond then',
-                         'end'])
-    expect(cop.messages).to eq(
-      ['Do not use `then` for multi-line `unless`.'])
-  end
-
-  it 'accepts multiline unless without then' do
-    inspect_source(cop, ['unless cond',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not get confused by a postfix unless' do
-    inspect_source(cop, 'two unless one')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not get confused by a nested postfix unless' do
-    inspect_source(cop,
-                   ['if two',
-                    '  puts 1',
-                    'end unless two'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not raise an error for an implicit match unless' do
-    expect do
-      inspect_source(cop,
-                     ['unless //',
-                      'end'])
-    end.not_to raise_error
-  end
-
-  it 'auto-corrects the usage of "then" in multiline if' do
-    new_source = autocorrect_source(cop, ['if cond then',
-                                          '  something',
-                                          'end'])
-    expect(new_source).to eq(['if cond',
-                              '  something',
-                              'end'].join("\n"))
-  end
-end

data/spec/rubocop/cop/style/multiline_operation_indentation_spec.rb

@@ -1,464 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::MultilineOperationIndentation do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    merged = RuboCop::ConfigLoader
-             .default_configuration['Style/MultilineOperationIndentation']
-             .merge(cop_config)
-    RuboCop::Config
-      .new('Style/MultilineOperationIndentation' => merged,
-           'Style/IndentationWidth' => { 'Width' => indentation_width })
-  end
-  let(:indentation_width) { 2 }
-
-  shared_examples 'common' do
-    it 'accepts indented operands in ordinary statement' do
-      inspect_source(cop,
-                     ['a +',
-                      '  b'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers an offense for no indentation of second line' do
-      inspect_source(cop,
-                     ['a +',
-                      'b'])
-      expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(['b'])
-    end
-
-    it 'registers an offense for one space indentation of second line' do
-      inspect_source(cop,
-                     ['a',
-                      ' .b'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(['.b'])
-    end
-
-    it 'registers an offense for proc call without a selector' do
-      inspect_source(cop,
-                     ['a',
-                      ' .(args)'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(['.('])
-    end
-
-    it 'registers an offense for three spaces indentation of second line' do
-      inspect_source(cop,
-                     ['a ||',
-                      '   b',
-                      'c and',
-                      '   d'])
-      expect(cop.messages).to eq(['Use 2 (not 3) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'] * 2)
-      expect(cop.highlights).to eq(%w(b d))
-    end
-
-    it 'registers an offense for extra indentation of third line' do
-      inspect_source(cop,
-                     ['   a ||',
-                      '     b ||',
-                      '       c'])
-      expect(cop.messages).to eq(['Use 2 (not 4) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(['c'])
-    end
-
-    it 'registers an offense for the emacs ruby-mode 1.1 indentation of an ' \
-       'expression in an array' do
-      inspect_source(cop,
-                     ['  [',
-                      '   a +',
-                      '   b',
-                      '  ]'])
-      expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(['b'])
-    end
-
-    it 'accepts two spaces indentation of second line' do
-      inspect_source(cop,
-                     ['   a ||',
-                      '     b'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts no extra indentation of third line' do
-      inspect_source(cop,
-                     ['   a &&',
-                      '     b &&',
-                      '     c'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts indented operands in for body' do
-      inspect_source(cop,
-                     ['for x in a',
-                      '  something &&',
-                      '    something_else',
-                      'end'])
-      expect(cop.highlights).to be_empty
-    end
-
-    it 'accepts alignment inside a grouped expression' do
-      inspect_source(cop,
-                     ['(a +',
-                      ' b)'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts an expression where the first operand spans multiple lines' do
-      inspect_source(cop,
-                     ['subject.each do |item|',
-                      '  result = resolve(locale) and return result',
-                      'end and nil'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers an offense for badly indented operands in chained ' \
-       'method call' do
-      inspect_source(cop,
-                     ['Foo',
-                      '.a',
-                      '  .b'])
-      expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(['.a'])
-    end
-
-    it 'registers an offense for badly indented operands in chained ' \
-       'method call' do
-      inspect_source(cop,
-                     ['Foo',
-                      '.a',
-                      '  .b(c)'])
-      expect(cop.messages).to eq(['Use 2 (not 0) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(['.a'])
-    end
-
-    it 'accepts even indentation of consecutive lines in typical RSpec code' do
-      inspect_source(cop,
-                     ['expect { Foo.new }.',
-                      '  to change { Bar.count }.',
-                      '  from(1).to(2)'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts any indentation of parameters to #[]' do
-      inspect_source(cop,
-                     ['payment = Models::IncomingPayments[',
-                      "        id:      input['incoming-payment-id'],",
-                      '           user_id: @user[:id]]'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers an offense for extra indentation of 3rd line in typical ' \
-       'RSpec code' do
-      inspect_source(cop,
-                     ['expect { Foo.new }.',
-                      '  to change { Bar.count }.',
-                      '      from(1).to(2)'])
-      expect(cop.messages).to eq(['Use 2 (not 6) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-    end
-  end
-
-  context 'when EnforcedStyle is aligned' do
-    let(:cop_config) { { 'EnforcedStyle' => 'aligned' } }
-
-    include_examples 'common'
-
-    it 'accepts aligned operands in if condition' do
-      inspect_source(cop,
-                     ['if a +',
-                      '   b',
-                      '  something',
-                      'end'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers an offense for misaligned operands in if condition' do
-      inspect_source(cop,
-                     ['if a +',
-                      '    b',
-                      '  something',
-                      'end'])
-      expect(cop.messages).to eq(['Align the operands of a condition in an ' \
-                                  '`if` statement spanning multiple lines.'])
-      expect(cop.highlights).to eq(['b'])
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'indented')
-    end
-
-    it 'registers an offense for misaligned string operand when the first ' \
-       'operand has backslash continuation' do
-      inspect_source(cop,
-                     ["flash[:error] = 'Here is a string ' \\",
-                      "                'That spans' <<",
-                      "  'multiple lines'"])
-      expect(cop.messages).to eq(['Align the operands of an expression in an ' \
-                                  'assignment spanning multiple lines.'])
-      expect(cop.highlights).to eq(["'multiple lines'"])
-    end
-
-    it 'registers an offense for misaligned string operand when plus is used' do
-      inspect_source(cop,
-                     ["flash[:error] = 'Here is a string ' +",
-                      "                'That spans' <<",
-                      "  'multiple lines'"])
-      expect(cop.messages).to eq(['Align the operands of an expression in an ' \
-                                  'assignment spanning multiple lines.'])
-      expect(cop.highlights).to eq(["'multiple lines'"])
-    end
-
-    it 'registers an offense for misaligned operands in unless condition' do
-      inspect_source(cop,
-                     ['unless a',
-                      '  .b',
-                      '  something',
-                      'end'])
-      expect(cop.messages).to eq(['Align the operands of a condition in an ' \
-                                  '`unless` statement spanning multiple ' \
-                                  'lines.'])
-      expect(cop.highlights).to eq(['.b'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for misaligned operands in while condition' do
-      inspect_source(cop,
-                     ['while a.',
-                      '    b',
-                      '  something',
-                      'end'])
-      expect(cop.messages).to eq(['Align the operands of a condition in a ' \
-                                  '`while` statement spanning multiple lines.'])
-      expect(cop.highlights).to eq(['b'])
-    end
-
-    it 'registers an offense for misaligned operands in until condition' do
-      inspect_source(cop,
-                     ['until a.',
-                      '    b',
-                      '  something',
-                      'end'])
-      expect(cop.messages).to eq(['Align the operands of a condition in an ' \
-                                  '`until` statement spanning multiple lines.'])
-      expect(cop.highlights).to eq(['b'])
-    end
-
-    it 'accepts aligned operands in assignment' do
-      inspect_source(cop,
-                     ['formatted_int = int_part',
-                      '                .to_s',
-                      '                .reverse',
-                      "                .gsub(/...(?=.)/, '\&_')"])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers an offense for unaligned operands in assignment' do
-      inspect_source(cop,
-                     ['bar = Foo',
-                      '  .a',
-                      '      .b(c)'])
-      expect(cop.messages).to eq(['Align the operands of an expression in an ' \
-                                  'assignment spanning multiple lines.'])
-      expect(cop.highlights).to eq(['.a'])
-    end
-
-    it 'auto-corrects' do
-      new_source = autocorrect_source(cop, ['until a.',
-                                            '    b',
-                                            '  something',
-                                            'end'])
-      expect(new_source).to eq(['until a.',
-                                '      b',
-                                '  something',
-                                'end'].join("\n"))
-    end
-  end
-
-  context 'when EnforcedStyle is indented' do
-    let(:cop_config) { { 'EnforcedStyle' => 'indented' } }
-
-    include_examples 'common'
-
-    it 'accepts indented operands in if condition' do
-      inspect_source(cop,
-                     ['if a +',
-                      '    b',
-                      '  something',
-                      'end'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers an offense for aligned operands in if condition' do
-      inspect_source(cop,
-                     ['if a +',
-                      '   b',
-                      '  something',
-                      'end'])
-      expect(cop.messages).to eq(['Use 4 (not 3) spaces for indenting a ' \
-                                  'condition in an `if` statement spanning ' \
-                                  'multiple lines.'])
-      expect(cop.highlights).to eq(['b'])
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'aligned')
-    end
-
-    it 'accepts the indentation of a broken string' do
-      inspect_source(cop,
-                     ["MSG = 'Use 2 (not %d) spaces for indenting a ' \\",
-                      "      'broken line.'"])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts normal indentation of method parameters' do
-      inspect_source(cop,
-                     ['Parser::Source::Range.new(expr.source_buffer,',
-                      '                          begin_pos,',
-                      '                          begin_pos + line.length)'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts any indentation of method parameters' do
-      inspect_source(cop,
-                     ['a(b.',
-                      '    c',
-                      '.d)'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts normal indentation inside grouped expression' do
-      inspect_source(cop,
-                     ['arg_array.size == a.size && (',
-                      '  arg_array == a ||',
-                      '  arg_array.map(&:children) == a.map(&:children)',
-                      ')'])
-      expect(cop.messages).to be_empty
-    end
-
-    [
-      %w(an if),
-      %w(an unless),
-      %w(a while),
-      %w(an until)
-    ].each do |article, keyword|
-      it "accepts double indentation of #{keyword} condition" do
-        inspect_source(cop,
-                       ["#{keyword} receiver.nil? &&",
-                        '    !args.empty? &&',
-                        '    BLACKLIST.include?(method_name)',
-                        'end',
-                        "#{keyword} receiver.",
-                        '    nil?',
-                        'end'])
-        expect(cop.messages).to be_empty
-      end
-
-      it "registers an offense for a 2 space indentation of #{keyword} " \
-         'condition' do
-        inspect_source(cop,
-                       ["#{keyword} receiver.nil? &&",
-                        '  !args.empty? &&',
-                        '  BLACKLIST.include?(method_name)',
-                        'end',
-                        "#{keyword} receiver.",
-                        '  nil?',
-                        'end'])
-        expect(cop.highlights).to eq(['!args.empty?',
-                                      'BLACKLIST.include?(method_name)',
-                                      'nil?'])
-        expect(cop.messages).to eq(['Use 4 (not 2) spaces for indenting a ' \
-                                    "condition in #{article} `#{keyword}` " \
-                                    'statement spanning multiple lines.'] * 3)
-      end
-
-      it "accepts indented operands in #{keyword} body" do
-        inspect_source(cop,
-                       ["#{keyword} a",
-                        '  something &&',
-                        '    something_else',
-                        'end'])
-        expect(cop.highlights).to be_empty
-      end
-    end
-
-    %w(unless if).each do |keyword|
-      it "accepts special indentation of return #{keyword} condition" do
-        inspect_source(cop,
-                       ["return #{keyword} receiver.nil? &&",
-                        '    !args.empty? &&',
-                        '    BLACKLIST.include?(method_name)'])
-        expect(cop.messages).to be_empty
-      end
-    end
-
-    it 'registers an offense for wrong indentation of for expression' do
-      inspect_source(cop,
-                     ['for n in a +',
-                      '  b',
-                      'end'])
-      expect(cop.messages).to eq(['Use 4 (not 2) spaces for indenting a ' \
-                                  'collection in a `for` statement spanning ' \
-                                  'multiple lines.'])
-      expect(cop.highlights).to eq(['b'])
-    end
-
-    it 'accepts special indentation of for expression' do
-      inspect_source(cop,
-                     ['for n in a +',
-                      '    b',
-                      'end'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts indentation of assignment' do
-      inspect_source(cop,
-                     ['formatted_int = int_part',
-                      '  .abs',
-                      '  .to_s',
-                      '  .reverse',
-                      "  .gsub(/...(?=.)/, '\&_')",
-                      '  .reverse'])
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers an offense for correct + unrecognized style' do
-      inspect_source(cop,
-                     ['a ||',
-                      '  b',
-                      'c and',
-                      '    d'])
-      expect(cop.messages).to eq(['Use 2 (not 4) spaces for indenting an ' \
-                                  'expression spanning multiple lines.'])
-      expect(cop.highlights).to eq(%w(d))
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for aligned operators in assignment' do
-      inspect_source(cop,
-                     ['formatted_int = int_part',
-                      '                .abs',
-                      '                .reverse'])
-      expect(cop.messages).to eq(['Use 2 (not 16) spaces for indenting an ' \
-                                  'expression in an assignment spanning ' \
-                                  'multiple lines.'] * 2)
-    end
-
-    it 'auto-corrects' do
-      new_source = autocorrect_source(cop, ['until a.',
-                                            '      b',
-                                            '  something',
-                                            'end'])
-      expect(new_source).to eq(['until a.',
-                                '    b',
-                                '  something',
-                                'end'].join("\n"))
-    end
-  end
-end