rubocop 0.12.0 → 0.13.0

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

@@ -6,9 +6,9 @@ module Rubocop
   module Cop
     module Style
       describe Semicolon do
-        let(:s) { Semicolon.new }
-        before do
-          Semicolon.config = {
+        subject(:s) { Semicolon.new }
+        let(:cop_config) do
+          {
             'AllowAfterParameterListInOneLineMethods' => false,
             'AllowBeforeEndInOneLineMethods' => true
           }

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

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe SignalException do
-        let(:cop) { described_class.new }
+        subject(:cop) { described_class.new }
 
         it 'registers an offence for raise in begin section' do
           inspect_source(cop,

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

@@ -5,35 +5,39 @@ require 'spec_helper'
 module Rubocop
   module Cop
     module Style
-      describe SingleLineMethods do
-        let(:slm) { SingleLineMethods.new }
-        before do
-          SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true }
-        end
+      describe SingleLineMethods, :config do
+        subject(:slm) { SingleLineMethods.new(config) }
+        let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
 
         it 'registers an offence for a single-line method' do
           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(
+          expect(slm.messages).to eq(
             [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'])
-          expect(slm.offences.size).to eq(3)
+        context 'when AllowIfMethodIsEmpty is disabled' do
+          let(:cop_config) { { 'AllowIfMethodIsEmpty' => false } }
+
+          it 'registers an offence for an empty method' do
+            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
         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'])
-          expect(slm.offences).to be_empty
+        context 'when AllowIfMethodIsEmpty is enabled' do
+          let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
+
+          it 'accepts a single-line empty method' do
+            inspect_source(slm, ['def no_op; end',
+                                 'def self.resource_class=(klass); end',
+                                 'def @table.columns; end'])
+            expect(slm.offences).to be_empty
+          end
         end
 
         it 'accepts a multi-line method' do

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

@@ -6,22 +6,22 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAfterColon do
-        let(:space) { SpaceAfterColon.new }
+        subject(:space) { SpaceAfterColon.new }
 
         it 'registers an offence for colon without space after it' do
           inspect_source(space, ['x = w ? {a:3}:4'])
-          expect(space.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ['Space missing after colon.'] * 2)
         end
 
         it 'allows the colons in symbols' do
           inspect_source(space, ['x = :a'])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
 
         it 'allows colons in strings' do
           inspect_source(space, ["str << ':'"])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
       end
     end

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

@@ -6,23 +6,23 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAfterComma do
-        let(:space) { SpaceAfterComma.new }
+        subject(:space) { SpaceAfterComma.new }
 
         it 'registers an offence for block argument commas without space' do
           inspect_source(space, ['each { |s,t| }'])
-          expect(space.offences.map(&:message)).to eq(
+          expect(space.messages).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(
+          expect(space.messages).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(
+          expect(space.messages).to eq(
             ['Space missing after comma.'])
         end
       end

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

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAfterControlKeyword do
-        let(:ap) { SpaceAfterControlKeyword.new }
+        subject(:ap) { SpaceAfterControlKeyword.new }
 
         it 'registers an offence for normal if' do
           inspect_source(ap,

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

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAfterMethodName do
-        let(:cop) { SpaceAfterMethodName.new }
+        subject(:cop) { SpaceAfterMethodName.new }
 
         it 'registers an offence for def with space before the parenthesis' do
           inspect_source(cop,

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

@@ -6,17 +6,17 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAfterSemicolon do
-        let(:space) { SpaceAfterSemicolon.new }
+        subject(:space) { SpaceAfterSemicolon.new }
 
         it 'registers an offence for semicolon without space after it' do
           inspect_source(space, ['x = 1;y = 2'])
-          expect(space.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ['Space missing after semicolon.'])
         end
 
         it 'does not crash if semicolon is the last character of the file' do
           inspect_source(space, ['x = 1;'])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
       end
     end

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

@@ -6,42 +6,43 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAroundBraces do
-        let(:space) { SpaceAroundBraces.new }
+        subject(:cop) { SpaceAroundBraces.new }
 
         it 'registers an offence for left brace without spaces' do
-          inspect_source(space, ['each{ puts }'])
-          expect(space.offences.map(&:message)).to eq(
-            ["Surrounding space missing for '{'."])
+          inspect_source(cop, ['each{ puts }'])
+          expect(cop.messages).to eq(["Surrounding space missing for '{'."])
+          expect(cop.highlights).to eq(['{'])
         end
 
         it 'registers an offence for right brace without inner space' do
-          inspect_source(space, ['each { puts}'])
-          expect(space.offences.map(&:message)).to eq(
+          inspect_source(cop, ['each { puts}'])
+          expect(cop.messages).to eq(
             ["Space missing to the left of '}'."])
+          expect(cop.highlights).to eq(['}'])
         end
 
         it 'accepts an empty hash literal with no space inside' do
-          inspect_source(space,
+          inspect_source(cop,
                          ['view_hash.each do |view_key|',
                           'end',
                           '@views = {}',
                           ''])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(cop.messages).to be_empty
         end
 
         it 'accepts string interpolation braces with no space inside' do
-          inspect_source(space,
+          inspect_source(cop,
                          ['"A=#{a}"',
                           ':"#{b}"',
                           '/#{c}/',
                           '`#{d}`',
                           'sprintf("#{message.gsub(/%/, \'%%\')}", line)'])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(cop.messages).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
+          inspect_source(cop, ["new({'user' => user_params})"])
+          expect(cop.messages).to be_empty
         end
       end
     end

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

@@ -6,11 +6,11 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAroundEqualsInParameterDefault do
-        let(:space) { SpaceAroundEqualsInParameterDefault.new }
+        subject(:space) { SpaceAroundEqualsInParameterDefault.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.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ['Surrounding space missing in default value assignment.'] * 2)
         end
 
@@ -26,7 +26,7 @@ module Rubocop
 
         it 'accepts default value assignment with space' do
           inspect_source(space, ['def f(x, y = 0, z = {})', 'end'])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
       end
     end

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

@@ -6,17 +6,17 @@ module Rubocop
   module Cop
     module Style
       describe SpaceAroundOperators do
-        let(:space) { SpaceAroundOperators.new }
+        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.offences.map(&:message)).to eq(
+          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.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ["Surrounding space missing for operator '?'.",
              "Surrounding space missing for operator ':'."])
         end
@@ -42,13 +42,13 @@ module Rubocop
                  'c=2']
           inspect_source(space, src)
           expect(space.offences.map(&:line)).to eq([1, 2])
-          expect(space.offences.map(&:message)).to eq(
+          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.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ["Surrounding space missing for operator '-'.",
              "Surrounding space missing for operator '&'.",
              "Surrounding space missing for operator '+'."])
@@ -56,35 +56,35 @@ module Rubocop
 
         it 'registers an offence for arguments to a method' do
           inspect_source(space, ['puts 1+2'])
-          expect(space.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ["Surrounding space missing for operator '+'."])
         end
 
         it 'accepts operator symbols' do
           inspect_source(space, ['func(:-)'])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
 
         it 'accepts ranges' do
           inspect_source(space, ['a, b = (1..2), (1...3)'])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
 
         it 'accepts scope operator' do
           source = ['@io.class == Zlib::GzipWriter']
           inspect_source(space, source)
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
 
         it 'accepts ::Kernel::raise' do
           source = ['::Kernel::raise IllegalBlockError.new']
           inspect_source(space, source)
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
 
         it 'accepts exclamation point negation' do
           inspect_source(space, ['x = !a&&!b'])
-          expect(space.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ["Surrounding space missing for operator '&&'."])
         end
 
@@ -93,7 +93,7 @@ module Rubocop
                                  '    !__getobj__',
                                  '  end'])
           expect(space.offences).to be_empty
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
 
         it 'accepts a unary' do
@@ -109,25 +109,25 @@ module Rubocop
                           '  def each *args',
                           '  end',
                           ''])
-          expect(space.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
 
         it 'accepts splat operator' do
           inspect_source(space, ['return *list if options'])
-          expect(space.offences.map(&:message)).to be_empty
+          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.offences.map(&:message)).to be_empty
+          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.offences.map(&:message)).to eq([])
+          expect(space.messages).to eq([])
         end
 
         it 'accepts an assignment with spaces' do
@@ -144,7 +144,7 @@ module Rubocop
           inspect_source(space,
                          ['x+= a+b-c*d/e%f^g|h&i||j',
                           'y -=k&&l'])
-          expect(space.offences.map(&:message))
+          expect(space.messages)
             .to eq(["Surrounding space missing for operator '+='.",
                     "Surrounding space missing for operator '+'.",
                     "Surrounding space missing for operator '-'.",
@@ -163,14 +163,14 @@ module Rubocop
           inspect_source(space,
                          ['x += a + b - c * d / e % f ^ g | h & i || j',
                           'y -= k && l'])
-          expect(space.offences.map(&:message)).to eq([])
+          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.offences.map(&:message)).to eq([])
+          expect(space.messages).to eq([])
         end
 
         it 'accepts an assignment followed by newline' do
@@ -180,7 +180,7 @@ module Rubocop
 
         it 'registers an offences for exponent operator with spaces' do
           inspect_source(space, ['x = a * b ** 2'])
-          expect(space.offences.map(&:message)).to eq(
+          expect(space.messages).to eq(
             ['Space around operator ** detected.'])
         end
 
@@ -191,9 +191,9 @@ module Rubocop
 
         it 'accepts unary operators without space' do
           inspect_source(space, ['[].map(&:size)',
-                                            '-3',
-                                            'x = +2'])
-          expect(space.offences.map(&:message)).to eq([])
+                                 '-3',
+                                 'x = +2'])
+          expect(space.messages).to eq([])
         end
 
         it 'accepts argument default values without space' do
@@ -202,13 +202,13 @@ module Rubocop
           inspect_source(space,
                          ['def init(name=nil)',
                           'end'])
-          expect(space.offences.map(&:message)).to be_empty
+          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.offences.map(&:message)).to be_empty
+          expect(space.messages).to be_empty
         end
       end
     end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceBeforeModifierKeyword do
+        subject(:cop) { described_class.new }
+
+        it 'registers an offence for missing space before if/unless' do
+          inspect_source(cop, ['(a = 3)if a == 2',
+                               'a = "test"if a == 2',
+                               'a = 42unless a == 2',
+                               'a = [1,2,3]unless a == 2',
+                               'a = {:a => "b"}if a == 2'])
+          expect(cop.highlights).to eq([')', '"', '2', ']', '}'])
+        end
+
+        it 'registers an offence for missing space before while/until' do
+          inspect_source(cop, ['(a = 3)while b',
+                               'a = "test"until b',
+                               'a = 42while b',
+                               'a = [1,2,3]until b',
+                               'a = {:a => "b"}while b'])
+          expect(cop.highlights).to eq([')', '"', '2', ']', '}'])
+        end
+
+        it 'accepts modifiers with preceding space' do
+          inspect_source(cop, ['(a = 3) if b',
+                               'a = "test" unless b',
+                               'a = 42 while b',
+                               'a = [1,2,3] until b'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts elsif at beginning of line' do
+          inspect_source(cop, ["if RUBY_VERSION.between?('1.9.2', '2.0.0')",
+                               "  require 'testing/performance/ruby/yarv'",
+                               'elsif RUBY_VERSION.between?("1.8.6", "1.9")',
+                               "  require 'testing/performance/ruby/mri'",
+                               'end'])
+          expect(cop.highlights).to eq([])
+        end
+
+        it 'does not crash on ternary conditionals' do
+          inspect_source(cop, 'a ? b : c')
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end