rubocop 0.13.1 → 0.14.0

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

@@ -2,132 +2,126 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe RedundantSelf do
-        subject(:cop) { RedundantSelf.new }
+describe Rubocop::Cop::Style::RedundantSelf do
+  subject(:cop) { described_class.new }
 
-        it 'reports an offence a self receiver on an rvalue' do
-          src = ['a = self.b']
-          inspect_source(cop, src)
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'reports an offence a self receiver on an rvalue' do
+    src = ['a = self.b']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  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 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 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 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 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 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 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)',
-                 '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
-        end
+  it 'accepts a self receiver for methods named like ruby keywords' do
+    src = ['a = self.class',
+           '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
+  end
 
-        it 'accepts a self receiver used to distinguish from blockarg' do
-          src = ['def requested_specs(&groups)',
-                 '  some_method(self.groups)',
-                 'end',
-                ]
-          inspect_source(cop, src)
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts a self receiver used to distinguish from blockarg' do
+    src = ['def requested_specs(&groups)',
+           '  some_method(self.groups)',
+           'end',
+          ]
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts a self receiver used to distinguish from argument' do
-          src = ['def requested_specs(groups)',
-                 '  some_method(self.groups)',
-                 'end',
-                ]
-          inspect_source(cop, src)
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts a self receiver used to distinguish from argument' do
+    src = ['def requested_specs(groups)',
+           '  some_method(self.groups)',
+           'end',
+          ]
+    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
+  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
 
-        it 'auto-corrects by removing redundant self' do
-          new_source = autocorrect_source(cop, ['self.x'])
-          expect(new_source).to eq('x')
-        end
-      end
-    end
+  it 'auto-corrects by removing redundant self' do
+    new_source = autocorrect_source(cop, ['self.x'])
+    expect(new_source).to eq('x')
   end
 end

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

@@ -2,78 +2,72 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe RegexpLiteral, :config do
-        subject(:rl) { RegexpLiteral.new(config) }
-        let(:cop_config) { { 'MaxSlashes' => 1 } }
+describe Rubocop::Cop::Style::RegexpLiteral, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'MaxSlashes' => 1 } }
 
-        context 'when a regexp uses // delimiters' do
-          context 'when MaxSlashes is 1' do
-            it 'registers an offence for two slashes in regexp' do
-              inspect_source(rl, ['x =~ /home\/\//',
-                                  'y =~ /etc\/top\//'])
-              expect(rl.messages)
-                .to eq(['Use %r for regular expressions matching more ' +
-                        "than 1 '/' character."] * 2)
-            end
+  context 'when a regexp uses // delimiters' do
+    context 'when MaxSlashes is 1' do
+      it 'registers an offence for two slashes in regexp' do
+        inspect_source(cop, ['x =~ /home\/\//',
+                             'y =~ /etc\/top\//'])
+        expect(cop.messages)
+          .to eq(['Use %r for regular expressions matching more ' +
+                  "than 1 '/' character."] * 2)
+      end
 
-            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
-          end
+      it 'accepts zero or one slash in regexp' do
+        inspect_source(cop, ['x =~ /\/home/',
+                             'y =~ /\//',
+                             'w =~ /\//m',
+                             'z =~ /a/'])
+        expect(cop.offences).to be_empty
+      end
+    end
 
-          context 'when MaxSlashes is 0' do
-            let(:cop_config) { { 'MaxSlashes' => 0 } }
+    context 'when MaxSlashes is 0' do
+      let(:cop_config) { { 'MaxSlashes' => 0 } }
 
-            it 'registers an offence for one slash in regexp' do
-              inspect_source(rl, ['x =~ /home\//'])
-              expect(rl.messages)
-                .to eq(['Use %r for regular expressions matching more ' +
-                        "than 0 '/' characters."])
-            end
+      it 'registers an offence for one slash in regexp' do
+        inspect_source(cop, ['x =~ /home\//'])
+        expect(cop.messages)
+          .to eq(['Use %r for regular expressions matching more ' +
+                  "than 0 '/' characters."])
+      end
 
