reek 4.4.0 → 4.4.1

data/spec/reek/smells/data_clump_spec.rb

@@ -1,178 +1,123 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/data_clump'
-require_relative 'smell_detector_shared'
 
-RSpec.shared_examples_for 'a data clump detector' do
-  it 'does not report small parameter sets' do
+RSpec.describe Reek::Smells::DataClump do
+  it 'reports the right values' do
     src = <<-EOS
-      # test module
-      #{context} Scrunch
-        def first(pa) @field == :sym ? 0 : 3; end
-        def second(pa) @field == :sym; end
-        def third(pa) pa - pb + @fred; end
+      class Alfa
+        def bravo  (echo, foxtrot); end
+        def charlie(echo, foxtrot); end
+        def delta  (echo, foxtrot); end
       end
     EOS
-    expect(src).not_to reek_of(:DataClump)
-  end
-
-  context 'with 3 identical pairs' do
-    let(:module_name) { 'Scrunch' }
-    let(:smells) do
-      src = <<-EOS
-        #{context} #{module_name}
-          def first(pa, pb) @field == :sym ? 0 : 3; end
-          def second(pa, pb) @field == :sym; end
-          def third(pa, pb) pa - pb + @fred; end
-        end
-      EOS
-      ctx = Reek::Context::ModuleContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      build(:smell_detector, smell_type: :DataClump).sniff(ctx)
-    end
-
-    it 'records only the one smell' do
-      expect(smells.length).to eq(1)
-    end
-
-    it 'reports all parameters' do
-      expect(smells[0].parameters[:parameters]).to eq(['pa', 'pb'])
-    end
 
-    it 'reports the number of occurrences' do
-      expect(smells[0].parameters[:count]).to eq(3)
-    end
-
-    it 'reports the declaration line numbers' do
-      expect(smells[0].lines).to eq([2, 3, 4])
-    end
-
-    it 'reports the correct smell type' do
-      expect(smells[0].smell_type).to eq(Reek::Smells::DataClump.smell_type)
-    end
-
-    it 'reports the context fq name' do
-      expect(smells[0].context).to eq(module_name)
-    end
-
-    it 'has the right message' do
-      expect(smells[0].message).to eq('takes parameters [pa, pb] to 3 methods')
-    end
-  end
-
-  it 'reports 3 swapped pairs' do
-    src = <<-EOS
-      #{context} Scrunch
-        def one(pa, pb) @field == :sym ? 0 : 3; end
-        def two(pb, pa) @field == :sym; end
-        def tri(pa, pb) pa - pb + @fred; end
-      end
-    EOS
     expect(src).to reek_of(:DataClump,
-                           count: 3,
-                           parameters: ['pa', 'pb'])
+                           lines:      [2, 3, 4],
+                           context:    'Alfa',
+                           message:    "takes parameters ['echo', 'foxtrot'] to 3 methods",
+                           source:     'string',
+                           parameters: ['echo', 'foxtrot'],
+                           count:      3)
   end
 
-  it 'reports 3 identical parameter sets' do
+  it 'does count all occurences' do
     src = <<-EOS
-      #{context} Scrunch
-        def first(pa, pb, pc) @field == :sym ? 0 : 3; end
-        def second(pa, pb, pc) @field == :sym; end
-        def third(pa, pb, pc) pa - pb + @fred; end
+      class Alfa
+        def bravo  (echo, foxtrot); end
+        def charlie(echo, foxtrot); end
+        def delta  (echo, foxtrot); end
+
+        def golf (juliett, kilo); end
+        def hotel(juliett, kilo); end
+        def india(juliett, kilo); end
       end
     EOS
-    expect(src).to reek_of(:DataClump,
-                           count: 3,
-                           parameters: ['pa', 'pb', 'pc'])
-  end
 
