rubocop 0.26.1 → 0.27.0

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::EmptyLinesAroundClassBody, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when EnforcedStyle is no_empty_lines' do
+    let(:cop_config) { { 'EnforcedStyle' => 'no_empty_lines' } }
+
+    it 'registers an offense for class body starting with a blank' do
+      inspect_source(cop,
+                     ['class SomeClass',
+                      '',
+                      '  do_something',
+                      'end'])
+      expect(cop.messages)
+        .to eq(['Extra empty line detected at class body beginning.'])
+    end
+
+    it 'autocorrects class body containing only a blank' do
+      corrected = autocorrect_source(cop,
+                                     ['class SomeClass',
+                                      '',
+                                      'end'])
+      expect(corrected).to eq ['class SomeClass',
+                               'end'].join("\n")
+    end
+
+    it 'registers an offense for class body ending with a blank' do
+      inspect_source(cop,
+                     ['class SomeClass',
+                      '  do_something',
+                      '',
+                      'end'])
+      expect(cop.messages)
+        .to eq(['Extra empty line detected at class body end.'])
+    end
+  end
+
+  context 'when EnforcedStyle is empty_lines' do
+    let(:cop_config) { { 'EnforcedStyle' => 'empty_lines' } }
+
+    it 'registers an offense for class body not starting or ending with a ' \
+       'blank' do
+      inspect_source(cop,
+                     ['class SomeClass',
+                      '  do_something',
+                      'end'])
+      expect(cop.messages).to eq(['Empty line missing at class body beginning.',
+                                  'Empty line missing at class body end.'])
+    end
+
+    it 'autocorrects class body containing nothing' do
+      corrected = autocorrect_source(cop,
+                                     ['class SomeClass',
+                                      'end'])
+      expect(corrected).to eq ['class SomeClass',
+                               '',
+                               'end'].join("\n")
+    end
+
+    it 'autocorrects beginning and end' do
+      new_source = autocorrect_source(cop,
+                                      ['class SomeClass',
+                                       '  do_something',
+                                       'end'])
+      expect(new_source).to eq(['class SomeClass',
+                                '',
+                                '  do_something',
+                                '',
+                                'end'].join("\n"))
+    end
+  end
+end

data/spec/rubocop/cop/style/{empty_lines_around_body_spec.rb → empty_lines_around_method_body_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe RuboCop::Cop::Style::EmptyLinesAroundBody do
+describe RuboCop::Cop::Style::EmptyLinesAroundMethodBody do
   subject(:cop) { described_class.new }
 
   it 'registers an offense for method body starting with a blank' do
@@ -11,7 +11,8 @@ describe RuboCop::Cop::Style::EmptyLinesAroundBody do
                     '',
                     '  do_something',
                     'end'])
-    expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Extra empty line detected at method body beginning.'])
   end
 
   # The cop only registers an offense if the extra line is completely emtpy. If
@@ -44,7 +45,8 @@ describe RuboCop::Cop::Style::EmptyLinesAroundBody do
                     '',
                     '  do_something',
                     'end'])
-    expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Extra empty line detected at method body beginning.'])
   end
 
   it 'autocorrects class method body starting with a blank' do
@@ -64,7 +66,8 @@ describe RuboCop::Cop::Style::EmptyLinesAroundBody do
                     '  do_something',
                     '',
                     'end'])
-    expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Extra empty line detected at method body end.'])
   end
 
   it 'registers an offense for class method body ending with a blank' do
@@ -73,52 +76,8 @@ describe RuboCop::Cop::Style::EmptyLinesAroundBody do
                     '  do_something',
                     '',
                     'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for class body starting with a blank' do
