reek 4.0.0.pre1 → 4.0.0

data/lib/reek/smells/uncommunicative_module_name.rb

@@ -28,12 +28,12 @@ module Reek
       # to be treated as exceptions; these names will not be reported as
       # uncommunicative.
       ACCEPT_KEY = 'accept'.freeze
-      DEFAULT_ACCEPT_NAMES = [].freeze
+      DEFAULT_ACCEPT_PATTERNS = [].freeze
 
       def self.default_config
-        super.merge(
+        super().merge(
           REJECT_KEY => DEFAULT_REJECT_PATTERNS,
-          ACCEPT_KEY => DEFAULT_ACCEPT_NAMES
+          ACCEPT_KEY => DEFAULT_ACCEPT_PATTERNS
         )
       end
 
@@ -66,16 +66,16 @@ module Reek
 
       # :reek:ControlParameter
       def acceptable_name?(context:, module_name:, fully_qualified_name:)
-        accept_names(context).any? { |accept_name| fully_qualified_name == accept_name } ||
-          reject_patterns(context).none? { |pattern| module_name.match pattern }
+        accept_patterns(context).any? { |accept_pattern| fully_qualified_name.match accept_pattern } ||
+          reject_patterns(context).none? { |reject_pattern| module_name.match reject_pattern }
       end
 
       def reject_patterns(context)
-        value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
+        Array value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
       end
 
-      def accept_names(context)
-        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_NAMES)
+      def accept_patterns(context)
+        Array value(ACCEPT_KEY, context, DEFAULT_ACCEPT_PATTERNS)
       end
     end
   end

data/lib/reek/smells/uncommunicative_parameter_name.rb

@@ -16,6 +16,8 @@ module Reek
     # Currently +UncommunicativeParameterName+ checks for
     # * 1-character names
     # * names ending with a number
+    # * names beginning with an underscore
+    # * names containing a capital letter (assuming camelCase)
     #
     # See {file:docs/Uncommunicative-Parameter-Name.md} for details.
     class UncommunicativeParameterName < SmellDetector
@@ -23,12 +25,12 @@ module Reek
       DEFAULT_REJECT_PATTERNS = [/^.$/, /[0-9]$/, /[A-Z]/, /^_/].freeze
 
       ACCEPT_KEY = 'accept'.freeze
-      DEFAULT_ACCEPT_NAMES = [].freeze
+      DEFAULT_ACCEPT_PATTERNS = [].freeze
 
       def self.default_config
         super.merge(
           REJECT_KEY => DEFAULT_REJECT_PATTERNS,
-          ACCEPT_KEY => DEFAULT_ACCEPT_NAMES
+          ACCEPT_KEY => DEFAULT_ACCEPT_PATTERNS
         )
       end
 
@@ -58,16 +60,16 @@ module Reek
       end
 
       def acceptable_name?(name:, context:)
-        accept_names(context).any? { |accept_name| name == accept_name } ||
-          reject_patterns(context).none? { |pattern| name.match pattern }
+        accept_patterns(context).any? { |accept_pattern| name.match accept_pattern } ||
+          reject_patterns(context).none? { |reject_pattern| name.match reject_pattern }
       end
 
       def reject_patterns(context)
-        value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
+        Array value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
       end
 
-      def accept_names(context)
-        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_NAMES)
+      def accept_patterns(context)
+        Array value(ACCEPT_KEY, context, DEFAULT_ACCEPT_PATTERNS)
       end
 
       # :reek:UtilityFunction

data/lib/reek/smells/unused_private_method.rb

@@ -78,9 +78,14 @@ module Reek
       # @param ctx [Context::ClassContext]
       # @return [Boolean]
       #
+      # :reek:FeatureEnvy
       def ignore_method?(ctx, method)
-        ignore_methods = value(EXCLUDE_KEY, ctx, DEFAULT_EXCLUDE_SET)
-        ignore_methods.any? { |ignore_method| method.name[ignore_method] }
+        # ignore_contexts will be e.g. ["Foo::Smelly#my_method", "..."]
+        ignore_contexts = value(EXCLUDE_KEY, ctx, DEFAULT_EXCLUDE_SET)
+        ignore_contexts.any? do |ignore_context|
+          full_name = "#{method.parent.full_name}##{method.name}"
+          full_name[ignore_context]
+        end
       end
     end
   end

