rubocop 0.18.1 → 0.19.0

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

@@ -5,10 +5,10 @@ require 'spec_helper'
 describe Rubocop::Cop::Style::Alias do
   subject(:cop) { described_class.new }
 
-  it 'registers an offence for alias with symbol args' do
+  it 'registers an offense for alias with symbol args' do
     inspect_source(cop,
                    ['alias :ala :bala'])
-    expect(cop.offences.size).to eq(1)
+    expect(cop.offenses.size).to eq(1)
     expect(cop.messages)
       .to eq(['Use alias_method instead of alias.'])
   end
@@ -18,10 +18,10 @@ describe Rubocop::Cop::Style::Alias do
     expect(corrected).to eq 'alias_method :ala, :bala'
   end
 
-  it 'registers an offence for alias with bareword args' do
+  it 'registers an offense for alias with bareword args' do
     inspect_source(cop,
                    ['alias ala bala'])
-    expect(cop.offences.size).to eq(1)
+    expect(cop.offenses.size).to eq(1)
     expect(cop.messages)
       .to eq(['Use alias_method instead of alias.'])
   end
@@ -31,22 +31,22 @@ describe Rubocop::Cop::Style::Alias do
     expect(corrected).to eq 'alias_method :ala, :bala'
   end
 
-  it 'does not register an offence for alias_method' do
+  it 'does not register an offense for alias_method' do
     inspect_source(cop,
                    ['alias_method :ala, :bala'])
-    expect(cop.offences).to be_empty
+    expect(cop.offenses).to be_empty
   end
 
-  it 'does not register an offence for :alias' do
+  it 'does not register an offense for :alias' do
     inspect_source(cop,
                    ['[:alias, :ala, :bala]'])
-    expect(cop.offences).to be_empty
+    expect(cop.offenses).to be_empty
   end
 
-  it 'does not register an offence for alias with gvars' do
+  it 'does not register an offense for alias with gvars' do
     inspect_source(cop,
                    ['alias $ala $bala'])
-    expect(cop.offences).to be_empty
+    expect(cop.offenses).to be_empty
   end
 
   it 'accepts alias in an instance_exec block' do
@@ -54,6 +54,6 @@ describe Rubocop::Cop::Style::Alias do
                    ['cli.instance_exec do',
                     '  alias :old_trap_interrupt :trap_interrupt',
                     'end'])
-    expect(cop.offences).to be_empty
+    expect(cop.offenses).to be_empty
   end
 end

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Rubocop::Cop::Style::AlignArray do
   subject(:cop) { described_class.new }
 
-  it 'registers an offence for misaligned array elements' do
+  it 'registers an offense for misaligned array elements' do
     inspect_source(cop, ['array = [',
                          '  a,',
                          '   b,',
@@ -13,7 +13,7 @@ describe Rubocop::Cop::Style::AlignArray do
                          '   d',
                          ']'])
     expect(cop.messages).to eq(['Align the elements of an array ' \
-                                'literal if they span more than ' +
+                                'literal if they span more than ' \
                                 'one line.'] * 2)
     expect(cop.highlights).to eq(%w(b d))
   end
@@ -25,18 +25,18 @@ describe Rubocop::Cop::Style::AlignArray do
                          '  c,',
                          '  d',
                          ']'])
-    expect(cop.offences).to be_empty
+    expect(cop.offenses).to be_empty
   end
 
   it 'accepts single line array' do
     inspect_source(cop, 'array = [ a, b ]')
-    expect(cop.offences).to be_empty
+    expect(cop.offenses).to be_empty
   end
 
   it 'accepts several elements per line' do
     inspect_source(cop, ['array = [ a, b,',
                          '          c, d ]'])
-    expect(cop.offences).to be_empty
+    expect(cop.offenses).to be_empty
   end
 
   it 'auto-corrects alignment' do
@@ -54,14 +54,30 @@ describe Rubocop::Cop::Style::AlignArray do
                               ']'].join("\n"))
   end
 
