reek 1.6.6 → 2.0.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
-    expect(src).not_to smell_of(DataClump)
+    expect(src).not_to reek_of(DataClump)
   end
 
   context 'with 3 identical pairs' do
@@ -62,9 +62,9 @@ EOS
   def tri(pa, pb) pa - pb + @fred; end
 end
 EOS
-    expect(src).to smell_of(DataClump,
-                            count: 3,
-                            parameters: ['pa', 'pb'])
+    expect(src).to reek_of(DataClump,
+                           count: 3,
+                           parameters: ['pa', 'pb'])
   end
 
   it 'reports 3 identical parameter sets' do
@@ -75,9 +75,9 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-    expect(src).to smell_of(DataClump,
-                            count: 3,
-                            parameters: ['pa', 'pb', 'pc'])
+    expect(src).to reek_of(DataClump,
+                           count: 3,
+                           parameters: ['pa', 'pb', 'pc'])
   end
 
   it 'reports re-ordered identical parameter sets' do
@@ -88,9 +88,9 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-    expect(src).to smell_of(DataClump,
-                            count: 3,
-                            parameters: ['pa', 'pb', 'pc'])
+    expect(src).to reek_of(DataClump,
+                           count: 3,
+                           parameters: ['pa', 'pb', 'pc'])
   end
 
   it 'counts only identical parameter sets' do
@@ -101,7 +101,7 @@ EOS
   def fc(name, windowW, windowH) end
 end
 EOS
-    expect(src).not_to smell_of(DataClump)
+    expect(src).not_to reek_of(DataClump)
   end
 
   it 'gets a real example right' do
@@ -114,7 +114,7 @@ EOS
   def c_raw_singleton (src, options) end
 end
 EOS
-    expect(src).to smell_of(DataClump, count: 5)
+    expect(src).to reek_of(DataClump, count: 5)
   end
 
   it 'correctly checks number of occurences' do
@@ -127,7 +127,7 @@ EOS
         def fe(p5, p1, p2) end
       end
     EOS
-    expect(src).not_to smell_of(DataClump)
+    expect(src).not_to reek_of(DataClump)
   end
 
   it 'detects clumps smaller than the total number of arguments' do
@@ -138,8 +138,8 @@ EOS
         def fc(p4, p1, p2) end
       end
     EOS
-    expect(src).to smell_of(DataClump,
-                            parameters: %w(p1 p2))
+    expect(src).to reek_of(DataClump,
+                           parameters: %w(p1 p2))
   end
 
   it 'ignores anonymous parameters' do
@@ -150,8 +150,8 @@ EOS
         def fc(p1, p2, *) end
       end
     EOS
-    expect(src).to smell_of(DataClump,
-                            parameters: %w(p1 p2))
+    expect(src).to reek_of(DataClump,
+                           parameters: %w(p1 p2))
   end
 end
 

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -12,13 +12,13 @@ describe DuplicateMethodCall do
     before :each do
       @source_name = 'copy-cat'
       @detector = DuplicateMethodCall.new(@source_name)
-      src = <<EOS
-def double_thing(other)
-  other[@thing]
-  not_the_sam(at = all)
-  other[@thing]
-end
-EOS
+      src = <<-EOS
+        def double_thing(other)
+          other[@thing]
+          not_the_sam(at = all)
+          other[@thing]
+        end
+      EOS
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
@@ -39,24 +39,28 @@ EOS
   context 'with repeated method calls' do
     it 'reports repeated call' do
       src = 'def double_thing() @other.thing + @other.thing end'
-      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing')
+      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
     end
+
     it 'reports repeated call to lvar' do
       src = 'def double_thing(other) other[@thing] + other[@thing] end'
-      expect(src).to smell_of(DuplicateMethodCall, name: 'other[@thing]')
+      expect(src).to reek_of(DuplicateMethodCall, name: 'other[@thing]')
     end
+
     it 'reports call parameters' do
       src = 'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'
-      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing(2, 3)')
+      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing(2, 3)')
     end
+
     it 'should report nested calls' do
       src = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-      expect(src).to smell_of(DuplicateMethodCall, { name: '@other.thing' },
-                              { name: '@other.thing.foo' })
+      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
+      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing.foo')
     end