-  it 'reports re-ordered identical parameter sets' do
-    src = <<-EOS
-      #{context} Scrunch
-        def first(pb, pa, pc) @field == :sym ? 0 : 3; end
-        def second(pc, pb, pa) @field == :sym; end
-        def third(pa, pb, pc) pa - pb + @fred; end
-      end
-    EOS
     expect(src).to reek_of(:DataClump,
-                           count: 3,
-                           parameters: ['pa', 'pb', 'pc'])
+                           lines:      [2, 3, 4],
+                           parameters: ['echo', 'foxtrot'])
+    expect(src).to reek_of(:DataClump,
+                           lines:      [6, 7, 8],
+                           parameters: ['juliett', 'kilo'])
   end
 
-  it 'counts only identical parameter sets' do
-    src = <<-EOS
-      #{context} RedCloth
-        def fa(p1, p2, p3, conten) end
-        def fb(p1, p2, p3, conten) end
-        def fc(name, windowW, windowH) end
-      end
-    EOS
-    expect(src).not_to reek_of(:DataClump)
-  end
+  %w(class module).each do |scope|
+    it "does not report parameter sets < 2 for #{scope}" do
+      src = <<-EOS
+        #{scope} Alfa
+          def bravo  (echo); end
+          def charlie(echo); end
+          def delta  (echo); end
+        end
+      EOS
 
-  it 'gets a real example right' do
-    src = <<-EOS
-      #{context} Inline
-        def generate(src, options) end
-        def c (src, options) end
-        def c_singleton (src, options) end
-        def c_raw (src, options) end
-        def c_raw_singleton (src, options) end
-      end
-    EOS
-    expect(src).to reek_of(:DataClump, count: 5)
-  end
+      expect(src).not_to reek_of(:DataClump)
+    end
 
-  it 'correctly checks number of occurences' do
-    src = <<-EOS
-      #{context} Smelly
-        def fa(p1, p2, p3) end
-        def fb(p2, p3, p4) end
-        def fc(p3, p4, p5) end
-        def fd(p4, p5, p1) end
-        def fe(p5, p1, p2) end
-      end
-    EOS
-    expect(src).not_to reek_of(:DataClump)
-  end
+    it "does not report less than 3 methods for #{scope}" do
+      src = <<-EOS
+        #{scope} Alfa
+          def bravo  (echo, foxtrot); end
+          def charlie(echo, foxtrot); end
+        end
+      EOS
 
-  it 'detects clumps smaller than the total number of arguments' do
-    src = <<-EOS
-      #{context} Smelly
-        def fa(p1, p2, p3) end
-        def fb(p1, p3, p2) end
-        def fc(p4, p1, p2) end
-      end
-    EOS
-    expect(src).to reek_of(:DataClump,
-                           parameters: %w(p1 p2))
-  end
+      expect(src).not_to reek_of(:DataClump)
+    end
 
-  it 'ignores anonymous parameters' do
-    src = <<-EOS
-      #{context} Smelly
-        def fa(p1, p2, *) end
-        def fb(p1, p2, *) end
-        def fc(p1, p2, *) end
-      end
-    EOS
-    expect(src).to reek_of(:DataClump,
-                           parameters: %w(p1 p2))
-  end
-end
+    it 'does not care about the order of arguments' do
+      src = <<-EOS
+        #{scope} Alfa
+          def bravo  (echo, foxtrot); end
+          def charlie(foxtrot, echo); end # <- This is the swapped one!
+          def delta  (echo, foxtrot); end
+        end
+      EOS
 
-RSpec.describe Reek::Smells::DataClump do
-  let(:detector) { build(:smell_detector, smell_type: :DataClump) }
+      expect(src).to reek_of(:DataClump,
+                             count: 3,
+                             parameters: ['echo', 'foxtrot'])
+    end
+
+    it 'reports parameter sets that are > 2' do
+      src = <<-EOS
+        #{scope} Alfa
+          def bravo  (echo, foxtrot, golf); end
+          def charlie(echo, foxtrot, golf); end
+          def delta  (echo, foxtrot, golf); end
+        end
+      EOS
 
-  it_should_behave_like 'SmellDetector'
+      expect(src).to reek_of(:DataClump,
+                             count: 3,
+                             parameters: ['echo', 'foxtrot', 'golf'])
+    end
 
