rubocop 0.3.2 → 0.4.0

data/spec/rubocop/cops/space_around_operators_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SpaceAroundOperators do
-      let (:space) { SpaceAroundOperators.new }
+      let(:space) { SpaceAroundOperators.new }
 
       it 'registers an offence for assignment without space on both sides' do
         inspect_source(space, 'file.rb', ['x=0', 'y= 0', 'z =0'])
-        space.offences.map(&:message).should ==
-          ["Surrounding space missing for operator '='."] * 3
+        expect(space.offences.map(&:message)).to eq(
+          ["Surrounding space missing for operator '='."] * 3)
       end
 
       it 'registers an offence in presence of modifier if statement' do
@@ -33,59 +33,59 @@ module Rubocop
         src = ["a=1 #{keyword} condition",
                'c=2']
         inspect_source(space, 'file.rb', src)
-        space.offences.map(&:line_number).should == [1, 2]
-        space.offences.map(&:message).should ==
-          ["Surrounding space missing for operator '='."] * 2
+        expect(space.offences.map(&:line_number)).to eq([1, 2])
+        expect(space.offences.map(&:message)).to eq(
+          ["Surrounding space missing for operator '='."] * 2)
       end
 
       it 'registers an offence for binary operators that could be unary' do
         inspect_source(space, 'file.rb', ['a-3', 'x&0xff', 'z+0'])
