reek 5.6.0 → 6.0.3

data/spec/reek/context_builder_spec.rb

@@ -3,42 +3,126 @@ require_lib 'reek/context_builder'
 
 RSpec.describe Reek::ContextBuilder do
   describe '#context_tree' do
-    let(:walker) do
-      code = 'class Car; def drive; end; end'
-      described_class.new(syntax_tree(code))
+    context 'with some simple example code' do
+      let(:walker) do
+        code = 'class Car; def drive; end; end'
+        described_class.new(syntax_tree(code))
+      end
+      let(:context_tree) { walker.context_tree }
+      let(:module_context) { context_tree.children.first }
+      let(:method_context) { module_context.children.first }
+
+      describe 'the starting node' do
+        it 'is a root node' do
+          expect(context_tree.type).to eq(:root)
+          expect(context_tree).to be_a(Reek::Context::RootContext)
+        end
+
+        it 'has one module_context child' do
+          aggregate_failures do
+            expect(context_tree.children.count).to eq 1
+            expect(module_context).to be_a(Reek::Context::ModuleContext)
+          end
+        end
+      end
+
+      describe 'the module node' do
+        it 'has one method_context child' do
+          aggregate_failures do
+            expect(method_context).to be_a(Reek::Context::MethodContext)
+            expect(module_context.children.size).to eq(1)
+          end
+        end
+
+        it 'holds a reference to the parent context' do
+          expect(method_context.parent).to eq(module_context)
+        end
+      end
     end
-    let(:context_tree) { walker.context_tree }
-    let(:module_context) { context_tree.children.first }
-    let(:method_context) { module_context.children.first }
 
-    it 'starts with a root node' do
-      expect(context_tree.type).to eq(:root)
-      expect(context_tree).to be_a(Reek::Context::RootContext)
+    it 'creates the proper context for all kinds of singleton methods' do
+      src = <<-RUBY
+        class Car
+          def self.start; end
+
+          class << self
+            def drive; end
+          end
+        end
+      RUBY
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_node = context_tree.children.first
+      start_method = class_node.children.first
+      drive_method = class_node.children.last
+
+      expect(start_method).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(drive_method).to be_instance_of Reek::Context::SingletonMethodContext
     end
 
-    it 'has one child' do
-      expect(context_tree.children.size).to eq(1)
+    it 'returns something sensible for nested metaclasses' do
+      src = <<-RUBY
+        class Foo
+          class << self
+            class << self
+              def bar; end
+            end
+          end
+        end
+      RUBY
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      method_context = class_context.children.first
+
+      expect(method_context).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(method_context.parent).to eq class_context
     end
 
-    describe 'the root node' do
-      it 'has one module_context' do
-        expect(module_context).to be_a(Reek::Context::ModuleContext)
-      end
+    it 'returns something sensible for nested method definitions' do
+      src = <<-RUBY
+        class Foo
+          def foo
+            def bar
+            end
+          end
+        end
+      RUBY
 
-      it 'holds a reference to the parent context' do
-        expect(module_context.parent).to eq(context_tree)
-      end
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      foo_context = class_context.children.first
+
+      bar_context = foo_context.children.first
+      expect(bar_context).to be_instance_of Reek::Context::MethodContext
+      expect(bar_context.parent).to eq foo_context
     end
 
-    describe 'the module node' do
-      it 'has one method_context' do
-        expect(method_context).to be_a(Reek::Context::MethodContext)
-        expect(module_context.children.size).to eq(1)
-      end
+    it 'returns something sensible for method definitions nested in singleton methods' do
+      src = <<-RUBY
+        class Foo
+          def self.foo
+            def bar
+            end
+          end
+        end
+      RUBY
 
-      it 'holds a reference to the parent context' do
-        expect(method_context.parent).to eq(module_context)
-      end
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      foo_context = class_context.children.first
+
+      bar_context = foo_context.children.first
+      expect(bar_context).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(bar_context.parent).to eq foo_context
     end
   end
 
