rubocop 0.3.2 → 0.4.0

data/spec/rubocop/cops/method_and_variable_snake_case_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe MethodAndVariableSnakeCase do
-      let (:snake_case) { MethodAndVariableSnakeCase.new }
+      let(:snake_case) { MethodAndVariableSnakeCase.new }
 
       it 'registers an offence for camel case in names' do
         inspect_source(snake_case, 'file.rb',
@@ -15,8 +15,8 @@ module Rubocop
                         '  @myAttribute = 3',
                         'end',
                        ])
-        snake_case.offences.map(&:message).should ==
-          ['Use snake_case for methods and variables.'] * 4
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'] * 4)
       end
 
       it 'accepts snake case in names' do
@@ -27,20 +27,20 @@ module Rubocop
                         '  @my_attribute = 3',
                         'end',
                        ])
-        snake_case.offences.map(&:message).should == []
+        expect(snake_case.offences.map(&:message)).to be_empty
       end
 
       it 'registers an offence for mixed snake case and camel case' do
         inspect_source(snake_case, 'file.rb',
                        ['def visit_Arel_Nodes_SelectStatement',
                         'end'])
-        snake_case.offences.map(&:message).should ==
-          ['Use snake_case for methods and variables.']
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
       end
 
       it 'accepts screaming snake case globals' do
         inspect_source(snake_case, 'file.rb', ['$MY_GLOBAL = 0'])
-        snake_case.offences.map(&:message).should == []
+        expect(snake_case.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/multiline_blocks_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe MultilineBlocks do
-      let (:blocks) { MultilineBlocks.new }
+      let(:blocks) { MultilineBlocks.new }
 
       it 'registers an offence for a multiline block with braces' do
         inspect_source(blocks, '', ['each { |x|',
                                     '}'])
-        blocks.offences.map(&:message).should ==
-          ['Avoid using {...} for multi-line blocks.']
+        expect(blocks.offences.map(&:message)).to eq(
+          ['Avoid using {...} for multi-line blocks.'])
       end
 
       it 'accepts a multiline block with do-end' do
         inspect_source(blocks, '', ['each do |x|',
                                     'end'])
-        blocks.offences.map(&:message).should == []
+        expect(blocks.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/multiline_if_then_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe MultilineIfThen do
-      let (:mit) { MultilineIfThen.new }
+      let(:mit) { MultilineIfThen.new }
 
       # if
 
@@ -18,13 +18,13 @@ module Rubocop
                                  'end',
                                  'if cond then # bad',
                                  'end'])
-        mit.offences.map(&:line_number).should == [1, 3, 5, 7]
+        expect(mit.offences.map(&:line_number)).to eq([1, 3, 5, 7])
       end
 
       it 'accepts multiline if without then' do
         inspect_source(mit, '', ['if cond',
                                           'end'])
-        mit.offences.map(&:message).should == []
+        expect(mit.offences.map(&:message)).to be_empty
       end
 
       it 'accepts table style if/then/elsif/ends' do
@@ -34,7 +34,7 @@ module Rubocop
                         'elsif @io == $stderr then str << "$stderr"',
                         'else                      str << @io.class.to_s',
                         'end'])
-        mit.offences.map(&:message).should == []
+        expect(mit.offences.map(&:message)).to be_empty
       end
 
       # unless
@@ -42,14 +42,14 @@ module Rubocop
       it 'registers an offence for then in multiline unless' do
         inspect_source(mit, '', ['unless cond then',
                                  'end'])
-        mit.offences.map(&:message).should ==
-          ['Never use then for multi-line if/unless.']
+        expect(mit.offences.map(&:message)).to eq(
+          ['Never use then for multi-line if/unless.'])
       end
 
       it 'accepts multiline unless without then' do
         inspect_source(mit, '', ['unless cond',
                                  'end'])