-  it 'auto-corrects array within array' do
+  it 'auto-corrects array within array with too much indentation' do
     original_source = ['[:l1,',
                        '  [:l2,',
+                       '',
                        '    [:l3,',
-                       '      [:l4]]]]']
+                       '     [:l4]]]]']
     new_source = autocorrect_source(cop, original_source)
     expect(new_source).to eq(['[:l1,',
                               ' [:l2,',
+                              '',
+                              '  [:l3,',
+                              '   [:l4]]]]'].join("\n"))
+  end
+
+  it 'auto-corrects array within array with too little indentation' do
+    original_source = ['[:l1,',
+                       '[:l2,',
+                       '',
+                       '  [:l3,',
+                       '   [:l4]]]]']
+    new_source = autocorrect_source(cop, original_source)
+    expect(new_source).to eq(['[:l1,',
+                              ' [:l2,',
+                              '',
                               '  [:l3,',
                               '   [:l4]]]]'].join("\n"))
   end

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

@@ -3,20 +3,101 @@
 require 'spec_helper'
 
 describe Rubocop::Cop::Style::AlignHash, :config do
+  subject(:cop) { described_class.new(config) }
+
   shared_examples 'not on separate lines' do
     it 'accepts single line hash' do
       inspect_source(cop, 'func(a: 0, bb: 1)')
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
 
     it 'accepts several pairs per line' do
       inspect_source(cop, ['func(a: 1, bb: 2,',
                            '     ccc: 3, dddd: 4)'])
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'always inspect last argument hash' do
+    let(:cop_config) do
+      {
+        'EnforcedLastArgumentHashStyle' => 'always_inspect'
+      }
+    end
+
+    it 'registers offence for misaligned keys in implicit hash' do
+      inspect_source(cop, ['func(a: 0,',
+                           '  b: 1)'])
+      expect(cop.offenses.size).to eq(1)
+    end
+
+    it 'registers offence for misaligned keys in explicit hash' do
+      inspect_source(cop, ['func({a: 0,',
+                           '  b: 1})'])
+      expect(cop.offenses.size).to eq(1)
+    end
+  end
+
+  context 'always ignore last argument hash' do
+    let(:cop_config) do
+      {
+        'EnforcedLastArgumentHashStyle' => 'always_ignore'
+      }
+    end
+
+    it 'accepts misaligned keys in implicit hash' do
+      inspect_source(cop, ['func(a: 0,',
+                           '  b: 1)'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts misaligned keys in explicit hash' do
+      inspect_source(cop, ['func({a: 0,',
+                           '  b: 1})'])
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'ignore implicit last argument hash' do
+    let(:cop_config) do
+      {
+        'EnforcedLastArgumentHashStyle' => 'ignore_implicit'
+      }
+    end
+
+    it 'accepts misaligned keys in implicit hash' do
+      inspect_source(cop, ['func(a: 0,',
+                           '  b: 1)'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'registers offence for misaligned keys in explicit hash' do
+      inspect_source(cop, ['func({a: 0,',
+                           '  b: 1})'])
+      expect(cop.offenses.size).to eq(1)
+    end
+  end
+
+  context 'ignore explicit last argument hash' do
+    let(:cop_config) do
+      {
+        'EnforcedLastArgumentHashStyle' => 'ignore_explicit'
+      }
+    end
+
+    it 'registers offence for misaligned keys in implicit hash' do
+      inspect_source(cop, ['func(a: 0,',
+                           '  b: 1)'])
+      expect(cop.offenses.size).to eq(1)
+    end
+
+    it 'accepts misaligned keys in explicit hash' do
+      inspect_source(cop, ['func({a: 0,',
+                           '  b: 1})'])
+      expect(cop.offenses).to be_empty
     end
   end
 
-  subject(:cop) { described_class.new(config) }
   let(:cop_config) do
     {
       'EnforcedHashRocketStyle' => 'key',
@@ -25,7 +106,7 @@ describe Rubocop::Cop::Style::AlignHash, :config do
   end
 
   context 'with default configuration' do
-    it 'registers an offence for misaligned hash keys' do
+    it 'registers an offense for misaligned hash keys' do
       inspect_source(cop, ['hash1 = {',
                            '  a: 0,',
                            '   bb: 1',
@@ -35,7 +116,7 @@ describe Rubocop::Cop::Style::AlignHash, :config do
                            " 'dddd'  =>  2",
                            '}'])
       expect(cop.messages).to eq(['Align the elements of a hash ' \
-                                  'literal if they span more than ' +
+                                  'literal if they span more than ' \
                                   'one line.'] * 2)
       expect(cop.highlights).to eq(['bb: 1',
                                     "'dddd'  =>  2"])
@@ -50,40 +131,40 @@ describe Rubocop::Cop::Style::AlignHash, :config do
                            "  'ccc' => 2,",
                            "  'dddd'  =>  2",
                            '}'])
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
 
-    it 'registers an offence for separator alignment' do
+    it 'registers an offense for separator alignment' do
       inspect_source(cop, ['hash = {',
                            "    'a' => 0,",
                            "  'bbb' => 1",
                            '}'])
-      expect(cop.offences.size).to eq(1)
+      expect(cop.offenses.size).to eq(1)
       expect(cop.highlights).to eq(["'bbb' => 1"])
     end
 
-    context 'with braceless hash as last argument' do
-      it 'registers an offence for misaligned hash keys' do
+    context 'with implicit hash as last argument' do
+      it 'registers an offense for misaligned hash keys' do
         inspect_source(cop, ['func(a: 0,',
                              '  b: 1)'])
-        expect(cop.offences.size).to eq(1)
+        expect(cop.offenses.size).to eq(1)
       end
 
-      it 'registers an offence for right alignment of keys' do
+      it 'registers an offense for right alignment of keys' do
         inspect_source(cop, ['func(a: 0,',
                              '   bbb: 1)'])
-        expect(cop.offences.size).to eq(1)
+        expect(cop.offenses.size).to eq(1)
       end
 
       it 'accepts aligned hash keys' do
         inspect_source(cop, ['func(a: 0,',
                              '     b: 1)'])
-        expect(cop.offences).to be_empty
+        expect(cop.offenses).to be_empty
       end
 
       it 'accepts an empty hash' do
         inspect_source(cop, 'h = {}')
-        expect(cop.offences).to be_empty
+        expect(cop.offenses).to be_empty
       end
     end
 
@@ -128,12 +209,12 @@ describe Rubocop::Cop::Style::AlignHash, :config do
                            '  bbb: 1',
                            '}'
                           ])
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
 
     it 'accepts an empty hash' do
       inspect_source(cop, 'h = {}')
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
 
     it 'accepts a multiline array of single line hashes' do
@@ -145,10 +226,10 @@ describe Rubocop::Cop::Style::AlignHash, :config do
                            '      { after:    %w( n o ) }',
                            '    ]',
                            '  end'])
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
 
