reek 4.4.0 → 4.4.1

data/spec/reek/smells/unused_private_method_spec.rb

@@ -1,100 +1,147 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/unused_private_method'
-require_lib 'reek/examiner'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UnusedPrivateMethod do
-  let(:detector) { build(:smell_detector, smell_type: :UnusedPrivateMethod) }
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        private
 
-  it_should_behave_like 'SmellDetector'
+        def charlie
+        end
+      end
+    EOS
+
+    expect(src).to reek_of(:UnusedPrivateMethod,
+                           lines:   [4],
+                           context: 'Alfa',
+                           message: "has the unused private instance method 'charlie'",
+                           source:  'string',
+                           name:    :charlie)
+  end
+
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        private
+
+        def charlie
+        end
+
+        def charlie
+        end
+      end
+    EOS
+
+    expect(src).to reek_of(:UnusedPrivateMethod,
+                           lines: [4],
+                           name:  :charlie)
+    expect(src).to reek_of(:UnusedPrivateMethod,
+                           lines: [7],
+                           name:  :charlie)
+  end
 
   context 'unused private methods' do
     it 'reports instance methods' do
       source = <<-EOF
-        class Car
+        class Alfa
           private
-          def start; end
-          def drive; end
+          def bravo; end
+          def charlie; end
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :start)
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :drive)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :bravo)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :charlie)
     end
 
     it 'reports instance methods in the correct class' do
       source = <<-EOF
-        class Car
-          class Engine
+        class Alfa
+          class Bravo
             private
-            def start; end
+            def charlie; end
           end
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod, context: 'Car::Engine', name: :start)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, context: 'Car', name: :start)
+      expect(source).to reek_of(:UnusedPrivateMethod,
+                                context: 'Alfa::Bravo',
+                                name: :charlie)
+      expect(source).not_to reek_of(:UnusedPrivateMethod,
+                                    context: 'Alfa',
+                                    name: :charlie)
     end
 
     it 'discounts calls to identically named methods in nested classes' do
       source = <<-EOF
-        class Car
-          class Engine
-            def vroom
-              start
+        class Alfa
+          class Bravo
+            def bravo
+              charlie
             end
+
             private
-            def start; end
+            def charlie; end
           end
+
           private
-          def start; end
+          def charlie; end
         end
       EOF
 
-      expect(source).not_to reek_of(:UnusedPrivateMethod, context: 'Car::Engine', name: :start)
-      expect(source).to reek_of(:UnusedPrivateMethod, context: 'Car', name: :start)
+      expect(source).not_to reek_of(:UnusedPrivateMethod,
+                                    context: 'Alfa::Bravo',
+                                    name: :charlie)
+      expect(source).to reek_of(:UnusedPrivateMethod,
+                                context: 'Alfa',
+                                name: :charlie)
     end
 
     it 'creates warnings correctly' do
       source = <<-EOF
-        class Car
+        class Alfa
           private
-          def start; end
-          def drive; end
+          def bravo; end
+          def charlie; end
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :drive, lines: [4])
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :start, lines: [3])
+      expect(source).to reek_of(:UnusedPrivateMethod,
+                                name: :bravo,
+                                lines: [3])
+      expect(source).to reek_of(:UnusedPrivateMethod,
+                                name: :charlie,
+                                lines: [4])
     end
   end
 
   describe 'configuring the detector via source code comment' do
     it 'does not report methods we excluded' do
       source = <<-EOF
-        # :reek:UnusedPrivateMethod: { exclude: [ start ] }
-        class Car
+        # :reek:UnusedPrivateMethod: { exclude: [ bravo ] }
+        class Alfa
           private
-          def start; end
-          def drive; end
+          def bravo; end
+          def charlie; end
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :drive)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :start)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :charlie)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :bravo)
     end
   end
 
   context 'used private methods' do
     it 'are not reported' do
       source = <<-EOF
-        class Car
-          def drive
-            start
+        class Alfa
+          def bravo
+            charlie
           end
 
           private
-          def start; end
+          def charlie; end
         end
       EOF
 
@@ -105,9 +152,9 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
   context 'unused protected methods' do
     it 'are not reported' do
       source = <<-EOF
-        class Car
+        class Alfa
           protected
-          def start; end
+          def bravo; end
         end
       EOF
 
@@ -118,8 +165,8 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
   context 'unused public methods' do
     it 'are not reported' do
       source = <<-EOF
-        class Car
-          def start; end
+        class Alfa
+          def bravo; end
         end
       EOF
 