-            it 'accepts zero slashes in regexp' do
-              inspect_source(rl, ['z =~ /a/'])
-              expect(rl.offences).to be_empty
-            end
+      it 'accepts zero slashes in regexp' do
+        inspect_source(cop, ['z =~ /a/'])
+        expect(cop.offences).to be_empty
+      end
 
-            it 'registers an offence for zero slashes in regexp' do
-              inspect_source(rl, ['y =~ %r(etc)'])
-              expect(rl.messages)
-                .to eq(['Use %r only for regular expressions matching more ' +
-                        "than 0 '/' characters."])
-            end
+      it 'registers an offence for zero slashes in regexp' do
+        inspect_source(cop, ['y =~ %r(etc)'])
+        expect(cop.messages)
+          .to eq(['Use %r only for regular expressions matching more ' +
+                  "than 0 '/' characters."])
+      end
 
-            it 'accepts regexp with one slash' do
-              inspect_source(rl, ['x =~ %r(/home)'])
-              expect(rl.offences).to be_empty
-            end
-          end
-        end
+      it 'accepts regexp with one slash' do
+        inspect_source(cop, ['x =~ %r(/home)'])
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
 
-        context 'when a regexp uses %r delimiters' do
-          context 'when MaxSlashes is 1' do
-            it 'registers an offence for zero or one slash in regexp' do
-              inspect_source(rl, ['x =~ %r(/home)',
-                                  'y =~ %r(etc)'])
-              expect(rl.messages)
-                .to eq(['Use %r only for regular expressions matching more ' +
-                        "than 1 '/' character."] * 2)
-            end
+  context 'when a regexp uses %r delimiters' do
+    context 'when MaxSlashes is 1' do
+      it 'registers an offence for zero or one slash in regexp' do
+        inspect_source(cop, ['x =~ %r(/home)',
+                             'y =~ %r(etc)'])
+        expect(cop.messages)
+          .to eq(['Use %r only for regular expressions matching more ' +
+                  "than 1 '/' character."] * 2)
+      end
 
-            it 'accepts regexp with two or more slashes' do
-              inspect_source(rl, ['x =~ %r(/home/)',
-                                  'y =~ %r(/////)'])
-              expect(rl.offences).to be_empty
-            end
-          end
-        end
+      it 'accepts regexp with two or more slashes' do
+        inspect_source(cop, ['x =~ %r(/home/)',
+                             'y =~ %r(/////)'])
+        expect(cop.offences).to be_empty
       end
     end
   end

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