@@ -370,91 +454,4 @@ RSpec.describe Reek::ContextBuilder do
       expect(nested_baz_context.visibility).to eq :public
     end
   end
-
-  describe '#context_tree' do
-    it 'creates the proper context for all kinds of singleton methods' do
-      src = <<-RUBY
-        class Car
-          def self.start; end
-
-          class << self
-            def drive; end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_node = context_tree.children.first
-      start_method = class_node.children.first
-      drive_method = class_node.children.last
-
-      expect(start_method).to be_instance_of Reek::Context::SingletonMethodContext
-      expect(drive_method).to be_instance_of Reek::Context::SingletonMethodContext
-    end
-
-    it 'returns something sensible for nested metaclasses' do
-      src = <<-RUBY
-        class Foo
-          class << self
-            class << self
-              def bar; end
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_context = context_tree.children.first
-      method_context = class_context.children.first
-
-      expect(method_context).to be_instance_of Reek::Context::SingletonMethodContext
-      expect(method_context.parent).to eq class_context
-    end
-
-    it 'returns something sensible for nested method definitions' do
-      src = <<-RUBY
-        class Foo
-          def foo
-            def bar
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_context = context_tree.children.first
-      foo_context = class_context.children.first
-
-      bar_context = foo_context.children.first
-      expect(bar_context).to be_instance_of Reek::Context::MethodContext
-      expect(bar_context.parent).to eq foo_context
-    end
-
-    it 'returns something sensible for method definitions nested in singleton methods' do
-      src = <<-RUBY
-        class Foo
-          def self.foo
-            def bar
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_context = context_tree.children.first
-      foo_context = class_context.children.first
-
-      bar_context = foo_context.children.first
-      expect(bar_context).to be_instance_of Reek::Context::SingletonMethodContext
-      expect(bar_context.parent).to eq foo_context
-    end
-  end
 end

data/spec/reek/report/code_climate/code_climate_configuration_spec.rb

@@ -3,9 +3,7 @@ require_lib 'reek/report/code_climate/code_climate_configuration'
 
 RSpec.describe Reek::Report::CodeClimateConfiguration do
   yml = described_class.load
-  smell_types = Reek::SmellDetectors::BaseDetector.descendants.map do |descendant|
-    descendant.name.demodulize
-  end
+  smell_types = Reek::SmellDetectors::BaseDetector.descendants.map(&:smell_type)
 
   smell_types.each do |name|
     config = yml.fetch(name)

data/spec/reek/report/code_climate/code_climate_fingerprint_spec.rb

@@ -8,12 +8,12 @@ RSpec.describe Reek::Report::CodeClimateFingerprint do
     context 'when fingerprinting a warning with no parameters' do
       let(:expected_fingerprint) { 'e68badd29db51c92363a7c6a2438d722' }
       let(:warning) do
-        build(:smell_warning,
-              smell_type: 'UtilityFunction',
-              context:    'alfa',
-              message:    "doesn't depend on instance state (maybe move it to another class?)",
-              lines:      lines,
-              source:     'a/ruby/source/file.rb')
+        Reek::SmellWarning.new(
+          'UtilityFunction',
+          context:    'alfa',
+          message:    "doesn't depend on instance state (maybe move it to another class?)",
+          lines:      lines,
+          source:     'a/ruby/source/file.rb')
       end
 
       context 'with code at a specific location' do
@@ -35,12 +35,12 @@ RSpec.describe Reek::Report::CodeClimateFingerprint do
 
     context 'when the fingerprint should not be computed' do
       let(:warning) do
-        build(:smell_warning,
-              smell_type: 'ManualDispatch',
-              context:    'Alfa#bravo',
-              message:    'manually dispatches method call',
-              lines:      [4],
-              source:     'a/ruby/source/file.rb')
+        Reek::SmellWarning.new(
+          'ManualDispatch',
+          context:    'Alfa#bravo',
+          message:    'manually dispatches method call',
+          lines:      [4],
+          source:     'a/ruby/source/file.rb')
       end
 
       it 'returns nil' do
