rubocop 0.12.0 → 0.13.0

data/spec/rubocop/cop/lint/useless_comparison_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Lint
       describe UselessComparison do
-        let(:cop) { UselessComparison.new }
+        subject(:cop) { UselessComparison.new }
 
         UselessComparison::OPS.each do |op|
           it "registers an offence for a simple comparison with #{op}" do

data/spec/rubocop/cop/lint/useless_setter_call_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe UselessSetterCall do
+        subject(:cop) { UselessSetterCall.new }
+
+        it 'registers an offence for def ending with lvar attr assignment' do
+          inspect_source(cop,
+                         ['def test',
+                          '  top = Top.new',
+                          '  top.attr = 5',
+                          'end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for defs ending with lvar attr assignment' do
+          inspect_source(cop,
+                         ['def Top.test',
+                          '  top = Top.new',
+                          '  top.attr = 5',
+                          'end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'accepts def ending with ivar assignment' do
+          inspect_source(cop,
+                         ['def test',
+                          '  something',
+                          '  @top = 5',
+                          'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts def ending ivar attr assignment' do
+          inspect_source(cop,
+                         ['def test',
+                          '  something',
+                          '  @top.attr = 5',
+                          'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts def ending with argument attr assignment' do
+          inspect_source(cop,
+                         ['def test(some_arg)',
+                          '  unrelated_local_variable = Top.new',
+                          '  some_arg.attr = 5',
+                          'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
+
+        context 'when a lvar has an object passed as argument ' +
+                'at the end of the method' do
+          it 'accepts the lvar attr assignment' do
+            inspect_source(cop,
+                           ['def test(some_arg)',
+                            '  @some_ivar = some_arg',
+                            '  @some_ivar.do_something',
+                            '  some_lvar = @some_ivar',
+                            '  some_lvar.do_something',
+                            '  some_lvar.attr = 5',
+                            'end'
+                           ])
+            expect(cop.offences).to be_empty
+          end
+        end
+
+        context 'when a lvar declared as an argument ' +
+                'is no longer the passed object at the end of the method' do
+          it 'registers an offence for the lvar attr assignment' do
+            inspect_source(cop,
+                           ['def test(some_arg)',
+                            '  some_arg = Top.new',
+                            '  some_arg.attr = 5',
+                            'end'
+                           ])
+            expect(cop.offences.size).to eq(1)
+          end
+        end
+
+        it 'is not confused by operators ending with =' do
+          inspect_source(cop,
+                         ['def test',
+                          '  top.attr == 5',
+                          'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cop/lint/void_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Lint
       describe Void do
-        let(:void_op) { Void.new }
+        subject(:void_op) { Void.new }
 
         Void::OPS.each do |op|
           it "registers an offence for void op #{op} if not on last line" do

data/spec/rubocop/cop/offence_spec.rb

@@ -110,11 +110,11 @@ module Rubocop
       describe '#<=>' do
         def offence(hash = {})
           attrs = {
-             sev: :convention,
+            sev:  :convention,
             line: 5,
-             col: 5,
-             mes: 'message',
-             cop: 'CopName'
+            col:  5,
+            mes:  'message',
+            cop:  'CopName'
           }.merge(hash)
 
           Offence.new(

data/spec/rubocop/cop/rails/has_and_belongs_to_many_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Rails
       describe HasAndBelongsToMany do
-        let(:cop) { described_class.new }
+        subject(:cop) { described_class.new }
 
         it 'registers an offence for has_and_belongs_to_many' do
           inspect_source(cop,

data/spec/rubocop/cop/rails/read_attribute_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Rails
       describe ReadAttribute do
-        let(:cop) { described_class.new }
+        subject(:cop) { described_class.new }
 
         it 'registers an offence for read_attribute' do
           inspect_source(cop,

data/spec/rubocop/cop/rails/validation_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Rails
       describe Validation do
-        let(:cop) { described_class.new }
+        subject(:cop) { described_class.new }
 
         Validation::BLACKLIST.each do |validation|
           it "registers an offence for #{validation}" do

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

@@ -6,18 +6,18 @@ module Rubocop
   module Cop
     module Style
       describe AccessControl do
-        let(:a) { AccessControl.new }
+        subject(:a) { AccessControl.new }
 
         it 'registers an offence for misaligned private' do
           inspect_source(a,
                          ['class Test',
-                           '',
-                           'private',
-                           '',
-                           '  def test; end',
-                           'end'])
+                          '',
+                          'private',
+                          '',
+                          '  def test; end',
+                          'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::INDENT_MSG, 'private')])
         end
 
@@ -30,20 +30,20 @@ module Rubocop
                           '  def test; end',
                           'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::INDENT_MSG, 'private')])
         end
 
         it 'registers an offence for misaligned private in singleton class' do
           inspect_source(a,
                          ['class << self',
-                           '',
-                           'private',
-                           '',
-                           '  def test; end',
-                           'end'])
+                          '',
+                          'private',
+                          '',
+                          '  def test; end',
+                          'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::INDENT_MSG, 'private')])
         end
 
@@ -57,7 +57,7 @@ module Rubocop
                           '  def test; end',
                           'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::INDENT_MSG, 'private')])
         end
 
@@ -71,7 +71,7 @@ module Rubocop
                           '  def test; end',
                           'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::INDENT_MSG, 'private')])
         end
 
@@ -84,7 +84,7 @@ module Rubocop
                           '  def test; end',
                           'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::INDENT_MSG, 'protected')])
         end
 
@@ -126,7 +126,7 @@ module Rubocop
                           '  def test; end',
                           'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::INDENT_MSG, 'private')])
         end
 
@@ -138,7 +138,7 @@ module Rubocop
                           '  def test; end',
                           'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::BLANK_MSG, 'protected')])
         end
 
@@ -150,7 +150,7 @@ module Rubocop
                           '  def test; end',
                           'end'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([format(AccessControl::BLANK_MSG, 'protected')])
         end
 

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

@@ -6,13 +6,13 @@ module Rubocop
   module Cop
     module Style
       describe Alias do
-        let(:a) { Alias.new }
+        subject(:a) { Alias.new }
 
         it 'registers an offence for alias with symbol args' do
           inspect_source(a,
                          ['alias :ala :bala'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([Alias::MSG])
         end
 
@@ -20,7 +20,7 @@ module Rubocop
           inspect_source(a,
                          ['alias ala bala'])
           expect(a.offences.size).to eq(1)
-          expect(a.offences.map(&:message))
+          expect(a.messages)
             .to eq([Alias::MSG])
         end
 

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe AlignArray do
+        subject(:cop) { described_class.new }
+
+        it 'registers an offence for misaligned array elements' do
+          inspect_source(cop, ['array = [',
+                               '  a,',
+                               '   b,',
+                               '  c,',
+                               '   d',
+                               ']'])
+          expect(cop.messages).to eq(['Align the elements of an array ' +
+                                      'literal if they span more than ' +
+                                      'one line.'] * 2)
+          expect(cop.highlights).to eq(%w(b d))
+        end
+
+        it 'accepts aligned array keys' do
+          inspect_source(cop, ['array = [',
+                               '  a,',
+                               '  b,',
+                               '  c,',
+                               '  d',
+                               ']'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts single line array' do
+          inspect_source(cop, 'array = [ a, b ]')
+          expect(cop.offences).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
+        end
+
+        it 'auto-corrects alignment' do
+          new_source = autocorrect_source(cop, ['array = [',
+                                                '  a,',
+                                                '   b,',
+                                                '  c,',
+                                                ' d',
+                                                ']'])
+          expect(new_source).to eq(['array = [',
+                                    '  a,',
+                                    '  b,',
+                                    '  c,',
+                                    '  d',
+                                    ']'].join("\n"))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,267 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe AlignHash, :config do
+        subject(:cop) { described_class.new(config) }
+        let(:cop_config) do
+          {
+            'EnforcedHashRocketStyle' => 'key',
+            'EnforcedColonStyle' => 'key'
+          }
+        end
+
+        context 'with default configuration' do
+          it 'registers an offence for misaligned hash keys' do
+            inspect_source(cop, ['hash1 = {',
+                                 '  a: 0,',
+                                 '   bb: 1',
+                                 '}',
+                                 'hash2 = {',
+                                 "  'ccc' => 2,",
+                                 " 'dddd'  =>  2",
+                                 '}'])
+            expect(cop.messages).to eq(['Align the elements of a hash ' +
+                                        'literal if they span more than ' +
+                                        'one line.'] * 2)
+            expect(cop.highlights).to eq(['bb: 1',
+                                          "'dddd'  =>  2"])
+          end
+
+          it 'accepts aligned hash keys' do
+            inspect_source(cop, ['hash1 = {',
+                                 '  a: 0,',
+                                 '  bb: 1,',
+                                 '}',
+                                 'hash2 = {',
+                                 "  'ccc' => 2,",
+                                 "  'dddd'  =>  2",
+                                 '}'])
+            expect(cop.offences).to be_empty
+          end
+
+          it 'registers an offence for separator alignment' do
+            inspect_source(cop, ['hash = {',
+                                 "    'a' => 0,",
+                                 "  'bbb' => 1",
+                                 '}'])
+            expect(cop.offences).to have(1).item
+            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
+              inspect_source(cop, ['func(a: 0,',
+                                   '  b: 1)'])
+              expect(cop.offences).to have(1).item
+            end
+
+            it 'registers an offence for right alignment of keys' do
+              inspect_source(cop, ['func(a: 0,',
+                                   '   bbb: 1)'])
+              expect(cop.offences).to have(1).item
+            end
+
+            it 'accepts aligned hash keys' do
+              inspect_source(cop, ['func(a: 0,',
+                                   '     b: 1)'])
+              expect(cop.offences).to be_empty
+            end
+          end
+
+          it 'auto-corrects alignment' do
+            new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
+                                                  '     bb: 1,',
+                                                  '           ccc: 2 }',
+                                                  'hash2 = { :a   => 0,',
+                                                  '     :bb  => 1,',
+                                                  '          :ccc  =>2 }',
+                                                 ])
+            expect(new_source).to eq(['hash1 = { a: 0,',
+                                      '          bb: 1,',
+                                      '          ccc: 2 }',
+                                      'hash2 = { :a   => 0,',
+                                      '          :bb  => 1,',
+                                      # Separator and value are not corrected
+                                      # in 'key' mode.
+                                      '          :ccc  =>2 }'].join("\n"))
+          end
+        end
+
+        it 'accepts single line hash' do
+          inspect_source(cop, 'hash = { a: 0, b: 1 }')
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts several pairs per line' do
+          inspect_source(cop, ['hash = { a: 0, b: 1,',
+                               '         c: 2, d: 3 }'])
+          expect(cop.offences).to be_empty
+        end
+
+        context 'with table alignment configuration' do
+          let(:cop_config) do
+            {
+              'EnforcedHashRocketStyle' => 'table',
+              'EnforcedColonStyle' => 'table'
+            }
+          end
+
+          it 'accepts aligned hash keys' do
+            inspect_source(cop, ['hash1 = {',
+                                 "  'a'   => 0,",
+                                 "  'bbb' => 1",
+                                 '}',
+                                 'hash2 = {',
+                                 '  a:   0,',
+                                 '  bbb: 1',
+                                 '}',
+                                ])
+            expect(cop.offences).to be_empty
+          end
+
+          it 'registers an offence for misaligned hash values' do
+            inspect_source(cop, ['hash1 = {',
+                                 "  'a'   =>  0,",
+                                 "  'bbb' => 1",
+                                 '}',
+                                 'hash2 = {',
+                                 '  a:   0,',
+                                 '  bbb:1',
+                                 '}',
+                                ])
+            expect(cop.highlights).to eq(["'a'   =>  0",
+                                          'bbb:1'])
+          end
+
+          it 'registers an offence for misaligned hash rockets' do
+            inspect_source(cop, ['hash = {',
+                                 "  'a'   => 0,",
+                                 "  'bbb'  => 1",
+                                 '}'])
+            expect(cop.offences).to have(1).item
+          end
+
+          it 'auto-corrects alignment' do
+            new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
+                                                  '     bb:   1,',
+                                                  '           ccc: 2 }',
+                                                  "hash2 = { 'a' => 0,",
+                                                  "     'bb' =>   1,",
+                                                  "           'ccc'  =>2 }"])
+            expect(new_source).to eq(['hash1 = { a:   0,',
+                                      '          bb:  1,',
+                                      '          ccc: 2 }',
+                                      "hash2 = { 'a'   => 0,",
+                                      "          'bb'  => 1,",
+                                      "          'ccc' => 2 }"].join("\n"))
+          end
+        end
+
+        context 'with invalid configuration' do
+          let(:cop_config) do
+            {
+              'EnforcedHashRocketStyle' => 'junk',
+              'EnforcedColonStyle' => 'junk'
+            }
+          end
+          it 'fails' do
+            src = ['hash = {',
+                   '  a: 0,',
+                   '  bb: 1',
+                   '}']
+            expect { inspect_source(cop, src) }.to raise_error(RuntimeError)
+          end
+        end
+
+        context 'with separator alignment configuration' do
+          let(:cop_config) do
+            {
+              'EnforcedHashRocketStyle' => 'separator',
+              'EnforcedColonStyle' => 'separator'
+            }
+          end
+
+          it 'accepts aligned hash keys' do
+            inspect_source(cop, ['hash1 = {',
+                                 '    a: 0,',
+                                 '  bbb: 1',
+                                 '}',
+                                 'hash2 = {',
+                                 "    'a' => 0,",
+                                 "  'bbb' => 1",
+                                 '}'])
+            expect(cop.offences).to be_empty
+          end
+
+          it 'registers an offence for misaligned hash values' do
+            inspect_source(cop, ['hash = {',
+                                 "    'a' =>  0,",
+                                 "  'bbb' => 1",
+                                 '}'])
+            expect(cop.offences).to have(1).item
+          end
+
+          it 'registers an offence for misaligned hash rockets' do
+            inspect_source(cop, ['hash = {',
+                                 "    'a'  => 0,",
+                                 "  'bbb' =>  1",
+                                 '}'])
+            expect(cop.offences).to have(1).item
+          end
+
+          it 'auto-corrects alignment' do
+            new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
+                                                  '     bb:    1,',
+                                                  '           ccc: 2 }',
+                                                  'hash2 = { a => 0,',
+                                                  '     bb =>    1,',
+                                                  '           ccc  =>2 }'])
+            expect(new_source).to eq(['hash1 = { a: 0,',
+                                      '         bb: 1,',
+                                      '        ccc: 2 }',
+                                      'hash2 = { a => 0,',
+                                      '         bb => 1,',
+                                      '        ccc => 2 }'].join("\n"))
+          end
+        end
+
+        context 'with different settings for => and :' do
+          let(:cop_config) do
+            {
+              'EnforcedHashRocketStyle' => 'key',
+              'EnforcedColonStyle' => 'separator'
+            }
+          end
+
+          it 'registers offences for misaligned entries' do
+            inspect_source(cop, ['hash1 = {',
+                                 '  a:   0,',
+                                 '  bbb: 1',
+                                 '}',
+                                 'hash2 = {',
+                                 "    'a' => 0,",
+                                 "  'bbb' => 1",
+                                 '}'])
+            expect(cop.highlights).to eq(['bbb: 1', "'bbb' => 1"])
+          end
+
+          it 'accepts aligned entries' do
+            inspect_source(cop, ['hash1 = {',
+                                 '    a: 0,',
+                                 '  bbb: 1',
+                                 '}',
+                                 'hash2 = {',
+                                 "  'a' => 0,",
+                                 "  'bbb' => 1",
+                                 '}'])
+            expect(cop.offences).to be_empty
+          end
+        end
+      end
+    end
+  end
+end