+
     it 'should ignore calls to new' do
       src = 'def double_thing() @other.new + @other.new end'
-      expect(src).not_to smell_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(DuplicateMethodCall)
     end
   end
 
@@ -72,7 +76,7 @@ EOS
           end
         end
       EOS
-      expect(src).not_to smell_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(DuplicateMethodCall)
     end
   end
 
@@ -84,7 +88,7 @@ EOS
           bar { baz }
         end
       EOS
-      expect(src).to smell_of(DuplicateMethodCall)
+      expect(src).to reek_of(DuplicateMethodCall)
     end
 
     it 'reports no smell if the blocks are different' do
@@ -94,7 +98,7 @@ EOS
           bar { qux }
         end
       EOS
-      expect(src).not_to smell_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(DuplicateMethodCall)
     end
   end
 
@@ -106,7 +110,7 @@ EOS
           bar.qux { baz }
         end
       EOS
-      expect(src).to smell_of(DuplicateMethodCall)
+      expect(src).to reek_of(DuplicateMethodCall)
     end
 
     it 'reports a smell if the blocks are different' do
@@ -116,14 +120,14 @@ EOS
           bar.qux { qux }
         end
       EOS
-      expect(src).to smell_of(DuplicateMethodCall)
+      expect(src).to reek_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'
-      expect(src).to smell_of(DuplicateMethodCall, name: '@other[thing] = true')
+      expect(src).to reek_of(DuplicateMethodCall, name: '@other[thing] = true')
     end
     it 'does not report multi-assignments' do
       src = <<EOS
@@ -132,61 +136,80 @@ def _parse ctxt
   error, ctxt.index = @err, @err_ind
 end
 EOS
-      expect(src).not_to smell_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(DuplicateMethodCall)
     end
   end
 
   context 'non-repeated method calls' do
     it 'should not report similar calls' do
       src = 'def equals(other) other.thing == self.thing end'
-      expect(src).not_to smell_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(DuplicateMethodCall)
     end
     it 'should respect call parameters' do
       src = 'def double_thing() @other.thing(3) + @other.thing(2) end'
-      expect(src).not_to smell_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(DuplicateMethodCall)
     end
   end
 
   context 'allowing up to 3 calls' do
     before :each do
-      @config = { DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 }
+      @config = { DuplicateMethodCall: { DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 } }
     end
+
     it 'does not report double calls' do
       src = 'def double_thing() @other.thing + @other.thing end'
-      expect(src).not_to smell_of(DuplicateMethodCall).with_config(@config)
+      with_test_config(@config) do
+        expect(src).not_to reek_of(DuplicateMethodCall)
+      end
     end
+
     it 'does not report triple calls' do
       src = 'def double_thing() @other.thing + @other.thing + @other.thing end'
-      expect(src).not_to smell_of(DuplicateMethodCall).with_config(@config)
+      with_test_config(@config) do
+        expect(src).not_to reek_of(DuplicateMethodCall)
+      end
     end
+
     it 'reports quadruple calls' do
       src = '
         def double_thing()
           @other.thing + @other.thing + @other.thing + @other.thing
         end
       '
-      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing', count: 4).
-        with_config(@config)
+      with_test_config(@config) do
+        expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing', count: 4)
+      end
     end
   end
 
   context 'allowing calls to some methods' do
     before :each do
