rubocop 0.11.1 → 0.12.0

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

@@ -6,33 +6,38 @@ module Rubocop
   module Cop
     module Style
       describe DefWithParentheses do
-        let(:def_par) { DefWithParentheses.new }
+        let(:cop) { described_class.new }
 
         it 'reports an offence for def with empty parens' do
           src = ['def func()',
                  'end']
-          inspect_source(def_par, src)
-          expect(def_par.offences.size).to eq(1)
+          inspect_source(cop, src)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'reports an offence for class def with empty parens' do
           src = ['def Test.func()',
                  'end']
-          inspect_source(def_par, src)
-          expect(def_par.offences.size).to eq(1)
+          inspect_source(cop, src)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'accepts def with arg and parens' do
           src = ['def func(a)',
                  'end']
-          inspect_source(def_par, src)
-          expect(def_par.offences).to be_empty
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
         end
 
         it 'accepts empty parentheses in one liners' do
           src = ["def to_s() join '/' end"]
-          inspect_source(def_par, src)
-          expect(def_par.offences).to be_empty
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'auto-removes unneeded parens' do
+          new_source = autocorrect_source(cop, "def test();\nsomething\nend")
+          expect(new_source).to eq("def test;\nsomething\nend")
         end
       end
     end

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

@@ -6,27 +6,32 @@ module Rubocop
   module Cop
     module Style
       describe DefWithoutParentheses do
-        let(:def_par) { DefWithoutParentheses.new }
+        let(:cop) { described_class.new }
 
         it 'reports an offence for def with parameters but no parens' do
           src = ['def func a, b',
                  'end']
-          inspect_source(def_par, src)
-          expect(def_par.offences.size).to eq(1)
+          inspect_source(cop, src)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'reports an offence for class def with parameters but no parens' do
           src = ['def Test.func a, b',
                  'end']
-          inspect_source(def_par, src)
-          expect(def_par.offences.size).to eq(1)
+          inspect_source(cop, src)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'accepts def with no args and no parens' do
           src = ['def func',
                  'end']
-          inspect_source(def_par, src)
-          expect(def_par.offences).to be_empty
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'auto-adds required parens' do
+          new_source = autocorrect_source(cop, 'def test param; end')
+          expect(new_source).to eq('def test (param); end')
         end
       end
     end

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

@@ -6,83 +6,98 @@ module Rubocop
   module Cop
     module Style
       describe EmptyLiteral do
-        let(:a) { EmptyLiteral.new }
+        let(:cop) { described_class.new }
 
         describe 'Empty Array' do
           it 'registers an offence for Array.new()' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = Array.new()'])
-            expect(a.offences.size).to eq(1)
-            expect(a.offences.map(&:message))
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences.map(&:message))
               .to eq([EmptyLiteral::ARR_MSG])
           end
 
           it 'registers an offence for Array.new' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = Array.new'])
-            expect(a.offences.size).to eq(1)
-            expect(a.offences.map(&:message))
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences.map(&:message))
               .to eq([EmptyLiteral::ARR_MSG])
           end
 
           it 'does not register an offence for Array.new(3)' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = Array.new(3)'])
-            expect(a.offences).to be_empty
+            expect(cop.offences).to be_empty
+          end
+
+          it 'auto-corrects Array.new to []' do
+            new_source = autocorrect_source(cop, 'test = Array.new')
+            expect(new_source).to eq('test = []')
           end
         end
 
         describe 'Empty Hash' do
           it 'registers an offence for Hash.new()' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = Hash.new()'])
-            expect(a.offences.size).to eq(1)
-            expect(a.offences.map(&:message))
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences.map(&:message))
               .to eq([EmptyLiteral::HASH_MSG])
           end
 
           it 'registers an offence for Hash.new' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = Hash.new'])
-            expect(a.offences.size).to eq(1)
-            expect(a.offences.map(&:message))
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences.map(&:message))
               .to eq([EmptyLiteral::HASH_MSG])
           end
 
           it 'does not register an offence for Hash.new(3)' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = Hash.new(3)'])
-            expect(a.offences).to be_empty
+            expect(cop.offences).to be_empty
           end
 
           it 'does not register an offence for Hash.new { block }' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = Hash.new { block }'])
-            expect(a.offences).to be_empty
+            expect(cop.offences).to be_empty
+          end
+
+          it 'auto-corrects Hash.new to {}' do
+            new_source = autocorrect_source(cop, 'test = Hash.new')
+            expect(new_source).to eq('test = {}')
           end
         end
 
         describe 'Empty String' do
           it 'registers an offence for String.new()' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = String.new()'])
