rubocop 0.7.2 → 0.8.0

data/spec/rubocop/cops/single_line_methods_spec.rb

@@ -9,40 +9,40 @@ module Rubocop
       before { SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true } }
 
       it 'registers an offence for a single-line method' do
-        inspect_source(slm, '',
+        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::ERROR_MESSAGE] * 3)
+          [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'])
+        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'])
+        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'])
+        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'])
+        inspect_source(slm, ['def NoSnakeCase',
+                             'end'])
         expect(slm.offences).to be_empty
       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

@@ -8,21 +8,60 @@ module Rubocop
       let(:ap) { SpaceAfterControlKeyword.new }
 
       it 'registers an offence for normal if' do
-        inspect_source(ap, 'file.rb',
+        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, 'file.rb', ['action unless(test)'])
+        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, 'file.rb', ['[:if, :unless].action'])
+        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,13 +8,13 @@ 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, 'file.rb', ['x = 1;'])
+        inspect_source(space, ['x = 1;'])
         expect(space.offences.map(&:message)).to be_empty
       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,23 +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, 'file.rb', ['def f(x, y="", z=1)', 'end'])
+        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, 'file.rb', ['def f(x, y=[])', 'end'])
+        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 = {})', 'end'])
+        inspect_source(space, ['def f(x, y = 0, z = {})', 'end'])
         expect(space.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/space_around_operators_spec.rb

@@ -8,13 +8,13 @@ module Rubocop
       let(:space) { SpaceAroundOperators.new }
 
       it 'registers an offence for assignment without space on both sides' do
-        inspect_source(space, 'file.rb', ['x=0', 'y= 0', 'z =0'])
+        inspect_source(space, ['x=0', 'y= 0', 'z =0'])
         expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for operator '='."] * 3)
       end
 
       it 'registers an offence for ternary operator without space' do
-        inspect_source(space, 'file.rb', ['x == 0?1:2'])
+        inspect_source(space, ['x == 0?1:2'])
         expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for operator '?'.",
            "Surrounding space missing for operator ':'."])
@@ -39,14 +39,14 @@ module Rubocop
       def check_modifier(keyword)
         src = ["a=1 #{keyword} condition",
                'c=2']
-        inspect_source(space, 'file.rb', src)
+        inspect_source(space, src)
         expect(space.offences.map(&:line_number)).to eq([1, 2])
         expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for operator '='."] * 2)
       end
 
       it 'registers an offence for binary operators that could be unary' do
-        inspect_source(space, 'file.rb', ['a-3', 'x&0xff', 'z+0'])
+        inspect_source(space, ['a-3', 'x&0xff', 'z+0'])
         expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for operator '-'.",
            "Surrounding space missing for operator '&'.",
@@ -54,99 +54,154 @@ module Rubocop
       end
 
       it 'registers an offence for arguments to a method' do
-        inspect_source(space, 'file.rb', ['puts 1+2'])
+        inspect_source(space, ['puts 1+2'])
         expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for operator '+'."])
       end
 
       it 'accepts operator symbols' do