@@ -130,26 +177,26 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
   describe 'prevent methods from being reported' do
     let(:source) do
       <<-EOF
-        class Car
+        class Alfa
           private
-          def start; end
-          def drive; end
+          def bravo; end
+          def charlie; end
         end
       EOF
     end
 
     it 'excludes them via direct match in the app configuration' do
-      config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => ['Car#drive'] }
+      config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => ['Alfa#charlie'] }
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :start).with_config(config)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :drive).with_config(config)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :bravo).with_config(config)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :charlie).with_config(config)
     end
 
     it 'excludes them via regex in the app configuration' do
-      config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => [/drive/] }
+      config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => [/charlie/] }
 
-      expect(source).to reek_of(:UnusedPrivateMethod, name: :start).with_config(config)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :drive).with_config(config)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :bravo).with_config(config)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :charlie).with_config(config)
     end
   end
 end

data/spec/reek/smells/utility_function_spec.rb

@@ -1,123 +1,146 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/utility_function'
-require_lib 'reek/examiner'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UtilityFunction do
-  describe 'a detector' do
-    let(:detector) { build(:smell_detector, smell_type: :UtilityFunction) }
+  it 'reports the right values' do
+    src = <<-EOS
+      def alfa(bravo)
+        bravo.charlie.delta
+      end
+    EOS
 
-    it_should_behave_like 'SmellDetector'
+    expect(src).to reek_of(:UtilityFunction,
+                           lines:   [1],
+                           context: 'alfa',
+                           message: "doesn't depend on instance state (maybe move it to another class?)",
+                           source:  'string')
+  end
 
-    context 'when a smells is reported' do
-      let(:warning) do
-        src = <<-EOS
-          def simple(arga)
-            arga.b.c
+  it 'counts a local call in a param initializer' do
+    expect('def alfa(bravo = charlie) bravo.to_s end').not_to reek_of(:UtilityFunction)
+  end
+
+  it 'counts usages of self' do
+    expect('def alfa(bravo); alfa.bravo(self); end').not_to reek_of(:UtilityFunction)
+  end
+
+  it 'counts self reference within a dstr' do
+    expect('def alfa(bravo); "#{self} #{bravo}"; end').not_to reek_of(:UtilityFunction)
+  end
+
+  it 'counts calls to self within a dstr' do
+    expect('def alfa(bravo); "#{self.gsub(/charlie/, /delta/)}"; end').
+      not_to reek_of(:UtilityFunction)
+  end
+
+  it 'does not report a method that calls super' do
+    expect('def alfa(bravo) super; bravo.to_s; end').not_to reek_of(:UtilityFunction)
+  end
+
+  it 'does not report a method that calls super with arguments' do
+    expect('def alfa(bravo) super(bravo); bravo.to_s; end').not_to reek_of(:UtilityFunction)
+  end
+
+  it 'should recognise a deep call' do
+    src = <<-EOS
+        class Alfa
+          def bravo(charlie)
+            charlie.each { |delta| foxtrot(delta) }
           end
-        EOS
-        Reek::Examiner.new(src, filter_by_smells: ['UtilityFunction']).smells[0]
-      end
 
-      it_should_behave_like 'common fields set correctly'
+          def foxtrot(golf)
+            @india << golf
+          end
+        end
+    EOS
 
-      it 'reports the line number of the method' do
-        expect(warning.lines).to eq([1])
-      end
+    expect(src).not_to reek_of(:UtilityFunction)
+  end
 
-      it 'has the right message' do
-        expect(warning.message).to eq("doesn't depend on instance state (maybe move it to another class?)")
-      end
-    end
+  it 'does not report empty method' do
+    expect('def alfa(bravo); end').not_to reek_of(:UtilityFunction)
   end
 
-  context 'with a singleton method' do
-    ['self', 'local_call', '$global'].each do |receiver|
-      it 'ignores the receiver' do
-        src = "def #{receiver}.simple(arga) arga.to_s + arga.to_i end"
-        expect(src).not_to reek_of(:UtilityFunction)
-      end
-    end
+  it 'does not report literal' do
+    expect('def alfa; 3; end').not_to reek_of(:UtilityFunction)
   end
 
-  context 'Singleton methods' do
-    it 'for classes with `class << self` notation should not report UtilityFunction' do
-      src = 'class C; class << self; def m(a) a.to_s; end; end; end'
-      expect(src).not_to reek_of(:UtilityFunction)
-    end
+  it 'does not report instance variable reference' do
+    expect('def alfa; @bravo; end').not_to reek_of(:UtilityFunction)
+  end
 
