reek 1.3.8 → 1.4.0

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -18,50 +18,50 @@ describe IrresponsibleModule do
 
       class C; def foo; end; end
     EOS
-    src.should_not reek_of(:IrresponsibleModule)
+    expect(src).not_to reek_of(:IrresponsibleModule)
   end
 
-  it "does not report a class having a comment" do
+  it 'does not report a class having a comment' do
     src = <<EOS
 # test class
 class Responsible; end
 EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-    @detector.examine_context(ctx).should be_empty
+    expect(@detector.examine_context(ctx)).to be_empty
   end
-  it "reports a class without a comment" do
+  it 'reports a class without a comment' do
     src = "class #{@bad_module_name}; end"
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     smells = @detector.examine_context(ctx)
-    smells.length.should == 1
-    smells[0].smell_class.should == IrresponsibleModule::SMELL_CLASS
-    smells[0].subclass.should == IrresponsibleModule::SMELL_SUBCLASS
-    smells[0].lines.should == [1]
-    smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY].should == @bad_module_name
+    expect(smells.length).to eq(1)
+    expect(smells[0].smell_class).to eq(IrresponsibleModule::SMELL_CLASS)
+    expect(smells[0].subclass).to eq(IrresponsibleModule::SMELL_SUBCLASS)
+    expect(smells[0].lines).to eq([1])
+    expect(smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]).to eq(@bad_module_name)
   end
-  it "reports a class with an empty comment" do
+  it 'reports a class with an empty comment' do
     src = <<EOS
 #
 #
-#  
+#
 class #{@bad_module_name}; end
 EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     smells = @detector.examine_context(ctx)
-    smells.length.should == 1
-    smells[0].smell_class.should == IrresponsibleModule::SMELL_CLASS
-    smells[0].subclass.should == IrresponsibleModule::SMELL_SUBCLASS
-    smells[0].lines.should == [4]
-    smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY].should == @bad_module_name
+    expect(smells.length).to eq(1)
+    expect(smells[0].smell_class).to eq(IrresponsibleModule::SMELL_CLASS)
+    expect(smells[0].subclass).to eq(IrresponsibleModule::SMELL_SUBCLASS)
+    expect(smells[0].lines).to eq([4])
+    expect(smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]).to eq(@bad_module_name)
   end
   it 'reports a fq module name correctly' do
     src = 'class Foo::Bar; end'
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     smells = @detector.examine_context(ctx)
-    smells.length.should == 1
-    smells[0].smell_class.should == IrresponsibleModule::SMELL_CLASS
-    smells[0].subclass.should == IrresponsibleModule::SMELL_SUBCLASS
-    smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY].should == 'Foo::Bar'
-    smells[0].context.should match(/#{smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]}/)
+    expect(smells.length).to eq(1)
+    expect(smells[0].smell_class).to eq(IrresponsibleModule::SMELL_CLASS)
+    expect(smells[0].subclass).to eq(IrresponsibleModule::SMELL_SUBCLASS)
+    expect(smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]).to eq('Foo::Bar')
+    expect(smells[0].context).to match(/#{smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]}/)
   end
 end

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -9,31 +9,31 @@ describe LongParameterList do
 
   context 'for methods with few parameters' do
     it 'should report nothing for no parameters' do
-      'def simple; f(3);true; end'.should_not smell_of(LongParameterList)
+      expect('def simple; f(3);true; end').not_to smell_of(LongParameterList)
     end
     it 'should report nothing for 1 parameter' do
-      'def simple(yep) f(3);true end'.should_not smell_of(LongParameterList)
+      expect('def simple(yep) f(3);true end').not_to smell_of(LongParameterList)
     end
     it 'should report nothing for 2 parameters' do
-      'def simple(yep,zero) f(3);true end'.should_not smell_of(LongParameterList)
+      expect('def simple(yep,zero) f(3);true end').not_to smell_of(LongParameterList)
     end
     it 'should not count an optional block' do
-      'def simple(alpha, yep, zero, &opt) f(3);true end'.should_not smell_of(LongParameterList)
+      expect('def simple(alpha, yep, zero, &opt) f(3);true end').not_to smell_of(LongParameterList)
     end
     it 'should not report inner block with too many parameters' do
       src = 'def simple(yep,zero); m[3]; rand(34); f.each { |arga, argb, argc, argd| true}; end'
-      src.should_not smell_of(LongParameterList)
+      expect(src).not_to smell_of(LongParameterList)
     end
 
     describe 'and default values' do
       it 'should report nothing for 1 parameter' do
-        'def simple(zero=nil) f(3);false end'.should_not smell_of(LongParameterList)
+        expect('def simple(zero=nil) f(3);false end').not_to smell_of(LongParameterList)
       end
       it 'should report nothing for 2 parameters with 1 default' do
-        'def simple(yep, zero=nil) f(3);false end'.should_not smell_of(LongParameterList)
+        expect('def simple(yep, zero=nil) f(3);false end').not_to smell_of(LongParameterList)
       end
       it 'should report nothing for 2 defaulted parameters' do
-        'def simple(yep=4, zero=nil) f(3);false end'.should_not smell_of(LongParameterList)
+        expect('def simple(yep=4, zero=nil) f(3);false end').not_to smell_of(LongParameterList)
       end
     end
   end
@@ -41,21 +41,21 @@ describe LongParameterList do
   describe 'for methods with too many parameters' do
     it 'should report 4 parameters' do
       src = 'def simple(arga, argb, argc, argd) f(3);true end'
-      src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
+      expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
     end
     it 'should report 8 parameters' do
       src = 'def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end'
-      src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 8)
+      expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 8)
     end
 
     describe 'and default values' do
       it 'should report 3 with 1 defaulted' do
         src = 'def simple(polly, queue, yep, zero=nil) f(3);false end'
