reek 1.3.8 → 1.4.0

data/spec/reek/smells/data_clump_spec.rb

@@ -14,7 +14,7 @@ shared_examples_for 'a data clump detector' do
   def third(pa) pa - pb + @fred; end
 end
 EOS
-    src.should_not smell_of(DataClump)
+    expect(src).not_to smell_of(DataClump)
   end
 
   context 'with 3 identical pairs' do
@@ -34,25 +34,25 @@ EOS
       @yaml = @warning.to_yaml
     end
     it 'records only the one smell' do
-      @smells.length.should == 1
+      expect(@smells.length).to eq(1)
     end
     it 'reports all parameters' do
-      @smells[0].smell[DataClump::PARAMETERS_KEY].should == ['pa', 'pb']
+      expect(@smells[0].smell[DataClump::PARAMETERS_KEY]).to eq(['pa', 'pb'])
     end
     it 'reports the number of occurrences' do
-      @smells[0].smell[DataClump::OCCURRENCES_KEY].should == 3
+      expect(@smells[0].smell[DataClump::OCCURRENCES_KEY]).to eq(3)
     end
     it 'reports all methods' do
-      @smells[0].smell[DataClump::METHODS_KEY].should == ['first', 'second', 'third']
+      expect(@smells[0].smell[DataClump::METHODS_KEY]).to eq(['first', 'second', 'third'])
     end
     it 'reports the declaration line numbers' do
-      @smells[0].lines.should == [2,3,4]
+      expect(@smells[0].lines).to eq([2, 3, 4])
     end
     it 'reports the correct smell class' do
-      @smells[0].smell_class.should == DataClump::SMELL_CLASS
+      expect(@smells[0].smell_class).to eq(DataClump::SMELL_CLASS)
     end
     it 'reports the context fq name' do
-      @smells[0].context.should == @module_name
+      expect(@smells[0].context).to eq(@module_name)
     end
   end
 
@@ -64,8 +64,9 @@ EOS
   def tri(pa, pb) pa - pb + @fred; end
 end
 EOS
-    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
-      DataClump::PARAMETERS_KEY => ['pa', 'pb']})
+    expect(src).to smell_of(DataClump,
+                            DataClump::OCCURRENCES_KEY => 3,
+                            DataClump::PARAMETERS_KEY => ['pa', 'pb'])
   end
 
   it 'reports 3 identical parameter sets' do
@@ -76,8 +77,9 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
-      DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc']})
+    expect(src).to smell_of(DataClump,
+                            DataClump::OCCURRENCES_KEY => 3,
+                            DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc'])
   end
 
   it 'reports re-ordered identical parameter sets' do
@@ -88,8 +90,9 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
-      DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc']})
+    expect(src).to smell_of(DataClump,
+                            DataClump::OCCURRENCES_KEY => 3,
+                            DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc'])
   end
 
   it 'counts only identical parameter sets' do
@@ -100,7 +103,7 @@ EOS
   def fc(name, windowW, windowH) end
 end
 EOS
-    src.should_not smell_of(DataClump)
+    expect(src).not_to smell_of(DataClump)
   end
 
   it 'gets a real example right' do
@@ -113,7 +116,7 @@ EOS
   def c_raw_singleton (src, options) end
 end
 EOS
-    src.should smell_of(DataClump, DataClump::OCCURRENCES_KEY => 5)
+    expect(src).to smell_of(DataClump, DataClump::OCCURRENCES_KEY => 5)
   end
 
   it 'correctly checks number of occurences' do
@@ -126,7 +129,7 @@ EOS
         def fe(p5, p1, p2) end
       end
     EOS
-    src.should_not smell_of(DataClump)
+    expect(src).not_to smell_of(DataClump)
   end
 
   it 'detects clumps smaller than the total number of arguments' do
@@ -137,8 +140,8 @@ EOS
         def fc(p4, p1, p2) end
       end
     EOS
-    src.should smell_of(DataClump,
-                        { DataClump::PARAMETERS_KEY => %w(p1 p2) })
+    expect(src).to smell_of(DataClump,
+                            DataClump::PARAMETERS_KEY => %w(p1 p2))
   end
 end
 

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -22,7 +22,7 @@ end
 EOS
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
-      smells.length.should == 1
+      expect(smells.length).to eq(1)
       @warning = smells[0]
     end
 
@@ -30,38 +30,38 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the call' do
-      @warning.smell[DuplicateMethodCall::CALL_KEY].should == 'other[@thing]'
+      expect(@warning.smell[DuplicateMethodCall::CALL_KEY]).to eq('other[@thing]')
     end
     it 'reports the correct lines' do
-      @warning.lines.should == [2,4]
+      expect(@warning.lines).to eq([2, 4])
     end
   end
 
-  context "with repeated method calls" do
+  context 'with repeated method calls' do
     it 'reports repeated call' do
       src = 'def double_thing() @other.thing + @other.thing end'
-      src.should smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing')
+      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing')
     end
     it 'reports repeated call to lvar' do
       src = 'def double_thing(other) other[@thing] + other[@thing] end'
-      src.should smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => 'other[@thing]')
+      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => 'other[@thing]')
     end
     it 'reports call parameters' do
       src = 'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'