data/lib/reek/version.rb

@@ -7,6 +7,6 @@ module Reek
   # @public
   module Version
     # @public
-    STRING = '4.0.0.pre1'.freeze
+    STRING = '4.0.0'.freeze
   end
 end

data/reek.gemspec

@@ -7,10 +7,9 @@ Gem::Specification.new do |s|
 
   s.authors = ['Kevin Rutherford', 'Timo Roessner', 'Matijs van Zuijlen', 'Piotr Szotkowski']
   s.default_executable = 'reek'
-  s.description = <<-DESC
-    Reek is a tool that examines Ruby classes, modules and methods and reports
-    any code smells it finds.
-  DESC
+  s.description =
+    'Reek is a tool that examines Ruby classes, modules and methods and reports ' \
+    'any code smells it finds.'
 
   s.license = 'MIT'
   s.email = ['timo.roessner@googlemail.com']

data/spec/reek/configuration/app_configuration_spec.rb

@@ -57,28 +57,6 @@ RSpec.describe Reek::Configuration::AppConfiguration do
       end
     end
 
-    describe '#from_map' do
-      it 'properly sets the configuration from simple data structures' do
-        config = described_class.from_map(directory_directives: directory_directives_value,
-                                          default_directive: default_directive_value,
-                                          excluded_paths: exclude_paths_value)
-
-        expect(config.send(:excluded_paths)).to eq(expected_excluded_paths)
-        expect(config.send(:default_directive)).to eq(expected_default_directive)
-        expect(config.send(:directory_directives)).to eq(expected_directory_directives)
-      end
-
-      it 'properly sets the configuration from native structures' do
-        config = described_class.from_map(directory_directives: expected_directory_directives,
-                                          default_directive: expected_default_directive,
-                                          excluded_paths: expected_excluded_paths)
-
-        expect(config.send(:excluded_paths)).to eq(expected_excluded_paths)
-        expect(config.send(:default_directive)).to eq(expected_default_directive)
-        expect(config.send(:directory_directives)).to eq(expected_directory_directives)
-      end
-    end
-
     describe '#from_hash' do
       it 'sets the configuration a unified simple data structure' do
         config = described_class.from_hash(combined_value)
@@ -104,7 +82,7 @@ RSpec.describe Reek::Configuration::AppConfiguration do
       end
 
       it 'returns the corresponding directive' do
-        configuration = described_class.from_map directory_directives: directory_directives
+        configuration = described_class.from_hash directory_directives
         expect(configuration.directive_for(source_via)).to eq(bang_config)
       end
     end
@@ -120,11 +98,12 @@ RSpec.describe Reek::Configuration::AppConfiguration do
         }
       end
       let(:source_via) { "#{directory}/dummy.rb" }
+      let(:configuration_as_hash) { directory_directives.merge(default_directive) }
 
       it 'returns the directory directive with the default directive reverse-merged' do
-        configuration = described_class.from_map directory_directives: directory_directives,
-                                                 default_directive: default_directive
+        configuration = described_class.from_hash configuration_as_hash
         actual = configuration.directive_for(source_via)
+
         expect(actual[Reek::Smells::IrresponsibleModule]).to be_truthy
         expect(actual[Reek::Smells::TooManyStatements]).to be_truthy
         expect(actual[Reek::Smells::TooManyStatements][:max_statements]).to eq(8)
@@ -138,10 +117,10 @@ RSpec.describe Reek::Configuration::AppConfiguration do
       let(:directory_directives) do
         { 'spec/samples/two_smelly_files' => attribute_config }
       end
+      let(:configuration_as_hash) { directory_directives.merge(default_directive) }
 
       it 'returns the default directive' do
