rubocop 0.13.1 → 0.14.0

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

@@ -2,65 +2,133 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SpaceAroundBlockBraces, :config do
-        subject(:cop) { SpaceAroundBlockBraces.new(config) }
-        let(:cop_config) { { 'NoSpaceBeforeBlockParameters' => false } }
-
-        it 'accepts braces surrounded by spaces' do
-          inspect_source(cop, ['each { puts }'])
-          expect(cop.messages).to be_empty
-          expect(cop.highlights).to be_empty
-        end
+describe Rubocop::Cop::Style::SpaceAroundBlockBraces, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) do
+    {
+      'EnforcedStyle' => 'space_inside_braces',
+      'SpaceBeforeBlockParameters' => true
+    }
+  end
 
-        it 'registers an offence for left brace without outer space' do
-          inspect_source(cop, ['each{ puts }'])
-          expect(cop.messages).to eq(["Surrounding space missing for '{'."])
-          expect(cop.highlights).to eq(['{'])
+  it 'accepts braces surrounded by spaces' do
+    inspect_source(cop, ['each { puts }'])
+    expect(cop.messages).to be_empty
+    expect(cop.highlights).to be_empty
+  end
+
+  it 'registers an offence for left brace without outer space' do
+    inspect_source(cop, ['each{ puts }'])
+    expect(cop.messages).to eq(['Space missing to the left of {.'])
+    expect(cop.highlights).to eq(['{'])
+  end
+
+  it 'registers an offence for left brace without inner space' do
+    inspect_source(cop, ['each {puts }'])
+    expect(cop.messages).to eq(['Space missing inside {.'])
+    expect(cop.highlights).to eq(['{'])
+  end
+
+  it 'registers an offence for right brace without inner space' do
+    inspect_source(cop, ['each { puts}'])
+    expect(cop.messages).to eq(['Space missing inside }.'])
+    expect(cop.highlights).to eq(['}'])
+  end
+
+  context 'with passed in parameters' do
+    it 'accepts left brace with inner space' do
+      inspect_source(cop, ['each { |x| puts }'])
+      expect(cop.messages).to be_empty
+      expect(cop.highlights).to be_empty
+    end
+
+    it 'registers an offence for left brace without inner space' do
+      inspect_source(cop, ['each {|x| puts }'])
+      expect(cop.messages).to eq(['Space between { and | missing.'])
+      expect(cop.highlights).to eq(['{'])
+    end
+
+    context 'and space before block parameters not allowed' do
+      let(:cop_config) do
+        {
+          'EnforcedStyle' => 'space_inside_braces',
+          'SpaceBeforeBlockParameters' => false
+        }
+      end
+
+      it 'registers an offence for left brace with inner space' do
+        inspect_source(cop, ['each { |x| puts }'])
+        expect(cop.messages).to eq(['Space between { and | detected.'])
+        expect(cop.highlights).to eq([' '])
+      end
+
+      it 'accepts left brace without inner space' do
+        inspect_source(cop, ['each {|x| puts }'])
+        expect(cop.messages).to be_empty
+        expect(cop.highlights).to be_empty
+      end
+    end
+  end
+
+  context 'configured with no_space_inside_braces' do
+    let(:cop_config) do
+      {
+        'EnforcedStyle' => 'no_space_inside_braces',
+        'SpaceBeforeBlockParameters' => true
+      }
+    end
+
+    it 'accepts braces without spaces inside' do
+      inspect_source(cop, ['each {puts}'])
+      expect(cop.messages).to be_empty
+      expect(cop.highlights).to be_empty
+    end
+
+    it 'registers an offence for left brace with inner space' do
+      inspect_source(cop, ['each { puts}'])
+      expect(cop.messages).to eq(['Space inside { detected.'])
+      expect(cop.highlights).to eq([' '])
+    end
+
+    it 'registers an offence for right brace with inner space' do
+      inspect_source(cop, ['each {puts  }'])
+      expect(cop.messages).to eq(['Space inside } detected.'])
+      expect(cop.highlights).to eq(['  '])
+    end
+
+    it 'registers an offence for left brace without outer space' do
+      inspect_source(cop, ['each{puts}'])
+      expect(cop.messages).to eq(['Space missing to the left of {.'])
+      expect(cop.highlights).to eq(['{'])
+    end
+
+    context 'with passed in parameters' do
+      context 'and space before block parameters allowed' do
+        it 'accepts left brace with inner space' do
+          inspect_source(cop, ['each { |x| puts}'])
+          expect(cop.messages).to eq([])
+          expect(cop.highlights).to eq([])
         end
 
         it 'registers an offence for left brace without inner space' do
