rubocop 0.3.2 → 0.4.0

data/spec/rubocop/cops/align_parameters_spec.rb

@@ -5,22 +5,22 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe AlignParameters do
-      let (:align) { AlignParameters.new }
+      let(:align) { AlignParameters.new }
 
       it 'registers an offence for parameters with single indent' do
         inspect_source(align, 'file.rb', ['function(a,',
                                          '  if b then c else d end)'])
-        align.offences.map(&:message).should ==
+        expect(align.offences.map(&:message)).to eq(
           ['Align the parameters of a method call if they span more than ' +
-           'one line.']
+           'one line.'])
       end
 
       it 'registers an offence for parameters with double indent' do
         inspect_source(align, 'file.rb', ['function(a,',
                                          '    if b then c else d end)'])
-        align.offences.map(&:message).should ==
+        expect(align.offences.map(&:message)).to eq(
           ['Align the parameters of a method call if they span more than ' +
-           'one line.']
+           'one line.'])
       end
 
       it 'accepts correctly aligned parameters' do
@@ -28,19 +28,19 @@ module Rubocop
                                          '         0, 1,',
                                          '         (x + y),',
                                          '         if b then c else d end)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'accepts calls that only span one line' do
         inspect_source(align, 'file.rb', ['find(path, s, @special[sexp[0]])'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it "doesn't get confused by a symbol argument" do
         inspect_source(align, '',
                        ['add_offence(:convention, index,',
                         '            ERROR_MESSAGE % kind)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it "doesn't get confused by splat operator" do
@@ -53,49 +53,49 @@ module Rubocop
                         '      c)',
                         'func3(*a)',
                        ])
-        align.offences.map(&:to_s).should ==
+        expect(align.offences.map(&:to_s)).to eq(
           ['C:  5: Align the parameters of a method call if they span ' +
-           'more than one line.']
+           'more than one line.'])
       end
 
       it 'can handle a correctly aligned string literal as first argument' do
         inspect_source(align, '',
                        ['add_offence(:convention, x,',
                         '            a)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle a string literal as other argument' do
         inspect_source(align, '',
                        ['add_offence(:convention,',
                         '            "", a)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it "doesn't get confused by a line break inside a parameter" do
         inspect_source(align, '',
                        ['read(path, { headers:    true,',
                         '             converters: :numeric })'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it "doesn't get confused by symbols with embedded expressions" do
         inspect_source(align, '',
                        ['send(:"#{name}_comments_path")'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it "doesn't get confused by regexen with embedded expressions" do
         inspect_source(align, '',
                        ['a(/#{name}/)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'accepts braceless hashes' do
         inspect_source(align, '',
                        ['run(collection, :entry_name => label,',
                         '                :paginator  => paginator)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'accepts the first parameter being on a new row' do
@@ -104,7 +104,7 @@ module Rubocop
                         '    a,',
                         '    b',
                         '  )'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle heredoc strings' do
@@ -115,7 +115,7 @@ module Rubocop
                '            end',
                '            EOS']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle a method call within a method call' do
@@ -124,13 +124,13 @@ module Rubocop
                         '  b(b1,',
                         '    b2),',
                         '  a2)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle a call embedded in a string' do
         inspect_source(align, '',
                        ['model("#{index(name)}", child)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle do-end' do
@@ -138,7 +138,7 @@ module Rubocop
                        ['      run(lambda do |e|',
                         "        w = e['warden']",
                         '      end)'])
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle a call with a block inside another call' do
@@ -147,19 +147,19 @@ module Rubocop
                "      col['name']",
                '    })']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle a ternary condition with a block reference' do
         src = ['cond ? a : func(&b)']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle parentheses used with no parameters' do
         src = ['func()']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle a multiline hash as first parameter' do
@@ -167,7 +167,7 @@ module Rubocop
                '  :space_before => "",',
                '}, state)']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle a multiline hash as second parameter' do
@@ -175,26 +175,26 @@ module Rubocop
                '  :value => value',
                '})']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle method calls without parentheses' do
         src = ['a(b c, d)']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it 'can handle other method calls without parentheses' do
         src = ['chars(Unicode.apply_mapping @wrapped_string, :uppercase)']
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
 
       it "doesn't check alignment if tabs are used to indent" do
         src = ['a(b,',
                "\tc)"]
         inspect_source(align, '', src)
-        align.offences.map(&:message).should == []
+        expect(align.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/ampersands_pipes_vs_and_or_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe AmpersandsPipesVsAndOr do
-      let (:amp) { AmpersandsPipesVsAndOr.new }
+      let(:amp) { AmpersandsPipesVsAndOr.new }
 
       it 'registers an offence for AND used in condition of if statement' do
         check('if', 'and', '&&')
@@ -48,9 +48,9 @@ module Rubocop
                                         'end'])
         # Just one offence should be registered. The good_operator
         # should be accepted.
-        amp.offences.map(&:message).should ==
-          ['Use &&/|| for boolean expressions, and/or for control flow.']
-        amp.offences[0].line_number.should == 1
+        expect(amp.offences.map(&:message)).to eq(
+          ['Use &&/|| for boolean expressions, and/or for control flow.'])
+        expect(amp.offences[0].line_number).to eq(1)
       end
     end
   end

data/spec/rubocop/cops/class_and_module_camel_case_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe ClassAndModuleCamelCase do
-      let (:camel_case) { ClassAndModuleCamelCase.new }
+      let(:camel_case) { ClassAndModuleCamelCase.new }
 
       it 'registers an offence for underscore in class and module name' do
         inspect_source(camel_case, 'file.rb',
@@ -15,8 +15,8 @@ module Rubocop
                         'module My_Module',
                         'end',
                        ])
-        camel_case.offences.map(&:message).should ==
-          ['Use CamelCase for classes and modules.'] * 2
+        expect(camel_case.offences.map(&:message)).to eq(
+          ['Use CamelCase for classes and modules.'] * 2)
       end
 
       it 'accepts CamelCase names' do
@@ -27,7 +27,7 @@ module Rubocop
                         'module Mine',
                         'end',
                        ])
-        camel_case.offences.map(&:message).should == []
+        expect(camel_case.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/collection_methods_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe CollectionMethods do
+      let(:cm) { CollectionMethods.new }
+
+      it 'registers an offence for collect' do
+        inspect_source(cm, 'file.rb', ['[1, 2, 3].collect { |e| e + 1 }'])
+        expect(cm.offences.size).to eq(1)
+        expect(cm.offences.map(&:message))
+          .to eq(['Prefer map over collect.'])
+      end
+
+      it 'registers an offence for inject' do
+        inspect_source(cm, 'file.rb', ['[1, 2, 3].inject { |e| e + 1 }'])
+        expect(cm.offences.size).to eq(1)
+        expect(cm.offences.map(&:message))
+          .to eq(['Prefer reduce over inject.'])
+      end
+
+      it 'registers an offence for detect' do
+        inspect_source(cm, 'file.rb', ['[1, 2, 3].detect { |e| e + 1 }'])
+        expect(cm.offences.size).to eq(1)
+        expect(cm.offences.map(&:message))
+          .to eq(['Prefer find over detect.'])
+      end
+
+      it 'registers an offence for find_all' do
+        inspect_source(cm, 'file.rb', ['[1, 2, 3].find_all { |e| e + 1 }'])
+        expect(cm.offences.size).to eq(1)
+        expect(cm.offences.map(&:message))
+          .to eq(['Prefer select over find_all.'])
+      end
+    end
+  end
+end

data/spec/rubocop/cops/cop_spec.rb

@@ -5,26 +5,26 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe Cop do
-      let (:cop) { Cop.new }
+      let(:cop) { Cop.new }
 
       it 'initially has 0 offences' do
-        cop.offences.size.should == 0
+        expect(cop.offences).to be_empty
       end
 
       it 'initially has nothing to report' do
-        cop.has_report?.should be_false
+        expect(cop.has_report?).to be_false
       end
 
       it 'keeps track of offences' do
         cop.add_offence(:convention, 1, 'message')
 
-        cop.offences.size.should == 1
+        expect(cop.offences.size).to eq(1)
       end
 
       it 'will report registered offences' do
         cop.add_offence(:convention, 1, 'message')
 
-        cop.has_report?.should be_true
+        expect(cop.has_report?).to be_true
       end
     end
   end

data/spec/rubocop/cops/def_with_parentheses_spec.rb

@@ -5,28 +5,28 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe DefWithParentheses do
-      let (:def_par) { DefWithParentheses.new }
+      let(:def_par) { DefWithParentheses.new }
 
       it 'reports an offence for def with empty parens' do
         src = ['def func()',
                'end']
         inspect_source(def_par, '', src)
-        def_par.offences.map(&:message).should ==
+        expect(def_par.offences.map(&:message)).to eq(
           ["Omit the parentheses in defs when the method doesn't accept any " +
-           'arguments.']
+           'arguments.'])
       end
 
       it 'accepts def with arg and parens' do
         src = ['def func(a)',
                'end']
         inspect_source(def_par, '', src)
-        def_par.offences.map(&:message).should == []
+        expect(def_par.offences.map(&:message)).to be_empty
       end
 
       it 'accepts empty parentheses in one liners' do
         src = ["def to_s() join '/' end"]
         inspect_source(def_par, '', src)
-        def_par.offences.map(&:message).should == []
+        expect(def_par.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/def_without_parentheses_spec.rb

@@ -5,21 +5,21 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe DefWithoutParentheses do
-      let (:def_par) { DefWithoutParentheses.new }
+      let(:def_par) { DefWithoutParentheses.new }
 
       it 'reports an offence for def with parameters but no parens' do
         src = ['def func a, b',
                'end']
         inspect_source(def_par, '', src)
-        def_par.offences.map(&:message).should ==
-          ['Use def with parentheses when there are arguments.']
+        expect(def_par.offences.map(&:message)).to eq(
+          ['Use def with parentheses when there are arguments.'])
       end
 
       it 'accepts def with no args and no parens' do
         src = ['def func',
                'end']
         inspect_source(def_par, '', src)
-        def_par.offences.map(&:message).should == []
+        expect(def_par.offences.map(&:message)).to be_empty
       end
     end
   end

data/spec/rubocop/cops/empty_lines_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe EmptyLines do
-      let (:empty_lines) { EmptyLines.new }
+      let(:empty_lines) { EmptyLines.new }
 
       it 'finds offences in inner classes' do
         inspect_source(empty_lines, '', ['class K',
@@ -21,8 +21,8 @@ module Rubocop
                                         '  def p',
                                         '  end',
                                         'end'])
-        empty_lines.offences.size.should == 2
-        empty_lines.offences.map(&:line_number).sort.should == [7, 11]
+        expect(empty_lines.offences.size).to eq(2)
+        expect(empty_lines.offences.map(&:line_number).sort).to eq([7, 11])
       end
 
       # Only one def, so rule about empty line *between* defs does not
@@ -31,7 +31,7 @@ module Rubocop
         inspect_source(empty_lines, '', ['x = 0',
                                         'def m',
                                         'end'])
-        empty_lines.offences.size.should == 0
+        expect(empty_lines.offences).to be_empty
       end
 
       # Only one def, so rule about empty line *between* defs does not
@@ -41,7 +41,7 @@ module Rubocop
                                         '  # 123',
                                         '  def m',
                                         '  end'])
-        empty_lines.offences.size.should == 0
+        expect(empty_lines.offences).to be_empty
       end
 
       it 'accepts the first def without leading empty line in a class' do
@@ -49,7 +49,7 @@ module Rubocop
                                         '  def m',
                                         '  end',
                                         'end'])
-        empty_lines.offences.size.should == 0
+        expect(empty_lines.offences).to be_empty
       end
 
       it 'accepts a def that follows an empty line and then a comment' do
@@ -64,7 +64,7 @@ module Rubocop
                                         '  end',
                                         'end',
                                        ])
-        empty_lines.offences.size.should == 0
+        expect(empty_lines.offences).to be_empty
       end
 
       it 'accepts a def that is the first of a module' do
@@ -76,7 +76,7 @@ module Rubocop
                   'end',
                  ]
         inspect_source(empty_lines, '', source)
-        empty_lines.offences.map(&:message).should == []
+        expect(empty_lines.offences.map(&:message)).to be_empty
       end
     end
   end