rubocop 0.9.1 → 0.10.0

data/spec/rubocop/cops/style/redundant_begin_spec.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe RedundantBegin do
+        let(:cop) { RedundantBegin.new }
+
+        it 'reports an offence for def with redundant begin block' do
+          src = ['def func',
+                 '  begin',
+                 '    ala',
+                 '  rescue => e',
+                 '    bala',
+                 '  end',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'reports an offence for defs with redundant begin block' do
+          src = ['def Test.func',
+                 '  begin',
+                 '    ala',
+                 '  rescue => e',
+                 '    bala',
+                 '  end',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'accepts a def with required begin block' do
+          src = ['def func',
+                 '  begin',
+                 '    ala',
+                 '  rescue => e',
+                 '    bala',
+                 '  end',
+                 '  something',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a defs with required begin block' do
+          src = ['def Test.func',
+                 '  begin',
+                 '    ala',
+                 '  rescue => e',
+                 '    bala',
+                 '  end',
+                 '  something',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/redundant_return_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe RedundantReturn do
+        let(:cop) { RedundantReturn.new }
+
+        it 'reports an offence for def with only a return' do
+          src = ['def func',
+                 '  return something',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'reports an offence for defs with only a return' do
+          src = ['def Test.func',
+                 '  return something',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'reports an offence for def ending with return' do
+          src = ['def func',
+                 '  one',
+                 '  two',
+                 '  return something',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'reports an offence for defs ending with return' do
+          src = ['def func',
+                 '  one',
+                 '  two',
+                 '  return something',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'accepts return in a non-final position' do
+          src = ['def func',
+                 '  return something if something_else',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'does not blow up on empty method body' do
+          src = ['def func',
+                 'end']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/redundant_self_spec.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe RedundantSelf do
+        let(:cop) { RedundantSelf.new }
+
+        it 'reports an offence a self receiver on an rvalue' do
+          src = ['a = self.b']
+          inspect_source(cop, src)
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'accepts a self receiver on an lvalue of an assignment' do
+          src = ['self.a = b']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a self receiver on an lvalue of an or-assignment' do
+          src = ['self.logger ||= Rails.logger']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a self receiver on an lvalue of an and-assignment' do
+          src = ['self.flag &&= value']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a self receiver on an lvalue of a plus-assignment' do
+          src = ['self.sum += 10']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a self receiver with the square bracket operator' do
+          src = ['self[a]']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a self receiver with the double less-than operator' do
+          src = ['self << a']
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a self receiver for methods named like ruby keywords' do
+          src = ['a = self.class',
+                 'self.for(deps, [], true)'
+                ]
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a self receiver used to distinguish from local variable' do
+          src = ['def requested_specs',
+                 '  @requested_specs ||= begin',
+                 '    groups = self.groups - Bundler.settings.without',
+                 '    groups.map! { |g| g.to_sym }',
+                 '    specs_for(groups)',
+                 '  end',
+                 'end',
+                ]
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/string_literals_spec.rb

@@ -6,14 +6,14 @@ module Rubocop
   module Cop
     module Style
       describe StringLiterals do
-        let(:sl) { StringLiterals.new }
+        let(:cop) { StringLiterals.new }
 
         it 'registers offence for double quotes when single quotes suffice' do
-          inspect_source(sl, ['s = "abc"',
+          inspect_source(cop, ['s = "abc"',
                               'x = "a\\\\b"',
                               'y ="\\\\b"',
                               'z = "a\\\\"'])
-          expect(sl.offences.size).to eq(4)
+          expect(cop.offences.size).to eq(4)
         end
 
         it 'accepts double quotes when they are needed' do
@@ -25,13 +25,13 @@ module Rubocop
                  'e = "#$test"',
                   'f = "\e"',
                  'g = "#@@test"']
-          inspect_source(sl, src)
-          expect(sl.offences).to be_empty
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
         end
 
         it 'accepts double quotes at the start of regexp literals' do
-          inspect_source(sl, ['s = /"((?:[^\\"]|\\.)*)"/'])
-          expect(sl.offences).to be_empty
+          inspect_source(cop, ['s = /"((?:[^\\"]|\\.)*)"/'])
+          expect(cop.offences).to be_empty
         end
 
         it 'accepts double quotes with some other special symbols' do
@@ -39,22 +39,27 @@ module Rubocop
           # http://www.ruby-doc.org/docs/ProgrammingRuby/html/language.html
           src = ['g = "\xf9"',
                  'copyright = "\u00A9"']
-          inspect_source(sl, src)
-          expect(sl.offences).to be_empty
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
         end
 
         it 'can handle double quotes within embedded expression' do
           src = ['"#{"A"}"']
-          inspect_source(sl, src)
-          expect(sl.offences).to be_empty
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
         end
 
         it 'can handle a built-in constant parsed as string' do
           # Parser will produce str nodes for constants such as __FILE__.
           src = ['if __FILE__ == $PROGRAM_NAME',
                  'end']
-          inspect_source(sl, src)
-          expect(sl.offences).to be_empty
+          inspect_source(cop, src)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'auto-corrects " with \'' do
+          new_source = autocorrect_source(cop, 's = "abc"')
+          expect(new_source).to eq("s = 'abc'")
         end
       end
     end

data/spec/rubocop/cops/style/trivial_accessors_spec.rb

@@ -6,14 +6,11 @@ module Rubocop
   module Cop
     module Style
       describe TrivialAccessors do
-        let(:trivial_accessors_finder) { TrivialAccessors.new }
-
-        before :each do
-          trivial_accessors_finder.offences.clear
-        end
+        TrivialAccessors.config = { 'ExactNameMatch' => false }
+        let(:cop) { TrivialAccessors.new }
 
         it 'finds trivial reader' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['def foo',
                           '  @foo',
                           'end',
@@ -21,13 +18,13 @@ module Rubocop
                           'def Foo',
                           '  @Foo',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(2)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(2)
+          expect(cop.offences
                    .map(&:line).sort).to eq([1, 5])
         end
 
         it 'finds trivial reader in a class' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialFoo',
                           '  def foo',
                           '    @foo',
@@ -36,13 +33,28 @@ module Rubocop
                           '    !foo',
                           '  end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(1)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences
+                   .map(&:line).sort).to eq([2])
+        end
+
+        it 'finds trivial reader in a class method' do
+          inspect_source(cop,
+                         ['class TrivialFoo',
+                          '  def self.foo',
+                          '    @foo',
+                          '  end',
+                          '  def bar',
+                          '    !foo',
+                          '  end',
+                          'end'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences
                    .map(&:line).sort).to eq([2])
         end
 
         it 'finds trivial reader in a nested class' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialFoo',
                           '  class Nested',
                           '    def foo',
@@ -50,13 +62,13 @@ module Rubocop
                           '    end',
                           '  end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(1)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences
                    .map(&:line).sort).to eq([3])
         end
 
         it 'finds trivial readers in a little less trivial class' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialFoo',
                           '  def foo',
                           '    @foo',
@@ -110,39 +122,39 @@ module Rubocop
                           '   @val',
                           ' end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(2)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(2)
+          expect(cop.offences
                    .map(&:line).sort).to eq([2, 8])
         end
 
         it 'finds trivial reader with braces' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class Test',
                           '  # trivial reader with braces',
                           '  def name()',
                           '    @name',
                           '  end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(1)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences
                    .map(&:line).sort).to eq([3])
         end
 
         it 'finds trivial writer without braces' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class Test',
                           '  # trivial writer without braces',
                           '  def name= name',
                           '    @name = name',
                           '  end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(1)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences
                    .map(&:line).sort).to eq([3])
         end
 
         it 'does not find trivial writer with function calls' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialTest',
                           ' def test=(val)',
                           '   @test = val',
@@ -150,11 +162,11 @@ module Rubocop
                           '   or_more_of_them',
                           ' end',
                           'end'])
-          expect(trivial_accessors_finder.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'finds trivials with less peculiar methods' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class NilStats',
                           'def most_traded_pair',
                           'end',
@@ -189,40 +201,40 @@ module Rubocop
                           '  #do stuff',
                           'end',
                           'end'])
-          expect(trivial_accessors_finder.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'finds oneliner trivials' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class Oneliner',
                           '  def foo; @foo; end',
                           '  def foo= foo; @foo = foo; end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(2)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(2)
+          expect(cop.offences
                    .map(&:line).sort).to eq([2, 3])
         end
 
         it 'does not find a trivial reader' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['def bar',
                           '  @bar + foo',
                           'end'])
-          expect(trivial_accessors_finder.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'finds trivial writer' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['def foo=(val)',
                           ' @foo = val',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(1)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences
                    .map(&:line).sort).to eq([1])
         end
 
         it 'finds trivial writer in a class' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialFoo',
                           '  def foo=(val)',
                           '    @foo = val',
@@ -242,13 +254,13 @@ module Rubocop
                           '    end',
                           '  end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(1)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences
                    .map(&:line).sort).to eq([2])
         end
 
         it 'finds trivial accessors in a little less trivial class' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialFoo',
                           ' def foo',
                           ' @foo',
@@ -263,21 +275,21 @@ module Rubocop
                           ' @bar = bar_value',
                           ' end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(3)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(3)
+          expect(cop.offences
                    .map(&:line).sort).to eq([2, 8, 11])
         end
 
         it 'does not find a trivial writer' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['def bar=(value)',
                           ' @bar = value + 42',
                           'end'])
-          expect(trivial_accessors_finder.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'finds trivial writers in a little less trivial class' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialFoo',
                           ' def foo_bar=(foo, bar)',
                           ' @foo_bar = foo + bar',
@@ -289,13 +301,13 @@ module Rubocop
                           ' @bar = bar_value',
                           ' end',
                           'end'])
-          expect(trivial_accessors_finder.offences.size).to eq(2)
-          expect(trivial_accessors_finder.offences
+          expect(cop.offences.size).to eq(2)
+          expect(cop.offences
                    .map(&:line).sort).to eq([5, 8])
         end
 
         it 'does not find trivial accessors with method calls' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          ['class TrivialFoo',
                           ' def foo_bar(foo)',
                           '   foo_bar = foo + 42',
@@ -309,11 +321,11 @@ module Rubocop
                           '   foo_method',
                           ' end',
                           'end'])
-          expect(trivial_accessors_finder.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'does not find trivial writer with exceptions' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          [' def expiration_formatted=(value)',
                           '   begin',
                           '     @expiration = foo_stuff',
@@ -322,15 +334,61 @@ module Rubocop
                           '   end',
                           '   self[:expiration] = @expiration',
                           ' end'])
-          expect(trivial_accessors_finder.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'accepts an initialize method looking like a writer' do
-          inspect_source(trivial_accessors_finder,
+          inspect_source(cop,
                          [' def initialize(value)',
                           '   @top = value',
                           ' end'])
-          expect(trivial_accessors_finder.offences).to be_empty
+          expect(cop.offences).to be_empty
+        end
+
+        context 'exact name match required' do
+          before { TrivialAccessors.config['ExactNameMatch'] = true }
+
+          it 'finds only 1 trivial reader' do
+            inspect_source(cop,
+                           ['def foo',
+                            '  @foo',
+                            'end',
+                            '',
+                            'def bar',
+                            '  @barr',
+                            'end'])
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences
+                     .map(&:line).sort).to eq([1])
+          end
+
+          it 'finds only 1 trivial writer' do
+            inspect_source(cop,
+                           ['def foo=(foo)',
+                            '  @foo = foo',
+                            'end',
+                            '',
+                            'def bar=(bar)',
+                            '  @barr = bar',
+                            'end'])
+            expect(cop.offences.size).to eq(1)
+            expect(cop.offences
+                     .map(&:line).sort).to eq([1])
+          end
+        end
+
+        context 'with predicates allowed' do
+          before do
+            described_class.config['AllowPredicates'] = true
+          end
+
+          it 'ignores accessors ending with a question mark' do
+            inspect_source(cop,
+                           [' def foo?',
+                            '   @foo',
+                            ' end'])
+            expect(cop.offences).to be_empty
+          end
         end
       end
     end