-        configuration = described_class.from_map directory_directives: directory_directives,
-                                                 default_directive: default_directive
+        configuration = described_class.from_hash configuration_as_hash
         expect(configuration.directive_for(source_via)).to eq(default_directive)
       end
     end

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -4,31 +4,87 @@ require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UncommunicativeMethodName do
   let(:detector) { build(:smell_detector, smell_type: :UncommunicativeMethodName) }
-
   it_should_behave_like 'SmellDetector'
 
-  ['help', '+', '-', '/', '*'].each do |method_name|
-    it "accepts the method name '#{method_name}'" do
-      src = "def #{method_name}(arg) basics(17) end"
-      expect(src).not_to reek_of(:UncommunicativeMethodName)
+  describe 'default configuration' do
+    it 'reports one-word names' do
+      expect('def a; end').to reek_of(:UncommunicativeMethodName)
+    end
+
+    it 'reports names ending with a digit' do
+      expect('def xyz1; end').to reek_of(:UncommunicativeMethodName)
+    end
+
+    it 'reports camelcased names' do
+      expect('def aBBa; end').to reek_of(:UncommunicativeMethodName)
+    end
+
+    it 'does not report one-letter special characters' do
+      ['+', '-', '/', '*'].each do |symbol|
+        expect("def #{symbol}; end").not_to reek_of(:UncommunicativeMethodName)
+      end
+    end
+  end
+
+  describe 'inspect' do
+    let(:source) { 'def x; end' }
+    let(:context) { code_context(source) }
+    let(:detector) { build(:smell_detector, smell_type: :UncommunicativeMethodName) }
+
+    it 'returns an array of smell warnings' do
+      smells = detector.inspect(context)
+      expect(smells.length).to eq(1)
+      expect(smells[0]).to be_a_kind_of(Reek::Smells::SmellWarning)
+    end
+
+    it 'contains proper smell warnings' do
+      smells = detector.inspect(context)
+      warning = smells[0]
+
+      expect(warning.smell_type).to eq(Reek::Smells::UncommunicativeMethodName.smell_type)
+      expect(warning.parameters[:name]).to eq('x')
+      expect(warning.context).to match(/#{warning.parameters[:name]}/)
+      expect(warning.lines).to eq([1])
     end
   end
 
-  ['x', 'x2', 'method2'].each do |method_name|
-    context 'with a bad name' do
-      let(:warning) do
-        src = "def #{method_name}; end"
-        ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-        detector.inspect(ctx).first
+  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|
+        configuration = accept_configuration_for(described_class, pattern: pattern)
+        expect(source).to_not reek_of(described_class, {}, configuration)
       end
+    end
+  end
 
-      it_should_behave_like 'common fields set correctly'
+  describe '`reject` patterns' do
+    let(:source) { 'def helper; end' }
 
-      it 'reports the correct values' do
-        expect(warning.parameters[:name]).to eq(method_name)
-        expect(warning.lines).to eq([1])
-        expect(warning.context).to eq(method_name)
+    it 'reject smelly names via regex / strings given by list / literal' do
+      [[/helper/], /helper/, ['helper'], 'helper'].each do |pattern|
+        configuration = reject_configuration_for(described_class, pattern: pattern)
+        expect(source).to reek_of(described_class, {}, configuration)
       end
     end
   end
+
+  describe '.default_config' do
+    it 'should merge in the default accept and reject patterns' do
+      expected = {
+        'enabled' => true,
+        'exclude' => [],
+        'reject'  => [/^[a-z]$/, /[0-9]$/, /[A-Z]/],
+        'accept'  => []
+      }
+      expect(described_class.default_config).to eq(expected)
+    end
+  end
+
+  describe '.contexts' do
+    it 'should be scoped to classes and modules' do
+      expect(described_class.contexts).to eq([:def, :defs])
+    end
+  end
 end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -5,74 +5,87 @@ require_lib 'reek/context/code_context'
 
 RSpec.describe Reek::Smells::UncommunicativeModuleName do
   let(:detector) { build(:smell_detector, smell_type: :UncommunicativeModuleName) }
-
   it_should_behave_like 'SmellDetector'
 
-  ['class', 'module'].each do |type|
-    it 'does not report one-word name' do
-      expect("#{type} Helper; end").not_to reek_of(:UncommunicativeModuleName)
-    end
+  describe 'default configuration' do
+    ['class', 'module'].each do |type|
+      it 'does not report one-word name' do
+        expect("#{type} Helper; end").not_to reek_of(:UncommunicativeModuleName)
+      end
 
-    it 'reports one-letter name' do
-      expect("#{type} X; end").to reek_of(:UncommunicativeModuleName, name: 'X')
-    end
+      it 'reports one-letter name' do
+        expect("#{type} X; end").to reek_of(:UncommunicativeModuleName, name: 'X')
+      end
 
-    it 'reports name of the form "x2"' do
-      expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName, name: 'X2')
-    end
+      it 'reports name of the form "x2"' do
+        expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName, name: 'X2')
+      end
 