-      src.should smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing(2, 3)')
+      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing(2, 3)')
     end
     it 'should report nested calls' do
       src = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-      src.should smell_of(DuplicateMethodCall, {DuplicateMethodCall::CALL_KEY => '@other.thing'},
-                                       {DuplicateMethodCall::CALL_KEY => '@other.thing.foo'})
+      expect(src).to smell_of(DuplicateMethodCall, { DuplicateMethodCall::CALL_KEY => '@other.thing' },
+                              DuplicateMethodCall::CALL_KEY => '@other.thing.foo')
     end
     it 'should ignore calls to new' do
       src = 'def double_thing() @other.new + @other.new end'
-      src.should_not smell_of(DuplicateMethodCall)
+      expect(src).not_to smell_of(DuplicateMethodCall)
     end
   end
 
-  context "with repeated simple method calls" do
+  context 'with repeated simple method calls' do
     it 'reports no smell' do
       src = <<-EOS
         def foo
@@ -73,14 +73,58 @@ EOS
           end
         end
       EOS
-      src.should_not smell_of(DuplicateMethodCall)
+      expect(src).not_to smell_of(DuplicateMethodCall)
+    end
+  end
+
+  context 'with repeated simple method calls with blocks' do
+    it 'reports a smell if the blocks are identical' do
+      src = <<-EOS
+        def foo
+          bar { baz }
+          bar { baz }
+        end
+      EOS
+      expect(src).to smell_of(DuplicateMethodCall)
+    end
+
+    it 'reports no smell if the blocks are different' do
+      src = <<-EOS
+        def foo
+          bar { baz }
+          bar { qux }
+        end
+      EOS
+      expect(src).not_to smell_of(DuplicateMethodCall)
+    end
+  end
+
+  context 'with repeated method calls with receivers with blocks' do
+    it 'reports a smell if the blocks are identical' do
+      src = <<-EOS
+        def foo
+          bar.qux { baz }
+          bar.qux { baz }
+        end
+      EOS
+      expect(src).to smell_of(DuplicateMethodCall)
+    end
+
+    it 'reports a smell if the blocks are different' do
+      src = <<-EOS
+        def foo
+          bar.qux { baz }
+          bar.qux { qux }
+        end
+      EOS
+      expect(src).to smell_of(DuplicateMethodCall)
     end
   end
 
   context 'with repeated attribute assignment' do
     it 'reports repeated assignment' do
       src = 'def double_thing(thing) @other[thing] = true; @other[thing] = true; end'
-      src.should smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other[thing] = true')
+      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other[thing] = true')
     end
     it 'does not report multi-assignments' do
       src = <<EOS
@@ -89,54 +133,54 @@ def _parse ctxt
   error, ctxt.index = @err, @err_ind
 end
 EOS
-      src.should_not smell_of(DuplicateMethodCall)
+      expect(src).not_to smell_of(DuplicateMethodCall)
     end
   end
 
-  context "non-repeated method calls" do
+  context 'non-repeated method calls' do
     it 'should not report similar calls' do
       src = 'def equals(other) other.thing == self.thing end'
-      src.should_not smell_of(DuplicateMethodCall)
+      expect(src).not_to smell_of(DuplicateMethodCall)
     end
     it 'should respect call parameters' do
       src = 'def double_thing() @other.thing(3) + @other.thing(2) end'
-      src.should_not smell_of(DuplicateMethodCall)
+      expect(src).not_to smell_of(DuplicateMethodCall)
     end
   end
 
-  context "allowing up to 3 calls" do
+  context 'allowing up to 3 calls' do
     before :each do
-      @config = {DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3}
+      @config = { DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 }
     end
     it 'does not report double calls' do
       src = 'def double_thing() @other.thing + @other.thing end'
-      src.should_not smell_of(DuplicateMethodCall).with_config(@config)
+      expect(src).not_to smell_of(DuplicateMethodCall).with_config(@config)
     end
     it 'does not report triple calls' do
       src = 'def double_thing() @other.thing + @other.thing + @other.thing end'
