reek 4.4.0 → 4.4.1

data/spec/reek/smells/feature_envy_spec.rb

@@ -1,250 +1,231 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/feature_envy'
-require_lib 'reek/examiner'
-require_relative 'smell_detector_shared'
 
-# TODO: Bring specs in line with specs for other detectors
 RSpec.describe Reek::Smells::FeatureEnvy do
-  context 'with no smell' 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
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        def bravo(charlie)
+          (charlie.delta - charlie.echo) * foxtrot
         end
-      EOS
-      expect(src).not_to reek_of(:FeatureEnvy)
-    end
+      end
+    EOS
+
+    expect(src).to reek_of(:FeatureEnvy,
+                           lines:   [3, 3],
+                           context: 'Alfa#bravo',
+                           message: "refers to 'charlie' more than self (maybe move it to another class?)",
+                           source:  'string',
+                           name:    'charlie')
   end
 
-  context 'with 2 calls to a parameter' do
-    it 'reports the smell' do
-      expect('
-        def envy(arga)
-          arga.b(arga) + arga.c(@fred)
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        def bravo(charlie)
+          (charlie.delta - charlie.echo) * foxtrot
         end
-      ').to reek_of(:FeatureEnvy, name: 'arga')
-    end
+
+        def golf(hotel)
+          (hotel.india + hotel.juliett) * kilo
+        end
+      end
+    EOS
+
+    expect(src).to reek_of(:FeatureEnvy,
+                           lines: [3, 3],
+                           name:  'charlie')
+    expect(src).to reek_of(:FeatureEnvy,
+                           lines: [7, 7],
+                           name:  'hotel')
+  end
+
+  it 'does not report use of self' do
+    expect('def alfa; self.to_s + self.to_i; end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report vcall with no argument' do
+    expect('def alfa; bravo; end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report single use' do
+    expect('def alfa(bravo); bravo.charlie(@delta); end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report return value' do
+    expect('def alfa(bravo); bravo.charlie(@delta); bravo; end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does ignore global variables' do
+    expect('def alfa; $bravo.to_a; $bravo[@charlie]; end').not_to reek_of(:FeatureEnvy)
   end
 
-  it 'should report highest affinity' do
+  it 'does not report class methods' do
+    expect('def alfa; self.class.bravo(self); end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report single use of an ivar' do
+    expect('def alfa; @bravo.to_a; end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report returning an ivar' do
+    expect('def alfa; @bravo.to_a; @bravo; end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report ivar usage in a parameter' do
+    expect('def alfa; @bravo.charlie + delta(@bravo) - echo(@bravo) end').
+      not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report single use of an lvar' do
+    expect('def alfa; bravo = @charlie; bravo.to_a; end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report returning an lvar' do
+    expect('def alfa; bravo = @charlie; bravo.to_a; lv end').not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'ignores lvar usage in a parameter' do
+    expect('def alfa; bravo = @item; bravo.charlie + delta(bravo) - echo(bravo); end').
+      not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'ignores multiple ivars' do
     src = <<-EOS
-      def total_envy
-        fred = @item
-        total = 0
-        total += fred.price
-        total += fred.tax
-        total *= 1.15
+      def func
+        @alfa.charlie
+        @alfa.delta
+
+        @bravo.echo
+        @bravo.foxtrot
+      end
+    EOS
+
+    expect(src).not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'report highest affinity' do
+    src = <<-EOS
+      def alfa
+        bravo = @charlie
+        delta = 0
+        delta += bravo.echo
+        delta += bravo.foxtrot
+        delta *= 1.15
       end
       EOS
-    expect(src).to reek_of(:FeatureEnvy, name: 'total')
-    expect(src).not_to reek_of(:FeatureEnvy, name: 'fred')
+
+    expect(src).to reek_of(:FeatureEnvy, name: 'delta')
+    expect(src).not_to reek_of(:FeatureEnvy, name: 'bravo')
   end
 
   it 'should report multiple affinities' do
     src = <<-EOS
-      def total_envy
-        fred = @item
-        total = 0
-        total += fred.price
-        total += fred.tax
+      def alfa
+        bravo = @charlie
+        delta = 0
+        delta += bravo.echo
+        delta += bravo.foxtrot
       end
       EOS
-    expect(src).to reek_of(:FeatureEnvy, name: 'total')
-    expect(src).to reek_of(:FeatureEnvy, name: 'fred')
+
+    expect(src).to reek_of(:FeatureEnvy, name: 'delta')
+    expect(src).to reek_of(:FeatureEnvy, name: 'bravo')
   end
 
-  it 'should not be fooled by duplication' do
-    expect('
-      def feed(thing)
-        @cow.feed_to(thing.pig)
-        @duck.feed_to(thing.pig)
+  it 'is not be fooled by duplication' do
+    src = <<-EOS
+      def alfa(bravo)
+        @charlie.delta(bravo.echo)
+        @foxtrot.delta(bravo.echo)
       end
-    ').to reek_only_of(:DuplicateMethodCall)
+    EOS
+
+    expect(src).to reek_only_of(:DuplicateMethodCall)
   end
 
-  it 'should count local calls' do
-    expect('
-      def feed(thing)
-        cow.feed_to(thing.pig)
-        duck.feed_to(thing.pig)
+  it 'does not count local calls' do
+    src = <<-EOS
+      def alfa(bravo)
+        @charlie.delta(bravo.echo)
+        @foxtrot.delta(bravo.echo)
       end
-    ').to reek_only_of(:DuplicateMethodCall)
+    EOS
+
+    expect(src).to reek_only_of(:DuplicateMethodCall)
   end
 
-  it 'should report many calls to lvar' do
-    expect('
-      def envy()
-        lv = @item
-        lv.price + lv.tax
+  it 'reports many calls to lvar' do
+    src = <<-EOS
+      def alfa
+        bravo = @charlie
+        bravo.delta + bravo.echo
       end
-    ').to reek_only_of(:FeatureEnvy)
-  end
+    EOS
 
-  it 'ignores frequent use of a call' do
-    expect('def func() other.a; other.b; nother.c end').not_to reek_of(:FeatureEnvy)
+    expect(src).to reek_only_of(:FeatureEnvy)
   end
 
   it 'counts =~ as a call' do
     src = <<-EOS
-    def foo arg
-      bar(arg.baz)
-      arg =~ /bar/
-    end
+      def alfa(bravo)
+        charlie(bravo.delta)
+        bravo =~ /charlie/
+      end
     EOS
+
     expect(src).to reek_of :FeatureEnvy
   end
 
   it 'counts += as a call' do
     src = <<-EOS
-    def foo arg
-      bar(arg.baz)
-      arg += 1
-    end
+      def alfa(bravo)
+        charlie(bravo.delta)
+        bravo += 1
+      end
     EOS
+
     expect(src).to reek_of :FeatureEnvy
   end
 
   it 'counts ivar assignment as call to self' do
     src = <<-EOS
-    def foo
-      bar = baz(1, 2)
+      def foo
+        bravo = charlie(1, 2)
 
-      @quuz = bar.qux
-      @zyxy = bar.foobar
-    end
+        @delta = bravo.echo
+        @foxtrot = bravo.golf
+      end
     EOS
+
     expect(src).not_to reek_of :FeatureEnvy
   end
 
   it 'counts self references correctly' do
     src = <<-EOS
-      def adopt(other)
-        other.keys.each do |key|
-          self[key] += 3
-          self[key] = o4
+      def alfa(bravo)
+        bravo.keys.each do |charlie|
+          self[charlie] += 3
+          self[charlie] = 4
         end
         self
       end
     EOS
-    expect(src).not_to reek_of(:FeatureEnvy)
-  end
 
-  it 'counts references to self correctly' do
-    ruby = <<-EOS
-      def report
-        unless @report
-          @report = Report.new
-          cf = SmellConfig.new
-          cf = cf.load_local(@dir) if @dir
-          ContextBuilder.new(@report, cf.smell_listeners).check_source(@source)
-        end
-        @report
-      end
-    EOS
-    expect(ruby).not_to reek_of(:FeatureEnvy)
+    expect(src).not_to reek_of(:FeatureEnvy)
   end
 
   it 'interprets << correctly' do
-    ruby = <<-EOS
-      def report_on(report)
-        if @is_doubled
-          report.record_doubled_smell(self)
+    src = <<-EOS
+      def alfa(bravo)
+        if @charlie
+          bravo.delta(self)
         else
-          report << self
+          bravo << self
         end
       end
     EOS
 
-    expect(ruby).not_to reek_of(:FeatureEnvy)
-  end
-end
-
-RSpec.describe Reek::Smells::FeatureEnvy do
-  let(:detector) { build(:smell_detector, smell_type: :FeatureEnvy) }
-
-  it_should_behave_like 'SmellDetector'
-
-  context 'when a smell is reported' do
-    let(:receiver) { 'other' }
-
-    let(:warning) do
-      src = <<-EOS
-        def envious(other)
-          #{receiver}.call
-          self.do_nothing
-          #{receiver}.other
-          #{receiver}.fred
-        end
-      EOS
-      Reek::Examiner.new(src, filter_by_smells: ['FeatureEnvy']).smells.first
-    end
-
-    it_should_behave_like 'common fields set correctly'
-
-    it 'reports the name' do
-      expect(warning.parameters[:name]).to eq(receiver)
-    end
-
-    it 'reports the lines' do
-      expect(warning.lines).to eq([2, 4, 5])
-    end
-
-    it 'has the right message' do
-      expect(warning.message).to eq('refers to other more than self (maybe move it to another class?)')
-    end
+    expect(src).not_to reek_of(:FeatureEnvy)
   end
 end

data/spec/reek/smells/instance_variable_assumption_spec.rb

@@ -3,104 +3,59 @@ require_relative '../../spec_helper'
 require_lib 'reek/smells/instance_variable_assumption'
 
 RSpec.describe Reek::Smells::InstanceVariableAssumption do
-  describe 'warning' do
-    context 'smell line' do
-      it 'should report the lines' do
-        src = <<-EOS
-          class Dummy
-            def test
-              @a
-            end
-          end
-        EOS
-
-        expect(src).to reek_of(:InstanceVariableAssumption, lines: [1])
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          @charlie
+        end
       end
-    end
-
-    context 'smell parameters' do
-      it 'should report the lines' do
-        src = <<-EOS
-          class Dummy
-            def test
-              @a
-            end
-          end
-        EOS
+    EOS
 
-        expect(src).to reek_of(:InstanceVariableAssumption, assumption: :@a)
-      end
-    end
-
-    context 'smell context' do
-      it 'should report the context' do
-        src = <<-EOS
-          class Dummy
-            def test
-              @a
-            end
-          end
-        EOS
+    expect(src).to reek_of(:InstanceVariableAssumption,
+                           lines:      [1],
+                           context:    'Alfa',
+                           message:    "assumes too much for instance variable '@charlie'",
+                           source:     'string',
+                           assumption: :@charlie)
+  end
 
-        expect(src).to reek_of(:InstanceVariableAssumption, context: 'Dummy')
-      end
-    end
-
-    context 'smell message' do
-      it 'should report the ivars in the message' do
-        message_a = 'assumes too much for instance variable @a'
-        message_b = 'assumes too much for instance variable @b'
-
-        src = <<-EOS
-          class Dummy
-            def test
-              [@a, @b]
-            end
-          end
-        EOS
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        def bravo
+          @charlie
+        end
 
-        expect(src).to reek_of(:InstanceVariableAssumption, message: message_a)
-        expect(src).to reek_of(:InstanceVariableAssumption, message: message_b)
+        def delta
+          @echo
+        end
       end
 
-      it 'should report each ivar once' do
-        message_a = 'assumes too much for instance variable @a'
-        message_b = 'assumes too much for instance variable @b'
-        message_c = 'assumes too much for instance variable @c'
-
-        src = <<-EOS
-          class Dummy
-            def test
-              [@a, @a, @b, @c]
-            end
-
-            def retest
-              @c
-            end
-          end
-        EOS
+    EOS
 
-        expect(src).to reek_of(:InstanceVariableAssumption, message: message_a)
-        expect(src).to reek_of(:InstanceVariableAssumption, message: message_b)
-        expect(src).to reek_of(:InstanceVariableAssumption, message: message_c)
-      end
-    end
+    expect(src).to reek_of(:InstanceVariableAssumption,
+                           lines: [1],
+                           assumption: :@charlie)
+    expect(src).to reek_of(:InstanceVariableAssumption,
+                           lines: [1],
+                           assumption: :@echo)
   end
 
   it 'should not report an empty class' do
     src = <<-EOS
-      class Dummy
+      class Alfa
       end
     EOS
 
     expect(src).not_to reek_of(:InstanceVariableAssumption)
   end
 
-  it 'should not report when lazy initializing' do
+  it 'does not report when lazy initializing' do
     src = <<-EOS
-      class Dummy
-        def test
-          @a ||= 1
+      class Alfa
+        def bravo
+          @charlie ||= 1
         end
       end
     EOS
@@ -108,88 +63,37 @@ RSpec.describe Reek::Smells::InstanceVariableAssumption do
     expect(src).not_to reek_of(:InstanceVariableAssumption)
   end
 
-  it 'should report when making instance variable assumption' do
-    src = <<-EOS
-      class Dummy
-        def test
-          @a
-        end
-      end
-    EOS
-
-    expect(src).to reek_of(:InstanceVariableAssumption)
-  end
-
   it 'reports variable even if others are initialized' do
     src = <<-EOS
-      class Dummy
+      class Alfa
         def initialize
-          @a = 1
+          @bravo = 1
         end
 
-        def test
-          [@a, @b]
+        def charlie
+          [@bravo, @delta]
         end
       end
     EOS
 
-    expect(src).to reek_of(:InstanceVariableAssumption)
+    expect(src).to reek_of(:InstanceVariableAssumption, assumption: :@delta)
   end
 
-  context 'inner classes' do
-    it 'should report outter class' do
-      src = <<-EOS
-        class Dummy
-          def test
-            @a
-          end
-
-          class Dummiest
-          end
-        end
-      EOS
-
-      expect(src).to reek_of(:InstanceVariableAssumption, context: 'Dummy')
-    end
-
-    it 'should report even if outer class initialize the variable' do
-      src = <<-EOS
-        class Dummy
-          def initialize
-            @a = 1
-          end
-
-          class Dummiest
-            def test
-              @a
-            end
-          end
+  it 'reports inner class even if outer class initializes the variable' do
+    src = <<-EOS
+      class Alfa
+        def initialize
+          @bravo = 1
         end
-      EOS
-
-      expect(src).to reek_of(:InstanceVariableAssumption, context: 'Dummy::Dummiest')
-    end
 
-    it 'should report inner classes' do
-      src = <<-EOS
-        class Dummy
-          def initialize
-            @a = 1
-          end
-
-          class Dummiest
-            def initialize
-              @b = 1
-            end
-
-            def test
-              @c
-            end
+        class Charlie
+          def delta
+            @bravo
           end
         end
-      EOS
+      end
+    EOS
 
-      expect(src).to reek_of(:InstanceVariableAssumption, context: 'Dummy::Dummiest')
-    end
+    expect(src).to reek_of(:InstanceVariableAssumption, context: 'Alfa::Charlie')
   end
 end