sabat-rubocop 0.9.0

data/spec/rubocop/cops/lint/end_in_method_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe EndInMethod do
+        let(:cop) { EndInMethod.new }
+
+        it 'reports an offence for def with an END inside' do
+          src = ['def test',
+                 '  END { something }',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'reports an offence for defs with an END inside' do
+          src = ['def self.test',
+                 '  END { something }',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'accepts END outside of def(s)' do
+          src = ['END { something }']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/lint/ensure_return_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe EnsureReturn do
+        let(:er) { EnsureReturn.new }
+
+        it 'registers an offence for return in ensure' do
+          inspect_source(er,
+                         ['begin',
+                          '  something',
+                          'ensure',
+                          '  file.close',
+                          '  return',
+                          'end'])
+          expect(er.offences.size).to eq(1)
+          expect(er.offences.map(&:message))
+            .to eq([EnsureReturn::MSG])
+        end
+
+        it 'does not register an offence for return outside ensure' do
+          inspect_source(er,
+                         ['begin',
+                          '  something',
+                          '  return',
+                          'ensure',
+                          '  file.close',
+                          'end'])
+          expect(er.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/lint/eval_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe Eval do
+        let(:a) { Eval.new }
+
+        it 'registers an offence for eval as function' do
+          inspect_source(a,
+                         ['eval(something)'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([Eval::MSG])
+        end
+
+        it 'registers an offence for eval as command' do
+          inspect_source(a,
+                         ['eval something'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([Eval::MSG])
+        end
+
+        it 'does not register an offence for eval as variable' do
+          inspect_source(a,
+                         ['eval = something'])
+          expect(a.offences).to be_empty
+        end
+
+        it 'does not register an offence for eval as method' do
+          inspect_source(a,
+                         ['something.eval'])
+          expect(a.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/lint/handle_exceptions_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe HandleExceptions do
+        let(:he) { HandleExceptions.new }
+
+        it 'registers an offence for empty rescue block' do
+          inspect_source(he,
+                         ['begin',
+                          '  something',
+                          'rescue',
+                          '  #do nothing',
+                          'end'])
+          expect(he.offences.size).to eq(1)
+          expect(he.offences.map(&:message))
+            .to eq([HandleExceptions::MSG])
+        end
+
+        it 'does not register an offence for rescue with body' do
+          inspect_source(he,
+                         ['begin',
+                          '  something',
+                          '  return',
+                          'rescue',
+                          '  file.close',
+                          'end'])
+          expect(he.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/lint/literal_in_condition_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe LiteralInCondition do
+        let(:cop) { LiteralInCondition.new }
+
+        %w(1 2.0 [1] {}).each do |lit|
+          it "registers an offence for literal #{lit} in condition" do
+            inspect_source(cop,
+                           ["if x && #{lit}",
+                            '  top',
+                            'end'
+                           ])
+            expect(cop.offences.size).to eq(1)
+          end
+
+          it "accepts literal #{lit} if it's not an and/or operand" do
+            inspect_source(cop,
+                           ["if test(#{lit})",
+                            '  top',
+                            'end'
+                           ])
+            expect(cop.offences).to be_empty
+          end
+
+          it "accepts literal #{lit} in non-toplevel and/or" do
+            inspect_source(cop,
+                           ["if (a || #{lit}).something",
+                            '  top',
+                            'end'
+                           ])
+            expect(cop.offences).to be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/lint/loop_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe Loop do
+        let(:loop) { Loop.new }
+
+        it 'registers an offence for begin/end/while' do
+          inspect_source(loop, ['begin something; top; end while test'])
+          expect(loop.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for begin/end/until' do
+          inspect_source(loop, ['begin something; top; end until test'])
+          expect(loop.offences.size).to eq(1)
+        end
+
+        it 'accepts normal while' do
+          inspect_source(loop, ['while test; one; two; end'])
+          expect(loop.offences).to be_empty
+        end
+
+        it 'accepts normal until' do
+          inspect_source(loop, ['until test; one; two; end'])
+          expect(loop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/lint/rescue_exception_spec.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe RescueException do
+        let(:re) { RescueException.new }
+
+        it 'registers an offence for rescue from Exception' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          'rescue Exception',
+                          '  #do nothing',
+                          'end'])
+          expect(re.offences.size).to eq(1)
+          expect(re.offences.map(&:message))
+            .to eq([RescueException::MSG])
+        end
+
+        it 'registers an offence for rescue with ::Exception' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          'rescue ::Exception',
+                          '  #do nothing',
+                          'end'])
+          expect(re.offences.size).to eq(1)
+          expect(re.offences.map(&:message))
+            .to eq([RescueException::MSG])
+        end
+
+        it 'registers an offence for rescue with StandardError, Exception' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          'rescue StandardError, Exception',
+                          '  #do nothing',
+                          'end'])
+          expect(re.offences.size).to eq(1)
+          expect(re.offences.map(&:message))
+            .to eq([RescueException::MSG])
+        end
+
+        it 'registers an offence for rescue with Exception => e' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          'rescue Exception => e',
+                          '  #do nothing',
+                          'end'])
+          expect(re.offences.size).to eq(1)
+          expect(re.offences.map(&:message))
+            .to eq([RescueException::MSG])
+        end
+
+        it 'does not register an offence for rescue with no class' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          '  return',
+                          'rescue',
+                          '  file.close',
+                          'end'])
+          expect(re.offences).to be_empty
+        end
+
+        it 'does not register an offence for rescue with no class and => e' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          '  return',
+                          'rescue => e',
+                          '  file.close',
+                          'end'])
+          expect(re.offences).to be_empty
+        end
+
+        it 'does not register an offence for rescue with other class' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          '  return',
+                          'rescue ArgumentError => e',
+                          '  file.close',
+                          'end'])
+          expect(re.offences).to be_empty
+        end
+
+        it 'does not register an offence for rescue with other classes' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          '  return',
+                          'rescue EOFError, ArgumentError => e',
+                          '  file.close',
+                          'end'])
+          expect(re.offences).to be_empty
+        end
+
+        it 'does not register an offence for rescue with a module prefix' do
+          inspect_source(re,
+                         ['begin',
+                          '  something',
+                          '  return',
+                          'rescue Test::Exception => e',
+                          '  file.close',
+                          'end'])
+          expect(re.offences).to be_empty
+        end
+
+        it 'does not crash when the splat operator is used in a rescue' do
+          inspect_source(re,
+                         ['ERRORS = [Exception]',
+                          'begin',
+                          '  a = 3 / 0',
+                          'rescue *ERRORS',
+                          '  puts e',
+                          'end'])
+          expect(re.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/lint/shadowing_outer_local_variable_spec.rb

@@ -0,0 +1,243 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe ShadowingOuterLocalVariable do
+        subject(:cop) { ShadowingOuterLocalVariable.new }
+
+        context 'when a block argument has same name ' +
+                'as an outer scope variable' do
+          let(:source) do
+            [
+              'def some_method',
+              '  foo = 1',
+              '  puts foo',
+              '  1.times do |foo|',
+              '  end',
+              'end'
+            ]
+          end
+
+          it 'registers an offence' do
+            inspect_source(cop, source)
+            expect(cop.offences).to have(1).item
+            expect(cop.offences.first.message)
+              .to include('Shadowing outer local variable - foo')
+            expect(cop.offences.first.line).to eq(4)
+          end
+
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when a splat block argument has same name ' +
+                'as an outer scope variable' do
+          let(:source) do
+            [
+              'def some_method',
+              '  foo = 1',
+              '  puts foo',
+              '  1.times do |*foo|',
+              '  end',
+              'end'
+            ]
+          end
+
+          it 'registers an offence' do
+            inspect_source(cop, source)
+            expect(cop.offences).to have(1).item
+            expect(cop.offences.first.message)
+              .to include('Shadowing outer local variable - foo')
+            expect(cop.offences.first.line).to eq(4)
+          end
+
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when a block block argument has same name ' +
+                'as an outer scope variable' do
+          let(:source) do
+            [
+              'def some_method',
+              '  foo = 1',
+              '  puts foo',
+              '  proc_taking_block = proc do |&foo|',
+              '  end',
+              '  proc_taking_block.call do',
+              '  end',
+              'end'
+            ]
+          end
+
+          it 'registers an offence' do
+            inspect_source(cop, source)
+            expect(cop.offences).to have(1).item
+            expect(cop.offences.first.message)
+              .to include('Shadowing outer local variable - foo')
+            expect(cop.offences.first.line).to eq(4)
+          end
+
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when a block local variable has same name ' +
+                'as an outer scope variable' do
+          let(:source) do
+            [
+              'def some_method',
+              '  foo = 1',
+              '  puts foo',
+              '  1.times do |i; foo|',
+              '    puts foo',
+              '  end',
+              'end'
+            ]
+          end
+
+          it 'registers an offence' do
+            inspect_source(cop, source)
+            expect(cop.offences).to have(1).item
+            expect(cop.offences.first.message)
+              .to include('Shadowing outer local variable - foo')
+            expect(cop.offences.first.line).to eq(4)
+          end
+
+          include_examples 'mimics MRI 2.0', 'shadowing'
+        end
+
+        context 'when a block argument has different name ' +
+                'with outer scope variables' do
+          let(:source) do
+            [
+              'def some_method',
+              '  foo = 1',
+              '  puts foo',
+              '  1.times do |bar|',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when an outer scope variable is reassigned in a block' do
+          let(:source) do
+            [
+              'def some_method',
+              '  foo = 1',
+              '  puts foo',
+              '  1.times do',
+              '    foo = 2',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when an outer scope variable is referenced in a block' do
+          let(:source) do
+            [
+              'def some_method',
+              '  foo = 1',
+              '  puts foo',
+              '  1.times do',
+              '    puts foo',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when multiple block arguments have same name "_"' do
+          let(:source) do
+            [
+              'def some_method',
+              '  1.times do |_, foo, _|',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when multiple block arguments have ' +
+                'a same name starts with "_"' do
+          let(:source) do
+            [
+              'def some_method',
+              '  1.times do |_foo, bar, _foo|',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when a block argument has same name "_" ' +
+                'as outer scope variable "_"' do
+          let(:source) do
+            [
+              'def some_method',
+              '  _ = 1',
+              '  puts _',
+              '  1.times do |_|',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when a block argument has a same name starts with "_" ' +
+                'as an outer scope variable' do
+          let(:source) do
+            [
+              'def some_method',
+              '  _foo = 1',
+              '  puts _foo',
+              '  1.times do |_foo|',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+
+        context 'when a method argument has same name ' +
+                'as an outer scope variable' do
+          let(:source) do
+            [
+              'class SomeClass',
+              '  foo = 1',
+              '  puts foo',
+              '  def some_method(foo)',
+              '  end',
+              'end'
+            ]
+          end
+
+          include_examples 'accepts'
+          include_examples 'mimics MRI 2.0'
+        end
+      end
+    end
+  end
+end