-    it 'for classes with `self.` notation should not report UtilityFunction' do
-      src = 'class C; def self.m(a) a.to_s; end; end'
-      expect(src).not_to reek_of(:UtilityFunction)
-    end
+  it 'does not report vcall' do
+    expect('def alfa; bravo; end').not_to reek_of(:UtilityFunction)
+  end
 
-    it 'for modules with `class << self` notation should not report UtilityFunction' do
-      src = 'module M; class << self; def self.m(a) a.to_s; end; end; end'
-      expect(src).not_to reek_of(:UtilityFunction)
-    end
+  it 'does not report references to self' do
+    expect('def alfa; self; end').not_to reek_of(:UtilityFunction)
+  end
 
-    it 'for modules with `self.` notation should not report UtilityFunction' do
-      src = 'module M; def self.simple(a) a.to_s; end; end'
-      expect(src).not_to reek_of(:UtilityFunction)
-    end
+  it 'recognises an ivar reference within a block' do
+    expect('def alfa(bravo) bravo.each { @charlie = 3} end').not_to reek_of(:UtilityFunction)
+  end
 
-    context 'by using `module_function`' do
-      it 'should not report UtilityFunction' do
-        src = 'class C; def m(a) a.to_s; end; module_function :m; end'
+  it 'reports a call to a constant' do
+    expect('def simple(arga) FIELDS[arga] end').to reek_of(:UtilityFunction, context: 'simple')
+  end
+
+  context 'Singleton methods' do
+    ['class', 'module'].each do |scope|
+      it "does not report for #{scope} with `class << self` notation" do
+        src = "#{scope} Alfa; class << self; def bravo(charlie) charlie.to_s; end; end; end"
+        expect(src).not_to reek_of(:UtilityFunction)
+      end
+
+      it "does not report for #{scope} with `self.` notation" do
+        src = "#{scope} Alfa; def self.bravo(charlie) charlie.to_s; end; end"
         expect(src).not_to reek_of(:UtilityFunction)
       end
+    end
 
-      it 'should not report UtilityFunction also when using multiple arguments' do
+    context 'by using `module_function`' do
+      it 'does not report UtilityFunction also when using multiple arguments' do
         src = <<-EOS
-          class C
-            def m1(a) a.to_s; end
-            def m2(a) a.to_s; end
-            module_function :m1, :m2
+          class Alfa
+            def bravo(charlie) charlie.to_s; end
+            def delta(echo) echo.to_s; end
+            module_function :bravo, :delta
           end
-          EOS
+        EOS
+
         expect(src).not_to reek_of(:UtilityFunction)
       end
 
       it 'does not report module functions defined by earlier modifier' do
         src = <<-EOF
-          module M
+          module Alfa
             module_function
-            def simple(a) a.to_s; end
+            def bravo(charlie) charlie.to_s; end
           end
         EOF
+
         expect(src).not_to reek_of(:UtilityFunction)
       end
 
       it 'reports functions preceded by canceled modifier' do
         src = <<-EOF
-          module M
+          module Alfa
             module_function
             public
-            def simple(a) a.to_s; end
+            def bravo(charlie) charlie.to_s; end
           end
         EOF
-        expect(src).to reek_of(:UtilityFunction, context: 'M#simple')
-      end
 
-      it 'does not report when module_function is called in separate scope' do
-        src = <<-EOF
-          class C
-            def m(a) a.to_s; end
-            begin
-              module_function :m
-            end
-          end
-        EOF
-        expect(src).not_to reek_of(:UtilityFunction)
+        expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo')
       end
 
-      it 'does not report when module_function modifier is called in separate scope' do
+      it 'does not report when module_function is called in separate scope' do
         src = <<-EOF
-          class C
+          class Alfa
+            def bravo(charlie) charlie.to_s; end
             begin
-              module_function
+              module_function :bravo
             end
-            def m(a) a.to_s; end
           end
         EOF
         expect(src).not_to reek_of(:UtilityFunction)
@@ -125,121 +148,31 @@ RSpec.describe Reek::Smells::UtilityFunction do
     end
   end
 