-      src.should_not smell_of(DuplicateMethodCall).with_config(@config)
+      expect(src).not_to smell_of(DuplicateMethodCall).with_config(@config)
     end
     it 'reports quadruple calls' do
       src = 'def double_thing() @other.thing + @other.thing + @other.thing + @other.thing end'
-      src.should smell_of(DuplicateMethodCall, {DuplicateMethodCall::CALL_KEY => '@other.thing', DuplicateMethodCall::OCCURRENCES_KEY => 4}).with_config(@config)
+      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing', DuplicateMethodCall::OCCURRENCES_KEY => 4).with_config(@config)
     end
   end
 
-  context "allowing calls to some methods" do
+  context 'allowing calls to some methods' do
     before :each do
-      @config = {DuplicateMethodCall::ALLOW_CALLS_KEY => ['@some.thing',/puts/]}
+      @config = { DuplicateMethodCall::ALLOW_CALLS_KEY => ['@some.thing', /puts/] }
     end
     it 'does not report calls to some methods' do
       src = 'def double_some_thing() @some.thing + @some.thing end'
-      src.should_not smell_of(DuplicateMethodCall).with_config(@config)
+      expect(src).not_to smell_of(DuplicateMethodCall).with_config(@config)
     end
     it 'reports calls to other methods' do
       src = 'def double_other_thing() @other.thing + @other.thing end'
-      src.should smell_of(DuplicateMethodCall, {DuplicateMethodCall::CALL_KEY => '@other.thing'}).with_config(@config)
+      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing').with_config(@config)
     end
     it 'does not report calls to methods specifed with a regular expression' do
       src = 'def double_puts() puts @other.thing; puts @other.thing end'
-      src.should smell_of(DuplicateMethodCall, {DuplicateMethodCall::CALL_KEY => '@other.thing'}).with_config(@config)
+      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing').with_config(@config)
     end
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

@@ -8,40 +8,40 @@ include Reek::Smells
 describe FeatureEnvy do
   context 'with no smell' do
     it 'should not report use of self' do
-      'def simple() self.to_s + self.to_i end'.should_not reek
+      expect('def simple() self.to_s + self.to_i end').not_to reek
     end
     it 'should not report vcall with no argument' do
-      'def simple() func; end'.should_not reek
+      expect('def simple() func; end').not_to reek
     end
     it 'should not report single use' do
-      'def no_envy(arga) arga.barg(@item) end'.should_not reek
+      expect('def no_envy(arga) arga.barg(@item) end').not_to reek
     end
     it 'should not report return value' do
-      'def no_envy(arga) arga.barg(@item); arga end'.should_not reek
+      expect('def no_envy(arga) arga.barg(@item); arga end').not_to reek
     end
     it 'should ignore global variables' do
-      'def no_envy() $s2.to_a; $s2[@item] end'.should_not reek
+      expect('def no_envy() $s2.to_a; $s2[@item] end').not_to reek
     end
     it 'should not report class methods' do
-      'def simple() self.class.new.flatten_merge(self) end'.should_not reek
+      expect('def simple() self.class.new.flatten_merge(self) end').not_to reek
     end
     it 'should not report single use of an ivar' do
-      'def no_envy() @item.to_a end'.should_not reek
+      expect('def no_envy() @item.to_a end').not_to reek
     end
     it 'should not report returning an ivar' do
-      'def no_envy() @item.to_a; @item end'.should_not reek
+      expect('def no_envy() @item.to_a; @item end').not_to reek
     end
     it 'should not report ivar usage in a parameter' do
-      'def no_envy() @item.price + tax(@item) - savings(@item) end'.should_not reek
+      expect('def no_envy() @item.price + tax(@item) - savings(@item) end').not_to reek
     end
     it 'should not report single use of an lvar' do
-      'def no_envy() lv = @item; lv.to_a end'.should_not reek
+      expect('def no_envy() lv = @item; lv.to_a end').not_to reek
     end
     it 'should not report returning an lvar' do
-      'def no_envy() lv = @item; lv.to_a; lv end'.should_not reek
+      expect('def no_envy() lv = @item; lv.to_a; lv end').not_to reek
     end
     it 'ignores lvar usage in a parameter' do
-      'def no_envy() lv = @item; lv.price + tax(lv) - savings(lv); end'.should_not reek
+      expect('def no_envy() lv = @item; lv.price + tax(lv) - savings(lv); end').not_to reek
     end
     it 'ignores multiple ivars' do
       src = <<EOS
@@ -52,7 +52,7 @@ describe FeatureEnvy do
     @nother.d
   end
 EOS
-      src.should_not reek
+      expect(src).not_to reek
       #
       # def other.func(me)
       #   a
