reek 4.6.0 → 5.0.0

data/spec/reek/smell_detectors/class_variable_spec.rb

@@ -63,49 +63,43 @@ RSpec.describe Reek::SmellDetectors::ClassVariable do
   end
 
   ['class', 'module'].each do |scope|
-    context "Scoped to #{scope}" do
-      context 'set in a method' do
-        it 'reports correctly' do
-          src = <<-EOS
-            #{scope} Alfa
-              def bravo
-                @@charlie = {}
-              end
+    context "when examining a #{scope}" do
+      it 'reports a class variable set in a method' do
+        src = <<-EOS
+          #{scope} Alfa
+            def bravo
+              @@charlie = {}
             end
-          EOS
+          end
+        EOS
 
-          expect(src).to reek_of(:ClassVariable)
-        end
+        expect(src).to reek_of(:ClassVariable, name: '@@charlie')
       end
 
-      context 'used in a method' do
-        it 'reports correctly' do
-          src = <<-EOS
-            #{scope} Alfa
-              def bravo
-                puts @@charlie
-              end
+      it 'reports a class variable used in a method' do
+        src = <<-EOS
+          #{scope} Alfa
+            def bravo
+              puts @@charlie
             end
-          EOS
+          end
+        EOS
 
-          expect(src).to reek_of(:ClassVariable)
-        end
+        expect(src).to reek_of(:ClassVariable, name: '@@charlie')
       end
 
-      context "set in #{scope} and used in a method" do
-        it 'reports correctly' do
-          src = <<-EOS
-            #{scope} Alfa
-              @@bravo = 42
+      it "reports a class variable set in the #{scope} body and used in a method" do
+        src = <<-EOS
+          #{scope} Alfa
+            @@bravo = 42
 
-              def charlie
-                puts @@bravo
-              end
+            def charlie
+              puts @@bravo
             end
-          EOS
+          end
+        EOS
 
-          expect(src).to reek_of(:ClassVariable)
-        end
+        expect(src).to reek_of(:ClassVariable, name: '@@bravo')
       end
     end
   end

data/spec/reek/smell_detectors/control_parameter_spec.rb

@@ -30,7 +30,7 @@ RSpec.describe Reek::SmellDetectors::ControlParameter do
       and reek_of(:ControlParameter, lines: [3], argument: 'charlie')
   end
 
-  context 'parameter not used to determine code path' do
+  context 'when a parameter is not used to determine code path' do
     it 'does not report a ternary check on an ivar' do
       src = 'def alfa(bravo) @charlie ? bravo : false end'
       expect(src).not_to reek_of(:ControlParameter)
@@ -52,7 +52,7 @@ RSpec.describe Reek::SmellDetectors::ControlParameter do
     end
   end
 
-  context 'parameter only used to determine code path' do
+  context 'when a parameter is only used to determine code path' do
     it 'reports a ternary check on a parameter' do
       src = 'def alfa(bravo); bravo ? true : false; end'
       expect(src).to reek_of(:ControlParameter)
@@ -144,7 +144,7 @@ RSpec.describe Reek::SmellDetectors::ControlParameter do
       expect(src).to reek_of(:ControlParameter)
     end
 
-    it 'reports on nested if statements where the inner if is a control parameter' do
+    it 'reports on nested suffix if statements where the inner if is a control parameter' do
       src = <<-EOS
         def nested(bravo)
           if true
@@ -157,6 +157,36 @@ RSpec.describe Reek::SmellDetectors::ControlParameter do
       expect(src).to reek_of(:ControlParameter)
     end
 
+    it 'reports on nested full if statements where the inner if is a control parameter' do
+      src = <<-EOS
+        def alfa(bravo)
+          if true
+            charlie
+          else
+            if bravo
+              delta
+            end
+          end
+        end
+      EOS
+
+      expect(src).to reek_of(:ControlParameter)
+    end
+
+    it 'reports on elsif statements' do
+      src = <<-EOS
+        def alfa(bravo)
+          if true
+            charlie
+          elsif bravo
+            delta
+          end
+        end
+      EOS
+
+      expect(src).to reek_of(:ControlParameter)
+    end
+
     it 'reports on explicit comparison in the condition' do
       src = 'def alfa(bravo); if bravo == charlie then charlie end; end'
       expect(src).to reek_of(:ControlParameter)
@@ -188,7 +218,7 @@ RSpec.describe Reek::SmellDetectors::ControlParameter do
     end
   end
 