-    it 'registers an offence for misaligned hash values' do
+    it 'registers an offense for misaligned hash values' do
       inspect_source(cop, ['hash1 = {',
                            "  'a'   =>  0,",
                            "  'bbb' => 1",
@@ -162,12 +243,12 @@ describe Rubocop::Cop::Style::AlignHash, :config do
                                     'bbb:1'])
     end
 
-    it 'registers an offence for misaligned hash rockets' do
+    it 'registers an offense for misaligned hash rockets' do
       inspect_source(cop, ['hash = {',
                            "  'a'   => 0,",
                            "  'bbb'  => 1",
                            '}'])
-      expect(cop.offences.size).to eq(1)
+      expect(cop.offenses.size).to eq(1)
     end
 
     it 'auto-corrects alignment' do
@@ -196,7 +277,7 @@ describe Rubocop::Cop::Style::AlignHash, :config do
 
     it 'accepts a single method argument entry with colon' do
       inspect_source(cop, ['merge(parent: nil)'])
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
   end
 
@@ -233,28 +314,28 @@ describe Rubocop::Cop::Style::AlignHash, :config do
                            "    'a' => 0,",
                            "  'bbb' => 1",
                            '}'])
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
 
     it 'accepts an empty hash' do
       inspect_source(cop, 'h = {}')
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
 