-    inspect_source(cop,
-                   ['class SomeClass',
-                    '',
-                    '  do_something',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'autocorrects class body containing only a blank' do
-    corrected = autocorrect_source(cop,
-                                   ['class SomeClass',
-                                    '',
-                                    'end'])
-    expect(corrected).to eq ['class SomeClass',
-                             'end'].join("\n")
-  end
-
-  it 'registers an offense for module body starting with a blank' do
-    inspect_source(cop,
-                   ['module SomeModule',
-                    '',
-                    '  do_something',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for class body ending with a blank' do
-    inspect_source(cop,
-                   ['class SomeClass',
-                    '  do_something',
-                    '',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for module body ending with a blank' do
-    inspect_source(cop,
-                   ['module SomeModule',
-                    '  do_something',
-                    '',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Extra empty line detected at method body end.'])
   end
 
   it 'is not fooled by single line methods' do

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::EmptyLinesAroundModuleBody, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when EnforcedStyle is no_empty_lines' do
+    let(:cop_config) { { 'EnforcedStyle' => 'no_empty_lines' } }
+
+    it 'registers an offense for module body starting with a blank' do
+      inspect_source(cop,
+                     ['module SomeModule',
+                      '',
+                      '  do_something',
+                      'end'])
+      expect(cop.messages)
+        .to eq(['Extra empty line detected at module body beginning.'])
+    end
+
+    it 'registers an offense for module body ending with a blank' do
+      inspect_source(cop,
+                     ['module SomeModule',
+                      '  do_something',
+                      '',
+                      'end'])
+      expect(cop.messages)
+        .to eq(['Extra empty line detected at module body end.'])
+    end
+
+    it 'autocorrects beginning and end' do
+      new_source = autocorrect_source(cop,
+                                      ['module SomeModule',
+                                       '',
+                                       '  do_something',
+                                       '',
+                                       'end'])
+      expect(new_source).to eq(['module SomeModule',
+                                '  do_something',
+                                'end'].join("\n"))
+    end
+  end
+
+  context 'when EnforcedStyle is empty_lines' do
+    let(:cop_config) { { 'EnforcedStyle' => 'empty_lines' } }
+
+    it 'registers an offense for module body not starting or ending with a ' \
+       'blank' do
+      inspect_source(cop,
+                     ['module SomeModule',
+                      '  do_something',
+                      'end'])
+      expect(cop.messages)
+        .to eq(['Empty line missing at module body beginning.',
+                'Empty line missing at module body end.'])
+    end
+
+    it 'registers an offense for module body not ending with a blank' do
+      inspect_source(cop,
+                     ['module SomeModule',
+                      '',
+                      '  do_something',
+                      'end'])
+      expect(cop.messages).to eq(['Empty line missing at module body end.'])
+    end
+
+    it 'autocorrects beginning and end' do
+      new_source = autocorrect_source(cop,
+                                      ['module SomeModule',
+                                       '  do_something',
+                                       'end'])
+      expect(new_source).to eq(['module SomeModule',
+                                '',
+                                '  do_something',
+                                '',
+                                'end'].join("\n"))
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ describe RuboCop::Cop::Style::FileName do
 
   before do
     allow(processed_source.buffer)
-    .to receive(:name).and_return(filename)
+      .to receive(:name).and_return(filename)
     _investigate(cop, processed_source)
   end
 

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

@@ -139,6 +139,18 @@ describe RuboCop::Cop::Style::FormatString, :config do
       expect(cop.offenses).to be_empty
     end
 
+    it 'accepts format without arguments' do
+      inspect_source(cop,
+                     ['format'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts sprintf without arguments' do
+      inspect_source(cop,
+                     ['sprintf'])
+      expect(cop.offenses).to be_empty
+    end
+
     it 'accepts String#%' do
       inspect_source(cop,
                      ['puts "%d" % 10'])

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

@@ -3,7 +3,12 @@
 require 'spec_helper'
 
 describe RuboCop::Cop::Style::IndentArray do
-  subject(:cop) { described_class.new }
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    RuboCop::Config
+      .new('Style/IndentationWidth' => { 'Width' => indentation_width })
+  end
+  let(:indentation_width) { 2 }
 
   it 'accepts multi-assignments' do
     inspect_source(cop, 'a, b = b, a')

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

@@ -10,7 +10,8 @@ describe RuboCop::Cop::Style::IndentHash do
     }
     RuboCop::Config.new('Style/AlignHash' => align_hash_config,
                         'Style/IndentHash' =>
-                        cop_config.merge(supported_styles))
+                        cop_config.merge(supported_styles),
+                        'Style/IndentationWidth' => { 'Width' => 2 })
   end
   let(:align_hash_config) do
     {

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

@@ -5,66 +5,25 @@ require 'spec_helper'
 describe RuboCop::Cop::Style::IndentationWidth do
   subject(:cop) { described_class.new(config) }
   let(:config) do
-    RuboCop::Config.new('Lint/EndAlignment' => end_alignment_config)
+    RuboCop::Config.new('Style/IndentationWidth' => cop_config,
+                        'Lint/EndAlignment' => end_alignment_config)
   end
   let(:end_alignment_config) do
     { 'Enabled' => true, 'AlignWith' => 'variable' }
   end
 
-  context 'with if statement' do
-    it 'registers an offense for bad indentation of an if body' do
-      inspect_source(cop,
-                     ['if cond',
-                      ' func',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-      expect(cop.highlights).to eq([' '])
-    end
-
-    it 'registers an offense for bad indentation of an else body' do
-      inspect_source(cop,
-                     ['if cond',
-                      '  func1',
-                      'else',
-                      ' func2',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-      expect(cop.highlights).to eq([' '])
-    end
-
-    it 'registers an offense for bad indentation of an elsif body' do
-      inspect_source(cop,
-                     ['if a1',
-                      '  b1',
-                      'elsif a2',
-                      ' b2',
-                      'else',
-                      '  c',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
-
-    it 'registers offense for bad indentation of ternary inside else' do
-      inspect_source(cop,
-                     ['if a',
-                      '  b',
-                      'else',
-                      '     x ? y : z',
-                      'end'])
-      expect(cop.messages)
-        .to eq(['Use 2 (not 5) spaces for indentation.'])
-      expect(cop.highlights).to eq(['     '])
-    end
-
-    it 'registers offense for bad indentation of modifier if in else' do
-      inspect_source(cop,
-                     ['if a',
-                      '  b',
-                      'else',
-                      '   x if y',
-                      'end'])
-      expect(cop.messages)
-        .to eq(['Use 2 (not 3) spaces for indentation.'])
+  context 'with Width set to 4' do
+    let(:cop_config) { { 'Width' => 4 } }
+
+    context 'with if statement' do
+      it 'registers an offense for bad indentation of an if body' do
+        inspect_source(cop,
+                       ['if cond',
+                        ' func',
+                        'end'])
+        expect(cop.messages).to eq(['Use 4 (not 1) spaces for indentation.'])
+        expect(cop.highlights).to eq([' '])
+      end
     end
 
     describe '#autocorrect' do
@@ -80,764 +39,848 @@ describe RuboCop::Cop::Style::IndentationWidth do
                                         'end'])
         expect(corrected)
           .to eq ['if a1',
-                  '  b1',
+                  '    b1',
                   '   b1', # Will be corrected by IndentationConsistency.
                   'elsif a2',
-                  '  b2',
+                  '    b2',
                   'else',
-                  '  c',
+                  '    c',
                   'end'].join("\n")
       end
+    end
+  end
 
-      it 'does not correct in scopes that contain block comments' do
-        corrected = autocorrect_source(cop,
-                                       ['module Foo',
-                                        'class Bar',
-                                        '=begin',
-                                        'This is a nice long',
-                                        'comment',
-                                        'which spans a few lines',
-                                        '=end',
-                                        'def baz',
-                                        'do_something',
-                                        'end',
-                                        'end',
-                                        'end'])
-        expect(corrected).to eq ['module Foo',
-                                 # The class has a block comment within, so
-                                 # it's not corrected.
-                                 'class Bar',
-                                 '=begin',
-                                 'This is a nice long',
-                                 'comment',
-                                 'which spans a few lines',
-                                 '=end',
-                                 # The method has no block comment inside, so
-                                 # it's corrected.
-                                 '  def baz',
-                                 # Method contents are also corrected.
-                                 '    do_something',
-                                 '  end',
-                                 'end',
-                                 'end'].join("\n")
-      end
-
-      it 'does not indent heredoc strings' do
-        corrected = autocorrect_source(cop,
-                                       ['module Foo',
-                                        'module Bar',
-                                        '  SOMETHING = <<GOO',
-                                        'text',
-                                        'more text',
-                                        'foo',
-                                        'GOO',
-                                        '  def baz',
-                                        '    do_something("#{x}")',
-                                        '  end',
-                                        'end',
-                                        'end'])
-        expect(corrected).to eq ['module Foo',
-                                 '  module Bar',
-                                 '    SOMETHING = <<GOO',
-                                 'text',
-                                 'more text',
-                                 'foo',
-                                 'GOO',
-                                 '    def baz',
-                                 '      do_something("#{x}")',
-                                 '    end',
-                                 '  end',
-                                 'end'].join("\n")
-      end
-
-      it 'indents parenthesized expressions' do
-        src = ['var1 = nil',
-               'array_list = []',
-               'if var1.attr1 != 0 || array_list.select{ |w|',
-               '                        (w.attr2 == var1.attr2)',
-               '                 }.blank?',
-               '  array_list << var1',
-               'end']
-        corrected = autocorrect_source(cop, src)
-        expect(corrected)
-          .to eq ['var1 = nil',
-                  'array_list = []',
-                  'if var1.attr1 != 0 || array_list.select{ |w|',
-                  '                   (w.attr2 == var1.attr2)',
-                  '                 }.blank?',
-                  '  array_list << var1',
-                  'end'].join("\n")
+  context 'with Width set to 2' do
+    let(:cop_config) { { 'Width' => 2 } }
+
+    context 'with if statement' do
+      it 'registers an offense for bad indentation of an if body' do
+        inspect_source(cop,
+                       ['if cond',
+                        ' func',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+        expect(cop.highlights).to eq([' '])
       end
 
-      it 'leaves rescue ; end unchanged' do
-        src = ['if variable',
-               '  begin',
-               '    do_something',
-               '  rescue ; end # consume any exception',
-               'end']
-        corrected = autocorrect_source(cop, src)
-        expect(corrected).to eq src.join("\n")
+      it 'registers an offense for bad indentation of an else body' do
+        inspect_source(cop,
+                       ['if cond',
+                        '  func1',
+                        'else',
+                        ' func2',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+        expect(cop.highlights).to eq([' '])
       end
 
-      it 'leaves block unchanged if block end is not on its own line' do
-        src = ['a_function {',
-               '  # a comment',
-               '  result = AObject.find_by_attr(attr) if attr',
-               '  result || AObject.make(',
-               '      :attr => attr,',
-               '      :attr2 => Other.get_value(),',
-               '      :attr3 => Another.get_value()) }']
-        corrected = autocorrect_source(cop, src)
-        expect(corrected).to eq src.join("\n")
+      it 'registers an offense for bad indentation of an elsif body' do
+        inspect_source(cop,
+                       ['if a1',
+                        '  b1',
+                        'elsif a2',
+                        ' b2',
+                        'else',
+                        '  c',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
       end
-    end
 
-    it 'accepts a one line if statement' do
-      inspect_source(cop,
-                     ['if cond then func1 else func2 end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts a correctly aligned if/elsif/else/end' do
-      inspect_source(cop,
-                     ['if a1',
-                      '  b1',
-                      'elsif a2',
-                      '  b2',
-                      'else',
-                      '  c',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts a correctly aligned if/elsif/else/end as a method argument' do
-      inspect_source(cop,
-                     ['foo(',
-                      '  if a1',
-                      '    b1',
-                      '  elsif a2',
-                      '    b2',
-                      '  else',
-                      '    c',
-                      '  end',
-                      ')'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts if/elsif/else/end laid out as a table' 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 'accepts if/then/else/end laid out as another table' do
-      inspect_source(cop,
-                     ["if File.exist?('config.save')",
-                      'then ConfigTable.load',
-                      'else ConfigTable.new',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'registers offense for bad indentation of ternary inside else' do
+        inspect_source(cop,
+                       ['if a',
+                        '  b',
+                        'else',
+                        '     x ? y : z',
+                        'end'])
+        expect(cop.messages)
+          .to eq(['Use 2 (not 5) spaces for indentation.'])
+        expect(cop.highlights).to eq(['     '])
+      end
 
-    it 'accepts an empty if' do
-      inspect_source(cop,
-                     ['if a',
-                      'else',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'registers offense for bad indentation of modifier if in else' do
+        inspect_source(cop,
+                       ['if a',
+                        '  b',
+                        'else',
+                        '   x if y',
+                        'end'])
+        expect(cop.messages)
+          .to eq(['Use 2 (not 3) spaces for indentation.'])
+      end
 
-    context 'with assignment' do
-      context 'when alignment style is variable' do
-        context 'and end is aligned with variable' do
-          it 'accepts an if with end aligned with setter' do
-            inspect_source(cop,
-                           ['foo.bar = if baz',
-                            '  derp',
-                            'end'])
-            expect(cop.offenses).to be_empty
-          end
+      describe '#autocorrect' do
+        it 'corrects bad indentation' do
+          corrected = autocorrect_source(cop,
+                                         ['if a1',
+                                          '   b1',
+                                          '   b1',
+                                          'elsif a2',
+                                          ' b2',
+                                          'else',
+                                          '    c',
+                                          'end'])
+          expect(corrected)
+            .to eq ['if a1',
+                    '  b1',
+                    '   b1', # Will be corrected by IndentationConsistency.
+                    'elsif a2',
+                    '  b2',
+                    'else',
+                    '  c',
+                    'end'].join("\n")
+        end
 
-          it 'accepts an if with end aligned with element assignment' do
-            inspect_source(cop,
-                           ['foo[bar] = if baz',
-                            '  derp',
-                            'end'])
-            expect(cop.offenses).to be_empty
-          end
+        it 'does not correct in scopes that contain block comments' do
+          corrected = autocorrect_source(cop,
+                                         ['module Foo',
+                                          'class Bar',
+                                          '=begin',
+                                          'This is a nice long',
+                                          'comment',
+                                          'which spans a few lines',
+                                          '=end',
+                                          'def baz',
+                                          'do_something',
+                                          'end',
+                                          'end',
+                                          'end'])
+          expect(corrected).to eq ['module Foo',
+                                   # The class has a block comment within, so
+                                   # it's not corrected.
+                                   'class Bar',
+                                   '=begin',
+                                   'This is a nice long',
+                                   'comment',
+                                   'which spans a few lines',
+                                   '=end',
+                                   # The method has no block comment inside, so
+                                   # it's corrected.
+                                   '  def baz',
+                                   # Method contents are also corrected.
+                                   '    do_something',
+                                   '  end',
+                                   'end',
+                                   'end'].join("\n")
+        end
 
-          it 'accepts an if with end aligned with variable' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '  0',
-                            'end',
-                            '@var = if a',
-                            '  0',
-                            'end',
-                            '$var = if a',
-                            '  0',
-                            'end',
-                            'var ||= if a',
-                            '  0',
-                            'end',
-                            'var &&= if a',
-                            '  0',
-                            'end',
-                            'var -= if a',
-                            '  0',
-                            'end',
-                            'VAR = if a',
-                            '  0',
-                            'end'])
-            expect(cop.offenses).to be_empty
-          end
+        it 'does not indent heredoc strings' do
+          corrected = autocorrect_source(cop,
+                                         ['module Foo',
+                                          'module Bar',
+                                          '  SOMETHING = <<GOO',
+                                          'text',
+                                          'more text',
+                                          'foo',
+                                          'GOO',
+                                          '  def baz',
+                                          '    do_something("#{x}")',
+                                          '  end',
+                                          'end',
+                                          'end'])
+          expect(corrected).to eq ['module Foo',
+                                   '  module Bar',
+                                   '    SOMETHING = <<GOO',
+                                   'text',
+                                   'more text',
+                                   'foo',
+                                   'GOO',
+                                   '    def baz',
+                                   '      do_something("#{x}")',
+                                   '    end',
+                                   '  end',
+                                   'end'].join("\n")
+        end
 
-          it 'accepts an if/else' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '  0',
-                            'else',
-                            '  1',
-                            'end'])
-            expect(cop.offenses).to be_empty
-          end
+        it 'indents parenthesized expressions' do
+          src = ['var1 = nil',
+                 'array_list = []',
+                 'if var1.attr1 != 0 || array_list.select{ |w|',
+                 '                        (w.attr2 == var1.attr2)',
+                 '                 }.blank?',
+                 '  array_list << var1',
+                 'end']
+          corrected = autocorrect_source(cop, src)
+          expect(corrected)
+            .to eq ['var1 = nil',
+                    'array_list = []',
+                    'if var1.attr1 != 0 || array_list.select{ |w|',
+                    '                   (w.attr2 == var1.attr2)',
+                    '                 }.blank?',
+                    '  array_list << var1',
+                    'end'].join("\n")
+        end
 
-          it 'accepts an if/else with chaining after the end' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '  0',
-                            'else',
-                            '  1',
-                            'end.abc.join("")'])
-            expect(cop.offenses).to be_empty
-          end
+        it 'leaves rescue ; end unchanged' do
+          src = ['if variable',
+                 '  begin',
+                 '    do_something',
+                 '  rescue ; end # consume any exception',
+                 'end']
+          corrected = autocorrect_source(cop, src)
+          expect(corrected).to eq src.join("\n")
+        end
 
-          it 'accepts an if/else with chaining with a block after the end' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '  0',
-                            'else',
-                            '  1',
-                            'end.abc.tap {}'])
-            expect(cop.offenses).to be_empty
-          end
+        it 'leaves block unchanged if block end is not on its own line' do
+          src = ['a_function {',
+                 '  # a comment',
+                 '  result = AObject.find_by_attr(attr) if attr',
+                 '  result || AObject.make(',
+                 '      :attr => attr,',
+                 '      :attr2 => Other.get_value(),',
+                 '      :attr3 => Another.get_value()) }']
+          corrected = autocorrect_source(cop, src)
+          expect(corrected).to eq src.join("\n")
         end
+      end
 
-        context 'and end is aligned with keyword' do
-          it 'registers an offense for an if with setter' do
-            inspect_source(cop,
-                           ['foo.bar = if baz',
-                            '            derp',
-                            '          end'])
-            expect(cop.messages)
-              .to eq(['Use 2 (not 12) spaces for indentation.'])
-          end
+      it 'accepts a one line if statement' do
+        inspect_source(cop,
+                       ['if cond then func1 else func2 end'])
+        expect(cop.offenses).to be_empty
+      end
 
-          it 'registers an offense for an if with element assignment' do
-            inspect_source(cop,
-                           ['foo[bar] = if baz',
-                            '             derp',
-                            '           end'])
-            expect(cop.messages)
-              .to eq(['Use 2 (not 13) spaces for indentation.'])
-          end
+      it 'accepts a correctly aligned if/elsif/else/end' do
+        inspect_source(cop,
+                       ['if a1',
+                        '  b1',
+                        'elsif a2',
+                        '  b2',
+                        'else',
+                        '  c',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-          it 'registers an offense for an if' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '        0',
-                            '      end'])
-            expect(cop.messages)
-              .to eq(['Use 2 (not 8) spaces for indentation.'])
-          end
+      it 'accepts a correctly aligned if/elsif/else/end as a method argument' do
+        inspect_source(cop,
+                       ['foo(',
+                        '  if a1',
+                        '    b1',
+                        '  elsif a2',
+                        '    b2',
+                        '  else',
+                        '    c',
+                        '  end',
+                        ')'])
+        expect(cop.offenses).to be_empty
+      end
 
-          it 'registers an offense for a while' do
-            inspect_source(cop,
-                           ['var = while a',
-                            '        b',
-                            '      end'])
-            expect(cop.messages)
-              .to eq(['Use 2 (not 8) spaces for indentation.'])
-          end
+      it 'accepts if/elsif/else/end laid out as a table' 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 'registers an offense for an until' do
-            inspect_source(cop,
-                           ['var = until a',
-                            '        b',
-                            '      end'])
-            expect(cop.messages)
-              .to eq(['Use 2 (not 8) spaces for indentation.'])
-          end
-        end
+      it 'accepts if/then/else/end laid out as another table' do
+        inspect_source(cop,
+                       ["if File.exist?('config.save')",
+                        'then ConfigTable.load',
+                        'else ConfigTable.new',
+                        'end'])
+        expect(cop.offenses).to be_empty
       end
 
-      shared_examples 'assignment and if with keyword alignment' do
-        context 'and end is aligned with variable' do
-          it 'registers an offense for an if' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '  0',
-                            'end'])
-            expect(cop.messages)
-              .to eq(['Use 2 (not -4) spaces for indentation.'])
-          end
+      it 'accepts an empty if' do
+        inspect_source(cop,
+                       ['if a',
+                        'else',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-          it 'registers an offense for a while' do
-            inspect_source(cop,
-                           ['var = while a',
-                            '  b',
-                            'end'])
-            expect(cop.messages)
-              .to eq(['Use 2 (not -4) spaces for indentation.'])
+      context 'with assignment' do
+        context 'when alignment style is variable' do
+          context 'and end is aligned with variable' do
+            it 'accepts an if with end aligned with setter' do
+              inspect_source(cop,
+                             ['foo.bar = if baz',
+                              '  derp',
+                              'end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an if with end aligned with element assignment' do
+              inspect_source(cop,
+                             ['foo[bar] = if baz',
+                              '  derp',
+                              'end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an if with end aligned with variable' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '  0',
+                              'end',
+                              '@var = if a',
+                              '  0',
+                              'end',
+                              '$var = if a',
+                              '  0',
+                              'end',
+                              'var ||= if a',
+                              '  0',
+                              'end',
+                              'var &&= if a',
+                              '  0',
+                              'end',
+                              'var -= if a',
+                              '  0',
+                              'end',
+                              'VAR = if a',
+                              '  0',
+                              'end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an if/else' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '  0',
+                              'else',
+                              '  1',
+                              'end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an if/else with chaining after the end' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '  0',
+                              'else',
+                              '  1',
+                              'end.abc.join("")'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an if/else with chaining with a block after the end' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '  0',
+                              'else',
+                              '  1',
+                              'end.abc.tap {}'])
+              expect(cop.offenses).to be_empty
+            end
           end
 
-          it 'autocorrects bad indentation' do
-            corrected = autocorrect_source(cop,
-                                           ['var = if a',
-                                            '  b',
-                                            'end',
-                                            '',
-                                            'var = while a',
-                                            '  b',
-                                            'end'])
-            expect(corrected).to eq ['var = if a',
-                                     '        b',
-                                     'end', # Not this cop's job to fix end.
-                                     '',
-                                     'var = while a',
-                                     '        b',
-                                     'end'].join("\n")
+          context 'and end is aligned with keyword' do
+            it 'registers an offense for an if with setter' do
+              inspect_source(cop,
+                             ['foo.bar = if baz',
+                              '            derp',
+                              '          end'])
+              expect(cop.messages)
+                .to eq(['Use 2 (not 12) spaces for indentation.'])
+            end
+
+            it 'registers an offense for an if with element assignment' do
+              inspect_source(cop,
+                             ['foo[bar] = if baz',
+                              '             derp',
+                              '           end'])
+              expect(cop.messages)
+                .to eq(['Use 2 (not 13) spaces for indentation.'])
+            end
+
+            it 'registers an offense for an if' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '        0',
+                              '      end'])
+              expect(cop.messages)
+                .to eq(['Use 2 (not 8) spaces for indentation.'])
+            end
+
+            it 'registers an offense for a while' do
+              inspect_source(cop,
+                             ['var = while a',
+                              '        b',
+                              '      end'])
+              expect(cop.messages)
+                .to eq(['Use 2 (not 8) spaces for indentation.'])
+            end
+
+            it 'registers an offense for an until' do
+              inspect_source(cop,
+                             ['var = until a',
+                              '        b',
+                              '      end'])
+              expect(cop.messages)
+                .to eq(['Use 2 (not 8) spaces for indentation.'])
+            end
           end
         end
 
-        context 'and end is aligned with keyword' do
-          it 'accepts an if in assignment' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '        0',
-                            '      end'])
-            expect(cop.offenses).to be_empty
+        shared_examples 'assignment and if with keyword alignment' do
+          context 'and end is aligned with variable' do
+            it 'registers an offense for an if' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '  0',
+                              'end'])
+              expect(cop.messages)
+                .to eq(['Use 2 (not -4) spaces for indentation.'])
+            end
+
+            it 'registers an offense for a while' do
+              inspect_source(cop,
+                             ['var = while a',
+                              '  b',
+                              'end'])
+              expect(cop.messages)
+                .to eq(['Use 2 (not -4) spaces for indentation.'])
+            end
+
+            it 'autocorrects bad indentation' do
+              corrected = autocorrect_source(cop,
+                                             ['var = if a',
+                                              '  b',
+                                              'end',
+                                              '',
+                                              'var = while a',
+                                              '  b',
+                                              'end'])
+              expect(corrected).to eq ['var = if a',
+                                       '        b',
+                                       'end', # Not this cop's job to fix end.
+                                       '',
+                                       'var = while a',
+                                       '        b',
+                                       'end'].join("\n")
+            end
           end
 
-          it 'accepts an if/else in assignment' do
-            inspect_source(cop,
-                           ['var = if a',
-                            '        0',
-                            '      else',
-                            '        1',
-                            '      end'])
-            expect(cop.offenses).to be_empty
+          context 'and end is aligned with keyword' do
+            it 'accepts an if in assignment' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '        0',
+                              '      end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an if/else in assignment' do
+              inspect_source(cop,
+                             ['var = if a',
+                              '        0',
+                              '      else',
+                              '        1',
+                              '      end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an if/else in assignment on next line' do
+              inspect_source(cop,
+                             ['var =',
+                              '  if a',
+                              '    0',
+                              '  else',
+                              '    1',
+                              '  end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts a while in assignment' do
+              inspect_source(cop,
+                             ['var = while a',
+                              '        b',
+                              '      end'])
+              expect(cop.offenses).to be_empty
+            end
+
+            it 'accepts an until in assignment' do
+              inspect_source(cop,
+                             ['var = until a',
+                              '        b',
+                              '      end'])
+              expect(cop.offenses).to be_empty
+            end
           end
+        end
 
-          it 'accepts an if/else in assignment on next line' do
-            inspect_source(cop,
-                           ['var =',
-                            '  if a',
-                            '    0',
-                            '  else',
-                            '    1',
-                            '  end'])
-            expect(cop.offenses).to be_empty
+        context 'when alignment style is keyword by choice' do
+          let(:end_alignment_config) do
+            { 'Enabled' => true, 'AlignWith' => 'keyword' }
           end
 
-          it 'accepts a while in assignment' do
-            inspect_source(cop,
-                           ['var = while a',
-                            '        b',
-                            '      end'])
-            expect(cop.offenses).to be_empty
-          end
+          include_examples 'assignment and if with keyword alignment'
+        end
 
-          it 'accepts an until in assignment' do
-            inspect_source(cop,
-                           ['var = until a',
-                            '        b',
-                            '      end'])
-            expect(cop.offenses).to be_empty
+        context 'when alignment style is keyword by default' do
+          let(:end_alignment_config) do
+            { 'Enabled' => false, 'AlignWith' => 'variable' }
           end
-        end
-      end
 
-      context 'when alignment style is keyword by choice' do
-        let(:end_alignment_config) do
-          { 'Enabled' => true, 'AlignWith' => 'keyword' }
+          include_examples 'assignment and if with keyword alignment'
         end
-
-        include_examples 'assignment and if with keyword alignment'
       end
 
-      context 'when alignment style is keyword by default' do
-        let(:end_alignment_config) do
-          { 'Enabled' => false, 'AlignWith' => 'variable' }
-        end
-
-        include_examples 'assignment and if with keyword alignment'
+      it 'accepts an if/else branches with rescue clauses' do
+        # Because of how the rescue clauses come out of Parser, these are
+        # special and need to be tested.
+        inspect_source(cop,
+                       ['if a',
+                        '  a rescue nil',
+                        'else',
+                        '  a rescue nil',
+                        'end'])
+        expect(cop.offenses).to be_empty
       end
     end
 
-    it 'accepts an if/else branches with rescue clauses' do
-      # Because of how the rescue clauses come out of Parser, these are
-      # special and need to be tested.
-      inspect_source(cop,
-                     ['if a',
-                      '  a rescue nil',
-                      'else',
-                      '  a rescue nil',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'with unless' do
-    it 'registers an offense for bad indentation of an unless body' do
-      inspect_source(cop,
-                     ['unless cond',
-                      ' func',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
+    context 'with unless' do
+      it 'registers an offense for bad indentation of an unless body' do
+        inspect_source(cop,
+                       ['unless cond',
+                        ' func',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+      end
 
-    it 'accepts an empty unless' do
-      inspect_source(cop,
-                     ['unless a',
-                      'else',
-                      'end'])
-      expect(cop.offenses).to be_empty
+      it 'accepts an empty unless' do
+        inspect_source(cop,
+                       ['unless a',
+                        'else',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'with case' do
-    it 'registers an offense for bad indentation in a case/when body' do
-      inspect_source(cop,
-                     ['case a',
-                      'when b',
-                      ' c',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
+    context 'with case' do
+      it 'registers an offense for bad indentation in a case/when body' do
+        inspect_source(cop,
+                       ['case a',
+                        'when b',
+                        ' c',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+      end
 
-    it 'registers an offense for bad indentation in a case/else body' do
-      inspect_source(cop,
-                     ['case a',
-                      'when b',
-                      '  c',
-                      'when d',
-                      '  e',
-                      'else',
-                      '   f',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
-    end
+      it 'registers an offense for bad indentation in a case/else body' do
+        inspect_source(cop,
+                       ['case a',
+                        'when b',
+                        '  c',
+                        'when d',
+                        '  e',
+                        'else',
+                        '   f',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
+      end
 
-    it 'accepts correctly indented case/when/else' do
-      inspect_source(cop,
-                     ['case a',
-                      'when b',
-                      '  c',
-                      '  c',
-                      'when d',
-                      'else',
-                      '  f',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts correctly indented case/when/else' do
+        inspect_source(cop,
+                       ['case a',
+                        'when b',
+                        '  c',
+                        '  c',
+                        'when d',
+                        'else',
+                        '  f',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    it 'accepts aligned values in when clause' do
-      inspect_source(cop,
-                     ['case superclass',
-                      'when /\A(#{NAMESPACEMATCH})(?:\s|\Z)/,',
-                      '     /\A(Struct|OStruct)\.new/,',
-                      '     /\ADelegateClass\((.+?)\)\s*\Z/,',
-                      '     /\A(#{NAMESPACEMATCH})\(/',
-                      '  $1',
-                      'when "self"',
-                      '  namespace.path',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts aligned values in when clause' do
+        inspect_source(cop,
+                       ['case superclass',
+                        'when /\A(#{NAMESPACEMATCH})(?:\s|\Z)/,',
+                        '     /\A(Struct|OStruct)\.new/,',
+                        '     /\ADelegateClass\((.+?)\)\s*\Z/,',
+                        '     /\A(#{NAMESPACEMATCH})\(/',
+                        '  $1',
+                        'when "self"',
+                        '  namespace.path',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    it 'accepts case/when/else laid out as a table' do
-      inspect_source(cop,
-                     ['case sexp.loc.keyword.source',
-                      "when 'if'     then cond, body, _else = *sexp",
-                      "when 'unless' then cond, _else, body = *sexp",
-                      'else               cond, body = *sexp',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts case/when/else laid out as a table' do
+        inspect_source(cop,
+                       ['case sexp.loc.keyword.source',
+                        "when 'if'     then cond, body, _else = *sexp",
+                        "when 'unless' then cond, _else, body = *sexp",
+                        'else               cond, body = *sexp',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    it 'accepts case/when/else with then beginning a line' do
-      inspect_source(cop,
-                     ['case sexp.loc.keyword.source',
-                      "when 'if'",
-                      'then cond, body, _else = *sexp',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts case/when/else with then beginning a line' do
+        inspect_source(cop,
+                       ['case sexp.loc.keyword.source',
+                        "when 'if'",
+                        'then cond, body, _else = *sexp',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    it 'accepts indented when/else plus indented body' do
-      # "Indent when as deep as case" is the job of another cop.
-      inspect_source(cop,
-                     ['case code_type',
-                      "  when 'ruby', 'sql', 'plain'",
-                      '    code_type',
-                      "  when 'erb'",
-                      "    'ruby; html-script: true'",
-                      '  when "html"',
-                      "    'xml'",
-                      '  else',
-                      "    'plain'",
-                      'end'])
-      expect(cop.offenses).to be_empty
+      it 'accepts indented when/else plus indented body' do
+        # "Indent when as deep as case" is the job of another cop.
+        inspect_source(cop,
+                       ['case code_type',
+                        "  when 'ruby', 'sql', 'plain'",
+                        '    code_type',
+                        "  when 'erb'",
+                        "    'ruby; html-script: true'",
+                        '  when "html"',
+                        "    'xml'",
+                        '  else',
+                        "    'plain'",
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'with while/until' do
-    it 'registers an offense for bad indentation of a while body' do
-      inspect_source(cop,
-                     ['while cond',
-                      ' func',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
+    context 'with while/until' do
+      it 'registers an offense for bad indentation of a while body' do
+        inspect_source(cop,
+                       ['while cond',
+                        ' func',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+      end
 
-    it 'registers an offense for bad indentation of begin/end/while' do
-      inspect_source(cop,
-                     ['something = begin',
-                      ' func1',
-                      '   func2',
-                      'end while cond'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
+      it 'registers an offense for bad indentation of begin/end/while' do
+        inspect_source(cop,
+                       ['something = begin',
+                        ' func1',
+                        '   func2',
+                        'end while cond'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+      end
 
-    it 'registers an offense for bad indentation of an until body' do
-      inspect_source(cop,
-                     ['until cond',
-                      ' func',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
+      it 'registers an offense for bad indentation of an until body' do
+        inspect_source(cop,
+                       ['until cond',
+                        ' func',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+      end
 
-    it 'accepts an empty while' do
-      inspect_source(cop,
-                     ['while a',
-                      'end'])
-      expect(cop.offenses).to be_empty
+      it 'accepts an empty while' do
+        inspect_source(cop,
+                       ['while a',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'with for' do
-    it 'registers an offense for bad indentation of a for body' do
-      inspect_source(cop,
-                     ['for var in 1..10',
-                      ' func',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
+    context 'with for' do
+      it 'registers an offense for bad indentation of a for body' do
+        inspect_source(cop,
+                       ['for var in 1..10',
+                        ' func',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+      end
 
-    it 'accepts an empty for' do
-      inspect_source(cop,
-                     ['for var in 1..10',
-                      'end'])
-      expect(cop.offenses).to be_empty
+      it 'accepts an empty for' do
+        inspect_source(cop,
+                       ['for var in 1..10',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'with def/defs' do
-    it 'registers an offense for bad indentation of a def body' do
-      inspect_source(cop,
-                     ['def test',
-                      '    func1',
-                      '     func2', # No offense registered for this.
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
-    end
+    context 'with def/defs' do
+      it 'registers an offense for bad indentation of a def body' do
+        inspect_source(cop,
+                       ['def test',
+                        '    func1',
+                        '     func2', # No offense registered for this.
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
+      end
 
-    it 'registers an offense for bad indentation of a defs body' do
-      inspect_source(cop,
-                     ['def self.test',
-                      '   func',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
-    end
+      it 'registers an offense for bad indentation of a defs body' do
+        inspect_source(cop,
+                       ['def self.test',
+                        '   func',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
+      end
 
-    it 'accepts an empty def body' do
-      inspect_source(cop,
-                     ['def test',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts an empty def body' do
+        inspect_source(cop,
+                       ['def test',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    it 'accepts an empty defs body' do
-      inspect_source(cop,
-                     ['def self.test',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts an empty defs body' do
+        inspect_source(cop,
+                       ['def self.test',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    if RUBY_VERSION >= '2.1'
-      context 'when modifier and def are on the same line' do
-        it 'accepts a correctly aligned body' do
-          inspect_source(cop,
-                         ['private def test',
-                          '  something',
-                          'end'])
-          expect(cop.offenses).to be_empty
-        end
+      if RUBY_VERSION >= '2.1'
+        context 'when modifier and def are on the same line' do
+          it 'accepts a correctly aligned body' do
+            inspect_source(cop,
+                           ['private def test',
+                            '  something',
+                            'end'])
+            expect(cop.offenses).to be_empty
+          end
 
-        it 'registers an offense for bad indentation of a def body' do
-          inspect_source(cop,
-                         ['private def test',
-                          '          something',
-                          '        end'])
-          expect(cop.messages)
-            .to eq(['Use 2 (not 10) spaces for indentation.'])
+          it 'registers an offense for bad indentation of a def body' do
+            inspect_source(cop,
+                           ['private def test',
+                            '          something',
+                            '        end'])
+            expect(cop.messages)
+              .to eq(['Use 2 (not 10) spaces for indentation.'])
+          end
         end
       end
     end
-  end
 
-  context 'with class' do
-    it 'registers an offense for bad indentation of a class body' do
-      inspect_source(cop,
-                     ['class Test',
-                      '    def func',
-                      '    end',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
-    end
+    context 'with class' do
+      it 'registers an offense for bad indentation of a class body' do
+        inspect_source(cop,
+                       ['class Test',
+                        '    def func',
+                        '    end',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
+      end
 
-    it 'accepts an empty class body' do
-      inspect_source(cop,
-                     ['class Test',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts an empty class body' do
+        inspect_source(cop,
+                       ['class Test',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    it 'accepts indented public, protected, and private' do
-      inspect_source(cop,
-                     ['class Test',
-                      '  public',
-                      '',
-                      '  def e',
-                      '  end',
-                      '',
-                      '  protected',
-                      '',
-                      '  def f',
-                      '  end',
-                      '',
-                      '  private',
-                      '',
-                      '  def g',
-                      '  end',
-                      'end'])
-      expect(cop.offenses).to be_empty
+      it 'accepts indented public, protected, and private' do
+        inspect_source(cop,
+                       ['class Test',
+                        '  public',
+                        '',
+                        '  def e',
+                        '  end',
+                        '',
+                        '  protected',
+                        '',
+                        '  def f',
+                        '  end',
+                        '',
+                        '  private',
+                        '',
+                        '  def g',
+                        '  end',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'with module' do
-    it 'registers an offense for bad indentation of a module body' do
-      inspect_source(cop,
-                     ['module Test',
-                      '    def func',
-                      '    end',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
-    end
+    context 'with module' do
+      it 'registers an offense for bad indentation of a module body' do
+        inspect_source(cop,
+                       ['module Test',
+                        '    def func',
+                        '    end',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 4) spaces for indentation.'])
+      end
 
-    it 'accepts an empty module body' do
-      inspect_source(cop,
-                     ['module Test',
-                      'end'])
-      expect(cop.offenses).to be_empty
+      it 'accepts an empty module body' do
+        inspect_source(cop,
+                       ['module Test',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'with begin/rescue/else/ensure/end' do
-    it 'registers an offense for bad indentation of bodies' do
-      inspect_source(cop,
-                     ['def my_func',
-                      "  puts 'do something outside block'",
-                      '  begin',
-                      "  puts 'do something error prone'",
-                      '  rescue SomeException, SomeOther => e',
-                      "   puts 'wrongly intended error handling'",
-                      '  rescue',
-                      "   puts 'wrongly intended error handling'",
-                      '  else',
-                      "     puts 'wrongly intended normal case handling'",
-                      '  ensure',
-                      "      puts 'wrongly intended common handling'",
-                      '  end',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 0) spaces for indentation.',
-                                  'Use 2 (not 1) spaces for indentation.',
-                                  'Use 2 (not 1) spaces for indentation.',
-                                  'Use 2 (not 3) spaces for indentation.',
-                                  'Use 2 (not 4) spaces for indentation.'])
+    context 'with begin/rescue/else/ensure/end' do
+      it 'registers an offense for bad indentation of bodies' do
+        inspect_source(cop,
+                       ['def my_func',
+                        "  puts 'do something outside block'",
+                        '  begin',
+                        "  puts 'do something error prone'",
+                        '  rescue SomeException, SomeOther => e',
+                        "   puts 'wrongly intended error handling'",
+                        '  rescue',
+                        "   puts 'wrongly intended error handling'",
+                        '  else',
+                        "     puts 'wrongly intended normal case handling'",
+                        '  ensure',
+                        "      puts 'wrongly intended common handling'",
+                        '  end',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 0) spaces for indentation.',
+                                    'Use 2 (not 1) spaces for indentation.',
+                                    'Use 2 (not 1) spaces for indentation.',
+                                    'Use 2 (not 3) spaces for indentation.',
+                                    'Use 2 (not 4) spaces for indentation.'])
+      end
     end
-  end
 
-  context 'with def/rescue/end' do
-    it 'registers an offense for bad indentation of bodies' do
-      inspect_source(cop,
-                     ['def my_func',
-                      "  puts 'do something error prone'",
-                      'rescue SomeException',
-                      " puts 'wrongly intended error handling'",
-                      'rescue',
-                      " puts 'wrongly intended error handling'",
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.',
-                                  'Use 2 (not 1) spaces for indentation.'])
+    context 'with def/rescue/end' do
+      it 'registers an offense for bad indentation of bodies' do
+        inspect_source(cop,
+                       ['def my_func',
+                        "  puts 'do something error prone'",
+                        'rescue SomeException',
+                        " puts 'wrongly intended error handling'",
+                        'rescue',
+                        " puts 'wrongly intended error handling'",
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.',
+                                    'Use 2 (not 1) spaces for indentation.'])
+      end
     end
-  end
 
-  context 'with block' do
-    it 'registers an offense for bad indentation of a do/end body' do
-      inspect_source(cop,
-                     ['a = func do',
-                      ' b',
-                      'end'])
-      expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
-    end
+    context 'with block' do
+      it 'registers an offense for bad indentation of a do/end body' do
+        inspect_source(cop,
+                       ['a = func do',
+                        ' b',
+                        'end'])
+        expect(cop.messages).to eq(['Use 2 (not 1) spaces for indentation.'])
+      end
 
-    it 'registers an offense for bad indentation of a {} body' do
-      inspect_source(cop,
-                     ['func {',
-                      '   b',
-                      '}'])
-      expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
-    end
+      it 'registers an offense for bad indentation of a {} body' do
+        inspect_source(cop,
+                       ['func {',
+                        '   b',
+                        '}'])
+        expect(cop.messages).to eq(['Use 2 (not 3) spaces for indentation.'])
+      end
 
-    it 'accepts a correctly indented block body' do
-      inspect_source(cop,
-                     ['a = func do',
-                      '  b',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts a correctly indented block body' do
+        inspect_source(cop,
+                       ['a = func do',
+                        '  b',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    it 'accepts an empty block body' do
-      inspect_source(cop,
-                     ['a = func do',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
+      it 'accepts an empty block body' do
+        inspect_source(cop,
+                       ['a = func do',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
 
-    # The cop uses the block end/} as the base for indentation, so if it's not
-    # on its own line, all bets are off.
-    it 'accepts badly indented code if block end is not on separate line' do
-      inspect_source(cop,
-                     ['foo {',
-                      'def baz',
-                      'end }'])
-      expect(cop.offenses).to be_empty
+      # The cop uses the block end/} as the base for indentation, so if it's not
+      # on its own line, all bets are off.
+      it 'accepts badly indented code if block end is not on separate line' do
+        inspect_source(cop,
+                       ['foo {',
+                        'def baz',
+                        'end }'])
+        expect(cop.offenses).to be_empty
+      end
     end
   end
 end