-  context 'parameter used besides determining code path' do
+  context 'when a parameter is used besides determining code path' do
     it 'does not report on if conditional expression' do
       src = 'def alfa(bravo); if bravo then charlie(bravo); end end'
       expect(src).not_to reek_of(:ControlParameter)

data/spec/reek/smell_detectors/duplicate_method_call_spec.rb

@@ -150,7 +150,7 @@ RSpec.describe Reek::SmellDetectors::DuplicateMethodCall do
     end
   end
 
-  context 'non-repeated method calls' do
+  context 'with non-repeated method calls' do
     it 'does not report similar calls' do
       src = 'def alfa(bravo) bravo.charlie == self.charlie end'
       expect(src).not_to reek_of(:DuplicateMethodCall)
@@ -162,7 +162,7 @@ RSpec.describe Reek::SmellDetectors::DuplicateMethodCall do
     end
   end
 
-  context 'allowing up to 3 calls' do
+  context 'when allowing up to 3 calls' do
     let(:config) do
       { Reek::SmellDetectors::DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 }
     end
@@ -189,7 +189,7 @@ RSpec.describe Reek::SmellDetectors::DuplicateMethodCall do
     end
   end
 
-  context 'allowing calls to some methods' do
+  context 'when allowing calls to some methods' do
     it 'does not report calls to some methods' do
       config = { Reek::SmellDetectors::DuplicateMethodCall::ALLOW_CALLS_KEY => ['@bravo.charlie'] }
       src = 'def alfa; @bravo.charlie + @bravo.charlie; end'

data/spec/reek/smell_detectors/feature_envy_spec.rb

@@ -130,7 +130,7 @@ RSpec.describe Reek::SmellDetectors::FeatureEnvy do
         delta += bravo.foxtrot
         delta *= 1.15
       end
-      EOS
+    EOS
 
     expect(src).
       to reek_of(:FeatureEnvy, name: 'delta').
@@ -145,7 +145,7 @@ RSpec.describe Reek::SmellDetectors::FeatureEnvy do
         delta += bravo.echo
         delta += bravo.foxtrot
       end
-      EOS
+    EOS
 
     expect(src).
       to reek_of(:FeatureEnvy, name: 'delta').
@@ -247,4 +247,49 @@ RSpec.describe Reek::SmellDetectors::FeatureEnvy do
 
     expect(src).not_to reek_of(:FeatureEnvy)
   end
+
+  it 'does not report on class methods defined by opening the metaclass' do
+    src = <<-EOS
+      class Alfa
+        class << self
+          def bravo(charlie)
+            delta = new(charlie)
+            delta.echo
+            delta.echo
+          end
+        end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report on class methods defined with an explicit receiver' do
+    src = <<-EOS
+      class Alfa
+        def self.bravo(charlie)
+          delta = new(charlie)
+          delta.echo
+          delta.echo
+        end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:FeatureEnvy)
+  end
+
+  it 'does not report module functions' do
+    src = <<-EOF
+      module Alfa
+        module_function
+        def bravo(charlie)
+          echo = delta(charlie)
+          echo.foxtrot
+          echo.foxtrot
+        end
+      end
+    EOF
+
+    expect(src).not_to reek_of(:FeatureEnvy)
+  end
 end

data/spec/reek/smell_detectors/irresponsible_module_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
   it 'does count all occurences' do
     src = <<-EOS
       class Alfa
-        # Method is necessary because we don't count empty classes.
+        # Method is necessary because we don't count namespace classes.
         def bravo; end
         class Charlie
         end
@@ -40,20 +40,9 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
       expect(src).to reek_of(:IrresponsibleModule)
     end
 
-    it "does not report re-opened #{scope}" do
-      src = <<-EOS
-        # Abstract base
-        #{scope} Alfa; end
-
-        #{scope} Alfa; def bravo; end; end
-      EOS
-
-      expect(src).not_to reek_of(:IrresponsibleModule)
-    end
-
     it "does not report a #{scope} having a comment" do
       src = <<-EOS
-        # Do not report me
+        # Do not report me, I'm responsible!
         #{scope} Alfa; end
       EOS
 
@@ -73,7 +62,7 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
 
     it "reports a #{scope} with a preceding comment with intermittent material" do
       src = <<-EOS
-        # This is a valid comment
+        # This is a comment that should not be related to Bravo
 
         require 'alfa'
 
@@ -87,13 +76,13 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
     it "reports a #{scope} with only a trailing comment" do
       src = <<-EOS
         #{scope} Alfa
-        end # end scope
+        end # This belongs to Alfa but doesn't count
       EOS
 
       expect(src).to reek_of(:IrresponsibleModule)
     end
 
