rubocop 0.12.0 → 0.13.0

data/spec/rubocop/cop/style/space_inside_brackets_spec.rb

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

data/spec/rubocop/cop/style/space_inside_hash_literal_braces_spec.rb

@@ -5,93 +5,79 @@ require 'spec_helper'
 module Rubocop
   module Cop
     module Style
-      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
+      describe SpaceInsideHashLiteralBraces, :config do
+        subject(:cop) { SpaceInsideHashLiteralBraces.new(config) }
+        let(:cop_config) { { 'EnforcedStyleIsWithSpaces' => true } }
 
         it 'registers an offence for hashes with no spaces if so configured' do
-          inspect_source(sihlb,
+          inspect_source(cop,
                          ['h = {a: 1, b: 2}',
                           'h = {a => 1 }'])
-          expect(sihlb.offences.map(&:message)).to eq(
+          expect(cop.messages).to eq(
             ['Space inside hash literal braces missing.'] * 3)
+          expect(cop.highlights).to eq(['{', '}', '{'])
         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)
+        context 'when EnforcedStyleIsWithSpaces is disabled' do
+          let(:cop_config) { { 'EnforcedStyleIsWithSpaces' => false } }
+
+          it 'registers an offence for hashes with spaces' do
+            inspect_source(cop,
+                           ['h = { a: 1, b: 2 }'])
+            expect(cop.messages).to eq(
+              ['Space inside hash literal braces detected.'] * 2)
+            expect(cop.highlights).to eq(['{', '}'])
+          end
+
+          it 'accepts hashes with no spaces' do
+            inspect_source(cop,
+                           ['h = {a: 1, b: 2}',
+                            'h = {a => 1}'])
+            expect(cop.offences).to be_empty
+          end
+
+          it 'accepts multiline hashes for no space' do
+            inspect_source(cop,
+                           ['h = {',
+                            '      a: 1,',
+                            '      b: 2,',
+                            '}'])
+            expect(cop.offences).to be_empty
+          end
+
+          it 'accepts empty hashes without spaces' do
+            inspect_source(cop, ['h = {}'])
+            expect(cop.offences).to be_empty
+          end
         end
 
         it 'accepts hashes with spaces by default' do
-          inspect_source(sihlb,
+          inspect_source(cop,
                          ['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 multiline hashes even if configured for no space' do
-          SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
-            false
-          inspect_source(sihlb,
-                         ['h = {',
-                          '      a: 1,',
-                          '      b: 2,',
-                          '}'])
-          expect(sihlb.offences).to be_empty
+          expect(cop.offences).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
+          inspect_source(cop, ['h = {}'])
+          expect(cop.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
+          inspect_source(cop, ['h = {}'])
+          expect(cop.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
+          inspect_source(cop, ['x(a: b.c)'])
+          expect(cop.offences).to be_empty
         end
 
         it 'can handle interpolation in a braceless hash literal' do
           # A tricky special case where the closing brace of the
           # interpolation risks getting confused for a hash literal brace.
-          inspect_source(sihlb, ['f(get: "#{x}")'])
-          expect(sihlb.offences).to be_empty
+          inspect_source(cop, ['f(get: "#{x}")'])
+          expect(cop.offences).to be_empty
         end
       end
     end

data/spec/rubocop/cop/style/space_inside_parens_spec.rb

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

data/spec/rubocop/cop/style/special_global_vars_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpecialGlobalVars do
+        subject(:cop) { described_class.new }
+
+        it 'registers an offence for $:' do
+          inspect_source(cop, ['puts $:'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages)
+            .to eq(['Prefer $LOAD_PATH over $:.'])
+        end
+
+        it 'registers an offence for $"' do
+          inspect_source(cop, ['puts $"'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages)
+            .to eq(['Prefer $LOADED_FEATURES over $".'])
+        end
+
+        it 'registers an offence for $0' do
+          inspect_source(cop, ['puts $0'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages)
+            .to eq(['Prefer $PROGRAM_NAME over $0.'])
+        end
+
+        it 'registers an offence for $$' do
+          inspect_source(cop, ['puts $$'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages)
+            .to eq(['Prefer $PID or $PROCESS_ID from English library' +
+              ' over $$.'])
+        end
+
+        it 'does not register an offence for backrefs like $1' do
+          inspect_source(cop, ['puts $1'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'auto-corrects $: to $LOAD_PATH' do
+          new_source = autocorrect_source(cop, '$:')
+          expect(new_source).to eq('$LOAD_PATH')
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cop/style/string_literals_spec.rb

@@ -6,13 +6,13 @@ module Rubocop
   module Cop
     module Style
       describe StringLiterals do
-        let(:cop) { StringLiterals.new }
+        subject(:cop) { StringLiterals.new }
 
         it 'registers offence for double quotes when single quotes suffice' do
           inspect_source(cop, ['s = "abc"',
-                              'x = "a\\\\b"',
-                              'y ="\\\\b"',
-                              'z = "a\\\\"'])
+                               'x = "a\\\\b"',
+                               'y ="\\\\b"',
+                               'z = "a\\\\"'])
           expect(cop.offences.size).to eq(4)
         end
 
@@ -23,7 +23,7 @@ module Rubocop
                  'c = "\'"',
                  'd = "#@test"',
                  'e = "#$test"',
-                  'f = "\e"',
+                 'f = "\e"',
                  'g = "#@@test"']
           inspect_source(cop, src)
           expect(cop.offences).to be_empty

data/spec/rubocop/cop/style/symbol_array_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe SymbolArray do
-        let(:sa) { SymbolArray.new }
+        subject(:sa) { SymbolArray.new }
 
         it 'registers an offence for arrays of symbols', { ruby: 2.0 } do
           inspect_source(sa,

data/spec/rubocop/cop/style/symbol_name_spec.rb

@@ -5,20 +5,12 @@ require 'spec_helper'
 module Rubocop
   module Cop
     module Style
-      describe SymbolName do
-        let(:symbol_name) { SymbolName.new }
-
-        before do
-          SymbolName.config =
-            Config.default_configuration.for_cop('SymbolName')
-        end
+      describe SymbolName, :config do
+        subject(:symbol_name) { SymbolName.new(config) }
+        let(:cop_config) { { 'AllowCamelCase' => true } }
 
         context 'when AllowCamelCase is true' do
-          before do
-            SymbolName.config = {
-              'AllowCamelCase' => true
-            }
-          end
+          let(:cop_config) { { 'AllowCamelCase' => true } }
 
           it 'does not register an offence for camel case in names' do
             inspect_source(symbol_name,
@@ -28,15 +20,32 @@ module Rubocop
         end
 
         context 'when AllowCamelCase is false' do
-          before do
-            SymbolName.config = {
-              'AllowCamelCase' => false
-            }
-          end
+          let(:cop_config) { { 'AllowCamelCase' => false } }
 
           it 'registers an offence for camel case in names' do
             inspect_source(symbol_name,
                            ['test = :BadIdea'])
+            expect(symbol_name.messages).to eq(
+              ['Use snake_case for symbols.'])
+          end
+        end
+
+        context 'when AllowDots is true' do
+          let(:cop_config) { { 'AllowDots' => true } }
+
+          it 'does not register an offence for dots in names' do
+            inspect_source(symbol_name,
+                           ['test = :"bad.idea"'])
+            expect(symbol_name.offences).to be_empty
+          end
+        end
+
+        context 'when AllowDots is false' do
+          let(:cop_config) { { 'AllowDots' => false } }
+
+          it 'registers an offence for dots in names' do
+            inspect_source(symbol_name,
+                           ['test = :"bad.idea"'])
             expect(symbol_name.offences.map(&:message)).to eq(
               ['Use snake_case for symbols.'])
           end
@@ -45,7 +54,7 @@ module Rubocop
         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(
+          expect(symbol_name.messages).to eq(
             ['Use snake_case for symbols.'] * 2)
         end
 

data/spec/rubocop/cop/style/tab_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe Tab do
-        let(:tab) { Tab.new }
+        subject(:tab) { Tab.new }
 
         it 'registers an offence for a line indented with tab' do
           inspect_source(tab, ["\tx = 0"])

data/spec/rubocop/cop/style/ternary_operator_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe MultilineTernaryOperator do
-        let(:op) { MultilineTernaryOperator.new }
+        subject(:op) { MultilineTernaryOperator.new }
 
         it 'registers offence for a multiline ternary operator expression' do
           inspect_source(op, ['a = cond ?',
@@ -21,7 +21,7 @@ module Rubocop
       end
 
       describe NestedTernaryOperator do
-        let(:op) { NestedTernaryOperator.new }
+        subject(:op) { NestedTernaryOperator.new }
 
         it 'registers an offence for a nested ternary operator expression' do
           inspect_source(op, ['a ? (b ? b1 : b2) : a2'])

data/spec/rubocop/cop/style/trailing_blank_lines_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe TrailingBlankLines do
+        subject(:cop) { described_class.new }
+
+        it 'accepts final newline' do
+          inspect_source(cop, ['x = 0', ''])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'registers an offence for multiple trailing blank lines' do
+          inspect_source(cop, ['x = 0', '', '', '', ''])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq(['3 trailing blank lines detected.'])
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cop/style/trailing_whitespace_spec.rb

@@ -6,22 +6,22 @@ module Rubocop
   module Cop
     module Style
       describe TrailingWhitespace do
-        let(:tws) { TrailingWhitespace.new }
+        subject(:cop) { described_class.new }
 
         it 'registers an offence for a line ending with space' do
           source = ['x = 0 ']
-          inspect_source(tws, source)
-          expect(tws.offences.size).to eq(1)
+          inspect_source(cop, source)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'registers an offence for a line ending with tab' do
-          inspect_source(tws, ["x = 0\t"])
-          expect(tws.offences.size).to eq(1)
+          inspect_source(cop, ["x = 0\t"])
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'accepts a line without trailing whitespace' do
-          inspect_source(tws, ["x = 0\n"])
-          expect(tws.offences).to be_empty
+          inspect_source(cop, ["x = 0\n"])
+          expect(cop.offences).to be_empty
         end
       end
     end