-        src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
+        expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
       end
       it 'should report with 3 defaulted' do
         src = 'def simple(aarg, polly=2, yep=:truth, zero=nil) f(3);false end'
-        src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
+        expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
       end
     end
   end
@@ -85,10 +85,10 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the number of parameters' do
-      @warning.smell[LongParameterList::PARAMETER_COUNT_KEY].should == 4
+      expect(@warning.smell[LongParameterList::PARAMETER_COUNT_KEY]).to eq(4)
     end
     it 'reports the line number of the method' do
-      @warning.lines.should == [1]
+      expect(@warning.lines).to eq([1])
     end
   end
 end

data/spec/reek/smells/long_yield_list_spec.rb

@@ -18,19 +18,19 @@ describe LongYieldList do
   context 'yield' do
     it 'should not report yield with no parameters' do
       src = 'def simple(arga, argb, &blk) f(3);yield; end'
-      src.should_not smell_of(LongYieldList)
+      expect(src).not_to smell_of(LongYieldList)
     end
     it 'should not report yield with few parameters' do
       src = 'def simple(arga, argb, &blk) f(3);yield a,b; end'
-      src.should_not smell_of(LongYieldList)
+      expect(src).not_to smell_of(LongYieldList)
     end
     it 'should report yield with many parameters' do
       src = 'def simple(arga, argb, &blk) f(3);yield arga,argb,arga,argb; end'
-      src.should smell_of(LongYieldList, LongYieldList::PARAMETER_COUNT_KEY => 4)
+      expect(src).to smell_of(LongYieldList, LongYieldList::PARAMETER_COUNT_KEY => 4)
     end
     it 'should not report yield of a long expression' do
       src = 'def simple(arga, argb, &blk) f(3);yield(if @dec then argb else 5+3 end); end'
-      src.should_not smell_of(LongYieldList)
+      expect(src).not_to smell_of(LongYieldList)
     end
   end
 
@@ -50,8 +50,8 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      @warning.smell['parameter_count'].should == 4
-      @warning.lines.should == [3]
+      expect(@warning.smell['parameter_count']).to eq(4)
+      expect(@warning.lines).to eq([3])
     end
   end
 end

data/spec/reek/smells/nested_iterators_spec.rb

@@ -9,20 +9,20 @@ describe NestedIterators do
   context 'with no iterators' do
     it 'reports no smells' do
       src = 'def fred() nothing = true; end'
-      src.should_not smell_of(NestedIterators)
+      expect(src).not_to smell_of(NestedIterators)
     end
   end
 
   context 'with one iterator' do
     it 'reports no smells' do
       src = 'def fred() nothing.each {|item| item}; end'