@@ -50,13 +50,13 @@ RSpec.describe Reek::Report::CodeClimateFingerprint do
 
     context 'when the smell warning has only identifying parameters' do
       let(:warning) do
-        build(:smell_warning,
-              smell_type: 'ClassVariable',
-              context:    'Alfa',
-              message:    "declares the class variable '@@#{name}'",
-              lines:      [4],
-              parameters: { name: "@@#{name}" },
-              source:     'a/ruby/source/file.rb')
+        Reek::SmellWarning.new(
+          'ClassVariable',
+          context:    'Alfa',
+          message:    "declares the class variable '@@#{name}'",
+          lines:      [4],
+          parameters: { name: "@@#{name}" },
+          source:     'a/ruby/source/file.rb')
       end
 
       context 'when the name is one thing' do
@@ -80,13 +80,13 @@ RSpec.describe Reek::Report::CodeClimateFingerprint do
 
     context 'when the smell warning has identifying and non-identifying parameters' do
       let(:warning) do
-        build(:smell_warning,
-              smell_type: 'DuplicateMethodCall',
-              context:    "Alfa##{name}",
-              message:    "calls '#{name}' #{count} times",
-              lines:      lines,
-              parameters: { name: "@@#{name}", count: count },
-              source:     'a/ruby/source/file.rb')
+        Reek::SmellWarning.new(
+          'DuplicateMethodCall',
+          context:    "Alfa##{name}",
+          message:    "calls '#{name}' #{count} times",
+          lines:      lines,
+          parameters: { name: "@@#{name}", count: count },
+          source:     'a/ruby/source/file.rb')
       end
 
       context 'when the parameters are provided' do

data/spec/reek/report/code_climate/code_climate_formatter_spec.rb

@@ -4,12 +4,12 @@ require_lib 'reek/report/code_climate/code_climate_formatter'
 RSpec.describe Reek::Report::CodeClimateFormatter do
   describe '#render' do
     let(:warning) do
-      build(:smell_warning,
-            smell_type: 'UtilityFunction',
-            context:    'context foo',
-            message:    'message bar',
-            lines:      [1, 2],
-            source:     'a/ruby/source/file.rb')
+      Reek::SmellWarning.new(
+        'UtilityFunction',
+        context:    'context foo',
+          message:    'message bar',
+          lines:      [1, 2],
+          source:     'a/ruby/source/file.rb')
     end
     let(:rendered) { described_class.new(warning).render }
     let(:json) { JSON.parse rendered.chop }

data/spec/reek/report/location_formatter_spec.rb

@@ -2,7 +2,7 @@ require_relative '../../spec_helper'
 require_lib 'reek/report/location_formatter'
 
 RSpec.describe Reek::Report::BlankLocationFormatter do
-  let(:warning) { build(:smell_warning, lines: [11, 9, 250, 100]) }
+  let(:warning) { build_smell_warning(lines: [11, 9, 250, 100]) }
 
   describe '.format' do
     it 'returns a blank String regardless of the warning' do
@@ -12,7 +12,7 @@ RSpec.describe Reek::Report::BlankLocationFormatter do
 end
 
 RSpec.describe Reek::Report::DefaultLocationFormatter do
-  let(:warning) { build(:smell_warning, lines: [11, 9, 250, 100]) }
+  let(:warning) { build_smell_warning(lines: [11, 9, 250, 100]) }
 
   describe '.format' do
     it 'returns a prefix with sorted line numbers' do
@@ -22,7 +22,7 @@ RSpec.describe Reek::Report::DefaultLocationFormatter do
 end
 
 RSpec.describe Reek::Report::SingleLineLocationFormatter do
-  let(:warning) { build(:smell_warning, lines: [11, 9, 250, 100]) }
+  let(:warning) { build_smell_warning(lines: [11, 9, 250, 100]) }
 
   describe '.format' do
     it 'returns the first line where the smell was found' do