-  context 'in a class' do
-    let(:context) { 'class' }
+    it 'detects clumps smaller than the total number of parameters' do
+      src = <<-EOS
+        # Total number of parameters is 3 but the clump size is 2.
+        #{scope} Alfa
+          def bravo  (echo,  foxtrot, golf);    end
+          def charlie(echo,  golf,    foxtrot); end
+          def delta  (hotel, echo,    foxtrot); end
+        end
+      EOS
 
-    it_should_behave_like 'a data clump detector'
-  end
+      expect(src).to reek_of(:DataClump,
+                             parameters: ['echo', 'foxtrot'])
+    end
 
-  context 'in a module' do
-    let(:context) { 'module' }
+    it 'ignores anonymous parameters' do
+      src = <<-EOS
+        #{scope} Alfa
+          def bravo  (echo, foxtrot, *); end
+          def charlie(echo, foxtrot, *); end
+          def delta  (echo, foxtrot, *); end
+        end
+      EOS
 
-    it_should_behave_like 'a data clump detector'
+      expect(src).to reek_of(:DataClump,
+                             parameters: ['echo', 'foxtrot'])
+    end
   end
 end

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -1,63 +1,70 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/duplicate_method_call'
-require_lib 'reek/context/code_context'
-require_lib 'reek/context_builder'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::DuplicateMethodCall do
-  context 'when a smell is reported' do
-    let(:detector) { build(:smell_detector, smell_type: :DuplicateMethodCall) }
-
-    let(:warning) do
-      src = <<-EOS
-        def double_thing(other)
-          other[@thing]
-          not_the_sam(at = all)
-          other[@thing]
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        def bravo(charlie)
+          charlie.delta
+          charlie.delta
         end
-      EOS
-      ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      smells = detector.sniff(ctx)
-      expect(smells.length).to eq(1)
-      smells.first
-    end
-
-    it_should_behave_like 'SmellDetector'
-    it_should_behave_like 'common fields set correctly'
+      end
+    EOS
+
+    expect(src).to reek_of(:DuplicateMethodCall,
+                           lines:   [3, 4],
+                           context: 'Alfa#bravo',
+                           message: "calls 'charlie.delta' 2 times",
+                           source:  'string',
+                           name:    'charlie.delta',
+                           count:   2)
+  end
 
-    it 'reports the call' do
-      expect(warning.parameters[:name]).to eq('other[@thing]')
-    end
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        def bravo(charlie)
+          charlie.delta
+          charlie.delta
+        end
 
-    it 'reports the correct lines' do
-      expect(warning.lines).to eq([2, 4])
-    end
+        def echo(foxtrot)
+          foxtrot.golf
+          foxtrot.golf
+        end
+      end
+    EOS
+
+    expect(src).to reek_of(:DuplicateMethodCall,
+                           lines: [3, 4],
+                           name:  'charlie.delta',
+                           count: 2)
+    expect(src).to reek_of(:DuplicateMethodCall,
+                           lines: [8, 9],
+                           name:  'foxtrot.golf',
+                           count: 2)
   end
 
   context 'with repeated method calls' do
-    it 'reports repeated call' do
-      src = 'def double_thing() @other.thing + @other.thing end'
-      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 reek_of(:DuplicateMethodCall, name: 'other[@thing]')
+      src = 'def alfa(bravo); bravo.charlie + bravo.charlie; end'
+      expect(src).to reek_of(:DuplicateMethodCall, name: 'bravo.charlie')
     end
 
     it 'reports call parameters' do
-      src = 'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'
-      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing(2,3)')
+      src = 'def alfa; @bravo.charlie(2, 3) + @bravo.charlie(2, 3); end'
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@bravo.charlie(2, 3)')
     end
 
     it 'should report nested calls' do
-      src = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
-      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing.foo')
+      src = 'def alfa; @bravo.charlie.delta + @bravo.charlie.delta; end'
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@bravo.charlie')
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@bravo.charlie.delta')
     end
 
     it 'should ignore calls to new' do
-      src = 'def double_thing() @other.new + @other.new end'
+      src = 'def alfa; @bravo.new + @bravo.new; end'
       expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
