rubocop 0.3.2 → 0.4.0

data/spec/rubocop/cops/encoding_spec.rb

@@ -5,36 +5,42 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe Encoding do
-      let (:encoding) { Encoding.new }
+      let(:encoding) { Encoding.new }
 
-      it 'registers an offence when no encoding present' do
+      it 'registers an offence when no encoding present', ruby: 1.9 do
         inspect_source(encoding, 'file.rb', ['def foo() end'])
 
-        encoding.offences.map(&:message).should ==
-          ['Missing encoding comment.']
+        expect(encoding.offences.map(&:message)).to eq(
+          ['Missing encoding comment.'])
       end
 
-      it 'accepts encoding on first line' do
+      it 'accepts encoding on first line', ruby: 1.9 do
         inspect_source(encoding, 'file.rb', ['# encoding: utf-8',
                                              'def foo() end'])
 
-        encoding.offences.should == []
+        expect(encoding.offences).to be_empty
       end
 
-      it 'accepts encoding on second line when shebang present' do
+      it 'accepts encoding on second line when shebang present', ruby: 1.9 do
         inspect_source(encoding, 'file.rb', ['#!/usr/bin/env ruby',
                                              '# encoding: utf-8',
                                              'def foo() end'])
 
-        encoding.offences.map(&:message).should == []
+        expect(encoding.offences.map(&:message)).to be_empty
       end
 
-      it 'registers an offence when encoding is in the wrong place' do
+      it 'books an offence when encoding is in the wrong place', ruby: 1.9 do
         inspect_source(encoding, 'file.rb', ['def foo() end',
                                              '# encoding: utf-8'])
 
-        encoding.offences.map(&:message).should ==
-          ['Missing encoding comment.']
+        expect(encoding.offences.map(&:message)).to eq(
+          ['Missing encoding comment.'])
+      end
+
+      it 'does not register an offence on Ruby 2.0', ruby: 2.0 do
+        inspect_source(encoding, 'file.rb', ['def foo() end'])
+
+        expect(encoding.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/end_of_line_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe EndOfLine do
-      let (:eol) { EndOfLine.new }
+      let(:eol) { EndOfLine.new }
 
       it 'registers an offence for CR+LF' do
         inspect_source(eol, 'file.rb', ["x=0\r", ''])
-        eol.offences.map(&:message).should ==
-          ['Carriage return character detected.']
+        expect(eol.offences.map(&:message)).to eq(
+          ['Carriage return character detected.'])
       end
 
       it 'registers an offence for CR at end of file' do
         inspect_source(eol, 'file.rb', ["x=0\r"])
-        eol.offences.map(&:message).should ==
-          ['Carriage return character detected.']
+        expect(eol.offences.map(&:message)).to eq(
+          ['Carriage return character detected.'])
       end
     end
   end

data/spec/rubocop/cops/favor_modifier_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe FavorModifier do
-      let (:if_until) { IfUnlessModifier.new }
-      let (:while_until) { WhileUntilModifier.new }
+      let(:if_until) { IfUnlessModifier.new }
+      let(:while_until) { WhileUntilModifier.new }
 
       it 'registers an offence for multiline if that fits on one line' do
         # This if statement fits exactly on one line if written as a modifier.
@@ -14,9 +14,9 @@ module Rubocop
                        ['if a_condition_that_is_just_short_enough',
                         '  some_long_metod_name(followed_by_args)',
                         'end'])
-        if_until.offences.map(&:message).should ==
+        expect(if_until.offences.map(&:message)).to eq(
           ['Favor modifier if/unless usage when you have a single-line body.' +
-           ' Another good alternative is the usage of control flow and/or.']
+           ' Another good alternative is the usage of control flow and/or.'])
       end
 
       it "accepts multiline if that doesn't fit on one line" do
@@ -31,23 +31,23 @@ module Rubocop
         inspect_source(if_until, 'file.rb', ['unless a',
                                         '  b',
                                         'end'])
-        if_until.offences.map(&:message).should ==
+        expect(if_until.offences.map(&:message)).to eq(
           ['Favor modifier if/unless usage when you have a single-line body.' +
-           ' Another good alternative is the usage of control flow and/or.']
+           ' Another good alternative is the usage of control flow and/or.'])
       end
 
       it 'accepts code with EOL comment since user might want to keep it' do
         inspect_source(if_until, 'file.rb', ['unless a',
                                              '  b # A comment',
                                              'end'])