@@ -2,121 +2,115 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe RescueModifier do
-        subject(:rm) { RescueModifier.new }
+describe Rubocop::Cop::Style::RescueModifier do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for modifier rescue' do
-          inspect_source(rm,
-                         ['method rescue handle'])
-          expect(rm.offences.size).to eq(1)
-          expect(rm.messages)
-            .to eq([RescueModifier::MSG])
-        end
+  it 'registers an offence for modifier rescue' do
+    inspect_source(cop,
+                   ['method rescue handle'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Avoid using rescue in its modifier form.'])
+  end
 
-        it 'handles more complex expression with modifier rescue' do
-          inspect_source(rm,
-                         ['method1 or method2 rescue handle'])
-          expect(rm.offences.size).to eq(1)
-          expect(rm.messages)
-            .to eq([RescueModifier::MSG])
-        end
+  it 'handles more complex expression with modifier rescue' do
+    inspect_source(cop,
+                   ['method1 or method2 rescue handle'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Avoid using rescue in its modifier form.'])
+  end
 
-        it 'handles modifier rescue in normal rescue' do
-          inspect_source(rm,
-                         ['begin',
-                          '  test rescue modifier_handle',
-                          'rescue',
-                          '  normal_handle',
-                          'end'])
-          expect(rm.offences.size).to eq(1)
-          expect(rm.offences.first.line).to eq(2)
-        end
+  it 'handles modifier rescue in normal rescue' do
+    inspect_source(cop,
+                   ['begin',
+                    '  test rescue modifier_handle',
+                    'rescue',
+                    '  normal_handle',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.first.line).to eq(2)
+  end
 
-        it 'does not register an offence for normal rescue' do
-          inspect_source(rm,
-                         ['begin',
-                          '  test',
-                          'rescue',
-                          '  handle',
-                          'end'])
-          expect(rm.offences).to be_empty
-        end
+  it 'does not register an offence for normal rescue' do
+    inspect_source(cop,
+                   ['begin',
+                    '  test',
+                    'rescue',
+                    '  handle',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for normal rescue with ensure' do
-          inspect_source(rm,
-                         ['begin',
-                          '  test',
-                          'rescue',
-                          '  handle',
-                          'ensure',
-                          '  cleanup',
-                          'end'])
-          expect(rm.offences).to be_empty
-        end
+  it 'does not register an offence for normal rescue with ensure' do
+    inspect_source(cop,
+                   ['begin',
+                    '  test',
+                    'rescue',
+                    '  handle',
+                    'ensure',
+                    '  cleanup',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for nested normal rescue' do
-          inspect_source(rm,
-                         ['begin',
-                          '  begin',
-                          '    test',
-                          '  rescue',
-                          '    handle_inner',
-                          '  end',
-                          'rescue',
-                          '  handle_outer',
-                          'end'])
-          expect(rm.offences).to be_empty
-        end
+  it 'does not register an offence for nested normal rescue' do
+    inspect_source(cop,
+                   ['begin',
+                    '  begin',
+                    '    test',
+                    '  rescue',
+                    '    handle_inner',
+                    '  end',
+                    'rescue',
+                    '  handle_outer',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'when an instance method has implicit begin' do
-          it 'accepts normal rescue' do
-            inspect_source(rm,
-                           ['def some_method',
-                            '  test',
-                            'rescue',
-                            '  handle',
-                            'end'])
-            expect(rm.offences).to be_empty
-          end
+  context 'when an instance method has implicit begin' do
+    it 'accepts normal rescue' do
+      inspect_source(cop,
+                     ['def some_method',
+                      '  test',
+                      'rescue',
+                      '  handle',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
 
-          it 'handles modifier rescue in body of implicit begin' do
-            inspect_source(rm,
-                           ['def some_method',
-                            '  test rescue modifier_handle',
-                            'rescue',
-                            '  normal_handle',
-                            'end'])
-            expect(rm.offences.size).to eq(1)
-            expect(rm.offences.first.line).to eq(2)
-          end
-        end
+    it 'handles modifier rescue in body of implicit begin' do
+      inspect_source(cop,
+                     ['def some_method',
+                      '  test rescue modifier_handle',
+                      'rescue',
+                      '  normal_handle',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.first.line).to eq(2)
+    end
+  end
 
-        context 'when a singleton method has implicit begin' do
-          it 'accepts normal rescue' do
-            inspect_source(rm,
-                           ['def self.some_method',
-                            '  test',
-                            'rescue',
-                            '  handle',
-                            'end'])
-            expect(rm.offences).to be_empty
-          end
+  context 'when a singleton method has implicit begin' do
+    it 'accepts normal rescue' do
+      inspect_source(cop,
+                     ['def self.some_method',
+                      '  test',
+                      'rescue',
+                      '  handle',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
 
-          it 'handles modifier rescue in body of implicit begin' do
-            inspect_source(rm,
-                           ['def self.some_method',
-                            '  test rescue modifier_handle',
-                            'rescue',
-                            '  normal_handle',
-                            'end'])
-            expect(rm.offences.size).to eq(1)
-            expect(rm.offences.first.line).to eq(2)
-          end
-        end
-      end
+    it 'handles modifier rescue in body of implicit begin' do
+      inspect_source(cop,
+                     ['def self.some_method',
+                      '  test rescue modifier_handle',
+                      'rescue',
+                      '  normal_handle',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.first.line).to eq(2)
     end
   end
 end