-  context 'with no calls' do
-    it 'does not report empty method' do
-      expect('def simple(arga) end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'does not report literal' do
-      expect('def simple() 3; end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'does not report instance variable reference' do
-      expect('def simple() @yellow end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'does not report vcall' do
-      expect('def simple() y end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'does not report references to self' do
-      expect('def into; self; end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'recognises an ivar reference within a block' do
-      expect('def clean(text) text.each { @fred = 3} end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'copes with nil superclass' do
-      expect('class Object; def is_maybe?() false end end').not_to reek_of(:UtilityFunction)
-    end
-  end
-
-  context 'with only one call' do
-    it 'reports a call to a parameter' do
-      expect('def simple(arga) arga.to_s end').to reek_of(:UtilityFunction, context: 'simple')
-    end
-
-    it 'reports a call to a constant' do
-      expect('def simple(arga) FIELDS[arga] end').to reek_of(:UtilityFunction, context: 'simple')
-    end
-  end
-
-  context 'with two or more calls' do
-    it 'reports two calls' do
-      src = 'def simple(arga) arga.to_s + arga.to_i end'
-      expect(src).to reek_of(:UtilityFunction, context: 'simple')
-      expect(src).not_to reek_of(:FeatureEnvy)
-    end
-
-    it 'counts a local call in a param initializer' do
-      expect('def simple(arga=local) arga.to_s end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'should count usages of self' do
-      expect('def <=>(other) Options[:sort_order].compare(self, other) end').
-        not_to reek_of(:UtilityFunction)
-    end
-
-    it 'should count self reference within a dstr' do
-      expect('def as(alias_name); "#{self} as #{alias_name}".to_sym; end').
-        not_to reek_of(:UtilityFunction)
-    end
-
-    it 'should count calls to self within a dstr' do
-      expect('def to_sql; "\'#{self.gsub(/\'/, "\'\'")}\'"; end').
-        not_to reek_of(:UtilityFunction)
-    end
-
-    it 'should report message chain' do
-      src = 'def simple(arga) arga.b.c end'
-      expect(src).to reek_of(:UtilityFunction, context: 'simple')
-      expect(src).not_to reek_of(:FeatureEnvy)
-    end
-
-    it 'does not report a method that calls super' do
-      expect('def child(arg) super; arg.to_s; end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'does not report a method that calls super with arguments' do
-      expect('def child(arg) super(arg * 2); arg.to_s; end').not_to reek_of(:UtilityFunction)
-    end
-
-    it 'should recognise a deep call' do
+  describe 'method visibility' do
+    it 'reports private methods' do
       src = <<-EOS
-        class Red
-          def deep(text)
-            text.each { |mod| atts = shelve(mod) }
-          end
-
-          def shelve(val)
-            @shelf << val
+        class Alfa
+          private
+          def bravo(charlie)
+            charlie.delta.echo
           end
         end
       EOS
-      expect(src).not_to reek_of(:UtilityFunction)
-    end
-  end
 
-  context 'with the default configuration' do
-    it 'reports private methods' do
-      src = <<-EOS
-          class C
-            private
-            def m1(a) a.to_s; end
-          end
-      EOS
-      expect(src).to reek_of(:UtilityFunction, context: 'C#m1')
+      expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo')
     end
 
     it 'reports protected methods' do
       src = <<-EOS
-          class C
-            protected
-            def m1(a) a.to_s; end
+        class Alfa
+          protected
+          def bravo(charlie)
+            charlie.delta.echo
           end
+        end
       EOS
-      expect(src).to reek_of(:UtilityFunction, context: 'C#m1')
+
+      expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo')
     end
   end
 
@@ -249,36 +182,45 @@ RSpec.describe Reek::Smells::UtilityFunction do
     end
 
     context 'public methods' do
-      it 'should still report UtilityFunction' do
+      it 'still reports UtilityFunction' do
         src = <<-EOS
-          class C
-            def m1(a) a.to_s; end
+          class Alfa
+            def bravo(charlie)
+              charlie.delta.echo
+            end
           end
         EOS
-        expect(src).to reek_of(:UtilityFunction, context: 'C#m1').with_config(config)
+
+        expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo').with_config(config)
       end
     end
 
     context 'private methods' do
-      it 'should not report UtilityFunction' do
+      it 'does not report UtilityFunction' do
         src = <<-EOS
-          class C
+          class Alfa
             private
-            def m1(a) a.to_s; end
+            def bravo(charlie)
+              charlie.delta.echo
+            end
           end
         EOS
+
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
     end
 
     context 'protected methods' do
-      it 'should not report UtilityFunction' do
+      it 'does not report UtilityFunction' do
         src = <<-EOS
-          class C
+          class Alfa
             protected
-            def m1(a) a.to_s; end
+            def bravo(charlie)
+              charlie.delta.echo
+            end
           end
         EOS
+
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
     end