-    it 'registers an offence for misaligned hash values' do
+    it 'registers an offense for misaligned hash values' do
       inspect_source(cop, ['hash = {',
                            "    'a' =>  0,",
                            "  'bbb' => 1",
                            '}'])
-      expect(cop.offences.size).to eq(1)
+      expect(cop.offenses.size).to eq(1)
     end
 
-    it 'registers an offence for misaligned hash rockets' do
+    it 'registers an offense for misaligned hash rockets' do
       inspect_source(cop, ['hash = {',
                            "    'a'  => 0,",
                            "  'bbb' =>  1",
                            '}'])
-      expect(cop.offences.size).to eq(1)
+      expect(cop.offenses.size).to eq(1)
     end
 
     include_examples 'not on separate lines'
@@ -283,7 +364,7 @@ describe Rubocop::Cop::Style::AlignHash, :config do
       }
     end
 
-    it 'registers offences for misaligned entries' do
+    it 'registers offenses for misaligned entries' do
       inspect_source(cop, ['hash1 = {',
                            '  a:   0,',
                            '  bbb: 1',
@@ -304,7 +385,7 @@ describe Rubocop::Cop::Style::AlignHash, :config do
                            "  'a' => 0,",
                            "  'bbb' => 1",
                            '}'])
-      expect(cop.offences).to be_empty
+      expect(cop.offenses).to be_empty
     end
   end
 end

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

@@ -2,221 +2,294 @@
 
 require 'spec_helper'
 
-describe Rubocop::Cop::Style::AlignParameters do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offence for parameters with single indent' do
-    inspect_source(cop, ['function(a,',
-                         '  if b then c else d end)'])
-    expect(cop.offences.size).to eq(1)
-    expect(cop.highlights).to eq(['if b then c else d end'])
-  end
+describe Rubocop::Cop::Style::AlignParameters, :config do
+  subject(:cop) { described_class.new(config) }
 
-  it 'registers an offence for parameters with double indent' do
-    inspect_source(cop, ['function(a,',
-                         '    if b then c else d end)'])
-    expect(cop.offences.size).to eq(1)
-  end
+  context 'aligned with first parameter' do
+    let(:cop_config) do
+      {
+        'EnforcedStyle' => 'with_first_parameter'
+      }
+    end
 