-      src.should_not smell_of(NestedIterators)
+      expect(src).not_to smell_of(NestedIterators)
     end
   end
 
   it 'should report nested iterators in a method' do
     src = 'def bad(fred) @fred.each {|item| item.each {|ting| ting.ting} } end'
-    src.should smell_of(NestedIterators)
+    expect(src).to smell_of(NestedIterators)
   end
 
   it 'should not report method with successive iterators' do
@@ -32,7 +32,7 @@ def bad(fred)
   @jim.each {|ting| ting.each }
 end
 EOS
-    src.should_not smell_of(NestedIterators)
+    expect(src).not_to smell_of(NestedIterators)
   end
 
   it 'should not report method with chained iterators' do
@@ -41,7 +41,7 @@ def chained
   @sig.keys.sort_by { |xray| xray.to_s }.each { |min| md5 << min.to_s }
 end
 EOS
-    src.should_not smell_of(NestedIterators)
+    expect(src).not_to smell_of(NestedIterators)
   end
 
   it 'should report nested iterators only once per method' do
@@ -51,7 +51,7 @@ def bad(fred)
   @jim.each {|ting| ting.each {|piece| @hal.send} }
 end
 EOS
-    src.should smell_of(NestedIterators, {})
+    expect(src).to smell_of(NestedIterators, {})
   end
 
   it 'reports nested iterators only once per method even if levels are different' do
@@ -61,7 +61,7 @@ EOS
         @jim.each {|ting| ting.each {|piece| piece.each {|atom| atom.foo } } }
       end
     EOS
-    src.should smell_of(NestedIterators, {})
+    expect(src).to smell_of(NestedIterators, {})
   end
 
   it 'reports nesting inside iterator arguments' do
@@ -76,7 +76,7 @@ EOS
         ) { |qux| qux.quuz }
       end
     EOS
-    src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2)
+    expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2)
   end
 
   it 'reports the deepest level of nesting only' do
@@ -89,12 +89,12 @@ EOS
         }
       end
     EOS
-    src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 3)
+    expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 3)
   end
 
   context 'when the allowed nesting depth is 3' do
     before :each do
-      @config = {NestedIterators::MAX_ALLOWED_NESTING_KEY => 3}
+      @config = { NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 }
     end
 
     it 'should not report nested iterators 2 levels deep' do
@@ -103,7 +103,7 @@ def bad(fred)
   @fred.each {|one| one.each {|two| two.two} }
 end
 EOS
-      src.should_not smell_of(NestedIterators).with_config(@config)
+      expect(src).not_to smell_of(NestedIterators).with_config(@config)
     end
 
     it 'should not report nested iterators 3 levels deep' do
@@ -112,7 +112,7 @@ def bad(fred)
   @fred.each {|one| one.each {|two| two.each {|three| three.three} } }
 end
 EOS
-      src.should_not smell_of(NestedIterators).with_config(@config)
+      expect(src).not_to smell_of(NestedIterators).with_config(@config)
     end
 
     it 'should report nested iterators 4 levels deep' do
@@ -121,38 +121,38 @@ def bad(fred)
   @fred.each {|one| one.each {|two| two.each {|three| three.each {|four| four.four} } } }
 end
 EOS
-      src.should smell_of(NestedIterators).with_config(@config)
+      expect(src).to smell_of(NestedIterators).with_config(@config)
     end
   end
 
   context 'when ignoring iterators' do
     before :each do
-      @config = {NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me']}
+      @config = { NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] }
     end
 
     it 'should not report nesting the ignored iterator inside another' do
       src = 'def bad(fred) @fred.each {|item| item.ignore_me {|ting| ting.ting} } end'
-      src.should_not smell_of(NestedIterators).with_config(@config)
+      expect(src).not_to smell_of(NestedIterators).with_config(@config)
     end
 
     it 'should not report nesting inside the ignored iterator' do
       src = 'def bad(fred) @fred.ignore_me {|item| item.each {|ting| ting.ting} } end'