-    it 'reports long name ending in a number' do
-      expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName, name: 'Printer2')
+      it 'reports long name ending in a number' do
+        expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName, name: 'Printer2')
+      end
     end
+  end
+
+  describe 'inspect' do
+    let(:source) { 'class Foo::X; end' }
+    let(:context) { code_context(source) }
+    let(:detector) { build(:smell_detector, smell_type: :UncommunicativeModuleName) }
 
-    it 'reports a bad scoped name' do
-      src = "#{type} Foo::X; end"
-      ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      smells = detector.inspect(ctx)
+    it 'returns an array of smell warnings' do
+      smells = detector.inspect(context)
       expect(smells.length).to eq(1)
-      expect(smells[0].smell_type).to eq(Reek::Smells::UncommunicativeModuleName.smell_type)
-      expect(smells[0].parameters[:name]).to eq('X')
-      expect(smells[0].context).to match(/#{smells[0].parameters[:name]}/)
+      expect(smells[0]).to be_a_kind_of(Reek::Smells::SmellWarning)
     end
-  end
 
-  context 'accept patterns' do
-    let(:configuration) do
-      default_directive_for_smell = {
-        default_directive: {
-          Reek::Smells::UncommunicativeModuleName => {
-            'accept' => ['Inline::C']
-          }
-        }
-      }
-      Reek::Configuration::AppConfiguration.from_map(default_directive_for_smell)
+    it 'contains proper smell warnings' do
+      smells = detector.inspect(context)
+      warning = smells[0]
+
+      expect(warning.smell_type).to eq(Reek::Smells::UncommunicativeModuleName.smell_type)
+      expect(warning.parameters[:name]).to eq('X')
+      expect(warning.context).to match(/#{warning.parameters[:name]}/)
+      expect(warning.lines).to eq([1])
     end
+  end
 
-    it 'make smelly name pass' do
-      src = 'module Inline::C; end'
+  describe '`accept` patterns' do
+    let(:source) { 'class Classy1; end' }
 
-      expect(src).to_not reek_of(described_class, {}, configuration)
+    it 'make smelly names pass via regex / strings given by list / literal' do
+      [[/lassy/], /lassy/, ['lassy'], 'lassy'].each do |pattern|
+        configuration = accept_configuration_for(described_class, pattern: pattern)
+        expect(source).to_not reek_of(described_class, {}, configuration)
+      end
     end
+  end
 
-    it 'reports names with typos' do
-      src = 'module Inline::K; end'
+  describe '`reject` patterns' do
+    let(:source) { 'class BaseHelper; end' }
 
-      expect(src).to reek_of(described_class, {}, configuration)
+    it 'reject smelly names via regex / strings given by list / literal' do
+      [[/Helper/], /Helper/, ['Helper'], 'Helper'].each do |pattern|
+        configuration = reject_configuration_for(described_class, pattern: pattern)
+        expect(source).to reek_of(described_class, {}, configuration)
+      end
     end
   end
 
-  context 'looking at the YAML' do
-    let(:warning) do
-      src = 'module Printer2; end'
-      ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.inspect(ctx).first
+  describe '.default_config' do
+    it 'should merge in the default accept and reject patterns' do
+      expected = {
+        'enabled' => true,
+        'exclude' => [],
+        'reject'  => [/^.$/, /[0-9]$/],
+        'accept'  => []
+      }
+      expect(described_class.default_config).to eq(expected)
     end
+  end
 
-    it_should_behave_like 'common fields set correctly'
-
-    it 'reports the correct values' do
-      expect(warning.parameters[:name]).to eq('Printer2')
-      expect(warning.lines).to eq([1])
+  describe '.contexts' do
+    it 'should be scoped to classes and modules' do
+      expect(described_class.contexts).to eq([:module, :class])
     end
   end
 end

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -5,7 +5,6 @@ require_lib 'reek/context/method_context'
 
 RSpec.describe Reek::Smells::UncommunicativeParameterName do
   let(:detector) { build(:smell_detector, smell_type: :UncommunicativeParameterName) }
-
   it_should_behave_like 'SmellDetector'
 
   { 'obj.' => 'with a receiver',
@@ -73,18 +72,65 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
     end
   end
 
-  context 'looking at the smell result fields' do
-    let(:warning) do
-      src = 'def bad(good, bad2, good_again); basics(good, bad2, good_again); end'
-      ctx = Reek::Context::MethodContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.inspect(ctx).first
+  describe 'inspect' do
+    let(:source) { 'def foo(bar2); baz(bar2); end' }
+    let(:context) { method_context(source) }
+    let(:detector) { build(:smell_detector, smell_type: :UncommunicativeParameterName) }
+
+    it 'returns an array of smell warnings' do
+      smells = detector.inspect(context)
+      expect(smells.length).to eq(1)
+      expect(smells[0]).to be_a_kind_of(Reek::Smells::SmellWarning)
     end
 
-    it_should_behave_like 'common fields set correctly'
+    it 'contains proper smell warnings' do
+      smells = detector.inspect(context)
+      warning = smells[0]
 
-    it 'reports the correct values' do
-      expect(warning.parameters[:name]).to eq('bad2')
+      expect(warning.smell_type).to eq(Reek::Smells::UncommunicativeParameterName.smell_type)
+      expect(warning.parameters[:name]).to eq('bar2')
+      expect(warning.context).to match('foo')
       expect(warning.lines).to eq([1])
     end
   end
+
+  describe '`accept` patterns' do
+    let(:source) { 'def foo(bar2); baz(bar2); end' }
+
+    it 'make smelly names pass via regex / strings given by list / literal' do
+      [[/bar2/], /bar2/, ['bar2'], 'bar2'].each do |pattern|
+        configuration = accept_configuration_for(described_class, pattern: pattern)
+        expect(source).to_not reek_of(described_class, {}, configuration)
+      end
+    end
+  end
+
+  describe '`reject` patterns' do
+    let(:source) { 'def foo(bar); baz(bar); end' }
+
+    it 'reject smelly names via regex / strings given by list / literal' do
+      [[/bar/], /bar/, ['bar'], 'bar'].each do |pattern|
+        configuration = reject_configuration_for(described_class, pattern: pattern)
+        expect(source).to reek_of(described_class, {}, configuration)
+      end
+    end
+  end
+
+  describe '.default_config' do
+    it 'should merge in the default accept and reject patterns' do
+      expected = {
+        'enabled' => true,
+        'exclude' => [],
+        'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/, /^_/],
+        'accept'  => []
+      }
+      expect(described_class.default_config).to eq(expected)
+    end
+  end
+
+  describe '.contexts' do
+    it 'should be scoped to classes and modules' do
+      expect(described_class.contexts).to eq([:def, :defs])
+    end
+  end
 end

data/spec/reek/smells/unused_parameters_spec.rb

@@ -66,5 +66,14 @@ RSpec.describe Reek::Smells::UnusedParameters do
       expect('def simple(var, kw: :val, **args); @var, @kw, @args = var, kw, args; end').
         not_to reek_of(:UnusedParameters)
     end
+
+    it 'reports nothing when using a parameter via self assignment' do
+      expect('def simple(counter); counter += 1; end').not_to reek_of(:UnusedParameters)
+    end
+
+    it 'reports nothing when using a parameter on a rescue' do
+      expect('def simple(tries = 3); puts "nothing"; rescue; retry if tries -= 1 > 0; raise; end').
+        not_to reek_of(:UnusedParameters)
+    end
   end
 end

data/spec/reek/smells/unused_private_method_spec.rb

@@ -115,4 +115,42 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
       expect(source).not_to reek_of(:UnusedPrivateMethod)
     end
   end
+
+  describe 'prevent methods from being reported' do
+    let(:source) do
+      <<-EOF
+        class Car
+          private
+          def start; end
+          def drive; end
+        end
+      EOF
+    end
+
+    it 'excludes them via direct match in the app configuration' do
+      configuration = test_configuration_for(
+        described_class =>
+          {
+            Reek::Smells::SmellConfiguration::ENABLED_KEY => true,
+            Reek::Smells::SmellDetector::EXCLUDE_KEY => ['Car#drive']
+          }
+      )
+
+      expect(source).to reek_of(:UnusedPrivateMethod, { name: :start }, configuration)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, { name: :drive }, configuration)
+    end
+
+    it 'excludes them via regex in the app configuration' do
+      configuration = test_configuration_for(
+        described_class =>
+          {
+            Reek::Smells::SmellConfiguration::ENABLED_KEY => true,
+            Reek::Smells::SmellDetector::EXCLUDE_KEY => [/drive/]
+          }
+      )
+
+      expect(source).to reek_of(:UnusedPrivateMethod, { name: :start }, configuration)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, { name: :drive }, configuration)
+    end
+  end
 end

data/spec/reek/smells/utility_function_spec.rb

@@ -220,13 +220,11 @@ RSpec.describe Reek::Smells::UtilityFunction do
   describe 'disabling UtilityFunction via configuration for non-public methods' do
     let(:configuration) do
       default_directive = {
-        default_directive: {
-          Reek::Smells::UtilityFunction => {
-            Reek::Smells::UtilityFunction::PUBLIC_METHODS_ONLY_KEY => true
-          }
+        Reek::Smells::UtilityFunction => {
+          Reek::Smells::UtilityFunction::PUBLIC_METHODS_ONLY_KEY => true
         }
       }
-      Reek::Configuration::AppConfiguration.from_map(default_directive)
+      Reek::Configuration::AppConfiguration.from_hash(default_directive)
     end
 
     context 'public methods' do

data/spec/spec_helper.rb

@@ -27,7 +27,7 @@ module Helpers
     when Pathname
       configuration = Reek::Configuration::AppConfiguration.from_path(config)
     when Hash
-      configuration = Reek::Configuration::AppConfiguration.from_map default_directive: config
+      configuration = Reek::Configuration::AppConfiguration.from_hash config
     else
       raise "Unknown config given in `test_configuration_for`: #{config.inspect}"
     end
@@ -41,6 +41,33 @@ module Helpers
     Reek::Source::SourceCode.from(code).syntax_tree
   end
 
+  # @param code [String] The given code.
+  #
+  # @return syntax_tree [Reek::Context::CodeContext]
+  def code_context(code)
+    Reek::Context::CodeContext.new(nil, syntax_tree(code))
+  end
+
+  # @param code [String] The given code.
+  #
+  # @return syntax_tree [Reek::Context::MethodContext]
+  def method_context(code)
+    Reek::Context::MethodContext.new(nil, syntax_tree(code))
+  end
+
+  # Helper methods to generate a configuration for smell types that support
+  # `accept` and `reject` settings.
+  %w(accept reject).each do |switch|
+    define_method("#{switch}_configuration_for") do |smell_type, pattern:|
+      hash = {
+        smell_type => {
+          switch => pattern
+        }
+      }
+      Reek::Configuration::AppConfiguration.from_hash(hash)
+    end
+  end
+
   # :reek:UncommunicativeMethodName
   def sexp(type, *children)
     @klass_map ||= Reek::AST::ASTNodeClassMap.new