data/spec/reek/smell_detectors/base_detector_spec.rb

@@ -5,13 +5,13 @@ require_lib 'reek/smell_detectors/duplicate_method_call'
 RSpec.describe Reek::SmellDetectors::BaseDetector do
   describe '.todo_configuration_for' do
     it 'returns exclusion configuration for the given smells' do
-      smell = create(:smell_warning, smell_type: 'Foo', context: 'Foo#bar')
+      smell = build_smell_warning(smell_type: 'Foo', context: 'Foo#bar')
       result = described_class.todo_configuration_for([smell])
       expect(result).to eq('BaseDetector' => { 'exclude' => ['Foo#bar'] })
     end
 
     it 'merges identical contexts' do
-      smell = create(:smell_warning, smell_type: 'Foo', context: 'Foo#bar')
+      smell = build_smell_warning(smell_type: 'Foo', context: 'Foo#bar')
       result = described_class.todo_configuration_for([smell, smell])
       expect(result).to eq('BaseDetector' => { 'exclude' => ['Foo#bar'] })
     end
@@ -20,7 +20,7 @@ RSpec.describe Reek::SmellDetectors::BaseDetector do
       let(:subclass) { Reek::SmellDetectors::TooManyStatements }
 
       it 'includes default exclusions' do
-        smell = create(:smell_warning, smell_type: 'TooManyStatements', context: 'Foo#bar')
+        smell = build_smell_warning(smell_type: 'TooManyStatements', context: 'Foo#bar')
         result = subclass.todo_configuration_for([smell])
 
         aggregate_failures do
@@ -31,16 +31,6 @@ RSpec.describe Reek::SmellDetectors::BaseDetector do
     end
   end
 
-  describe '.valid_detector?' do
-    it 'returns true for a valid detector' do
-      expect(described_class.valid_detector?('DuplicateMethodCall')).to be true
-    end
-
-    it 'returns false for an invalid detector' do
-      expect(described_class.valid_detector?('Unknown')).to be false
-    end
-  end
-
   describe '.to_detector' do
     it 'returns the right detector' do
       expect(described_class.to_detector('DuplicateMethodCall')).to eq(Reek::SmellDetectors::DuplicateMethodCall)

data/spec/reek/smell_detectors/data_clump_spec.rb

@@ -76,6 +76,20 @@ RSpec.describe Reek::SmellDetectors::DataClump do
                              parameters: ['echo', 'foxtrot'])
     end
 
+    it 'reports arguments in alphabetical order even if they are never used that way' do
+      src = <<-RUBY
+        #{scope} Alfa
+          def bravo  (foxtrot, echo); end
+          def charlie(foxtrot, echo); end
+          def delta  (foxtrot, echo); end
+        end
+      RUBY
+
+      expect(src).to reek_of(:DataClump,
+                             count: 3,
+                             parameters: ['echo', 'foxtrot'])
+    end
+
     it 'reports parameter sets that are > 2' do
       src = <<-RUBY
         #{scope} Alfa

data/spec/reek/smell_detectors/missing_safe_method_spec.rb

@@ -50,13 +50,19 @@ RSpec.describe Reek::SmellDetectors::MissingSafeMethod do
 
   it 'does not report methods we excluded via comment' do
     source = <<-RUBY
-      # :reek:MissingSafeMethod: { exclude: [ bravo! ] }
+      # :reek:MissingSafeMethod { exclude: [ bravo! ] }
       class Alfa
         def bravo!
         end
+
+        def charlie!
+        end
       end
     RUBY
 
-    expect(source).not_to reek_of(:MissingSafeMethod)
+    aggregate_failures do
+      expect(source).not_to reek_of(:MissingSafeMethod, name: 'bravo!')
+      expect(source).to reek_of(:MissingSafeMethod, name: 'charlie!')
+    end
   end
 end

data/spec/reek/smell_detectors/nil_check_spec.rb

