rubocop 0.4.0 → 0.8.0

data/spec/rubocop/cops/space_around_operators_spec.rb

@@ -8,11 +8,18 @@ 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, ['x == 0?1:2'])
+        expect(space.offences.map(&:message)).to eq(
+          ["Surrounding space missing for operator '?'.",
+           "Surrounding space missing for operator ':'."])
+      end
+
       it 'registers an offence in presence of modifier if statement' do
         check_modifier('if')
       end
@@ -32,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 '&'.",
@@ -47,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 =\n  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

data/spec/rubocop/cops/space_inside_brackets_spec.rb

@@ -8,33 +8,39 @@ module Rubocop
       let(:space) { SpaceInsideBrackets.new }
 
       it 'registers an offence for an array literal with spaces inside' do
-        inspect_source(space, 'file.rb', ['a = [1, 2 ]',
+        inspect_source(space, ['a = [1, 2 ]',
                                          'b = [ 1, 2]'])
         expect(space.offences.map(&:message)).to eq(
           ['Space inside square brackets detected.',
            'Space inside square brackets detected.'])
       end
 
+      it 'accepts space inside strings within square brackets' do
+        inspect_source(space, ["['Encoding:',",
+                               " '  Enabled: false']"])
+        expect(space.offences.map(&:message)).to be_empty
+      end
+
       it 'accepts space inside square brackets if on its own row' do
-        inspect_source(space, 'file.rb', ['a = [',
-                                         '     1, 2',
-                                         '    ]'])
+        inspect_source(space, ['a = [',
+                               '     1, 2',
+                               '    ]'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts square brackets as method name' do
-        inspect_source(space, 'file.rb', ['def Vector.[](*array)',
+        inspect_source(space, ['def Vector.[](*array)',
                                          'end'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts square brackets called with method call syntax' do
-        inspect_source(space, 'file.rb', ['subject.[](0)'])
+        inspect_source(space, ['subject.[](0)'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'only reports a single space once' do
-        inspect_source(space, 'file.rb', ['[ ]'])
+        inspect_source(space, ['[ ]'])
         expect(space.offences.map(&:message)).to eq(
           ['Space inside square brackets detected.'])
       end

data/spec/rubocop/cops/space_inside_hash_literal_braces_spec.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SpaceInsideHashLiteralBraces do
+      let(:sihlb) { SpaceInsideHashLiteralBraces.new }
+      before do
+        SpaceInsideHashLiteralBraces.config = {
+          'EnforcedStyleIsWithSpaces' => true
+        }
+      end
+
+      it 'registers an offence for hashes with no spaces by default' do
+        inspect_source(sihlb,
+                       ['h = {a: 1, b: :two}',
+                        'h = {a => 1 }'])
+        expect(sihlb.offences.map(&:message)).to eq(
+          ['Space inside hash literal braces missing.'] * 3)
+      end
+
+      it 'registers an offence for hashes with no spaces if so configured' do
+        inspect_source(sihlb,
+                       ['h = {a: 1, b: 2}',
+                        'h = {a => 1 }'])
+        expect(sihlb.offences.map(&:message)).to eq(
+          ['Space inside hash literal braces missing.'] * 3)
+      end
+
+      it 'registers an offence for hashes with spaces if so configured' do
+        SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+          false
+        inspect_source(sihlb,
+                       ['h = { a: 1, b: 2 }'])
+        expect(sihlb.offences.map(&:message)).to eq(
+          ['Space inside hash literal braces detected.'] * 2)
+      end
+
+      it 'accepts hashes with spaces by default' do
+        inspect_source(sihlb,
+                       ['h = { a: 1, b: 2 }',
+                        'h = { a => 1 }'])
+        expect(sihlb.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts hashes with no spaces if so configured' do
+        SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+          false
+        inspect_source(sihlb,
+                       ['h = {a: 1, b: 2}',
+                        'h = {a => 1}'])
+        expect(sihlb.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts empty hashes without spaces by default' do
+        inspect_source(sihlb, ['h = {}'])
+        expect(sihlb.offences).to be_empty
+      end
+
+      it 'accepts empty hashes without spaces if configured false' do
+        SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+          false
+        inspect_source(sihlb, ['h = {}'])
+        expect(sihlb.offences).to be_empty
+      end
+
+      it 'accepts empty hashes without spaces even if configured true' do
+        inspect_source(sihlb, ['h = {}'])
+        expect(sihlb.offences).to be_empty
+      end
+
+      it 'accepts hash literals with no braces' do
+        inspect_source(sihlb, ['x(a: b.c)'])
+        expect(sihlb.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/space_inside_parens_spec.rb

@@ -8,20 +8,24 @@ module Rubocop
       let(:space) { SpaceInsideParens.new }
 
       it 'registers an offence for spaces inside parens' do
-        inspect_source(space, 'file.rb', ['f( 3)',
-                                         'g(3 )'])
+        inspect_source(space, ['f( 3)',
+                               'g(3 )'])
         expect(space.offences.map(&:message)).to eq(
           ['Space inside parentheses detected.',
            'Space inside parentheses detected.'])
       end
 
       it 'accepts parentheses in block parameter list' do
-        inspect_source(space, 'file.rb',
+        inspect_source(space,
                        ['list.inject(Tms.new) { |sum, (label, item)|',
                         '}'])
         expect(space.offences.map(&:message)).to be_empty
       end
 
+      it 'accepts parentheses with no spaces' do
+        inspect_source(space, ['split("\n")'])
+        expect(space.offences.map(&:message)).to be_empty
+      end
     end
   end
 end

data/spec/rubocop/cops/string_literals_spec.rb

@@ -8,7 +8,7 @@ module Rubocop
       let(:sl) { StringLiterals.new }
 
       it 'registers an offence for double quotes when single quotes suffice' do
-        inspect_source(sl, 'file.rb', ['s = "abc"'])
+        inspect_source(sl, ['s = "abc"'])
         expect(sl.offences.map(&:message)).to eq(
           ["Prefer single-quoted strings when you don't need string " +
            'interpolation or special symbols.'])
@@ -17,16 +17,31 @@ module Rubocop
       it 'accepts double quotes when they are needed' do
         src = ['a = "\n"',
                'b = "#{encode_severity}:#{sprintf("%3d", line_number)}: #{m}"',
-               'c = "\'"']
-        inspect_source(sl, 'file.rb', src)
+               'c = "\'"',
+               'd = "#@test"',
+               'e = "#$test"',
+               'f = "#@@test"']
+        inspect_source(sl, src)
         expect(sl.offences.map(&:message)).to be_empty
       end
 
-      it 'can handle double quotes within embedded expression' do
-        src = ['"#{"A"}"']
-        inspect_source(sl, 'file.rb', src)
+      it 'accepts double quotes with some other special symbols' do
+        pending
+        # "Substitutions in double-quoted strings"
+        # http://www.ruby-doc.org/docs/ProgrammingRuby/html/language.html
+        src = ['g = "\xf9"']
+        inspect_source(sl, src)
         expect(sl.offences.map(&:message)).to be_empty
       end
+
+      it 'can handle double quotes within embedded expression' do
+        # This seems to be a Parser bug
+        pending do
+          src = ['"#{"A"}"']
+          inspect_source(sl, src)
+          expect(sl.offences.map(&:message)).to be_empty
+        end
+      end
     end
   end
 end

data/spec/rubocop/cops/symbol_array_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SymbolArray do
+      let(:sa) { SymbolArray.new }
+
+      it 'registers an offence for arrays of symbols', { ruby: 2.0 } do
+        inspect_source(sa,
+                       ['[:one, :two, :three]'])
+        expect(sa.offences.size).to eq(1)
+      end
+
+      it 'does not reg an offence for array with non-syms', { ruby: 2.0 } do
+        inspect_source(sa,
+                       ['[:one, :two, "three"]'])
+        expect(sa.offences).to be_empty
+      end
+
+      it 'does not reg an offence for array starting with %i', { ruby: 2.0 } do
+        inspect_source(sa,
+                       ['%i(one two three)'])
+        expect(sa.offences).to be_empty
+      end
+
+      it 'does not reg an offence for array with one element', { ruby: 2.0 } do
+        inspect_source(sa,
+                       ['[:three]'])
+        expect(sa.offences).to be_empty
+      end
+
+      it 'does nothing on Ruby 1.9', { ruby: 1.9 } do
+        inspect_source(sa,
+                       ['[:one, :two, :three]'])
+        expect(sa.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/symbol_name_spec.rb

@@ -0,0 +1,119 @@
+  # encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SymbolName do
+      let(:symbol_name) { SymbolName.new }
+
+      before do
+        SymbolName.config = Config.default_configuration.for_cop('SymbolName')
+      end
+
+      context 'when AllowCamelCase is true' do
+        before do
+          SymbolName.config = {
+            'AllowCamelCase' => true
+          }
+        end
+
+        it 'does not register an offence for camel case in names' do
+          inspect_source(symbol_name,
+                         ['test = :BadIdea'])
+          expect(symbol_name.offences).to be_empty
+        end
+      end
+
+      context 'when AllowCamelCase is false' do
+        before do
+          SymbolName.config = {
+            'AllowCamelCase' => false
+          }
+        end
+
+        it 'registers an offence for camel case in names' do
+          inspect_source(symbol_name,
+                         ['test = :BadIdea'])
+          expect(symbol_name.offences.map(&:message)).to eq(
+            ['Use snake_case for symbols.'])
+        end
+      end
+
+      it 'registers an offence for symbol used as hash label' do
+        inspect_source(symbol_name,
+                       ['{ KEY_ONE: 1, KEY_TWO: 2 }'])
+        expect(symbol_name.offences.map(&:message)).to eq(
+          ['Use snake_case for symbols.'] * 2)
+      end
+
+      it 'accepts snake case in names' do
+        inspect_source(symbol_name,
+                       ['test = :good_idea'])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'accepts snake case in hash label names' do
+        inspect_source(symbol_name,
+                       ['{ one: 1, one_more_3: 2 }'])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'accepts snake case with a prefix @ in names' do
+        inspect_source(symbol_name,
+                       ['test = :@good_idea'])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'accepts snake case with ? suffix' do
+        inspect_source(symbol_name,
+                       ['test = :good_idea?'])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'accepts snake case with ! suffix' do
+        inspect_source(symbol_name,
+                       ['test = :good_idea!'])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'accepts snake case with = suffix' do
+        inspect_source(symbol_name,
+                       ['test = :good_idea='])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'accepts special cases - !, [] and **' do
+        inspect_source(symbol_name,
+                       ['test = :**',
+                        'test = :!',
+                        'test = :[]',
+                        'test = :[]='])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'accepts special cases - ==, <=>, >, <, >=, <=' do
+        inspect_source(symbol_name,
+                       ['test = :==',
+                        'test = :<=>',
+                        'test = :>',
+                        'test = :<',
+                        'test = :>=',
+                        'test = :<='])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'can handle an alias of and operator without crashing' do
+        inspect_source(symbol_name,
+                       ['alias + add'])
+        expect(symbol_name.offences).to be_empty
+      end
+
+      it 'registers an offence for SCREAMING_symbol_name' do
+        inspect_source(symbol_name,
+                       ['test = :BAD_IDEA'])
+        expect(symbol_name.offences.size).to eq(1)
+      end
+    end
+  end
+end

data/spec/rubocop/cops/syntax_spec.rb

@@ -7,11 +7,34 @@ module Rubocop
     describe Syntax do
       let(:sc) { Syntax.new }
 
-      it 'registers an offence for unused variables', ruby: 2.0 do
-        sc.inspect('file.rb', ['x = 5', 'puts 10'], nil, nil)
-        expect(sc.offences.size).to eq(1)
-        expect(sc.offences.first.message)
-          .to eq('Assigned but unused variable - x')
+      if RUBY_ENGINE == 'ruby'
+        it 'registers an offence for unused variables', ruby: 2.0 do
+          source = "x = 5\nputs 10"
+          Dir.mktmpdir do |tmpdir|
+            path = File.join(tmpdir, 'file.rb')
+            File.open(path, 'w') { |f| f.write(source) }
+            sc.inspect_file(path)
+          end
+          expect(sc.offences.size).to eq(1)
+          expect(sc.offences.first.message)
+            .to eq('Assigned but unused variable - x')
+        end
+
+        describe '#process_line' do
+          it 'processes warnings correctly' do
+            l, s, m = sc.process_line('admin.rb:1: warning: possibly useless')
+            expect(l).to eq(1)
+            expect(s).to eq(:warning)
+            expect(m).to eq('Possibly useless')
+          end
+
+          it 'processes errors correctly' do
+            l, s, m = sc.process_line('admin.rb:1: unterminated string meets')
+            expect(l).to eq(1)
+            expect(s).to eq(:error)
+            expect(m).to eq('Unterminated string meets')
+          end
+        end
       end
     end
   end

data/spec/rubocop/cops/tab_spec.rb

@@ -8,12 +8,12 @@ module Rubocop
       let(:tab) { Tab.new }
 
       it 'registers an offence for a line indented with tab' do
-        tab.inspect('file.rb', ["\tx = 0"], nil, nil)
+        tab.inspect(["\tx = 0"], nil, nil, nil)
         expect(tab.offences.size).to eq(1)
       end
 
       it 'accepts a line with tab in a string' do
-        tab.inspect('file.rb', [%Q(x = "\t")], nil, nil)
+        tab.inspect(["(x = \"\t\")"], nil, nil, nil)
         expect(tab.offences).to be_empty
       end
     end