-        inspect_source(space, 'file.rb', ['func(:-)'])
+        inspect_source(space, ['func(:-)'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts ranges' do
-        inspect_source(space, 'file.rb', ['a, b = (1..2), (1...3)'])
+        inspect_source(space, ['a, b = (1..2), (1...3)'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts scope operator' do
         source = ['@io.class == Zlib::GzipWriter']
-        inspect_source(space, 'file.rb', source)
+        inspect_source(space, source)
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts ::Kernel::raise' do
         source = ['::Kernel::raise IllegalBlockError.new']
-        inspect_source(space, 'file.rb', source)
+        inspect_source(space, source)
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts exclamation point negation' do
-        inspect_source(space, 'file.rb', ['x = !a&&!b'])
+        inspect_source(space, ['x = !a&&!b'])
         expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for operator '&&'."])
       end
 
       it 'accepts exclamation point definition' do
-        inspect_source(space, 'file.rb', ['  def !',
-                                         '    !__getobj__',
-                                         '  end'])
+        inspect_source(space, ['  def !',
+                               '    !__getobj__',
+                               '  end'])
         expect(space.offences).to be_empty
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts a unary' do
-        inspect_source(space, 'file.rb',
+        inspect_source(space,
                        ['  def bm(label_width = 0, *labels, &blk)',
                         '    benchmark(CAPTION, label_width, FORMAT,',
                         '              *labels, &blk)',
                         '  end',
+                        '',
+                        '  def each &block',
+                        '  end',
+                        '',
+                        '  def each *args',
+                        '  end',
                         ''])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts splat operator' do
-        inspect_source(space, 'file.rb', ['return *list if options'])
+        inspect_source(space, ['return *list if options'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts def of operator' do
-        inspect_source(space, 'file.rb', ['def +(other); end'])
+        inspect_source(space, ['def +(other); end',
+                               'def self.===(other); end'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
+      it 'accepts an operator at the end of a line' do
+        inspect_source(space,
+                       ["['Favor unless over if for negative ' +",
+                        " 'conditions.'] * 2"])
+        expect(space.offences.map(&:message)).to eq([])
+      end
+
       it 'accepts an assignment with spaces' do
-        inspect_source(space, 'file.rb', ['x = 0'])
+        inspect_source(space, ['x = 0'])
         expect(space.offences).to be_empty
       end
 
+      it 'registers an offence for operators without spaces' do
+        inspect_source(space,
+                       ['x+= a+b-c*d/e%f^g|h&i||j',
+                        'y -=k&&l'])
+        expect(space.offences.map(&:message))
+          .to eq(["Surrounding space missing for operator '+='.",
+                  "Surrounding space missing for operator '+'.",
+                  "Surrounding space missing for operator '-'.",
+                  "Surrounding space missing for operator '*'.",
+                  "Surrounding space missing for operator '/'.",
+                  "Surrounding space missing for operator '%'.",
+                  "Surrounding space missing for operator '^'.",
+                  "Surrounding space missing for operator '|'.",
+                  "Surrounding space missing for operator '&'.",
+                  "Surrounding space missing for operator '||'.",
+                  "Surrounding space missing for operator '-='.",
+                  "Surrounding space missing for operator '&&'."])
+      end
+
+      it 'accepts operators with spaces' do
+        inspect_source(space,
+                       ['x += a + b - c * d / e % f ^ g | h & i || j',
+                        'y -= k && l'])
+        expect(space.offences.map(&:message)).to eq([])
+      end
+
       it "accepts some operators that are exceptions and don't need spaces" do
-        inspect_source(space, 'file.rb', ['(1..3)',
-                                         'ActionController::Base',
-                                         'each { |s, t| }'])
-        expect(space.offences.map(&:message)).to be_empty
+        inspect_source(space, ['(1..3)',
+                               'ActionController::Base',
+                               'each { |s, t| }'])
+        expect(space.offences.map(&:message)).to eq([])
       end
 
       it 'accepts an assignment followed by newline' do
-        inspect_source(space, 'file.rb', ['x =', '0'])
+        inspect_source(space, ['x =', '0'])
         expect(space.offences).to be_empty
       end
 
       it 'registers an offences for exponent operator with spaces' do
-        inspect_source(space, 'file.rb', ['x = a * b ** 2'])
+        inspect_source(space, ['x = a * b ** 2'])
         expect(space.offences.map(&:message)).to eq(
           ['Space around operator ** detected.'])
       end
 
       it 'accepts exponent operator without spaces' do
-        inspect_source(space, 'file.rb', ['x = a * b**2'])
+        inspect_source(space, ['x = a * b**2'])
         expect(space.offences).to be_empty
       end
 
       it 'accepts unary operators without space' do
-        inspect_source(space, 'file.rb', ['[].map(&:size)',
-                                         '-3',
-                                         'x = +2'])
+        inspect_source(space, ['[].map(&:size)',
+                                          '-3',
+                                          'x = +2'])
+        expect(space.offences.map(&:message)).to eq([])
+      end
+
+      it 'accepts argument default values without space' do
+        # These are handled by SpaceAroundEqualsInParameterDefault,
+        # so SpaceAroundOperators leaves them alone.
+        inspect_source(space,
+                       ['def init(name=nil)',
+                        'end'])
+        expect(space.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts the construct class <<self with no space after <<' do
+        inspect_source(space, ['class <<self',
+                               'end'])
         expect(space.offences.map(&:message)).to be_empty
       end
     end