-        mit.offences.map(&:message).should == []
+        expect(mit.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/new_lambda_literal_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe NewLambdaLiteral do
-      let (:lambda_literal) { NewLambdaLiteral.new }
+      let(:lambda_literal) { NewLambdaLiteral.new }
 
       it 'registers an offence for an old lambda call' do
         inspect_source(lambda_literal, 'file.rb', ['f = lambda { |x| x }'])
-        lambda_literal.offences.map(&:message).should ==
-          ['The new lambda literal syntax is preferred in Ruby 1.9.']
+        expect(lambda_literal.offences.map(&:message)).to eq(
+          ['The new lambda literal syntax is preferred in Ruby 1.9.'])
       end
 
       it 'accepts the new lambda literal' do
         inspect_source(lambda_literal, 'file.rb', ['lambda = ->(x) { x }',
                                               'lambda.(1)'])
-        lambda_literal.offences.map(&:message).should == []
+        expect(lambda_literal.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/numeric_literals_spec.rb

@@ -5,44 +5,44 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe NumericLiterals do
-      let (:num) { NumericLiterals.new }
+      let(:num) { NumericLiterals.new }
 
       it 'registers an offence for a long integer without underscores' do
         inspect_source(num, 'file.rb', ['a = 123456'])
-        num.offences.map(&:message).should ==
+        expect(num.offences.map(&:message)).to eq(
           ['Add underscores to large numeric literals to improve their ' +
-           'readability.']
+           'readability.'])
       end
 
       it 'registers an offence for an integer with not enough underscores' do
         inspect_source(num, 'file.rb', ['a = 123456_789000'])
-        num.offences.map(&:message).should ==
+        expect(num.offences.map(&:message)).to eq(
           ['Add underscores to large numeric literals to improve their ' +
-           'readability.']
+           'readability.'])
       end
 
       it 'registers an offence for a long float without underscores' do
         inspect_source(num, 'file.rb', ['a = 1.234567'])
-        num.offences.map(&:message).should ==
+        expect(num.offences.map(&:message)).to eq(
           ['Add underscores to large numeric literals to improve their ' +
-           'readability.']
+           'readability.'])
       end
 
       it 'accepts long numbers with underscore' do
         inspect_source(num, 'file.rb', ['a = 123_456',
                                        'b = 1.234_56'])
-        num.offences.map(&:message).should == []
+        expect(num.offences.map(&:message)).to be_empty
       end
 
       it 'accepts a short integer without underscore' do
         inspect_source(num, 'file.rb', ['a = 123'])
-        num.offences.map(&:message).should == []
+        expect(num.offences.map(&:message)).to be_empty
       end
 
       it 'accepts short numbers without underscore' do
         inspect_source(num, 'file.rb', ['a = 123',
                                        'b = 123.456'])
-        num.offences.map(&:message).should == []
+        expect(num.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/offence_spec.rb

@@ -8,15 +8,15 @@ module Rubocop
       it 'has a few required attributes' do
         offence = Offence.new(:convention, 1, 'message')
 
-        offence.severity.should == :convention
-        offence.line_number.should == 1
-        offence.message.should == 'message'
+        expect(offence.severity).to eq(:convention)
+        expect(offence.line_number).to eq(1)
+        expect(offence.message).to eq('message')
       end
 
       it 'overrides #to_s' do
         offence = Offence.new(:convention, 1, 'message')
 
-        offence.to_s.should == 'C:  1: message'
+        expect(offence.to_s).to eq('C:  1: message')
       end
     end
   end

data/spec/rubocop/cops/one_line_conditional_spec.rb

@@ -5,12 +5,11 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe OneLineConditional do
-      let (:olc) { OneLineConditional.new }
+      let(:olc) { OneLineConditional.new }
 
       it 'registers an offence for one line if/then/end' do
         inspect_source(olc, '', ['if cond then run else dont end'])
-        olc.offences.map(&:message).should ==
-          ['Favor the ternary operator (?:) over if/then/else/end constructs.']
+        expect(olc.offences.map(&:message)).to eq([olc.error_message])
       end
     end
   end

data/spec/rubocop/cops/parameter_lists_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe ParameterLists do
-      let (:list) { ParameterLists.new }
+      let(:list) { ParameterLists.new }
 
       it 'registers an offence for a method def with 5 parameters' do
         inspect_source(list, 'file.rb', ['def meth(a, b, c, d, e)',
                                          'end'])
-        list.offences.map(&:message).should ==
-          ['Avoid parameter lists longer than four parameters.']
+        expect(list.offences.map(&:message)).to eq(
+          ['Avoid parameter lists longer than four parameters.'])
       end
 
       it 'accepts a method def with 4 parameters' do
         inspect_source(list, 'file.rb', ['def meth(a, b, c, d)',
                                          'end'])
-        list.offences.map(&:message).should == []
+        expect(list.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/parentheses_around_condition_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe ParenthesesAroundCondition do
-      let (:pac) { ParenthesesAroundCondition.new }
+      let(:pac) { ParenthesesAroundCondition.new }
 
       it 'registers an offence for parentheses around condition' do
         inspect_source(pac, 'file.rb', ['if (x > 10)',
@@ -22,9 +22,9 @@ module Rubocop
                                         'x += 1 while (x < 10)',
                                         'x += 1 until (x < 10)',
                                        ])
-        pac.offences.map(&:message).should ==
+        expect(pac.offences.map(&:message)).to eq(
           ["Don't use parentheses around the condition of an if/unless/" +
-           'while/until, unless the condition contains an assignment.'] * 9
+           'while/until, unless the condition contains an assignment.'] * 9)
       end
 
       it 'accepts condition without parentheses' do
@@ -41,7 +41,7 @@ module Rubocop
                                         'x += 1 while x < 10',
                                         'x += 1 until x < 10',
                                        ])