-    it "does not report #{scope} used only as namespaces" do
+    it "does not report #{scope} used only as a namespace" do
       src = <<-EOS
         #{scope} Alfa
           # Describes Bravo
@@ -104,10 +93,28 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
         end
       EOS
 
-      expect(src).not_to reek_of(:IrresponsibleModule)
+      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
+    end
+
+    it "does not report #{scope} used only as a namespace for several nested moduless" do
+      src = <<-EOS
+        #{scope} Alfa
+          # Describes Bravo
+          class Bravo
+            def charlie
+            end
+          end
+
+          # Describes Delta
+          module Delta
+          end
+        end
+      EOS
+
+      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
     end
 
-    it "reports #{scope} that have both a nested #{scope} and methods" do
+    it "reports #{scope} that is used as a namespace but also has methods" do
       src = <<-EOS
         #{scope} Alfa
           def bravo
@@ -122,7 +129,7 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
       expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
     end
 
-    it "reports #{scope} that has both a nested #{scope} and singleton methods" do
+    it "reports #{scope} that is used as a namespace but also has singleton methods" do
       src = <<-EOS
         #{scope} Alfa
           def self.bravo
@@ -147,10 +154,40 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
         end
       EOS
 
-      expect(src).not_to reek_of(:IrresponsibleModule)
+      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
+    end
+
+    it "does not report #{scope} only containing constants" do
+      src = <<-EOS
+        #{scope} Alfa
+          Bravo = 23
+        end
+      EOS
+
+      expect(src).not_to reek_of(:IrresponsibleModule, context: 'Alfa')
+    end
+
+    it "reports #{scope} that contains method calls" do
+      src = <<-EOS
+        #{scope} Alfa
+          bravo :charlie
+        end
+      EOS
+
+      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
+    end
+
+    it "reports #{scope} that contains non-constant assignments" do
+      src = <<-EOS
+        #{scope} Alfa
+          bravo = charlie
+        end
+      EOS
+
+      expect(src).to reek_of(:IrresponsibleModule, context: 'Alfa')
     end
 
-    it "reports a #{scope} defined through assignment" do
+    it "reports an irresponsible #{scope} defined through assignment" do
       src = <<-EOS
         # Alfa is responsible, but Bravo is not
         #{scope} Alfa
@@ -174,6 +211,7 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
 
     it 'does not report constants that are not classes' do
       src = <<-EOS
+        # Alfa is responsible
         #{scope} Alfa
           Bravo = 23
           Charlie = Hash.new

data/spec/reek/smell_detectors/{prima_donna_method_spec.rb → missing_safe_method_spec.rb}

@@ -1,7 +1,7 @@
 require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/prima_donna_method'
+require_lib 'reek/smell_detectors/missing_safe_method'
 
-RSpec.describe Reek::SmellDetectors::PrimaDonnaMethod do
+RSpec.describe Reek::SmellDetectors::MissingSafeMethod do
   it 'reports the right values' do
     src = <<-EOS
       class Alfa
@@ -10,10 +10,10 @@ RSpec.describe Reek::SmellDetectors::PrimaDonnaMethod do
       end
     EOS
 
