rubocop 0.4.0 → 0.8.0

data/spec/rubocop/cops/rescue_exception_spec.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    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

data/spec/rubocop/cops/rescue_modifier_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe RescueModifier do
+      let(:rm) { RescueModifier.new }
+
+      it 'registers an offence for modifier rescue' do
+        inspect_source(rm,
+                       ['method rescue handle'])
+        expect(rm.offences.size).to eq(1)
+        expect(rm.offences.map(&:message))
+          .to eq([RescueModifier::MSG])
+      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.offences.map(&:message))
+          .to eq([RescueModifier::MSG])
+      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
+    end
+  end
+end

data/spec/rubocop/cops/semicolon_spec.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Semicolon do
+      let(:s) { Semicolon.new }
+      before do
+        Semicolon.config = {
+          'AllowAfterParameterListInOneLineMethods' => false,
+          'AllowBeforeEndInOneLineMethods' => true
+        }
+      end
+
+      it 'registers an offence for a single expression' do
+        inspect_source(s,
+                       ['puts "this is a test";'])
+        expect(s.offences.size).to eq(1)
+        expect(s.offences.map(&:message)).to eq([Semicolon::MSG])
+      end
+
+      it 'registers an offence for several expressions' do
+        inspect_source(s,
+                       ['puts "this is a test"; puts "So is this"'])
+        expect(s.offences.size).to eq(1)
+        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,
+                       ['def foo(a) x(1); y(2); z(3); end'])
+        expect(s.offences.size).to eq(1)
+      end
+
+      it 'accepts semicolon before end if so configured' do
+        inspect_source(s,
+                       ['def foo(a) z(3); end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts semicolon after params if so configured' do
+        inspect_source(s,
+                       ['def foo(a); z(3) end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts one line method definitions' do
+        inspect_source(s,
+                       ['def foo1; x(3) end',
+                        'def initialize(*_); end',
+                        'def foo2() x(3); end',
+                        'def foo3; x(3); end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts one line empty class definitions' do
+        inspect_source(s,
+                       ['# Prefer a single-line format for class ...',
+                        'class Foo < Exception; end',
+                        '',
+                        'class Bar; end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts one line empty method definitions' do
+        inspect_source(s,
+                       ['# One exception to the rule are empty-body methods',
+                        'def no_op; end',
+                        '',
+                        'def foo; end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts one line empty module definitions' do
+        inspect_source(s,
+                       ['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,
+                       ['module Foo; end;'])
+        expect(s.offences.size).to eq(1)
+      end
+    end
+  end
+end

data/spec/rubocop/cops/single_line_methods_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SingleLineMethods do
+      let(:slm) { SingleLineMethods.new }
+      before { SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true } }
+
+      it 'registers an offence for a single-line method' do
+        inspect_source(slm,
+                       ['def some_method; body end',
+                        'def link_to(name, url); {:name => name}; end',
+                        'def @table.columns; super; end'])
+        expect(slm.offences.map(&:message)).to eq(
+          [SingleLineMethods::MSG] * 3)
+      end
+
+      it 'registers an offence for an empty method if so configured' do
+        SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => false }
+        inspect_source(slm, ['def no_op; end',
+                             'def self.resource_class=(klass); end',
+                             'def @table.columns; end'])
+        expect(slm.offences.size).to eq(3)
+      end
+
+      it 'accepts a single-line empty method if so configured' do
+        SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true }
+        inspect_source(slm, ['def no_op; end',
+                             'def self.resource_class=(klass); end',
+                             'def @table.columns; end'])
+        expect(slm.offences).to be_empty
+      end
+
+      it 'accepts a multi-line method' do
+        inspect_source(slm, ['def some_method',
+                             '  body',
+                             'end'])
+        expect(slm.offences).to be_empty
+      end
+
+      it 'does not crash on an method with a capitalized name' do
+        inspect_source(slm, ['def NoSnakeCase',
+                             'end'])
+        expect(slm.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/space_after_colon_spec.rb

@@ -8,18 +8,18 @@ module Rubocop
       let(:space) { SpaceAfterColon.new }
 
       it 'registers an offence for colon without space after it' do
-        inspect_source(space, 'file.rb', ['x = w ? {a:3}:4'])
+        inspect_source(space, ['x = w ? {a:3}:4'])
         expect(space.offences.map(&:message)).to eq(
           ['Space missing after colon.'] * 2)
       end
 
       it 'allows the colons in symbols' do
-        inspect_source(space, 'file.rb', ['x = :a'])
+        inspect_source(space, ['x = :a'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'allows colons in strings' do
-        inspect_source(space, 'file.rb', ["str << ':'"])
+        inspect_source(space, ["str << ':'"])
         expect(space.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/space_after_comma_spec.rb

@@ -7,8 +7,20 @@ module Rubocop
     describe SpaceAfterComma do
       let(:space) { SpaceAfterComma.new }
 
-      it 'registers an offence for block argument commas' do
-        inspect_source(space, 'file.rb', ['each { |s,t| }'])
+      it 'registers an offence for block argument commas without space' do
+        inspect_source(space, ['each { |s,t| }'])
+        expect(space.offences.map(&:message)).to eq(
+          ['Space missing after comma.'])
+      end
+
+      it 'registers an offence for array index commas without space' do
+        inspect_source(space, ['formats[0,1]'])
+        expect(space.offences.map(&:message)).to eq(
+          ['Space missing after comma.'])
+      end
+
+      it 'registers an offence for method call arg commas without space' do
+        inspect_source(space, ['a(1,2)'])
         expect(space.offences.map(&:message)).to eq(
           ['Space missing after comma.'])
       end

data/spec/rubocop/cops/space_after_control_keyword_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SpaceAfterControlKeyword do
+      let(:ap) { SpaceAfterControlKeyword.new }
+
+      it 'registers an offence for normal if' do
+        inspect_source(ap,
+                       ['if(test) then result end'])
+        expect(ap.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for modifier unless' do
+        inspect_source(ap, ['action unless(test)'])
+
+        expect(ap.offences.size).to eq(1)
+      end
+
+      it 'does not get confused by keywords' do
+        inspect_source(ap, ['[:if, :unless].action'])
+        expect(ap.offences).to be_empty
+      end
+
+      it 'does not get confused by the ternary operator' do
+        inspect_source(ap, ['a ? b : c'])
+        expect(ap.offences).to be_empty
+      end
+
+      it 'registers an offence for if, elsif, and unless' do
+        inspect_source(ap,
+                       ['if(a)',
+                        'elsif(b)',
+                        '  unless(c)',
+                        '  end',
+                        'end'])
+        expect(ap.offences.map(&:line_number)).to eq([1, 2, 3])
+      end
+
+      it 'registers an offence for case and when' do
+        inspect_source(ap,
+                       ['case(a)',
+                        'when(0) then 1',
+                        'end'])
+        expect(ap.offences.map(&:line_number)).to eq([1, 2])
+      end
+
+      it 'registers an offence for case and when' do
+        inspect_source(ap,
+                       ['case(a)',
+                        'when(0) then 1',
+                        'end'])
+        expect(ap.offences.map(&:line_number)).to eq([1, 2])
+      end
+
+      it 'registers an offence for while and until' do
+        inspect_source(ap,
+                       ['while(a)',
+                        '  b until(c)',
+                        'end'])
+        expect(ap.offences.map(&:line_number)).to eq([1, 2])
+      end
+    end
+  end
+end

data/spec/rubocop/cops/space_after_semicolon_spec.rb

@@ -8,10 +8,15 @@ module Rubocop
       let(:space) { SpaceAfterSemicolon.new }
 
       it 'registers an offence for semicolon without space after it' do
-        inspect_source(space, 'file.rb', ['x = 1;y = 2'])
+        inspect_source(space, ['x = 1;y = 2'])
         expect(space.offences.map(&:message)).to eq(
           ['Space missing after semicolon.'])
       end
+
+      it 'does not crash if semicolon is the last character of the file' do
+        inspect_source(space, ['x = 1;'])
+        expect(space.offences.map(&:message)).to be_empty
+      end
     end
   end
 end

data/spec/rubocop/cops/space_around_braces_spec.rb

@@ -8,25 +8,40 @@ module Rubocop
       let(:space) { SpaceAroundBraces.new }
 
       it 'registers an offence for left brace without spaces' do
-        inspect_source(space, 'file.rb', ['each{ puts }'])
+        inspect_source(space, ['each{ puts }'])
         expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for '{'."])
       end
 
       it 'registers an offence for right brace without inner space' do
-        inspect_source(space, 'file.rb', ['each { puts}'])
+        inspect_source(space, ['each { puts}'])
         expect(space.offences.map(&:message)).to eq(
           ["Space missing to the left of '}'."])
       end
 
       it 'accepts an empty hash literal with no space inside' do
-        inspect_source(space, 'file.rb',
+        inspect_source(space,
                        ['view_hash.each do |view_key|',
                         'end',
                         '@views = {}',
                         ''])
         expect(space.offences.map(&:message)).to be_empty
       end
+
+      it 'accepts string interpolation braces with no space inside' do
+        inspect_source(space,
+                       ['"A=#{a}"',
+                        ':"#{b}"',
+                        '/#{c}/',
+                        '`#{d}`',
+                        'sprintf("#{message.gsub(/%/, \'%%\')}", line)'])
+        expect(space.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts braces around a hash literal argument' do
+        inspect_source(space, ["new({'user' => user_params})"])
+        expect(space.offences.map(&:message)).to be_empty
+      end
     end
   end
 end

data/spec/rubocop/cops/space_around_equals_in_default_parameter_spec.rb

@@ -8,13 +8,23 @@ module Rubocop
       let(:space) { SpaceAroundEqualsInParameterDefault.new }
 
       it 'registers an offence for default value assignment without space' do
-        inspect_source(space, 'file.rb', ['def f(x, y=0, z=1)', 'end'])
+        inspect_source(space, ['def f(x, y=0, z=1)', 'end'])
         expect(space.offences.map(&:message)).to eq(
           ['Surrounding space missing in default value assignment.'] * 2)
       end
 
+      it 'registers an offence for assignment of empty string without space' do
+        inspect_source(space, ['def f(x, y="", z=1)', 'end'])
+        expect(space.offences.size).to eq(2)
+      end
+
+      it 'registers an offence for assignment of empty list without space' do
+        inspect_source(space, ['def f(x, y=[])', 'end'])
+        expect(space.offences.size).to eq(1)
+      end
+
       it 'accepts default value assignment with space' do
-        inspect_source(space, 'file.rb', ['def f(x, y = 0, z = 1)', 'end'])
+        inspect_source(space, ['def f(x, y = 0, z = {})', 'end'])
         expect(space.offences.map(&:message)).to be_empty
       end
     end