rubocop 0.10.0 → 0.11.0

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

@@ -13,7 +13,7 @@ module Rubocop
                  '  return something',
                  'end']
           inspect_source(cop, src)
-          expect(cop.offences).to have(1).item
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'reports an offence for defs with only a return' do
@@ -21,7 +21,7 @@ module Rubocop
                  '  return something',
                  'end']
           inspect_source(cop, src)
-          expect(cop.offences).to have(1).item
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'reports an offence for def ending with return' do
@@ -31,7 +31,7 @@ module Rubocop
                  '  return something',
                  'end']
           inspect_source(cop, src)
-          expect(cop.offences).to have(1).item
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'reports an offence for defs ending with return' do
@@ -41,7 +41,7 @@ module Rubocop
                  '  return something',
                  'end']
           inspect_source(cop, src)
-          expect(cop.offences).to have(1).item
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'accepts return in a non-final position' do

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

@@ -11,7 +11,7 @@ module Rubocop
         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
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'accepts a self receiver on an lvalue of an assignment' do
@@ -52,7 +52,41 @@ module Rubocop
 
         it 'accepts a self receiver for methods named like ruby keywords' do
           src = ['a = self.class',
-                 'self.for(deps, [], true)'
+                 'self.for(deps, [], true)',
+                 'self.and(other)',
+                 'self.or(other)',
+                 'self.alias',
+                 'self.begin',
+                 'self.break',
+                 'self.case',
+                 'self.def',
+                 'self.defined',
+                 'self.do',
+                 'self.else',
+                 'self.elsif',
+                 'self.end',
+                 'self.ensure',
+                 'self.false',
+                 'self.if',
+                 'self.in',
+                 'self.module',
+                 'self.next',
+                 'self.nil',
+                 'self.not',
+                 'self.redo',
+                 'self.rescue',
+                 'self.retry',
+                 'self.return',
+                 'self.self',
+                 'self.super',
+                 'self.then',
+                 'self.true',
+                 'self.undef',
+                 'self.unless',
+                 'self.until',
+                 'self.when',
+                 'self.while',
+                 'self.yield'
                 ]
           inspect_source(cop, src)
           expect(cop.offences).to be_empty

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

