rubocop 0.7.2 → 0.8.0

data/spec/rubocop/cops/one_line_conditional_spec.rb

@@ -8,7 +8,7 @@ module Rubocop
       let(:olc) { OneLineConditional.new }
 
       it 'registers an offence for one line if/then/end' do
-        inspect_source(olc, '', ['if cond then run else dont end'])
+        inspect_source(olc, ['if cond then run else dont end'])
         expect(olc.offences.map(&:message)).to eq([olc.error_message])
       end
     end

data/spec/rubocop/cops/op_method_spec.rb

@@ -9,29 +9,26 @@ module Rubocop
 
       it 'registers an offence for arg not named other' do
         inspect_source(om,
-                       'file.rb',
                        ['def +(another)',
                         '  another',
                         'end'])
         expect(om.offences.size).to eq(1)
         expect(om.offences.map(&:message))
-          .to eq([sprintf(OpMethod::ERROR_MESSAGE, '+')])
+          .to eq([sprintf(OpMethod::MSG, '+')])
       end
 
       it 'works properly even if the argument is not surrounded with braces' do
         inspect_source(om,
-                       'file.rb',
                        ['def + another',
                         '  another',
                         'end'])
         expect(om.offences.size).to eq(1)
         expect(om.offences.map(&:message))
-          .to eq([sprintf(OpMethod::ERROR_MESSAGE, '+')])
+          .to eq([sprintf(OpMethod::MSG, '+')])
       end
 
       it 'does not register an offence for arg named other' do
         inspect_source(om,
-                       'file.rb',
                        ['def +(other)',
                         '  other',
                         'end'])
@@ -40,7 +37,6 @@ module Rubocop
 
       it 'does not register an offence for []' do
         inspect_source(om,
-                       'file.rb',
                        ['def [](index)',
                         '  other',
                         'end'])
@@ -49,7 +45,6 @@ module Rubocop
 
       it 'does not register an offence for []=' do
         inspect_source(om,
-                       'file.rb',
                        ['def []=(index, value)',
                         '  other',
                         'end'])
@@ -58,7 +53,6 @@ module Rubocop
 
       it 'does not register an offence for <<' do
         inspect_source(om,
-                       'file.rb',
                        ['def <<(cop)',
                         '  other',
                         'end'])