-      src.should_not smell_of(NestedIterators).with_config(@config)
+      expect(src).not_to smell_of(NestedIterators).with_config(@config)
     end
 
     it 'should report nested iterators inside the ignored iterator' do
       src = 'def bad(fred) @fred.ignore_me {|item| item.each {|ting| ting.each {|other| other.other} } } end'
-      src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+      expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
     end
 
     it 'should report nested iterators outside the ignored iterator' do
       src = 'def bad(fred) @fred.each {|item| item.each {|ting| ting.ignore_me {|other| other.other} } } end'
-      src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+      expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
     end
 
     it 'should report nested iterators with the ignored iterator between them' do
       src = 'def bad(fred) @fred.each {|item| item.ignore_me {|ting| ting.ting {|other| other.other} } } end'
-      src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+      expect(src).to smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
     end
   end
 end
@@ -181,8 +181,8 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports correct values' do
-      @warning.smell[NestedIterators::NESTING_DEPTH_KEY].should == 2
-      @warning.lines.should == [3]
+      expect(@warning.smell[NestedIterators::NESTING_DEPTH_KEY]).to eq(2)
+      expect(@warning.lines).to eq([3])
     end
   end
 end

data/spec/reek/smells/nil_check_spec.rb

@@ -18,14 +18,14 @@ describe NilCheck do
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       detector = NilCheck.new('source_name')
       smells = detector.examine_context(ctx)
-      smells[0].lines.should eq [2]
+      expect(smells[0].lines).to eq [2]
     end
 
-    it 'should report nothing when scope includes no nil checks' do
-      'def no_nils; end'.should_not smell_of(NilCheck)
+    it 'reports nothing when scope includes no nil checks' do
+      expect('def no_nils; end').not_to smell_of(NilCheck)
     end
 
-    it 'should report when scope uses multiple nil? methods' do
+    it 'reports when scope uses multiple nil? methods' do
       src = <<-eos
       def chk_multi_nil(para)
         para.nil?
@@ -33,26 +33,24 @@ describe NilCheck do
         \"\".nil?
       end
       eos
-      src.should smell_of(NilCheck,
-                          {NilCheck => nil}, {NilCheck => nil})
+      expect(src).to smell_of(NilCheck, {}, {})
     end
 
-    it 'should report twice when scope uses == nil and === nil' do
-      src= <<-eos
+    it 'reports twice when scope uses == nil and === nil' do
+      src = <<-eos
       def chk_eq_nil(para)
         para == nil
         para === nil
       end
       eos
-      src.should smell_of(NilCheck,
-                          {NilCheck => nil}, {NilCheck => nil})
+      expect(src).to smell_of(NilCheck, {}, {})
     end
 
-    it 'should report when scope uses nil ==' do
-      'def chk_eq_nil_rev(para); nil == para; end'.should smell_of(NilCheck)
+    it 'reports when scope uses nil ==' do
+      expect('def chk_eq_nil_rev(para); nil == para; end').to smell_of(NilCheck)
     end
 
-    it 'should report when scope uses multiple case-clauses checking nil' do
+    it 'reports when scope uses multiple case-clauses checking nil' do
       src = <<-eos
       def case_nil
         case @inst_var
@@ -65,8 +63,18 @@ describe NilCheck do
         end
       end
       eos
-      src.should smell_of(NilCheck,
-                          {NilCheck => nil}, {NilCheck => nil})
+      expect(src).to smell_of(NilCheck, {}, {})
+    end
+
+    it 'reports a when clause that checks nil and other values' do
+      src = <<-eos
+      def case_nil
+        case @inst_var
+        when nil, false then puts "Hello"
+        end
+      end
+      eos
+      expect(src).to smell_of(NilCheck)
     end
   end
 end

data/spec/reek/smells/prima_donna_method_spec.rb

@@ -7,11 +7,11 @@ include Reek::Smells
 
 describe PrimaDonnaMethod do
   it 'should report nothing when method and bang counterpart exist' do
-    'class C; def m; end; def m!; end; end'.should_not smell_of(PrimaDonnaMethod)
+    expect('class C; def m; end; def m!; end; end').not_to smell_of(PrimaDonnaMethod)
   end
 
   it 'should report PrimaDonnaMethod when only bang method exists' do