-        pac.offences.map(&:message).should == []
+        expect(pac.offences.map(&:message)).to be_empty
       end
 
       # Parentheses are sometimes used to help the editor make nice
@@ -51,13 +51,13 @@ module Rubocop
                                         '    @lex_state != EXPR_FNAME &&',
                                         '    trans[1])',
                                         'end'])
-        pac.offences.map(&:message).should == []
+        expect(pac.offences.map(&:message)).to be_empty
       end
 
       it 'accepts parentheses around assignment' do
         inspect_source(pac, 'file.rb', ['if (x = self.next_value)',
                                         'end'])
-        pac.offences.map(&:message).should == []
+        expect(pac.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/single_line_blocks_spec.rb

@@ -5,17 +5,17 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SingleLineBlocks do
-      let (:blocks) { SingleLineBlocks.new }
+      let(:blocks) { SingleLineBlocks.new }
 
       it 'registers an offence for a single line block with do-end' do
         inspect_source(blocks, '', ['each do |x| end'])
-        blocks.offences.map(&:message).should ==
-          ['Prefer {...} over do...end for single-line blocks.']
+        expect(blocks.offences.map(&:message)).to eq(
+          ['Prefer {...} over do...end for single-line blocks.'])
       end
 
       it 'accepts a single line block with braces' do
         inspect_source(blocks, '', ['each { |x| }'])
-        blocks.offences.map(&:message).should == []
+        expect(blocks.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/space_after_colon_spec.rb

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

data/spec/rubocop/cops/space_after_comma_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SpaceAfterComma do
-      let (:space) { SpaceAfterComma.new }
+      let(:space) { SpaceAfterComma.new }
 
       it 'registers an offence for block argument commas' do
         inspect_source(space, 'file.rb', ['each { |s,t| }'])
-        space.offences.map(&:message).should ==
-          ['Space missing after comma.']
+        expect(space.offences.map(&:message)).to eq(
+          ['Space missing after comma.'])
       end
     end
   end

data/spec/rubocop/cops/space_after_semicolon_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SpaceAfterSemicolon do
-      let (:space) { SpaceAfterSemicolon.new }
+      let(:space) { SpaceAfterSemicolon.new }
 
       it 'registers an offence for semicolon without space after it' do
         inspect_source(space, 'file.rb', ['x = 1;y = 2'])
-        space.offences.map(&:message).should ==
-          ['Space missing after semicolon.']
+        expect(space.offences.map(&:message)).to eq(
+          ['Space missing after semicolon.'])
       end
     end
   end

data/spec/rubocop/cops/space_around_braces_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SpaceAroundBraces do
-      let (:space) { SpaceAroundBraces.new }
+      let(:space) { SpaceAroundBraces.new }
 
       it 'registers an offence for left brace without spaces' do
         inspect_source(space, 'file.rb', ['each{ puts }'])
-        space.offences.map(&:message).should ==
-          ["Surrounding space missing for '{'."]
+        expect(space.offences.map(&:message)).to eq(
+          ["Surrounding space missing for '{'."])
       end
 
       it 'registers an offence for right brace without inner space' do
         inspect_source(space, 'file.rb', ['each { puts}'])
-        space.offences.map(&:message).should ==
-          ["Space missing to the left of '}'."]
+        expect(space.offences.map(&:message)).to eq(
+          ["Space missing to the left of '}'."])
       end
 
       it 'accepts an empty hash literal with no space inside' do
@@ -25,7 +25,7 @@ module Rubocop
                         'end',
                         '@views = {}',
                         ''])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/space_around_equals_in_default_parameter_spec.rb

@@ -5,17 +5,17 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SpaceAroundEqualsInParameterDefault do
-      let (:space) { SpaceAroundEqualsInParameterDefault.new }
+      let(:space) { SpaceAroundEqualsInParameterDefault.new }
 
       it 'registers an offence for default value assignment without space' do
         inspect_source(space, 'file.rb', ['def f(x, y=0, z=1)', 'end'])
-        space.offences.map(&:message).should ==
-          ['Surrounding space missing in default value assignment.'] * 2
+        expect(space.offences.map(&:message)).to eq(
+          ['Surrounding space missing in default value assignment.'] * 2)
       end
 
       it 'accepts default value assignment with space' do
         inspect_source(space, 'file.rb', ['def f(x, y = 0, z = 1)', 'end'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
     end
   end