@@ -67,7 +61,6 @@ module Rubocop
 
       it 'does not register an offence for non binary operators' do
         inspect_source(om,
-                       'file.rb',
                        ['def -@', # Unary minus
                         'end',
                         '',

data/spec/rubocop/cops/parameter_lists_spec.rb

@@ -8,16 +8,16 @@ module Rubocop
       let(:list) { ParameterLists.new }
 
       it 'registers an offence for a method def with 5 parameters' do
-        inspect_source(list, 'file.rb', ['def meth(a, b, c, d, e)',
-                                         'end'])
-        expect(list.offences.map(&:message)).to eq(
-          ['Avoid parameter lists longer than four parameters.'])
+        inspect_source(list, ['def meth(a, b, c, d, e)',
+                              'end'])
+        expect(list.messages).to eq(
+          ['Avoid parameter lists longer than 4 parameters.'])
       end
 
       it 'accepts a method def with 4 parameters' do
-        inspect_source(list, 'file.rb', ['def meth(a, b, c, d)',
-                                         'end'])
-        expect(list.offences.map(&:message)).to be_empty
+        inspect_source(list, ['def meth(a, b, c, d)',
+                              'end'])
+        expect(list.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/parentheses_around_condition_spec.rb

@@ -8,57 +8,54 @@ module Rubocop
       let(:pac) { ParenthesesAroundCondition.new }
 
       it 'registers an offence for parentheses around condition' do
-        inspect_source(pac, 'file.rb', ['if (x > 10)',
-                                        'elsif (x < 3)',
-                                        'end',
-                                        'unless (x > 10)',
-                                        'end',
-                                        'while (x > 10)',
-                                        'end',
-                                        'until (x > 10)',
-                                        'end',
-                                        'x += 1 if (x < 10)',
-                                        'x += 1 unless (x < 10)',
-                                        'x += 1 while (x < 10)',
-                                        'x += 1 until (x < 10)',
-                                       ])
-        expect(pac.offences.map(&:message)).to eq(
-          ["Don't use parentheses around the condition of an if/unless/" +
-           'while/until, unless the condition contains an assignment.'] * 9)
+        inspect_source(pac, ['if (x > 10)',
+                             'elsif (x < 3)',
+                             'end',
+                             'unless (x > 10)',
+                             'end',
+                             'while (x > 10)',
+                             'end',
+                             'until (x > 10)',
+                             'end',
+                             'x += 1 if (x < 10)',
+                             'x += 1 unless (x < 10)',
+                             'x += 1 while (x < 10)',
+                             'x += 1 until (x < 10)',
+                            ])
+        expect(pac.offences.size).to eq(9)
       end
 
       it 'accepts condition without parentheses' do
-        inspect_source(pac, 'file.rb', ['if x > 10',
-                                        'end',
-                                        'unless x > 10',
-                                        'end',
-                                        'while x > 10',
-                                        'end',
-                                        'until x > 10',
-                                        'end',
-                                        'x += 1 if x < 10',
-                                        'x += 1 unless x < 10',
-                                        'x += 1 while x < 10',
-                                        'x += 1 until x < 10',
-                                       ])
-        expect(pac.offences.map(&:message)).to be_empty
+        inspect_source(pac, ['if x > 10',
+                             'end',
+                             'unless x > 10',
+                             'end',
+                             'while x > 10',
+                             'end',
+                             'until x > 10',
+                             'end',
+                             'x += 1 if x < 10',
+                             'x += 1 unless x < 10',
+                             'x += 1 while x < 10',
+                             'x += 1 until x < 10',
+                            ])
+        expect(pac.offences).to be_empty
       end
 
-      # Parentheses are sometimes used to help the editor make nice
-      # indentation of conditions spanning several lines.
-      it 'accepts parentheses around multiline conditions' do
-        inspect_source(pac, 'file.rb', ['if (@lex_state != EXPR_BEG &&',
-                                        '    @lex_state != EXPR_FNAME &&',
-                                        '    trans[1])',
-                                        'end'])
-        expect(pac.offences.map(&:message)).to be_empty
+      it 'is not confused by leading brace in subexpression' do
+        inspect_source(pac, ['(a > b) && other ? one : two'])
+        expect(pac.offences).to be_empty
       end
 
-      it 'accepts parentheses around assignment' do
-        inspect_source(pac, 'file.rb', ['if (x = self.next_value)',
-                                        'end'])
-        expect(pac.offences.map(&:message)).to be_empty
-      end
+      # Parentheses are sometimes used to help the editor make nice
+      # indentation of conditions spanning several lines.
+      # it 'accepts parentheses around multiline conditions' do
+      #   inspect_source(pac, ['if (@lex_state != EXPR_BEG &&',
+      #                        '    @lex_state != EXPR_FNAME &&',
+      #                        '    trans[1])',
+      #                        'end'])
+      #   expect(pac.offences.map(&:message)).to be_empty
+      # end
     end
   end
 end

data/spec/rubocop/cops/percent_r_spec.rb

@@ -8,20 +8,20 @@ module Rubocop
       let(:apr) { PercentR.new }
 
       it 'registers an offence for %r with zero or one slash in regexp' do
-        inspect_source(apr, 'file.rb', ['x =~ %r(/home)',
-                                        'y =~ %r(etc)'])
+        inspect_source(apr, ['x =~ %r(/home)',
+                             'y =~ %r(etc)'])
         expect(apr.offences.map(&:message))
-          .to eq([PercentR::ERROR_MESSAGE] * 2)
+          .to eq([PercentR::MSG] * 2)
       end
 
       it 'accepts %r with at least two slashes in regexp' do
-        inspect_source(apr, 'file.rb', ['x =~ %r(/home/)',
-                                        'y =~ %r(/////)'])
+        inspect_source(apr, ['x =~ %r(/home/)',
+                             'y =~ %r(/////)'])
         expect(apr.offences.map(&:message)).to be_empty
       end
 
       it 'accepts slash delimiters for regexp' do
-        inspect_source(apr, 'file.rb', ['x =~ /\/home/'])
+        inspect_source(apr, ['x =~ /\/home/'])
         expect(apr.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/reduce_arguments_spec.rb

@@ -8,7 +8,7 @@ module Rubocop
       let(:reduce_arguments) { ReduceArguments.new }
 
       it 'find wrong argument names in calls with different syntax' do
-        inspect_source(reduce_arguments, '',
+        inspect_source(reduce_arguments,
                        ['def m',
                         '  [0, 1].reduce { |c, d| c + d }',
                         '  [0, 1].reduce{ |c, d| c + d }',
@@ -23,7 +23,7 @@ module Rubocop
       end
 
       it 'allows calls with proper argument names' do
-        inspect_source(reduce_arguments, '',
+        inspect_source(reduce_arguments,
                        ['def m',
                         '  [0, 1].reduce { |a, e| a + e }',
                         '  [0, 1].reduce{ |a, e| a + e }',
@@ -36,7 +36,7 @@ module Rubocop
       end
 
       it 'ignores do..end blocks' do
-        inspect_source(reduce_arguments, '',
+        inspect_source(reduce_arguments,
                        ['def m',
                         '  [0, 1].reduce do |c, d|',
                         '    c + d',
@@ -46,7 +46,7 @@ module Rubocop
       end
 
       it 'ignores :reduce symbols' do
-        inspect_source(reduce_arguments, '',
+        inspect_source(reduce_arguments,
                        ['def m',
                         '  call_method(:reduce) { |a, b| a + b}',
                         'end'])

data/spec/rubocop/cops/rescue_exception_spec.rb

@@ -9,7 +9,6 @@ module Rubocop
 
       it 'registers an offence for rescue from Exception' do
         inspect_source(re,
-                       'file.rb',
                        ['begin',
                         '  something',
                         'rescue Exception',
@@ -17,12 +16,35 @@ module Rubocop
                         'end'])
         expect(re.offences.size).to eq(1)
         expect(re.offences.map(&:message))
-          .to eq([RescueException::ERROR_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,
-                       'file.rb',
                        ['begin',
                         '  something',
                         'rescue Exception => e',
@@ -30,12 +52,33 @@ module Rubocop
                         'end'])
         expect(re.offences.size).to eq(1)
         expect(re.offences.map(&:message))
-          .to eq([RescueException::ERROR_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,
-                       'file.rb',
                        ['begin',
                         '  something',
                         '  return',
@@ -47,7 +90,6 @@ module Rubocop
 
       it 'does not register an offence for rescue with other classes' do
         inspect_source(re,
-                       'file.rb',
                        ['begin',
                         '  something',
                         '  return',
@@ -59,7 +101,6 @@ module Rubocop
 
       it 'does not register an offence for rescue with a module prefix' do
         inspect_source(re,
-                       'file.rb',
                        ['begin',
                         '  something',
                         '  return',
@@ -71,7 +112,6 @@ module Rubocop
 
       it 'does not crash when the splat operator is used in a rescue' do
         inspect_source(re,
-                       'file.rb',
                        ['ERRORS = [Exception]',
                         'begin',
                         '  a = 3 / 0',

data/spec/rubocop/cops/rescue_modifier_spec.rb

@@ -9,25 +9,22 @@ module Rubocop
 
       it 'registers an offence for modifier rescue' do
         inspect_source(rm,
-                       'file.rb',
                        ['method rescue handle'])
         expect(rm.offences.size).to eq(1)
         expect(rm.offences.map(&:message))
-          .to eq([RescueModifier::ERROR_MESSAGE])
+          .to eq([RescueModifier::MSG])
       end
 
       it 'handles more complex expression with modifier rescue' do
         inspect_source(rm,
-                       'file.rb',
                        ['method1 or method2 rescue handle'])
         expect(rm.offences.size).to eq(1)
         expect(rm.offences.map(&:message))
-          .to eq([RescueModifier::ERROR_MESSAGE])
+          .to eq([RescueModifier::MSG])
       end
 
       it 'does not register an offence for normal rescue' do
         inspect_source(rm,
-                       'file.rb',
                        ['begin',
                         '  test',
                         'rescue',

data/spec/rubocop/cops/semicolon_spec.rb

@@ -15,62 +15,38 @@ module Rubocop
 
       it 'registers an offence for a single expression' do
         inspect_source(s,
-                       'file.rb',
                        ['puts "this is a test";'])
         expect(s.offences.size).to eq(1)
-        expect(s.offences.map(&:message)).to eq([Semicolon::ERROR_MESSAGE])
+        expect(s.offences.map(&:message)).to eq([Semicolon::MSG])
       end
 
       it 'registers an offence for several expressions' do
         inspect_source(s,
-                       'file.rb',
                        ['puts "this is a test"; puts "So is this"'])
         expect(s.offences.size).to eq(1)
-        expect(s.offences.map(&:message)).to eq([Semicolon::ERROR_MESSAGE])
+        expect(s.offences.map(&:message)).to eq([Semicolon::MSG])
       end
 
       it 'registers an offence for one line method with two statements' do
         inspect_source(s,
-                       'file.rb',
                        ['def foo(a) x(1); y(2); z(3); end'])
-        expect(s.offences.size).to eq(2)
-      end
-
-      it 'registers an offence for semicolon before end if so configured' do
-        Semicolon.config['AllowBeforeEndInOneLineMethods'] = false
-        inspect_source(s,
-                       'file.rb',
-                       ['def foo(a) z(3); end'])
         expect(s.offences.size).to eq(1)
       end
 
       it 'accepts semicolon before end if so configured' do
         inspect_source(s,
-                       'file.rb',
                        ['def foo(a) z(3); end'])
         expect(s.offences).to be_empty
       end
 
-      it 'registers an offence for semicolon after params if so configured' do
-        inspect_source(s,
-                       'file.rb',
-                       ['def foo(a); y(2); z(3) end',
-                        'def bar(a) y(2); z(3) end'])
-        expect(s.offences.size).to eq(3)
-      end
-
       it 'accepts semicolon after params if so configured' do
-        Semicolon.config['AllowAfterParameterListInOneLineMethods'] = true
         inspect_source(s,
-                       'file.rb',
                        ['def foo(a); z(3) end'])
         expect(s.offences).to be_empty
       end
 
       it 'accepts one line method definitions' do
-        Semicolon.config['AllowAfterParameterListInOneLineMethods'] = true
         inspect_source(s,
-                       'file.rb',
                        ['def foo1; x(3) end',
                         'def initialize(*_); end',
                         'def foo2() x(3); end',
@@ -80,7 +56,6 @@ module Rubocop
 
       it 'accepts one line empty class definitions' do
         inspect_source(s,
-                       'file.rb',
                        ['# Prefer a single-line format for class ...',
                         'class Foo < Exception; end',
                         '',
@@ -90,7 +65,6 @@ module Rubocop
 
       it 'accepts one line empty method definitions' do
         inspect_source(s,
-                       'file.rb',
                        ['# One exception to the rule are empty-body methods',
                         'def no_op; end',
                         '',
@@ -100,14 +74,12 @@ module Rubocop
 
       it 'accepts one line empty module definitions' do
         inspect_source(s,
-                       'file.rb',
                        ['module Foo; end'])
         expect(s.offences).to be_empty
       end
 
       it 'registers an offence for semicolon at the end no matter what' do
         inspect_source(s,
-                       'file.rb',
                        ['module Foo; end;'])
         expect(s.offences.size).to eq(1)
       end