-  it 'accepts multiline []= method call' do
-    inspect_source(cop, ['Test.config["something"] =',
-                         ' true'])
-    expect(cop.offences).to be_empty
-  end
+    it 'registers an offense for parameters with single indent' do
+      inspect_source(cop, ['function(a,',
+                           '  if b then c else d end)'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.highlights).to eq(['if b then c else d end'])
+    end
 
-  it 'accepts correctly aligned parameters' do
-    inspect_source(cop, ['function(a,',
-                         '         0, 1,',
-                         '         (x + y),',
-                         '         if b then c else d end)'])
-    expect(cop.offences).to be_empty
-  end
+    it 'registers an offense for parameters with double indent' do
+      inspect_source(cop, ['function(a,',
+                           '    if b then c else d end)'])
+      expect(cop.offenses.size).to eq(1)
+    end
 
-  it 'accepts calls that only span one line' do
-    inspect_source(cop, ['find(path, s, @special[sexp[0]])'])
-    expect(cop.offences).to be_empty
-  end
+    it 'accepts multiline []= method call' do
+      inspect_source(cop, ['Test.config["something"] =',
+                           ' true'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it "doesn't get confused by a symbol argument" do
-    inspect_source(cop, ['add_offence(index,',
-                         '            MSG % kind)'])
-    expect(cop.offences).to be_empty
-  end
+    it 'accepts correctly aligned parameters' do
+      inspect_source(cop, ['function(a,',
+                           '         0, 1,',
+                           '         (x + y),',
+                           '         if b then c else d end)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it "doesn't get confused by splat operator" do
-    inspect_source(cop, ['func1(*a,',
-                         '      *b,',
-                         '      c)',
-                         'func2(a,',
-                         '     *b,',
-                         '      c)',
-                         'func3(*a)'
-                        ])
-    expect(cop.offences.map(&:to_s))
-      .to eq(['C:  5:  6: Align the parameters of a method call if ' \
-              'they span more than one line.'])
-    expect(cop.highlights).to eq(['*b'])
-  end
+    it 'accepts calls that only span one line' do
+      inspect_source(cop, ['find(path, s, @special[sexp[0]])'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it "doesn't get confused by extra comma at the end" do
-    inspect_source(cop, ['func1(a,',
-                         '     b,)'])
-    expect(cop.offences.map(&:to_s))
-      .to eq(['C:  2:  6: Align the parameters of a method call if ' \
-              'they span more than one line.'])
-    expect(cop.highlights).to eq(['b'])
-  end
+    it "doesn't get confused by a symbol argument" do
+      inspect_source(cop, ['add_offense(index,',
+                           '            MSG % kind)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle a correctly aligned string literal as first argument' do
-    inspect_source(cop, ['add_offence(x,',
-                         '            a)'])
-    expect(cop.offences).to be_empty
-  end
+    it "doesn't get confused by splat operator" do
+      inspect_source(cop, ['func1(*a,',
+                           '      *b,',
+                           '      c)',
+                           'func2(a,',
+                           '     *b,',
+                           '      c)',
+                           'func3(*a)'
+                          ])
+      expect(cop.offenses.map(&:to_s))
+        .to eq(['C:  5:  6: Align the parameters of a method call if ' \
+                'they span more than one line.'])
+      expect(cop.highlights).to eq(['*b'])
+    end
 
-  it 'can handle a string literal as other argument' do
-    inspect_source(cop, ['add_offence(',
-                         '            "", a)'])
-    expect(cop.offences).to be_empty
-  end
+    it "doesn't get confused by extra comma at the end" do
+      inspect_source(cop, ['func1(a,',
+                           '     b,)'])
+      expect(cop.offenses.map(&:to_s))
+        .to eq(['C:  2:  6: Align the parameters of a method call if ' \
+                'they span more than one line.'])
+      expect(cop.highlights).to eq(['b'])
+    end
 
-  it "doesn't get confused by a line break inside a parameter" do
-    inspect_source(cop, ['read(path, { headers:    true,',
-                         '             converters: :numeric })'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle a correctly aligned string literal as first argument' do
+      inspect_source(cop, ['add_offense(x,',
+                           '            a)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it "doesn't get confused by symbols with embedded expressions" do
-    inspect_source(cop, ['send(:"#{name}_comments_path")'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle a string literal as other argument' do
+      inspect_source(cop, ['add_offense(',
+                           '            "", a)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it "doesn't get confused by regexen with embedded expressions" do
-    inspect_source(cop, ['a(/#{name}/)'])
-    expect(cop.offences).to be_empty
-  end
+    it "doesn't get confused by a line break inside a parameter" do
+      inspect_source(cop, ['read(path, { headers:    true,',
+                           '             converters: :numeric })'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'accepts braceless hashes' do
-    inspect_source(cop, ['run(collection, :entry_name => label,',
-                         '                :paginator  => paginator)'])
-    expect(cop.offences).to be_empty
-  end
+    it "doesn't get confused by symbols with embedded expressions" do
+      inspect_source(cop, ['send(:"#{name}_comments_path")'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'accepts the first parameter being on a new row' do
-    inspect_source(cop, ['  match(',
-                         '    a,',
-                         '    b',
-                         '  )'])
-    expect(cop.offences).to be_empty
-  end
+    it "doesn't get confused by regexen with embedded expressions" do
+      inspect_source(cop, ['a(/#{name}/)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle heredoc strings' do
-    inspect_source(cop, ['class_eval(<<-EOS, __FILE__, __LINE__ + 1)',
-                         '            def run_#{name}_callbacks(*args)',
-                         '              a = 1',
-                         '              return value',
-                         '            end',
-                         '            EOS'])
-    expect(cop.offences).to be_empty
-  end
+    it 'accepts braceless hashes' do
+      inspect_source(cop, ['run(collection, :entry_name => label,',
+                           '                :paginator  => paginator)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle a method call within a method call' do
-    inspect_source(cop, ['a(a1,',
-                         '  b(b1,',
-                         '    b2),',
-                         '  a2)'])
-    expect(cop.offences).to be_empty
-  end
+    it 'accepts the first parameter being on a new row' do
+      inspect_source(cop, ['  match(',
+                           '    a,',
+                           '    b',
+                           '  )'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle a call embedded in a string' do
-    inspect_source(cop, ['model("#{index(name)}", child)'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle heredoc strings' do
+      inspect_source(cop, ['class_eval(<<-EOS, __FILE__, __LINE__ + 1)',
+                           '            def run_#{name}_callbacks(*args)',
+                           '              a = 1',
+                           '              return value',
+                           '            end',
+                           '            EOS'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle do-end' do
-    inspect_source(cop, ['      run(lambda do |e|',
-                         "        w = e['warden']",
-                         '      end)'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle a method call within a method call' do
+      inspect_source(cop, ['a(a1,',
+                           '  b(b1,',
+                           '    b2),',
+                           '  a2)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle a call with a block inside another call' do
-    src = ['new(table_name,',
-           '    exec_query("info(\'#{row[\'name\']}\')").map { |col|',
-           "      col['name']",
-           '    })']
-    inspect_source(cop, src)
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle a call embedded in a string' do
+      inspect_source(cop, ['model("#{index(name)}", child)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle a ternary condition with a block reference' do
-    inspect_source(cop, ['cond ? a : func(&b)'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle do-end' do
+      inspect_source(cop, ['      run(lambda do |e|',
+                           "        w = e['warden']",
+                           '      end)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle parentheses used with no parameters' do
-    inspect_source(cop, ['func()'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle a call with a block inside another call' do
+      src = ['new(table_name,',
+             '    exec_query("info(\'#{row[\'name\']}\')").map { |col|',
+             "      col['name']",
+             '    })']
+      inspect_source(cop, src)
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle a multiline hash as second parameter' do
-    inspect_source(cop, ['tag(:input, {',
-                         '  :value => value',
-                         '})'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle a ternary condition with a block reference' do
+      inspect_source(cop, ['cond ? a : func(&b)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle method calls without parentheses' do
-    inspect_source(cop, ['a(b c, d)'])
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle parentheses used with no parameters' do
+      inspect_source(cop, ['func()'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'can handle other method calls without parentheses' do
-    src = ['chars(Unicode.apply_mapping @wrapped_string, :uppercase)']
-    inspect_source(cop, src)
-    expect(cop.offences).to be_empty
-  end
+    it 'can handle a multiline hash as second parameter' do
+      inspect_source(cop, ['tag(:input, {',
+                           '  :value => value',
+                           '})'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'auto-corrects alignment' do
-    new_source = autocorrect_source(cop, ['func(a,',
-                                          '       b,',
-                                          'c)'])
-    expect(new_source).to eq(['func(a,',
-                              '     b,',
-                              '     c)'].join("\n"))
-  end
+    it 'can handle method calls without parentheses' do
+      inspect_source(cop, ['a(b c, d)'])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'auto-corrects each line of a multi-line parameter to the right' do
-    new_source =
-      autocorrect_source(cop,
-                         ['create :transaction, :closed,',
-                          '      account:          account,',
-                          '      open_price:       1.29,',
-                          '      close_price:      1.30'])
-    expect(new_source)
-      .to eq(['create :transaction, :closed,',
-              '       account:          account,',
-              '       open_price:       1.29,',
-              '       close_price:      1.30'].join("\n"))
-  end
+    it 'can handle other method calls without parentheses' do
+      src = ['chars(Unicode.apply_mapping @wrapped_string, :uppercase)']
+      inspect_source(cop, src)
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'auto-corrects alignment' do
+      new_source = autocorrect_source(cop, ['func(a,',
+                                            '       b,',
+                                            'c)'])
+      expect(new_source).to eq(['func(a,',
+                                '     b,',
+                                '     c)'].join("\n"))
+    end
+
+    it 'auto-corrects each line of a multi-line parameter to the right' do
+      new_source =
+        autocorrect_source(cop,
+                           ['create :transaction, :closed,',
+                            '      account:          account,',
+                            '      open_price:       1.29,',
+                            '      close_price:      1.30'])
+      expect(new_source)
+        .to eq(['create :transaction, :closed,',
+                '       account:          account,',
+                '       open_price:       1.29,',
+                '       close_price:      1.30'].join("\n"))
+    end
+
+    it 'auto-corrects each line of a multi-line parameter to the left' do
+      new_source =
+        autocorrect_source(cop,
+                           ['create :transaction, :closed,',
+                            '         account:          account,',
+                            '         open_price:       1.29,',
+                            '         close_price:      1.30'])
+      expect(new_source)
+        .to eq(['create :transaction, :closed,',
+                '       account:          account,',
+                '       open_price:       1.29,',
+                '       close_price:      1.30'].join("\n"))
+    end
 
-  it 'auto-corrects each line of a multi-line parameter to the left' do
-    new_source =
-      autocorrect_source(cop,
-                         ['create :transaction, :closed,',
-                          '         account:          account,',
-                          '         open_price:       1.29,',
-                          '         close_price:      1.30'])
-    expect(new_source)
-      .to eq(['create :transaction, :closed,',
-              '       account:          account,',
-              '       open_price:       1.29,',
-              '       close_price:      1.30'].join("\n"))
+    it 'auto-corrects only parameters that begin a line' do
+      original_source = ['foo(:bar, {',
+                         '    whiz: 2, bang: 3 }, option: 3)']
+      new_source = autocorrect_source(cop, original_source)
+      expect(new_source).to eq(original_source.join("\n"))
+    end
   end
 
-  it 'auto-corrects only parameters that begin a line' do
-    original_source = ['foo(:bar, {',
-                       '    whiz: 2, bang: 3 }, option: 3)']
-    new_source = autocorrect_source(cop, original_source)
-    expect(new_source).to eq(original_source.join("\n"))
+  context 'aligned with fixed indentation' do
+    let(:cop_config) do
+      {
+        'EnforcedStyle' => 'with_fixed_indentation'
+      }
+    end
+
+    let(:correct_source) do
+      [
+        'create :transaction, :closed,',
+        '  account:     account,',
+        '  open_price:  1.29,',
+        '  close_price: 1.30'
+      ]
+    end
+
+    it 'does not autocorrect correct source' do
+      expect(autocorrect_source(cop, correct_source))
+        .to eq(correct_source.join("\n"))
+    end
+
+    it 'autocorrects by outdenting when indented too far' do
+      original_source = [
+        'create :transaction, :closed,',
+        '       account:     account,',
+        '       open_price:  1.29,',
+        '       close_price: 1.30'
+      ]
+
+      expect(autocorrect_source(cop, original_source))
+        .to eq(correct_source.join("\n"))
+    end
+
+    it 'autocorrects by indenting when not indented' do
+      original_source = [
+        'create :transaction, :closed,',
+        'account:     account,',
+        'open_price:  1.29,',
+        'close_price: 1.30'
+      ]
+
+      expect(autocorrect_source(cop, original_source))
+        .to eq(correct_source.join("\n"))
+    end
+
+    it 'autocorrects when first line is indented' do
+      original_source = [
+        '  create :transaction, :closed,',
+        '  account:     account,',
+        '  open_price:  1.29,',
+        '  close_price: 1.30'
+      ]
+
+      correct_source = [
+        '  create :transaction, :closed,',
+        '    account:     account,',
+        '    open_price:  1.29,',
+        '    close_price: 1.30'
+      ]
+
+      expect(autocorrect_source(cop, original_source))
+        .to eq(correct_source.join("\n"))
+    end
   end
 end