-        if_until.offences.map(&:message).should == []
+        expect(if_until.offences.map(&:message)).to be_empty
       end
 
       it 'accepts if-else-end' do
         inspect_source(if_until, 'file.rb',
                        ['if args.last.is_a? Hash then args.pop else ' +
                         'Hash.new end'])
-        if_until.offences.map(&:message).should == []
+        expect(if_until.offences.map(&:message)).to be_empty
       end
 
       it "accepts multiline unless that doesn't fit on one line" do
@@ -86,9 +86,9 @@ module Rubocop
         inspect_source(cop, 'file.rb', ["#{keyword} a",
                                         '  b',
                                         'end'])
-        cop.offences.map(&:message).should ==
+        expect(cop.offences.map(&:message)).to eq(
           ['Favor modifier while/until usage when you have a single-line ' +
-           'body.']
+           'body.'])
       end
 
       def check_too_long(cop, keyword)
@@ -96,7 +96,7 @@ module Rubocop
                        ["  #{keyword} a_lengthy_condition_that_goes_on_and_on",
                         '    some_long_metod_name(followed_by_args)',
                         '  end'])
-        cop.offences.map(&:message).should == []
+        expect(cop.offences.map(&:message)).to be_empty
       end
 
       def check_short_multiline(cop, keyword)
@@ -105,7 +105,7 @@ module Rubocop
                         "  require 'simplecov'",
                         '  SimpleCov.start',
                         'end'])
-        cop.offences.map(&:message).should == []
+        expect(cop.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/favor_unless_over_negated_if_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe FavorUnlessOverNegatedIf do
-      let (:fav_unless) { FavorUnlessOverNegatedIf.new }
+      let(:fav_unless) { FavorUnlessOverNegatedIf.new }
 
       it 'registers an offence for if with exclamation point condition' do
         inspect_source(fav_unless, 'file.rb',
@@ -14,9 +14,9 @@ module Rubocop
                         'end',
                         'some_method if !a_condition',
                        ])
-        fav_unless.offences.map(&:message).should ==
+        expect(fav_unless.offences.map(&:message)).to eq(
           ['Favor unless (or control flow or) over if for negative ' +
-           'conditions.'] * 2
+           'conditions.'] * 2)
       end
 
       it 'registers an offence for if with "not" condition' do
@@ -25,10 +25,10 @@ module Rubocop
                         '  some_method',
                         'end',
                         'some_method if not a_condition'])
-        fav_unless.offences.map(&:message).should ==
+        expect(fav_unless.offences.map(&:message)).to eq(
           ['Favor unless (or control flow or) over if for negative ' +
-           'conditions.'] * 2
-        fav_unless.offences.map(&:line_number).should == [1, 4]
+           'conditions.'] * 2)
+        expect(fav_unless.offences.map(&:line_number)).to eq([1, 4])
       end
 
       it 'accepts an if/else with negative condition' do
@@ -43,7 +43,7 @@ module Rubocop
                         'elsif other_condition',
                         '  something_else',
                         'end'])
-        fav_unless.offences.map(&:message).should == []
+        expect(fav_unless.offences.map(&:message)).to be_empty
       end
 
       it 'accepts an if where only part of the contition is negated' do
@@ -55,7 +55,7 @@ module Rubocop
                         '  some_method',
                         'end',
                         'some_method if not a_condition or another_condition'])
-        fav_unless.offences.map(&:message).should == []
+        expect(fav_unless.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/favor_until_over_negated_while_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe FavorUntilOverNegatedWhile do
-      let (:fav_until) { FavorUntilOverNegatedWhile.new }
+      let(:fav_until) { FavorUntilOverNegatedWhile.new }
 
       it 'registers an offence for while with exclamation point condition' do
         inspect_source(fav_until, 'file.rb',
@@ -14,8 +14,8 @@ module Rubocop
                         'end',
                         'some_method while !a_condition',
                        ])
-        fav_until.offences.map(&:message).should ==
-          ['Favor until over while for negative conditions.'] * 2
+        expect(fav_until.offences.map(&:message)).to eq(
+          ['Favor until over while for negative conditions.'] * 2)
       end
 
       it 'registers an offence for while with "not" condition' do
@@ -24,9 +24,9 @@ module Rubocop
                         '  some_method',
                         'end',
                         'some_method while not a_condition'])