-          inspect_source(cop, ['each {puts }'])
-          expect(cop.messages).to eq(["Surrounding space missing for '{'."])
+          inspect_source(cop, ['each {|x| puts}'])
+          expect(cop.messages).to eq(['Space between { and | missing.'])
           expect(cop.highlights).to eq(['{'])
         end
+      end
 
-        it 'registers an offence for right brace without inner space' do
-          inspect_source(cop, ['each { puts}'])
-          expect(cop.messages).to eq(["Space missing to the left of '}'."])
-          expect(cop.highlights).to eq(['}'])
+      context 'and space before block parameters not allowed' do
+        let(:cop_config) do
+          {
+            'EnforcedStyle' => 'no_space_inside_braces',
+            'SpaceBeforeBlockParameters' => false
+          }
         end
 
-        context 'with passed in parameters' do
-          it 'accepts left brace with inner space' do
-            inspect_source(cop, ['each { |x| puts }'])
-            expect(cop.messages).to be_empty
-            expect(cop.highlights).to be_empty
-          end
-
-          it 'registers an offence for left brace without inner space' do
-            inspect_source(cop, ['each {|x| puts }'])
-            expect(cop.messages).to eq(["Surrounding space missing for '{'."])
-            expect(cop.highlights).to eq(['{'])
-          end
-
-          context 'space before block parameters not allowed' do
-            let(:cop_config) { { 'NoSpaceBeforeBlockParameters' => true } }
-
-            it 'registers an offence for left brace with inner space' do
-              inspect_source(cop, ['each { |x| puts }'])
-              expect(cop.messages).to eq(['Space between { and | detected.'])
-              expect(cop.highlights).to eq(['{'])
-            end
-
-            it 'accepts left brace without inner space' do
-              inspect_source(cop, ['each {|x| puts }'])
-              expect(cop.messages).to be_empty
-              expect(cop.highlights).to be_empty
-            end
-          end
+        it 'registers an offence for left brace with inner space' do
+          inspect_source(cop, ['each { |x| puts}'])
+          expect(cop.messages).to eq(['Space between { and | detected.'])
+          expect(cop.highlights).to eq([' '])
         end
       end
     end

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

@@ -2,33 +2,27 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SpaceAroundEqualsInParameterDefault do
-        subject(:space) { SpaceAroundEqualsInParameterDefault.new }
+describe Rubocop::Cop::Style::SpaceAroundEqualsInParameterDefault do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for default value assignment without space' do
-          inspect_source(space, ['def f(x, y=0, z=1)', 'end'])
-          expect(space.messages).to eq(
-            ['Surrounding space missing in default value assignment.'] * 2)
-        end
+  it 'registers an offence for default value assignment without space' do
+    inspect_source(cop, ['def f(x, y=0, z=1)', 'end'])
+    expect(cop.messages).to eq(
+      ['Surrounding space missing in default value assignment.'] * 2)
+  end
 
-        it 'registers an offence for assignment 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 empty string without space' do
+    inspect_source(cop, ['def f(x, y="", z=1)', 'end'])
+    expect(cop.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 'registers an offence for assignment of empty list without space' do
+    inspect_source(cop, ['def f(x, y=[])', 'end'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts default value assignment with space' do
-          inspect_source(space, ['def f(x, y = 0, z = {})', 'end'])
-          expect(space.messages).to be_empty
-        end
-      end
-    end
+  it 'accepts default value assignment with space' do
+    inspect_source(cop, ['def f(x, y = 0, z = {})', 'end'])
+    expect(cop.messages).to be_empty
   end
 end

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

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