rubocop 0.7.2 → 0.8.0

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

@@ -13,15 +13,15 @@ module Rubocop
       end
 
       it 'registers an offence for hashes with no spaces by default' do
-        inspect_source(sihlb, '',
-                       ['h = {a: 1, b: 2}',
+        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, '',
+        inspect_source(sihlb,
                        ['h = {a: 1, b: 2}',
                         'h = {a => 1 }'])
         expect(sihlb.offences.map(&:message)).to eq(
@@ -31,14 +31,14 @@ module Rubocop
       it 'registers an offence for hashes with spaces if so configured' do
         SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
           false
-        inspect_source(sihlb, '',
+        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, '',
+        inspect_source(sihlb,
                        ['h = { a: 1, b: 2 }',
                         'h = { a => 1 }'])
         expect(sihlb.offences.map(&:message)).to be_empty
@@ -47,26 +47,31 @@ module Rubocop
       it 'accepts hashes with no spaces if so configured' do
         SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
           false
-        inspect_source(sihlb, '',
+        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 = {}'])
+        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 = {}'])
+        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 = {}'])
+        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

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.'])
@@ -21,15 +21,27 @@ module Rubocop
                'd = "#@test"',
                'e = "#$test"',
                'f = "#@@test"']
-        inspect_source(sl, 'file.rb', src)
+        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

@@ -9,14 +9,30 @@ module Rubocop
 
       it 'registers an offence for arrays of symbols', { ruby: 2.0 } do
         inspect_source(sa,
-                       'file.rb',
                        ['[: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,
-                       'file.rb',
                        ['[:one, :two, :three]'])
         expect(sa.offences).to be_empty
       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,26 +7,33 @@ 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')
-      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')
+      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
 
-        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')
+        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

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', ["(x = \"\t\")"], nil, nil)
+        tab.inspect(["(x = \"\t\")"], nil, nil, nil)
         expect(tab.offences).to be_empty
       end
     end

data/spec/rubocop/cops/ternary_operator_spec.rb

@@ -8,16 +8,14 @@ module Rubocop
       let(:op) { MultilineTernaryOperator.new }
 
       it 'registers an offence for a multiline ternary operator expression' do
-        inspect_source(op, 'file.rb', ['a = cond ?',
-                                        '  b : c'])
-        expect(op.offences.map(&:message)).to eq(
-          ['Avoid multi-line ?: (the ternary operator); use if/unless ' +
-           'instead.'])
+        inspect_source(op, ['a = cond ?',
+                            '  b : c'])
+        expect(op.offences.size).to eq(1)
       end
 
       it 'accepts a single line ternary operator expression' do
-        inspect_source(op, 'file.rb', ['a = cond ? b : c'])
-        expect(op.offences.map(&:message)).to be_empty
+        inspect_source(op, ['a = cond ? b : c'])
+        expect(op.offences).to be_empty
       end
     end
 
@@ -25,19 +23,17 @@ module Rubocop
       let(:op) { NestedTernaryOperator.new }
 
       it 'registers an offence for a nested ternary operator expression' do
-        inspect_source(op, 'file.rb', ['a ? (b ? b1 : b2) : a2'])
-        expect(op.offences.map(&:message)).to eq(
-          ['Ternary operators must not be nested. Prefer if/else constructs ' +
-           'instead.'])
+        inspect_source(op, ['a ? (b ? b1 : b2) : a2'])
+        expect(op.offences.size).to eq(1)
       end
 
       it 'accepts a non-nested ternary operator within an if' do
-        inspect_source(op, 'file.rb', ['a = if x',
-                                       '  cond ? b : c',
-                                       'else',
-                                       '  d',
-                                       'end'])
-        expect(op.offences.map(&:message)).to be_empty
+        inspect_source(op, ['a = if x',
+                            '  cond ? b : c',
+                            'else',
+                            '  d',
+                            'end'])
+        expect(op.offences).to be_empty
       end
     end
   end