-        fav_until.offences.map(&:message).should ==
-          ['Favor until over while for negative conditions.'] * 2
-        fav_until.offences.map(&:line_number).should == [1, 4]
+        expect(fav_until.offences.map(&:message)).to eq(
+          ['Favor until over while for negative conditions.'] * 2)
+        expect(fav_until.offences.map(&:line_number)).to eq([1, 4])
       end
 
       it 'accepts an while where only part of the contition is negated' do
@@ -38,7 +38,7 @@ module Rubocop
                         '  some_method',
                         'end',
                         'some_method while not a_condition or other_cond'])
-        fav_until.offences.map(&:message).should == []
+        expect(fav_until.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/grammar_spec.rb

@@ -7,13 +7,12 @@ module Rubocop
     describe Grammar do
       EXAMPLE = '3.times { |i| x = "#{y}#{z}}" }'
       tokens = Ripper.lex(EXAMPLE).map { |t| Token.new(*t) }
-      let (:grammar) { Grammar.new(tokens) }
+      let(:grammar) { Grammar.new(tokens) }
 
-      it 'correlates token indices to grammar paths' do
+      it 'correlates token indices to grammar paths', ruby: 2.0 do
         method_block = [:program, :method_add_block]
         brace_block = method_block + [:brace_block]
-        Ripper.lex(EXAMPLE).should ==
-          [[[1, 0], :on_int, '3'],
+        test_2_0 = [[[1, 0], :on_int, '3'],
            [[1, 1], :on_period, '.'],
            [[1, 2], :on_ident, 'times'],
            [[1, 7], :on_sp, ' '],
@@ -30,20 +29,21 @@ module Rubocop
            [[1, 18], :on_tstring_beg, '"'],
            [[1, 19], :on_embexpr_beg, '#{'], # 15
            [[1, 21], :on_ident, 'y'],
-           [[1, 22], :on_rbrace, '}'],
+           [[1, 22], :on_embexpr_end, '}'], # [[1, 22], :on_rbrace, '}'],
            [[1, 23], :on_embexpr_beg, '#{'],
            [[1, 25], :on_ident, 'z'],
-           [[1, 26], :on_rbrace, '}'], # 20
+           [[1, 26], :on_embexpr_end, '}'], # [[1, 26], :on_rbrace, '}'], # 20
            [[1, 27], :on_tstring_content, '}'],
            [[1, 28], :on_tstring_end, '"'],
            [[1, 29], :on_sp, ' '],
            [[1, 30], :on_rbrace, '}']]
-
+        expect(Ripper.lex(EXAMPLE)).to eq(test_2_0) if RUBY_VERSION >= '2.0'
         sexp = Ripper.sexp(EXAMPLE)
         Position.make_position_objects(sexp)
 
         varref = (RUBY_VERSION == '1.9.2') ? :var_ref : :vcall
-        grammar.correlate(sexp).should == {
+
+        test = {
           0  => method_block + [:call, :@int],                    # 3
           2  => method_block + [:call, :@ident],                  # times
           4  => brace_block,                                      # {
@@ -58,8 +58,13 @@ module Rubocop
                                :string_embexpr, varref, :@ident], # z
           21 => brace_block + [:assign, :string_literal, :string_content,
                                :@tstring_content],                # }
-          24 => brace_block,                                      # }
         }
+        if RUBY_VERSION >= '2.0'
+          expect(grammar.correlate(sexp)).to eq(test)
+        else
+          test = (test[24] = brace_block)
+          expect(grammar.correlate(sexp)).to eq(test)
+        end
       end
     end
   end

data/spec/rubocop/cops/hash_syntax_spec.rb

@@ -5,39 +5,39 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe HashSyntax do
-      let (:hash_syntax) { HashSyntax.new }
+      let(:hash_syntax) { HashSyntax.new }
 
       it 'registers an offence for hash rocket syntax when new is possible' do
         inspect_source(hash_syntax, '', ['x = { :a => 0 }'])
-        hash_syntax.offences.map(&:message).should ==
-          ['Ruby 1.8 hash syntax detected']
+        expect(hash_syntax.offences.map(&:message)).to eq(
+          ['Ruby 1.8 hash syntax detected'])
       end
 
       it 'registers an offence for mixed syntax when new is possible' do
         inspect_source(hash_syntax, '', ['x = { :a => 0, b: 1 }'])
-        hash_syntax.offences.map(&:message).should ==
-          ['Ruby 1.8 hash syntax detected']
+        expect(hash_syntax.offences.map(&:message)).to eq(
+          ['Ruby 1.8 hash syntax detected'])
       end
 
       it 'registers an offence for hash rockets in method calls' do
         inspect_source(hash_syntax, '', ['func(3, :a => 0)'])
-        hash_syntax.offences.map(&:message).should ==
-          ['Ruby 1.8 hash syntax detected']
+        expect(hash_syntax.offences.map(&:message)).to eq(
+          ['Ruby 1.8 hash syntax detected'])
       end
 
       it 'accepts hash rockets when keys have different types' do
         inspect_source(hash_syntax, '', ['x = { :a => 0, "b" => 1 }'])
-        hash_syntax.offences.map(&:message).should == []
+        expect(hash_syntax.offences.map(&:message)).to be_empty
       end
 
       it 'accepts new syntax in a hash literal' do
         inspect_source(hash_syntax, '', ['x = { a: 0, b: 1 }'])
-        hash_syntax.offences.map(&:message).should == []
+        expect(hash_syntax.offences.map(&:message)).to be_empty
       end
 
       it 'accepts new syntax in method calls' do
         inspect_source(hash_syntax, '', ['func(3, a: 0)'])
-        hash_syntax.offences.map(&:message).should == []
+        expect(hash_syntax.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/if_with_semicolon_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe IfWithSemicolon do
-      let (:iws) { IfWithSemicolon.new }
+      let(:iws) { IfWithSemicolon.new }
 
       it 'registers an offence for one line if/;/end' do
         inspect_source(iws, '', ['if cond; run else dont end'])
-        iws.offences.map(&:message).should ==
-          ['Never use if x; Use the ternary operator instead.']
+        expect(iws.offences.map(&:message)).to eq(
+          ['Never use if x; Use the ternary operator instead.'])
       end
     end
   end

data/spec/rubocop/cops/indentation_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe Indentation do
-      let (:ind) { Indentation.new }
+      let(:ind) { Indentation.new }
 
       it "registers an offence for a when clause that's deeper than case" do
         source = ['case a',
@@ -15,8 +15,8 @@ module Rubocop
                   '        end',
                   'end']
         inspect_source(ind, 'file.rb', source)
-        ind.offences.map(&:message).should ==
-          ['Indent when as deep as case.'] * 2
+        expect(ind.offences.map(&:message)).to eq(
+          ['Indent when as deep as case.'] * 2)
       end
 
       it "accepts a when clause that's equally indented with case" do
@@ -33,7 +33,7 @@ module Rubocop
                   'end',
                   '']
         inspect_source(ind, 'file.rb', source)
-        ind.offences.size.should == 0
+        expect(ind.offences).to be_empty
       end
 
       it "doesn't get confused by strings with case in them" do
@@ -43,7 +43,7 @@ module Rubocop
                   'end',
                   '']
         inspect_source(ind, 'file.rb', source)
-        ind.offences.map(&:message).should == []
+        expect(ind.offences.map(&:message)).to be_empty
       end
 
       it "doesn't get confused by symbols named case or when" do
@@ -56,7 +56,7 @@ module Rubocop
                   'end',
                   '']
         inspect_source(ind, 'file.rb', source)
-        ind.offences.map(&:message).should == []
+        expect(ind.offences.map(&:message)).to be_empty
       end
 
       it 'accepts correctly indented whens in complex combinations' do
@@ -79,7 +79,7 @@ module Rubocop
                   'end',
                   '']
         inspect_source(ind, 'file.rb', source)
-        ind.offences.map(&:message).should == []
+        expect(ind.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/line_length_spec.rb

@@ -5,17 +5,17 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe LineLength do
-      let (:ll) { LineLength.new }
+      let(:ll) { LineLength.new }
 
       it "registers an offence for a line that's 80 characters wide" do
         ll.inspect('file.rb', ['#' * 80], nil, nil)
-        ll.offences.size.should == 1
-        ll.offences.first.message.should == 'Line is too long. [80/79]'
+        expect(ll.offences.size).to eq(1)
+        expect(ll.offences.first.message).to eq('Line is too long. [80/79]')
       end
 
       it "accepts a line that's 79 characters wide" do
         ll.inspect('file.rb', ['#' * 79], nil, nil)
-        ll.offences.size.should == 0
+        expect(ll.offences).to be_empty
       end
     end
   end