@@ -76,14 +76,14 @@ RSpec.describe Reek::SmellDetectors::NilCheck do
     expect(src).to reek_of(:NilCheck)
   end
 
-  it 'reports when scope uses &.' do
+  it 'does not report when scope uses &.' do
     src = <<-RUBY
       def alfa(bravo)
         bravo&.charlie
       end
     RUBY
 
-    expect(src).to reek_of(:NilCheck)
+    expect(src).not_to reek_of(:NilCheck)
   end
 
   it 'reports all lines when scope uses multiple nilchecks' do
@@ -95,6 +95,6 @@ RSpec.describe Reek::SmellDetectors::NilCheck do
       end
     RUBY
 
-    expect(src).to reek_of(:NilCheck, lines: [2, 3, 4])
+    expect(src).to reek_of(:NilCheck, lines: [2, 3])
   end
 end

data/spec/reek/smell_detectors/utility_function_spec.rb

@@ -161,6 +161,22 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
     end
   end
 
+  context 'when examining refinements' do
+    it 'reports on the refined class' do
+      src = <<-RUBY
+        module Alfa
+          refine Bravo do
+            def bravo(charlie)
+              charlie.delta.echo
+            end
+          end
+        end
+      RUBY
+
+      expect(src).to reek_of(:UtilityFunction, context: 'Bravo#bravo')
+    end
+  end
+
   describe 'method visibility' do
     it 'reports private methods' do
       src = <<-RUBY

data/spec/reek/smell_warning_spec.rb

@@ -24,23 +24,23 @@ RSpec.describe Reek::SmellWarning do
     end
 
     context 'when smells differ only by detector' do
-      let(:first) { build(:smell_warning, smell_type: 'DuplicateMethodCall') }
-      let(:second) { build(:smell_warning, smell_type: 'FeatureEnvy') }
+      let(:first) { build_smell_warning(smell_type: 'DuplicateMethodCall') }
+      let(:second) { build_smell_warning(smell_type: 'FeatureEnvy') }
 
       it_behaves_like 'first sorts ahead of second'
     end
 
     context 'when smells differ only by lines' do
-      let(:first) { build(:smell_warning, smell_type: 'FeatureEnvy', lines: [2]) }
-      let(:second) { build(:smell_warning, smell_type: 'FeatureEnvy', lines: [3]) }
+      let(:first) { build_smell_warning(smell_type: 'FeatureEnvy', lines: [2]) }
+      let(:second) { build_smell_warning(smell_type: 'FeatureEnvy', lines: [3]) }
 
       it_behaves_like 'first sorts ahead of second'
     end
 
     context 'when smells differ only by context' do
-      let(:first) { build(:smell_warning, smell_type: 'DuplicateMethodCall', context: 'first') }
+      let(:first) { build_smell_warning(smell_type: 'DuplicateMethodCall', context: 'first') }
       let(:second) do
-        build(:smell_warning, smell_type: 'DuplicateMethodCall', context: 'second')
+        build_smell_warning(smell_type: 'DuplicateMethodCall', context: 'second')
       end
 
       it_behaves_like 'first sorts ahead of second'
@@ -48,11 +48,11 @@ RSpec.describe Reek::SmellWarning do
 
     context 'when smells differ only by message' do
       let(:first) do