-        space.offences.map(&:message).should ==
+        expect(space.offences.map(&:message)).to eq(
           ["Surrounding space missing for operator '-'.",
            "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, 'file.rb', ['puts 1+2'])
-        space.offences.map(&:message).should ==
-          ["Surrounding space missing for operator '+'."]
+        expect(space.offences.map(&:message)).to eq(
+          ["Surrounding space missing for operator '+'."])
       end
 
       it 'accepts operator symbols' do
         inspect_source(space, 'file.rb', ['func(:-)'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts ranges' do
         inspect_source(space, 'file.rb', ['a, b = (1..2), (1...3)'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts scope operator' do
         source = ['@io.class == Zlib::GzipWriter']
         inspect_source(space, 'file.rb', source)
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts ::Kernel::raise' do
         source = ['::Kernel::raise IllegalBlockError.new']
         inspect_source(space, 'file.rb', source)
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts exclamation point negation' do
         inspect_source(space, 'file.rb', ['x = !a&&!b'])
-        space.offences.map(&:message).should ==
-          ["Surrounding space missing for operator '&&'."]
+        expect(space.offences.map(&:message)).to eq(
+          ["Surrounding space missing for operator '&&'."])
       end
 
       it 'accepts exclamation point definition' do
         inspect_source(space, 'file.rb', ['  def !',
                                          '    !__getobj__',
                                          '  end'])
-        space.offences.should == []
-        space.offences.map(&:message).should == []
+        expect(space.offences).to be_empty
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts a unary' do
@@ -95,52 +95,52 @@ module Rubocop
                         '              *labels, &blk)',
                         '  end',
                         ''])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts splat operator' do
         inspect_source(space, 'file.rb', ['return *list if options'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts def of operator' do
         inspect_source(space, 'file.rb', ['def +(other); end'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts an assignment with spaces' do
         inspect_source(space, 'file.rb', ['x = 0'])
-        space.offences.size.should == 0
+        expect(space.offences).to be_empty
       end
 
       it "accepts some operators that are exceptions and don't need spaces" do
         inspect_source(space, 'file.rb', ['(1..3)',
                                          'ActionController::Base',
                                          'each { |s, t| }'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts an assignment followed by newline' do
         inspect_source(space, 'file.rb', ['x =\n  0'])
-        space.offences.size.should == 0
+        expect(space.offences).to be_empty
       end
 
       it 'registers an offences for exponent operator with spaces' do
         inspect_source(space, 'file.rb', ['x = a * b ** 2'])
-        space.offences.map(&:message).should ==
-          ['Space around operator ** detected.']
+        expect(space.offences.map(&:message)).to eq(
+          ['Space around operator ** detected.'])
       end
 
       it 'accepts exponent operator without spaces' do
         inspect_source(space, 'file.rb', ['x = a * b**2'])
-        space.offences.size.should == 0
+        expect(space.offences).to be_empty
       end
 
       it 'accepts unary operators without space' do
         inspect_source(space, 'file.rb', ['[].map(&:size)',
                                          '-3',
                                          'x = +2'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/space_inside_brackets_spec.rb

@@ -5,38 +5,38 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SpaceInsideBrackets do
-      let (:space) { SpaceInsideBrackets.new }
+      let(:space) { SpaceInsideBrackets.new }
 
       it 'registers an offence for an array literal with spaces inside' do
         inspect_source(space, 'file.rb', ['a = [1, 2 ]',
                                          'b = [ 1, 2]'])
-        space.offences.map(&:message).should ==
+        expect(space.offences.map(&:message)).to eq(
           ['Space inside square brackets detected.',
-           'Space inside square brackets detected.']
+           'Space inside square brackets detected.'])
       end
 
       it 'accepts space inside square brackets if on its own row' do
         inspect_source(space, 'file.rb', ['a = [',
                                          '     1, 2',
                                          '    ]'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts square brackets as method name' do
         inspect_source(space, 'file.rb', ['def Vector.[](*array)',
                                          'end'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'accepts square brackets called with method call syntax' do
         inspect_source(space, 'file.rb', ['subject.[](0)'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
       it 'only reports a single space once' do
         inspect_source(space, 'file.rb', ['[ ]'])
-        space.offences.map(&:message).should ==
-          ['Space inside square brackets detected.']
+        expect(space.offences.map(&:message)).to eq(
+          ['Space inside square brackets detected.'])
       end
     end
   end

data/spec/rubocop/cops/space_inside_parens_spec.rb

@@ -5,21 +5,21 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe SpaceInsideParens do
-      let (:space) { SpaceInsideParens.new }
+      let(:space) { SpaceInsideParens.new }
 
       it 'registers an offence for spaces inside parens' do
         inspect_source(space, 'file.rb', ['f( 3)',
                                          'g(3 )'])
-        space.offences.map(&:message).should ==
+        expect(space.offences.map(&:message)).to eq(
           ['Space inside parentheses detected.',
-           'Space inside parentheses detected.']
+           'Space inside parentheses detected.'])
       end
 
       it 'accepts parentheses in block parameter list' do
         inspect_source(space, 'file.rb',
                        ['list.inject(Tms.new) { |sum, (label, item)|',
                         '}'])
-        space.offences.map(&:message).should == []
+        expect(space.offences.map(&:message)).to be_empty
       end
 
     end

data/spec/rubocop/cops/string_literals_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe StringLiterals do
-      let (:sl) { StringLiterals.new }
+      let(:sl) { StringLiterals.new }
 
       it 'registers an offence for double quotes when single quotes suffice' do
         inspect_source(sl, 'file.rb', ['s = "abc"'])
-        sl.offences.map(&:message).should ==
+        expect(sl.offences.map(&:message)).to eq(
           ["Prefer single-quoted strings when you don't need string " +
-           'interpolation or special symbols.']
+           'interpolation or special symbols.'])
       end
 
       it 'accepts double quotes when they are needed' do
@@ -19,13 +19,13 @@ module Rubocop
                'b = "#{encode_severity}:#{sprintf("%3d", line_number)}: #{m}"',
                'c = "\'"']
         inspect_source(sl, 'file.rb', src)
-        sl.offences.map(&:message).should == []
+        expect(sl.offences.map(&:message)).to be_empty
       end
 
       it 'can handle double quotes within embedded expression' do
         src = ['"#{"A"}"']
         inspect_source(sl, 'file.rb', src)
-        sl.offences.map(&:message).should == []
+        expect(sl.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/syntax_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Syntax do
+      let(:sc) { Syntax.new }
+
+      it 'registers an offence for unused variables', ruby: 2.0 do
+        sc.inspect('file.rb', ['x = 5', 'puts 10'], nil, nil)
+        expect(sc.offences.size).to eq(1)
+        expect(sc.offences.first.message)
+          .to eq('Assigned but unused variable - x')
+      end
+    end
+  end
+end

data/spec/rubocop/cops/tab_spec.rb

@@ -5,16 +5,16 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe Tab do
-      let (:tab) { Tab.new }
+      let(:tab) { Tab.new }
 
       it 'registers an offence for a line indented with tab' do
         tab.inspect('file.rb', ["\tx = 0"], nil, nil)
-        tab.offences.size.should == 1
+        expect(tab.offences.size).to eq(1)
       end
 
       it 'accepts a line with tab in a string' do
         tab.inspect('file.rb', [%Q(x = "\t")], nil, nil)
-        tab.offences.size.should == 0
+        expect(tab.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/ternary_operator_spec.rb

@@ -5,30 +5,30 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe MultilineTernaryOperator do
-      let (:op) { MultilineTernaryOperator.new }
+      let(:op) { MultilineTernaryOperator.new }
 
       it 'registers an offence for a multiline ternary operator expression' do
         inspect_source(op, 'file.rb', ['a = cond ?',
                                         '  b : c'])
-        op.offences.map(&:message).should ==
+        expect(op.offences.map(&:message)).to eq(
           ['Avoid multi-line ?: (the ternary operator); use if/unless ' +
-           'instead.']
+           'instead.'])
       end
 
       it 'accepts a single line ternary operator expression' do
         inspect_source(op, 'file.rb', ['a = cond ? b : c'])
-        op.offences.map(&:message).should == []
+        expect(op.offences.map(&:message)).to be_empty
       end
     end
 
     describe NestedTernaryOperator do
-      let (:op) { NestedTernaryOperator.new }
+      let(:op) { NestedTernaryOperator.new }
 
       it 'registers an offence for a nested ternary operator expression' do
         inspect_source(op, 'file.rb', ['a ? (b ? b1 : b2) : a2'])
-        op.offences.map(&:message).should ==
+        expect(op.offences.map(&:message)).to eq(
           ['Ternary operators must not be nested. Prefer if/else constructs ' +
-           'instead.']
+           'instead.'])
       end
 
       it 'accepts a non-nested ternary operator within an if' do
@@ -37,7 +37,7 @@ module Rubocop
                                        'else',
                                        '  d',
                                        'end'])
-        op.offences.map(&:message).should == []
+        expect(op.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/trailing_whitespace_spec.rb

@@ -5,22 +5,22 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe TrailingWhitespace do
-      let (:tws) { TrailingWhitespace.new }
+      let(:tws) { TrailingWhitespace.new }
 
       it 'registers an offence for a line ending with space' do
         source = ['x = 0 ']
         tws.inspect('file.rb', source, nil, nil)
-        tws.offences.size.should == 1
+        expect(tws.offences.size).to eq(1)
       end
 
       it 'registers an offence for a line ending with tab' do
         tws.inspect('file.rb', ["x = 0\t"], nil, nil)
-        tws.offences.size.should == 1
+        expect(tws.offences.size).to eq(1)
       end
 
       it 'accepts a line without trailing whitespace' do
         tws.inspect('file.rb', ["x = 0\n"], nil, nil)
-        tws.offences.size.should == 0
+        expect(tws.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/unless_else_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe UnlessElse do
-      let (:ue) { UnlessElse.new }
+      let(:ue) { UnlessElse.new }
 
       it 'registers an offence for an unless with else' do
         inspect_source(ue, 'file.rb', ['unless x',
@@ -13,16 +13,16 @@ module Rubocop
                                        'else',
                                        '  a = 0',
                                        'end'])
-        ue.offences.map(&:message).should ==
+        expect(ue.offences.map(&:message)).to eq(
           ['Never use unless with else. Rewrite these with the ' +
-           'positive case first.']
+           'positive case first.'])
       end
 
       it 'accepts an unless without else' do
         inspect_source(ue, 'file.rb', ['unless x',
                                        '  a = 1',
                                        'end'])
-        ue.offences.map(&:message).should == []
+        expect(ue.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/when_then_spec.rb

@@ -5,21 +5,21 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe WhenThen do
-      let (:wt) { WhenThen.new }
+      let(:wt) { WhenThen.new }
 
       it 'registers an offence for when x;' do
         inspect_source(wt, 'file.rb', ['case a',
                                        'when b; c',
                                        'end'])
-        wt.offences.map(&:message).should ==
-          ['Never use "when x;". Use "when x then" instead.']
+        expect(wt.offences.map(&:message)).to eq(
+          ['Never use "when x;". Use "when x then" instead.'])
       end
 
       it 'accepts when x then' do
         inspect_source(wt, 'file.rb', ['case a',
                                        'when b then c',
                                        'end'])
-        wt.offences.map(&:message).should == []
+        expect(wt.offences.map(&:message)).to be_empty
       end
 
       it 'accepts ; separating statements in the body of when' do
@@ -31,7 +31,7 @@ module Rubocop
                                        'when f',
                                        '  g; h',
                                        'end'])
-        wt.offences.map(&:message).should == []
+        expect(wt.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/reports/emacs_style_spec.rb

@@ -6,7 +6,7 @@ require 'stringio'
 module Rubocop
   module Report
     describe EmacsStyle do
-      let (:emacs_style) { Rubocop::Report.create('test', :emacs_style) }
+      let(:emacs_style) { Rubocop::Report.create('test', :emacs_style) }
 
       it 'displays parsable text' do
         cop = Cop::Cop.new
@@ -17,8 +17,8 @@ module Rubocop
 
         s = StringIO.new
         emacs_style.display(s)
-        s.string.should == ['test:1: C: message 1',
-                            "test:11: F: message 2\n"].join("\n")
+        expect(s.string).to eq ['test:1: C: message 1',
+                                "test:11: F: message 2\n"].join("\n")
       end
     end
   end