-            expect(a.offences.size).to eq(1)
-            expect(a.offences.map(&:message))
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences.map(&:message))
               .to eq([EmptyLiteral::STR_MSG])
           end
 
           it 'registers an offence for String.new' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = String.new'])
-            expect(a.offences.size).to eq(1)
-            expect(a.offences.map(&:message))
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences.map(&:message))
               .to eq([EmptyLiteral::STR_MSG])
           end
 
           it 'does not register an offence for String.new("top")' do
-            inspect_source(a,
+            inspect_source(cop,
                            ['test = String.new("top")'])
-            expect(a.offences).to be_empty
+            expect(cop.offences).to be_empty
+          end
+
+          it 'auto-corrects String.new to empty string literal' do
+            new_source = autocorrect_source(cop, 'test = String.new')
+            expect(new_source).to eq("test = ''")
           end
         end
       end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe EvenOdd do
+        let(:cop) { described_class.new }
+
+        it 'registers an offence for x % 2 == 0' do
+          inspect_source(cop,
+                         ['x % 2 == 0'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([EvenOdd::MSG_EVEN])
+        end
+
+        it 'registers an offence for (x % 2) == 0' do
+          inspect_source(cop,
+                         ['(x % 2) == 0'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([EvenOdd::MSG_EVEN])
+        end
+
+        it 'registers an offence for x % 2 == 1' do
+          inspect_source(cop,
+                         ['x % 2 == 1'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([EvenOdd::MSG_ODD])
+        end
+
+        it 'registers an offence for (x % 2) == 1' do
+          inspect_source(cop,
+                         ['(x % 2) == 1'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([EvenOdd::MSG_ODD])
+        end
+
+        it 'accepts x % 3 == 0' do
+          inspect_source(cop,
+                         ['x % 3 == 0'])
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -28,20 +28,20 @@ module Rubocop
         end
 
         it 'registers an offence for short multiline if near an else etc' do
-           inspect_source(if_unless,
-                          ['if x',
-                           '  y',
-                           'elsif x1',
-                           '  y1',
-                           'else',
-                           '  z',
-                           'end',
-                           'n = a ? 0 : 1',
-                           'm = 3 if m0',
-                           '',
-                           'if a',
-                           '  b',
-                           'end'])
+          inspect_source(if_unless,
+                         ['if x',
+                          '  y',
+                          'elsif x1',
+                          '  y1',
+                          'else',
+                          '  z',
+                          'end',
+                          'n = a ? 0 : 1',
+                          'm = 3 if m0',
+                          '',
+                          'if a',
+                          '  b',
+                          'end'])
           expect(if_unless.offences.size).to eq(1)
         end
 
@@ -148,6 +148,7 @@ module Rubocop
           expect(cop.offences.map(&:message)).to eq(
             ['Favor modifier while/until usage when you have a single-line ' +
              'body.'])
+          expect(cop.offences.map { |o| o.location.source }).to eq([keyword])
         end
 
         def check_too_long(cop, keyword)

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe HashMethods do
+        let(:cop) { described_class.new }
+
+        it 'registers an offence for has_key? with one arg' do
+          inspect_source(cop,
+                         ['o.has_key?(o)'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages)
+            .to eq(['has_key? is deprecated in favor of key?.'])
+        end
+
+        it 'accepts has_key? with no args' do
+          inspect_source(cop,
+                         ['o.has_key?'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'registers an offence for has_value? with one arg' do
+          inspect_source(cop,
+                         ['o.has_value?(o)'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages)
+            .to eq(['has_value? is deprecated in favor of value?.'])
+        end
+
+        it 'accepts has_value? with no args' do
+          inspect_source(cop,
+                         ['o.has_value?'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'auto-corrects has_key? with key?' do
+          new_source = autocorrect_source(cop, 'hash.has_key?(:test)')
+          expect(new_source).to eq('hash.key?(:test)')
+        end
+
+        it 'auto-corrects has_value? with value?' do
+          new_source = autocorrect_source(cop, 'hash.has_value?(value)')
+          expect(new_source).to eq('hash.value?(value)')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,390 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe IndentationWidth do
+        let(:cop) { described_class.new }
+
+        context 'with if statement' do
+          it 'registers an offence for bad indentation of an if body' do
+            inspect_source(cop,
+                           ['if cond',
+                            ' func',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.'])
+          end
+
+          it 'registers an offence for bad indentation of an else body' do
+            inspect_source(cop,
+                           ['if cond',
+                            '  func1',
+                            'else',
+                            ' func2',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.'])
+          end
+
+          it 'registers an offence for bad indentation of an elsif body' do
+            inspect_source(cop,
+                           ['if a1',
+                            '  b1',
+                            'elsif a2',
+                            ' b2',
+                            'else',
+                            '  c',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.'])
+          end
+
+          it 'registers offence for bad indentation of ternary inside else' do
+            inspect_source(cop,
+                           ['if a',
+                            '  b',
+                            'else',
+                            '     x ? y : z',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 5) spaces for indentation.'])
+          end
+
+          it 'registers offence for bad indentation of modifier if in else' do
+            inspect_source(cop,
+                           ['if a',
+                            '  b',
+                            'else',
+                            '   x if y',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 3) spaces for indentation.'])
+          end
+
+          it 'accepts a one line if statement' do
+            inspect_source(cop,
+                           ['if cond then func1 else func2 end'])
+            expect(cop.offences).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.offences).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.offences).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.offences).to be_empty
+          end
+
+          it 'accepts an empty if' do
+            inspect_source(cop,
+                           ['if a',
+                            'else',
+                            'end'])
+            expect(cop.offences).to be_empty
+          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.offences).to be_empty
+          end
+        end
+
+        context 'with unless' do
+          it 'registers an offence for bad indentation of an unless body' do
+            inspect_source(cop,
+                           ['unless cond',
+                            ' func',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .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.offences).to be_empty
+          end
+        end
+
+        context 'with case' do
+          it 'registers an offence for bad indentation in a case/when body' do
+            inspect_source(cop,
+                           ['case a',
+                            'when b',
+                            ' c',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.'])
+          end
+
+          it 'registers an offence 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.offences.map(&:message))
+              .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',
+                            'when d',
+                            'else',
+                            '  f',
+                            'end'])
+            expect(cop.offences).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.offences).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.offences).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.offences).to be_empty
+          end
+
+          it 'accepts an empty case' do
+            inspect_source(cop,
+                           ['case a',
+                            'end'])
+            expect(cop.offences).to be_empty
+          end
+        end
+
+        context 'with while/until' do
+          it 'registers an offence for bad indentation of a while body' do
+            inspect_source(cop,
+                           ['while cond',
+                            ' func',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.'])
+          end
+
+          it 'registers an offence for bad indentation of begin/end/while' do
+            inspect_source(cop,
+                           ['begin',
+                            ' func1',
+                            '   func2',
+                            'end while cond'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.',
+                      'Use 2 (not 3) spaces for indentation.'])
+          end
+
+          it 'registers an offence for bad indentation of an until body' do
+            inspect_source(cop,
+                           ['until cond',
+                            ' func',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.'])
+          end
+
+          it 'accepts an empty while' do
+            inspect_source(cop,
+                           ['while a',
+                            'end'])
+            expect(cop.offences).to be_empty
+          end
+        end
+
+        context 'with for' do
+          it 'registers an offence for bad indentation of a for body' do
+            inspect_source(cop,
+                           ['for var in 1..10',
+                            ' func',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .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.offences).to be_empty
+          end
+        end
+
+        context 'with def/defs' do
+          it 'registers an offence for bad indentation of a def body' do
+            inspect_source(cop,
+                           ['def test',
+                            '    func1',
+                            '     func2', # No offence registered for this.
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 4) spaces for indentation.'])
+          end
+
+          it 'registers an offence for bad indentation of a defs body' do
+            inspect_source(cop,
+                           ['def self.test',
+                            '   func',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .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.offences).to be_empty
+          end
+
+          it 'accepts an empty defs body' do
+            inspect_source(cop,
+                           ['def self.test',
+                            'end'])
+            expect(cop.offences).to be_empty
+          end
+        end
+
+        context 'with class' do
+          it 'registers an offence for bad indentation of a class body' do
+            inspect_source(cop,
+                           ['class Test',
+                            '    def func',
+                            '    end',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .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.offences).to be_empty
+          end
+        end
+
+        context 'with module' do
+          it 'registers an offence for bad indentation of a module body' do
+            inspect_source(cop,
+                           ['module Test',
+                            '    def func',
+                            '    end',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .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.offences).to be_empty
+          end
+        end
+
+        context 'with block' do
+          it 'registers an offence for bad indentation of a do/end body' do
+            inspect_source(cop,
+                           ['a = func do',
+                            ' b',
+                            'end'])
+            expect(cop.offences.map(&:message))
+              .to eq(['Use 2 (not 1) spaces for indentation.'])
+          end
+
+          it 'registers an offence for bad indentation of a {} body' do
+            inspect_source(cop,
+                           ['func {',
+                            '   b',
+                            '}'])
+            expect(cop.offences.map(&:message))
+              .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.offences).to be_empty
+          end
+
+          it 'accepts an empty block body' do
+            inspect_source(cop,
+                           ['a = func do',
+                            'end'])
+            expect(cop.offences).to be_empty
+          end
+        end
+      end
+    end
+  end
+end