-        build(:smell_warning, smell_type: 'DuplicateMethodCall',
+        build_smell_warning(smell_type: 'DuplicateMethodCall',
                               context: 'ctx', message: 'first message')
       end
       let(:second) do
-        build(:smell_warning, smell_type: 'DuplicateMethodCall',
+        build_smell_warning(smell_type: 'DuplicateMethodCall',
                               context: 'ctx', message: 'second message')
       end
 
@@ -61,10 +61,10 @@ RSpec.describe Reek::SmellWarning do
 
     context 'when smells differ by name and message' do
       let(:first) do
-        build(:smell_warning, smell_type: 'FeatureEnvy', message: 'second message')
+        build_smell_warning(smell_type: 'FeatureEnvy', message: 'second message')
       end
       let(:second) do
-        build(:smell_warning, smell_type: 'UtilityFunction', message: 'first message')
+        build_smell_warning(smell_type: 'UtilityFunction', message: 'first message')
       end
 
       it_behaves_like 'first sorts ahead of second'
@@ -72,13 +72,13 @@ RSpec.describe Reek::SmellWarning do
 
     context 'when smells differ everywhere' do
       let(:first) do
-        build(:smell_warning, smell_type: 'DuplicateMethodCall',
+        build_smell_warning(smell_type: 'DuplicateMethodCall',
                               context: 'Dirty#a',
                               message: 'calls @s.title twice')
       end
 
       let(:second) do
-        build(:smell_warning, smell_type: 'UncommunicativeVariableName',
+        build_smell_warning(smell_type: 'UncommunicativeVariableName',
                               context: 'Dirty',
                               message: "has the variable name '@s'")
       end

data/spec/reek/source/source_code_spec.rb

@@ -62,5 +62,18 @@ RSpec.describe Reek::Source::SourceCode do
         expect { src.syntax_tree }.to raise_error error_class, error_message
       end
     end
+
+    if RUBY_VERSION >= '2.7'
+      context 'with ruby 2.7 syntax' do
+        context 'with forward_args (`...`)' do
+          let(:source_code) { described_class.new(source: 'def alpha(...) bravo(...); end') }
+
+          it 'returns a :forward_args node' do
+            result = source_code.syntax_tree
+            expect(result.children[1].type).to eq(:forward_args)
+          end
+        end
+      end
+    end
   end
 end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -1,7 +1,6 @@
 require 'pathname'
 require_relative '../../spec_helper'
 require_lib 'reek/spec'
-require 'active_support/core_ext/hash/except'
 
 RSpec.describe Reek::Spec::ShouldReekOf do
   describe 'smell type selection' do

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -40,7 +40,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
   end
 
   context 'with 1 non-matching smell' do
-    let(:smells) { [build(:smell_warning, smell_type: 'ControlParameter')] }
+    let(:smells) { [build_smell_warning(smell_type: 'ControlParameter')] }
 
     it_behaves_like 'no match'
   end
@@ -48,8 +48,8 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
   context 'with 2 non-matching smells' do
     let(:smells) do
       [
-        build(:smell_warning, smell_type: 'ControlParameter'),
-        build(:smell_warning, smell_type: 'FeatureEnvy')
+        build_smell_warning(smell_type: 'ControlParameter'),
+        build_smell_warning(smell_type: 'FeatureEnvy')
       ]
     end
 
@@ -59,8 +59,8 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
   context 'with 1 non-matching and 1 matching smell' do
     let(:smells) do
       [
-        build(:smell_warning, smell_type: 'ControlParameter'),
-        build(:smell_warning, smell_type: expected_smell_type.to_s,
+        build_smell_warning(smell_type: 'ControlParameter'),
+        build_smell_warning(smell_type: expected_smell_type.to_s,
                               message: "message mentioning #{expected_context_name}")
       ]
     end
@@ -70,7 +70,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
 
   context 'with 1 matching smell' do
     let(:smells) do
-      [build(:smell_warning, smell_type: expected_smell_type.to_s,
+      [build_smell_warning(smell_type: expected_smell_type.to_s,
                              message: "message mentioning #{expected_context_name}")]
     end
 

data/spec/reek/spec/smell_matcher_spec.rb

@@ -3,7 +3,7 @@ require_lib 'reek/spec/smell_matcher'
 
 RSpec.describe Reek::Spec::SmellMatcher do
   let(:smell_warning) do
-    build(:smell_warning, smell_type: 'UncommunicativeVariableName',
+    build_smell_warning(smell_type: 'UncommunicativeVariableName',
                           message: "has the variable name '@s'",
                           parameters: { test: 'something' })
   end