-      @config = { DuplicateMethodCall::ALLOW_CALLS_KEY => ['@some.thing', /puts/] }
+      @config = { DuplicateMethodCall:
+                  { 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'
-      expect(src).not_to smell_of(DuplicateMethodCall).with_config(@config)
+
+      with_test_config(@config) do
+        expect(src).not_to reek_of(DuplicateMethodCall)
+      end
     end
+
     it 'reports calls to other methods' do
       src = 'def double_other_thing() @other.thing + @other.thing end'
-      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing').
-        with_config(@config)
+
+      with_test_config(@config) do
+        expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
+      end
     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'
-      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing').
-        with_config(@config)
+
+      with_test_config(@config) do
+        expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
+      end
     end
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

@@ -10,60 +10,64 @@ describe FeatureEnvy do
     it 'should not report use of self' do
       expect('def simple() self.to_s + self.to_i end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report vcall with no argument' do
       expect('def simple() func; end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report single use' do
       expect('def no_envy(arga) arga.barg(@item) end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report return value' do
       expect('def no_envy(arga) arga.barg(@item); arga end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should ignore global variables' do
       expect('def no_envy() $s2.to_a; $s2[@item] end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report class methods' do
       expect('def simple() self.class.new.flatten_merge(self) end').
         not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report single use of an ivar' do
       expect('def no_envy() @item.to_a end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report returning an ivar' do
       expect('def no_envy() @item.to_a; @item end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report ivar usage in a parameter' do
       expect('def no_envy() @item.price + tax(@item) - savings(@item) end').
         not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report single use of an lvar' do
       expect('def no_envy() lv = @item; lv.to_a end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'should not report returning an lvar' do
       expect('def no_envy() lv = @item; lv.to_a; lv end').not_to reek_of(:FeatureEnvy)
     end
+
     it 'ignores lvar usage in a parameter' do
       expect('def no_envy() lv = @item; lv.price + tax(lv) - savings(lv); end').
         not_to reek_of(:FeatureEnvy)
     end
+
     it 'ignores multiple ivars' do
-      src = <<EOS
-  def func
-    @other.a
-    @other.b
-    @nother.c
-    @nother.d
-  end
-EOS
+      src = <<-EOS
+        def func
+          @other.a
+          @other.b
+          @nother.c
+          @nother.d
+        end
+      EOS
       expect(src).not_to reek_of(:FeatureEnvy)
-      #
-      # def other.func(me)
-      #   a
-      #   b
-      #   me.nother_c
-      #   me.nother_d
-      # end
-      #
     end
   end
 
@@ -73,34 +77,34 @@ EOS
         def envy(arga)
           arga.b(arga) + arga.c(@fred)
         end
-      ').to reek_only_of(:FeatureEnvy, /arga/)
+      ').to reek_only_of(:FeatureEnvy)
     end
   end
 
   it 'should report highest affinity' do
-    src = <<EOS
-def total_envy
-  fred = @item
-  total = 0
-  total += fred.price
-  total += fred.tax
-  total *= 1.15
-end
-EOS
-    expect(src).to reek_only_of(:FeatureEnvy, /total/)
+    src = <<-EOS
+      def total_envy
+        fred = @item
+        total = 0
+        total += fred.price
+        total += fred.tax
+        total *= 1.15
+      end
+      EOS
+    expect(src).to reek_only_of(:FeatureEnvy)
   end
 
   it 'should report multiple affinities' do
-    src = <<EOS
-def total_envy
-  fred = @item
-  total = 0
-  total += fred.price
-  total += fred.tax
-end
-EOS
-    expect(src).to reek_of(:FeatureEnvy, /total/)
-    expect(src).to reek_of(:FeatureEnvy, /fred/)
+    src = <<-EOS
+      def total_envy
+        fred = @item
+        total = 0
+        total += fred.price
+        total += fred.tax
+      end
+      EOS
+    expect(src).to reek_of(:FeatureEnvy,  name: 'total')
+    expect(src).to reek_of(:FeatureEnvy,  name: 'fred')
   end
 
   it 'should not be fooled by duplication' do
@@ -109,7 +113,7 @@ EOS
         @cow.feed_to(thing.pig)
         @duck.feed_to(thing.pig)
       end
-    ').to reek_only_of(:Duplication, /thing.pig/)
+    ').to reek_only_of(:Duplication)
   end
 
   it 'should count local calls' do
@@ -118,7 +122,7 @@ EOS
         cow.feed_to(thing.pig)
         duck.feed_to(thing.pig)
       end
-    ').to reek_only_of(:Duplication, /thing.pig/)
+    ').to reek_only_of(:Duplication)
   end
 
   it 'should report many calls to lvar' do
@@ -127,7 +131,7 @@ EOS
         lv = @item
         lv.price + lv.tax
       end
-    ').to reek_only_of(:FeatureEnvy, /lv/)
+    ').to reek_only_of(:FeatureEnvy)
     #
     # def moved_version
     #   price + tax