@@ -65,15 +72,12 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
   context 'with repeated simple method calls' do
     it 'reports no smell' do
       src = <<-EOS
-        def foo
-          case bar
-          when :baz
-            :qux
-          else
-            bar
-          end
+        def alfa
+          bravo
+          bravo
         end
       EOS
+
       expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
@@ -81,21 +85,23 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
   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 }
+        def alfa
+          bravo { charlie }
+          bravo { charlie }
         end
       EOS
+
       expect(src).to reek_of(:DuplicateMethodCall)
     end
 
     it 'reports no smell if the blocks are different' do
       src = <<-EOS
-        def foo
-          bar { baz }
-          bar { qux }
+        def alfa
+          bravo { charlie }
+          bravo { delta }
         end
       EOS
+
       expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
@@ -103,49 +109,59 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
   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 }
+        def alfa
+          bravo.charlie { delta }
+          bravo.charlie { delta }
         end
       EOS
+
       expect(src).to reek_of(:DuplicateMethodCall)
     end
 
     it 'reports a smell if the blocks are different' do
       src = <<-EOS
-        def foo
-          bar.qux { baz }
-          bar.qux { qux }
+        def alfa
+          bravo.charlie { delta }
+          bravo.charlie { echo }
         end
       EOS
+
       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 reek_of(:DuplicateMethodCall, name: '@other[thing] = true')
+      src = <<-EOS
+        def alfa(bravo)
+          @charlie[bravo] = true
+          @charlie[bravo] = true
+        end
+      EOS
+
+      expect(src).to reek_of(:DuplicateMethodCall)
     end
+
     it 'does not report multi-assignments' do
       src = <<-EOS
-        def _parse ctxt
-          ctxt.index, result = @ind, @result
-          error, ctxt.index = @err, @err_ind
+        def alfa
+          bravo, charlie = delta, echo
+          charlie, bravo = delta, echo
         end
       EOS
+
       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'
+      src = 'def alfa(bravo) bravo.charlie == self.charlie end'
       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'
+      src = 'def alfa; @bravo.charlie(3) + @bravo.charlie(2) end'
       expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
@@ -156,47 +172,44 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
     end
 
     it 'does not report double calls' do
-      src = 'def double_thing() @other.thing + @other.thing end'
+      src = 'def alfa(bravo); bravo.charlie + bravo.charlie; end'
       expect(src).not_to reek_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 = 'def alfa(bravo); bravo.charlie + bravo.charlie + bravo.charlie; end'
       expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
     end
 
     it 'reports quadruple calls' do
-      src = '
-        def double_thing()
-          @other.thing + @other.thing + @other.thing + @other.thing
+      src = <<-EOS
+        def alfa
+          bravo.charlie + bravo.charlie + bravo.charlie + bravo.charlie
         end
-      '
+      EOS
+
       expect(src).to reek_of(:DuplicateMethodCall,
-                             name: '@other.thing', count: 4).with_config(config)
+                             count: 4).with_config(config)
     end
   end
 
   context 'allowing calls to some methods' do
-    let(:config) do
-      { Reek::Smells::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'
-
+      config = { Reek::Smells::DuplicateMethodCall::ALLOW_CALLS_KEY => ['@bravo.charlie'] }
+      src = 'def alfa; @bravo.charlie + @bravo.charlie; end'
       expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
     end
 
     it 'reports calls to other methods' do
-      src = 'def double_other_thing() @other.thing + @other.thing end'
-
-      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing').with_config(config)
+      config = { Reek::Smells::DuplicateMethodCall::ALLOW_CALLS_KEY => ['@delta.charlie'] }
+      src = 'def alfa; @bravo.charlie + @bravo.charlie; end'
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@bravo.charlie').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'
-
-      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing').with_config(config)
+      config = { Reek::Smells::DuplicateMethodCall::ALLOW_CALLS_KEY => [/charlie/] }
+      src = 'def alfa; puts @bravo.charlie; puts @bravo.charlie; end'
+      expect(src).not_to reek_of(:DuplicateMethodCall, name: '@bravo.charlie').with_config(config)
     end
   end
 end