@@ -22,6 +22,7 @@ module Rubocop
             it 'accepts zero or one slash in regexp' do
               inspect_source(rl, ['x =~ /\/home/',
                                   'y =~ /\//',
+                                  'w =~ /\//m',
                                   'z =~ /a/'])
               expect(rl.offences).to be_empty
             end

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

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SignalException do
+        let(:cop) { described_class.new }
+
+        it 'registers an offence for raise in begin section' do
+          inspect_source(cop,
+                         ['begin',
+                          '  raise',
+                          'rescue Exception',
+                          '  #do nothing',
+                          'end'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([SignalException::FAIL_MSG])
+        end
+
+        it 'registers an offence for raise in def body' do
+          inspect_source(cop,
+                         ['def test',
+                          '  raise',
+                          'rescue Exception',
+                          '  #do nothing',
+                          'end'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([SignalException::FAIL_MSG])
+        end
+
+        it 'registers an offence for fail in rescue section' do
+          inspect_source(cop,
+                         ['begin',
+                          '  fail',
+                          'rescue Exception',
+                          '  fail',
+                          'end'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([SignalException::RAISE_MSG])
+        end
+
+        it 'registers an offence for fail def rescue section' do
+          inspect_source(cop,
+                         ['def test',
+                          '  fail',
+                          'rescue Exception',
+                          '  fail',
+                          'end'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq([SignalException::RAISE_MSG])
+        end
+
+        it 'is not confused by nested begin/rescue' do
+          inspect_source(cop,
+                         ['begin',
+                          '  raise',
+                          '  begin',
+                          '    raise',
+                          '  rescue',
+                          '    fail',
+                          '  end',
+                          'rescue Exception',
+                          '  #do nothing',
+                          'end'])
+          expect(cop.offences.size).to eq(3)
+          expect(cop.messages).to eq([SignalException::FAIL_MSG] * 2 +
+                                     [SignalException::RAISE_MSG])
+        end
+      end
+    end
+  end
+end

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

@@ -43,6 +43,16 @@ module Rubocop
           expect(cop.offences).to be_empty
         end
 
+        it 'accepts " in a %w' do
+          inspect_source(cop, ['%w(")'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts \\\\\n in a string' do # this would be: "\\\n"
+          inspect_source(cop, ['"foo \\\\\n bar"'])
+          expect(cop.offences).to be_empty
+        end
+
         it 'can handle double quotes within embedded expression' do
           src = ['"#{"A"}"']
           inspect_source(cop, src)

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

@@ -105,6 +105,19 @@ module Rubocop
           expect(symbol_name.offences).to be_empty
         end
 
+        it 'accepts non snake case arguments to private_constant' do
+          inspect_source(symbol_name,
+                         ['private_constant :NORMAL_MODE, :ADMIN_MODE'])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'registers an offence for non snake case symbol near ' +
+            'private_constant' do
+          inspect_source(symbol_name,
+                         ['private_constant f(:ADMIN_MODE)'])
+          expect(symbol_name.offences.size).to eq(1)
+        end
+
         it 'can handle an alias of and operator without crashing' do
           inspect_source(symbol_name,
                          ['alias + add'])

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

@@ -6,8 +6,10 @@ module Rubocop
   module Cop
     module Style
       describe TrivialAccessors do
-        TrivialAccessors.config = { 'ExactNameMatch' => false }
-        let(:cop) { TrivialAccessors.new }
+        subject(:cop) { described_class.new }
+        before do
+          described_class.config = {}
+        end
 
         it 'finds trivial reader' do
           inspect_source(cop,
@@ -346,7 +348,7 @@ module Rubocop
         end
 
         context 'exact name match required' do
-          before { TrivialAccessors.config['ExactNameMatch'] = true }
+          before { described_class.config['ExactNameMatch'] = true }
 
           it 'finds only 1 trivial reader' do
             inspect_source(cop,
@@ -390,6 +392,29 @@ module Rubocop
             expect(cop.offences).to be_empty
           end
         end
+
+        context 'with whitelist defined' do
+          before do
+            described_class.config = {
+              'Whitelist' => ['to_foo', 'bar=']
+            }
+          end
+
+          it 'ignores accessors in the whitelist' do
+            inspect_source(cop,
+                           [' def to_foo',
+                            '   @foo',
+                            ' end'])
+            expect(cop.offences).to be_empty
+          end
+          it 'ignores writers in the whitelist' do
+            inspect_source(cop,
+                           [' def bar=(bar)',
+                            '   @bar = bar',
+                            ' end'])
+            expect(cop.offences).to be_empty
+          end
+        end
       end
     end
   end

data/spec/rubocop/cops/variable_inspector_spec.rb

@@ -247,39 +247,39 @@ module Rubocop
       end
 
       describe NodeScanner do
-        let(:source) do
-          <<-END
-            class SomeClass
-              foo = 1.to_s
-              bar = 2.to_s
-              def some_method
-                baz = 3.to_s
-              end
-            end
-          END
-        end
+        describe '.scan_nodes_in_scope' do
+          let(:ast) do
+            processed_source = Rubocop::SourceParser.parse(source)
+            processed_source.ast
+          end
 
-        let(:ast) do
-          processed_source = Rubocop::SourceParser.parse(source)
-          processed_source.ast
-        end
+          let(:source) do
+            <<-END
+              class SomeClass
+                foo = 1.to_s
+                bar = 2.to_s
+                def some_method
+                  baz = 3.to_s
+                end
+              end
+            END
+          end
 
-        # (class
-        #   (const nil :SomeClass) nil
-        #   (begin
-        #     (lvasgn :foo
-        #       (send
-        #         (int 1) :to_s))
-        #     (lvasgn :bar
-        #       (send
-        #         (int 2) :to_s))
-        #     (def :some_method
-        #       (args)
-        #       (lvasgn :baz
-        #         (send
-        #           (int 3) :to_s)))))
+          # (class
+          #   (const nil :SomeClass) nil
+          #   (begin
+          #     (lvasgn :foo
+          #       (send
+          #         (int 1) :to_s))
+          #     (lvasgn :bar
+          #       (send
+          #         (int 2) :to_s))
+          #     (def :some_method
+          #       (args)
+          #       (lvasgn :baz
+          #         (send
+          #           (int 3) :to_s)))))
 
-        describe '.scan_nodes_in_scope' do
           it 'does not scan children of inner scope node' do
             scanned_node_count = 0
 
@@ -316,15 +316,196 @@ module Rubocop
             expect(index).not_to eq(0)
           end
 
-          it 'passes node index in the scope as second block argument' do
-            last_index = -1
+          let(:trace) { [] }
+
+          before do
+            NodeScanner.scan_nodes_in_scope(ast) do |node|
+              short_info = node.type.to_s
+              node.children.each do |child|
+                break if child.is_a?(Parser::AST::Node)
+                short_info << " #{child.inspect}"
+              end
+              trace << short_info
+            end
+          end
+
+          context 'when invoking a method ' +
+                  'which is taking block and normal arguments' do
+            let(:source) do
+              <<-END
+                some_method(foo = 1) do |block_arg|
+                  content_of_block = 2
+                end
+                puts foo
+              END
+            end
+
+            # (begin
+            #   (block
+            #     (send nil :some_method
+            #       (lvasgn :foo
+            #         (int 1)))
+            #     (args
+            #       (arg :block_arg))
+            #     (lvasgn :content_of_block
+            #       (int 2)))
+            #   (send nil :puts
+            #     (lvar :foo)))
+
+            it 'scans the method node and its normal argument nodes' do
+              expect(trace).to eq([
+                'block',
+                'send nil :some_method',
+                'lvasgn :foo',
+                'int 1',
+                'send nil :puts',
+                'lvar :foo'
+              ])
+            end
+          end
+
+          context 'when opening singleton class of an instance' do
+            let(:source) do
+              <<-END
+                instance = Object.new
+                class << instance
+                  content_of_singleton_class = 1
+                end
+                p instance
+              END
+            end
+
+            # (begin
+            #   (lvasgn :instance
+            #     (send
+            #       (const nil :Object) :new))
+            #   (sclass
+            #     (lvar :instance)
+            #     (lvasgn :content_of_singleton_class
+            #       (int 1)))
+            #   (send nil :p
+            #     (lvar :instance)))
+
+            it 'scans the subject instance node' do
+              expect(trace).to eq([
+                'lvasgn :instance',
+                'send',
+                'const nil :Object',
+                'sclass',
+                'lvar :instance',
+                'send nil :p',
+                'lvar :instance'
+              ])
+            end
+          end
+
+          context 'when defining singleton method' do
+            let(:source) do
+              <<-END
+                instance = Object.new
+                def instance.some_method(method_arg)
+                  content_of_method = 2
+                end
+                p instance
+              END
+            end
+
+            # (begin
+            #   (lvasgn :instance
+            #     (send
+            #       (const nil :Object) :new))
+            #   (defs
+            #     (lvar :instance) :some_method
+            #     (args
+            #       (arg :method_arg))
+            #     (lvasgn :content_of_method
+            #       (int 2)))
+            #   (send nil :p
+            #     (lvar :instance)))
+
+            it 'scans the subject instance node' do
+              expect(trace).to eq([
+                'lvasgn :instance',
+                'send',
+                'const nil :Object',
+                'defs',
+                'lvar :instance',
+                'send nil :p',
+                'lvar :instance'
+              ])
+            end
+          end
+
+          context 'when scanning around post while loop' do
+            let(:source) do
+              <<-END
+                begin
+                  foo = 1
+                end while foo > 10
+                puts foo
+              END
+            end
 
-            NodeScanner.scan_nodes_in_scope(ast) do |node, index|
-              expect(index).to eq(last_index + 1)
-              last_index = index
+            # (begin
+            #   (while-post
+            #     (send
+            #       (lvar :foo) :>
+            #       (int 10))
+            #     (kwbegin
+            #       (lvasgn :foo
+            #         (int 1))))
+            #   (send nil :puts
+            #     (lvar :foo)))
+
+            it 'scans loop body nodes first then condition nodes' do
+              expect(trace).to eq([
+                'while_post',
+                'kwbegin',
+                'lvasgn :foo',
+                'int 1',
+                'send',
+                'lvar :foo',
+                'int 10',
+                'send nil :puts',
+                'lvar :foo'
+              ])
             end
+          end
 
-            expect(last_index).not_to eq(-1)
+          context 'when scanning around post until loop' do
+            let(:source) do
+              <<-END
+                begin
+                  foo = 1
+                end until foo < 10
+                puts foo
+              END
+            end
+
+            # (begin
+            #   (until-post
+            #     (send
+            #       (lvar :foo) :<
+            #       (int 10))
+            #     (kwbegin
+            #       (lvasgn :foo
+            #         (int 1))))
+            #   (send nil :puts
+            #     (lvar :foo)))
+
+            it 'scans loop body nodes first then condition nodes' do
+              expect(trace).to eq([
+                'until_post',
+                'kwbegin',
+                'lvasgn :foo',
+                'int 1',
+                'send',
+                'lvar :foo',
+                'int 10',
+                'send nil :puts',
+                'lvar :foo'
+              ])
+            end
           end
         end
       end