@@ -66,7 +66,7 @@ EOS
 
   context 'with 2 calls to a parameter' do
     it 'reports the smell' do
-      'def envy(arga) arga.b(arga) + arga.c(@fred) end'.should reek_only_of(:FeatureEnvy, /arga/)
+      expect('def envy(arga) arga.b(arga) + arga.c(@fred) end').to reek_only_of(:FeatureEnvy, /arga/)
     end
   end
 
@@ -80,7 +80,7 @@ def total_envy
   total *= 1.15
 end
 EOS
-    src.should reek_only_of(:FeatureEnvy, /total/)
+    expect(src).to reek_only_of(:FeatureEnvy, /total/)
   end
 
   it 'should report multiple affinities' do
@@ -92,20 +92,20 @@ def total_envy
   total += fred.tax
 end
 EOS
-    src.should reek_of(:FeatureEnvy, /total/)
-    src.should reek_of(:FeatureEnvy, /fred/)
+    expect(src).to reek_of(:FeatureEnvy, /total/)
+    expect(src).to reek_of(:FeatureEnvy, /fred/)
   end
 
   it 'should not be fooled by duplication' do
-    'def feed(thing) @cow.feed_to(thing.pig); @duck.feed_to(thing.pig) end'.should reek_only_of(:Duplication, /thing.pig/)
+    expect('def feed(thing) @cow.feed_to(thing.pig); @duck.feed_to(thing.pig) end').to reek_only_of(:Duplication, /thing.pig/)
   end
 
   it 'should count local calls' do
-    'def feed(thing) cow.feed_to(thing.pig); duck.feed_to(thing.pig) end'.should reek_only_of(:Duplication, /thing.pig/)
+    expect('def feed(thing) cow.feed_to(thing.pig); duck.feed_to(thing.pig) end').to reek_only_of(:Duplication, /thing.pig/)
   end
 
   it 'should report many calls to lvar' do
-    'def envy() lv = @item; lv.price + lv.tax; end'.should reek_only_of(:FeatureEnvy, /lv/)
+    expect('def envy() lv = @item; lv.price + lv.tax; end').to reek_only_of(:FeatureEnvy, /lv/)
     #
     # def moved_version
     #   price + tax
@@ -117,7 +117,7 @@ EOS
   end
 
   it 'ignores frequent use of a call' do
-    'def func() other.a; other.b; nother.c end'.should_not reek_of(:FeatureEnvy)
+    expect('def func() other.a; other.b; nother.c end').not_to reek_of(:FeatureEnvy)
   end
 
   it 'counts self references correctly' do
@@ -130,7 +130,7 @@ def adopt(other)
   self
 end
 EOS
-    src.should_not reek
+    expect(src).not_to reek
   end
 end
 
@@ -147,7 +147,7 @@ def report
   @report
 end
 EOS
-    ruby.should_not reek
+    expect(ruby).not_to reek
   end
 
   it 'interprets << correctly' do
@@ -161,7 +161,7 @@ def report_on(report)
 end
 EOS
 
-    ruby.should_not reek
+    expect(ruby).not_to reek
   end
 end
 
@@ -190,26 +190,26 @@ EOS
       @smells = @detector.examine_context(@mctx)
     end
     it 'reports only that smell' do
-      @smells.length.should == 1
+      expect(@smells.length).to eq(1)
     end
     it 'reports the source' do
-      @smells[0].source.should == @source_name
+      expect(@smells[0].source).to eq(@source_name)
     end
     it 'reports the class' do
-      @smells[0].smell_class.should == FeatureEnvy::SMELL_CLASS
+      expect(@smells[0].smell_class).to eq(FeatureEnvy::SMELL_CLASS)
     end
     it 'reports the subclass' do
-      @smells[0].subclass.should == FeatureEnvy::SMELL_SUBCLASS
+      expect(@smells[0].subclass).to eq(FeatureEnvy::SMELL_SUBCLASS)
     end
     it 'reports the envious receiver' do
-      @smells[0].smell[FeatureEnvy::RECEIVER_KEY].should == @receiver
+      expect(@smells[0].smell[FeatureEnvy::RECEIVER_KEY]).to eq(@receiver)
     end
     it 'reports the number of references' do
-      @smells[0].smell[FeatureEnvy::REFERENCES_KEY].should == 3
+      expect(@smells[0].smell[FeatureEnvy::REFERENCES_KEY]).to eq(3)
     end
     it 'reports the referring lines' do
-      pending
-      @smells[0].lines.should == [2, 4, 5]
+      skip
+      expect(@smells[0].lines).to eq([2, 4, 5])
     end
   end
 end