-    expect(src).to reek_of(:PrimaDonnaMethod,
-                           lines:   [1],
+    expect(src).to reek_of(:MissingSafeMethod,
+                           lines:   [2],
                            context: 'Alfa',
-                           message: "has prima donna method 'bravo!'",
+                           message: "has missing safe method 'bravo!'",
                            source:  'string',
                            name:    'bravo!')
   end
@@ -30,8 +30,8 @@ RSpec.describe Reek::SmellDetectors::PrimaDonnaMethod do
     EOS
 
     expect(src).
-      to reek_of(:PrimaDonnaMethod, lines: [1], name: 'bravo!').
-      and reek_of(:PrimaDonnaMethod, lines: [1], name: 'charlie!')
+      to reek_of(:MissingSafeMethod, lines: [2], name: 'bravo!').
+      and reek_of(:MissingSafeMethod, lines: [5], name: 'charlie!')
   end
 
   it 'reports nothing when method and bang counterpart exist' do
@@ -45,18 +45,18 @@ RSpec.describe Reek::SmellDetectors::PrimaDonnaMethod do
       end
     EOS
 
-    expect(src).not_to reek_of(:PrimaDonnaMethod)
+    expect(src).not_to reek_of(:MissingSafeMethod)
   end
 
   it 'does not report methods we excluded via comment' do
     source = <<-EOF
-      # :reek:PrimaDonnaMethod: { exclude: [ bravo! ] }
+      # :reek:MissingSafeMethod: { exclude: [ bravo! ] }
       class Alfa
         def bravo!
         end
       end
     EOF
 
-    expect(source).not_to reek_of(:PrimaDonnaMethod)
+    expect(source).not_to reek_of(:MissingSafeMethod)
   end
 end

data/spec/reek/smell_detectors/module_initialize_spec.rb

@@ -50,6 +50,20 @@ RSpec.describe Reek::SmellDetectors::ModuleInitialize do
     expect(src).not_to reek_of(:ModuleInitialize)
   end
 
+  it 'reports nothing for a method named initialize in a nested dynamic class' do
+    src = <<-EOF
+      module Alfa
+        def self.bravo
+          Class.new do
+            def initialize; end
+          end
+        end
+      end
+    EOF
+
+    expect(src).not_to reek_of(:ModuleInitialize)
+  end
+
   it 'can be disabled via comment' do
     src = <<-EOS
       # :reek:ModuleInitialize

data/spec/reek/smell_detectors/nested_iterators_spec.rb

@@ -223,7 +223,7 @@ RSpec.describe Reek::SmellDetectors::NestedIterators do
     expect(src).not_to reek_of(:NestedIterators)
   end
 
-  context 'setting the allowed nesting depth to 3' do
+  context 'when setting the allowed nesting depth to 3' do
     let(:config) do
       { Reek::SmellDetectors::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 }
     end

data/spec/reek/smell_detectors/too_many_constants_spec.rb

@@ -33,7 +33,7 @@ RSpec.describe Reek::SmellDetectors::TooManyConstants do
 
   it 'does not report when increasing default' do
     src = <<-EOS
-      # :reek:TooManyConstants: { max_constants: 3 }
+      # :reek:TooManyConstants { max_constants: 3 }
       class Alfa
         Bravo = Charlie = Delta = 1
       end
@@ -44,7 +44,7 @@ RSpec.describe Reek::SmellDetectors::TooManyConstants do
 
   it 'does not report when disabled' do
     src = <<-EOS
-      # :reek:TooManyConstants: { enabled: false }
+      # :reek:TooManyConstants { enabled: false }
       class Alfa
         Bravo = Charlie = Delta = 1
       end
@@ -96,7 +96,7 @@ RSpec.describe Reek::SmellDetectors::TooManyConstants do
   it 'does not report outer module when inner module suppressed' do
     src = <<-EOS
       module Alfa
-        # ignore :reek:TooManyConstants:
+        # ignore :reek:TooManyConstants
         module Bravo
           Charlie = Delta = Echo = 1
         end

data/spec/reek/smell_detectors/too_many_instance_variables_spec.rb

@@ -37,7 +37,7 @@ RSpec.describe Reek::SmellDetectors::TooManyInstanceVariables do
 
   it 'has a configurable maximum' do
     src = <<-EOS
-      # :reek:TooManyInstanceVariables: { max_instance_variables: 3 }
+      # :reek:TooManyInstanceVariables { max_instance_variables: 3 }
       class Alfa
         def bravo
           @charlie = @delta = @echo = 1

data/spec/reek/smell_detectors/uncommunicative_method_name_spec.rb

@@ -41,18 +41,18 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeMethodName do
   describe '`accept` patterns' do
     let(:source) { 'def x; end' }
 
-    it 'make smelly names pass via regex / strings given by list / literal' do
-      [[/x/], /x/, ['x'], 'x'].each do |pattern|
-        expect(source).not_to reek_of(:UncommunicativeMethodName).with_config('accept' => pattern)
-      end
+    it 'make smelly names pass' do
+      pattern = /x/
+      expect(source).not_to reek_of(:UncommunicativeMethodName).with_config('accept' => pattern)
     end
   end
 
   describe '`reject` patterns' do
     let(:source) { 'def alfa; end' }
 
-    it 'reject smelly names via regex / strings given by list / literal' do
-      [[/alfa/], /alfa/, ['alfa'], 'alfa'].each do |pattern|
+    it 'reject smelly names' do
+      patterns = [/alf/, /lfa/]
+      patterns.each do |pattern|
         expect(source).to reek_of(:UncommunicativeMethodName).with_config('reject' => pattern)
       end
     end

data/spec/reek/smell_detectors/uncommunicative_module_name_spec.rb

@@ -39,8 +39,9 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeModuleName do
   describe '`accept` patterns' do
     let(:source) { 'class Alfa1; end' }
 
-    it 'makes smelly names pass via regex / strings given by list / literal' do
-      [[/lfa/], /lfa/, ['lfa'], 'lfa'].each do |pattern|
+    it 'make smelly names pass ' do
+      patterns = [/lfa1/, /Alfa1/]
+      patterns.each do |pattern|
         expect(source).not_to reek_of(:UncommunicativeModuleName).with_config('accept' => pattern)
       end
     end
@@ -49,8 +50,9 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeModuleName do
   describe '`reject` patterns' do
     let(:source) { 'class Alfa; end' }
 
-    it 'rejects smelly names via regex / strings given by list / literal' do
-      [[/Alfa/], /Alfa/, ['Alfa'], 'Alfa'].each do |pattern|
+    it 'reject smelly names' do
+      patterns = [/lfa/, /Alf/]
+      patterns.each do |pattern|
         expect(source).to reek_of(:UncommunicativeModuleName).with_config('reject' => pattern)
       end
     end

data/spec/reek/smell_detectors/uncommunicative_parameter_name_spec.rb

@@ -32,15 +32,6 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
   { 'alfa.' => 'with a receiver',
     '' => 'without a receiver' }.each do |host, description|
     context "in a method definition #{description}" do
-      it 'does not recognise *' do
-        expect("def #{host}bravo(*); end").not_to reek_of(:UncommunicativeParameterName)
-      end
-
-      it 'does not report unused parameters' do
-        src = "def #{host}bravo(x); charlie; end"
-        expect(src).not_to reek_of(:UncommunicativeParameterName)
-      end
-
       it 'does not report two-letter parameter names' do
         src = "def #{host}bravo(ab); charlie(ab); end"
         expect(src).not_to reek_of(:UncommunicativeParameterName)
@@ -56,6 +47,26 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
         expect(src).to reek_of(:UncommunicativeParameterName, name: 'param2')
       end
 
+      it 'reports unused parameters' do
+        src = "def #{host}bravo(x); charlie; end"
+        expect(src).to reek_of(:UncommunicativeParameterName)
+      end
+
+      it 'reports splat parameters' do
+        expect("def #{host}bravo(*a); charlie(a); end").
+          to reek_of(:UncommunicativeParameterName, name: 'a')
+      end
+
+      it 'reports double splat parameters' do
+        expect("def #{host}bravo(**a); charlie(a); end").
+          to reek_of(:UncommunicativeParameterName, name: 'a')
+      end
+
+      it 'reports block parameters' do
+        expect("def #{host}bravo(&a); charlie(a); end").
+          to reek_of(:UncommunicativeParameterName, name: 'a')
+      end
+
       it 'does not report unused anonymous parameter' do
         src = "def #{host}bravo(_); charlie; end"
         expect(src).not_to reek_of(:UncommunicativeParameterName)
@@ -63,12 +74,20 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
 
       it 'reports used anonymous parameter' do
         src = "def #{host}bravo(_); charlie(_) end"
-        expect(src).to reek_of(:UncommunicativeParameterName)
+        expect(src).to reek_of(:UncommunicativeParameterName, name: '_')
       end
 
       it 'reports used parameters marked as unused' do
         src = "def #{host}bravo(_unused) charlie(_unused) end"
-        expect(src).to reek_of(:UncommunicativeParameterName)
+        expect(src).to reek_of(:UncommunicativeParameterName, name: '_unused')
+      end
+
+      it 'does not report anonymous splat' do
+        expect("def #{host}bravo(*); end").not_to reek_of(:UncommunicativeParameterName)
+      end
+
+      it 'does not report anonymous double splat' do
+        expect("def #{host}bravo(**); end").not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports names inside array decomposition' do
@@ -88,8 +107,9 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
   describe '`accept` patterns' do
     let(:source) { 'def alfa(bar2); charlie(bar2); end' }
 
-    it 'make smelly names pass via regex / strings given by list / literal' do
-      [[/bar2/], /bar2/, ['bar2'], 'bar2'].each do |pattern|
+    it 'make smelly names pass' do
+      patterns = [/bar2/, /ar2/]
+      patterns.each do |pattern|
         expect(source).not_to reek_of(:UncommunicativeParameterName).with_config('accept' => pattern)
       end
     end
@@ -98,8 +118,9 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
   describe '`reject` patterns' do
     let(:source) { 'def alfa(bravo); charlie(bravo); end' }
 
-    it 'reject smelly names via regex / strings given by list / literal' do
-      [[/bravo/], /bravo/, ['bravo'], 'bravo'].each do |pattern|
+    it 'reject smelly names' do
+      patterns = [/brav/, /ravo/]
+      patterns.each do |pattern|
         expect(source).to reek_of(:UncommunicativeParameterName).with_config('reject' => pattern)
       end
     end