-    'class C; def m!; end; end'.should smell_of(PrimaDonnaMethod)
+    expect('class C; def m!; end; end').to smell_of(PrimaDonnaMethod)
   end
 
   describe 'the right smell' do
@@ -23,9 +23,9 @@ describe PrimaDonnaMethod do
       smells = detector.examine_context(ctx)
       warning = smells[0]
 
-      warning.smell['class'].should    == 'PrimaDonnaMethod'
-      warning.smell['subclass'].should == 'PrimaDonnaMethod'
-      warning.lines.should             == [1]
+      expect(warning.smell['class']).to eq('PrimaDonnaMethod')
+      expect(warning.smell['subclass']).to eq('PrimaDonnaMethod')
+      expect(warning.lines).to eq([1])
     end
   end
 end

data/spec/reek/smells/repeated_conditional_spec.rb

@@ -18,7 +18,7 @@ describe RepeatedConditional do
     it 'gathers an empty hash' do
       ast = 'module Stable; end'.to_reek_source.syntax_tree
       ctx = CodeContext.new(nil, ast)
-      @detector.conditional_counts(ctx).length.should == 0
+      expect(@detector.conditional_counts(ctx).length).to eq(0)
     end
   end
 
@@ -26,7 +26,7 @@ describe RepeatedConditional do
     it 'does not record the condition' do
       ast = 'def fred() yield(3) if block_given?; end'.to_reek_source.syntax_tree
       ctx = CodeContext.new(nil, ast)
-      @detector.conditional_counts(ctx).length.should == 0
+      expect(@detector.conditional_counts(ctx).length).to eq(0)
     end
   end
 
@@ -34,7 +34,7 @@ describe RepeatedConditional do
     it 'does not record the condition' do
       ast = 'def fred() case; when 3; end; end'.to_reek_source.syntax_tree
       ctx = CodeContext.new(nil, ast)
-      @detector.conditional_counts(ctx).length.should == 0
+      expect(@detector.conditional_counts(ctx).length).to eq(0)
     end
   end
 
@@ -64,10 +64,10 @@ EOS
       @conds = @detector.conditional_counts(@ctx)
     end
     it 'finds both conditionals' do
-      @conds.length.should == 2
+      expect(@conds.length).to eq(2)
     end
     it 'knows there are three copies' do
-      @conds[@cond_expr].length.should == 3
+      expect(@conds[@cond_expr].length).to eq(3)
     end
 
     context 'looking at the YAML' do
@@ -77,22 +77,22 @@ EOS
         @yaml = warning.to_yaml
       end
       it 'reports the source' do
-        @yaml.should match(/source:\s*#{@source_name}/)
+        expect(@yaml).to match(/source:\s*#{@source_name}/)
       end
       it 'reports the class' do
-        @yaml.should match(/class:\s*SimulatedPolymorphism/)
+        expect(@yaml).to match(/class:\s*SimulatedPolymorphism/)
       end
       it 'reports the subclass' do
-        @yaml.should match(/subclass:\s*RepeatedConditional/)
+        expect(@yaml).to match(/subclass:\s*RepeatedConditional/)
       end
       it 'reports the expression' do
-        @yaml.should match(/expression:\s*"?\(#{@cond}\)"?/)
+        expect(@yaml).to match(/expression:\s*"?\(#{@cond}\)"?/)
       end
       it 'reports the number of occurrences' do
-        @yaml.should match(/occurrences:\s*3/)
+        expect(@yaml).to match(/occurrences:\s*3/)
       end
       it 'reports the referring lines' do
-        @yaml.should match(/lines:\s*- 4\s*- 7\s*- 12/)
+        expect(@yaml).to match(/lines:\s*- 4\s*- 7\s*- 12/)
       end
     end
   end
@@ -120,13 +120,13 @@ EOS
       @conds = @detector.conditional_counts(ctx)
     end
     it 'finds exactly one conditional' do
-      @conds.length.should == 1
+      expect(@conds.length).to eq(1)
     end
     it 'returns the condition expr' do
-      @conds.keys[0].should == @cond_expr
+      expect(@conds.keys[0]).to eq(@cond_expr)
     end
     it 'knows there are three copies' do
-      @conds[@cond_expr].length.should == 2
+      expect(@conds[@cond_expr].length).to eq(2)
     end
   end