reek 4.7.1 → 5.0.0

data/lib/reek/smell_detectors/base_detector.rb

@@ -15,40 +15,33 @@ module Reek
     #   - {file:README.md}
     # for details.
     #
-    # :reek:UnusedPrivateMethod: { exclude: [ smell_warning ] }
-    # :reek:TooManyMethods: { max_methods: 18 }
+    # @quality :reek:UnusedPrivateMethod { exclude: [ smell_warning ] }
+    # @quality :reek:TooManyMethods { max_methods: 18 }
     class BaseDetector
       attr_reader :config
       # The name of the config field that lists the names of code contexts
       # that should not be checked. Add this field to the config for each
       # smell that should ignore this code element.
-      EXCLUDE_KEY = 'exclude'.freeze
+      EXCLUDE_KEY = 'exclude'
 
       # The default value for the +EXCLUDE_KEY+ if it isn't specified
       # in any configuration file.
       DEFAULT_EXCLUDE_SET = [].freeze
 
-      def initialize(config = {})
-        @config = SmellConfiguration.new self.class.default_config.merge(config)
+      def initialize(configuration: {}, context: nil)
+        @config = SmellConfiguration.new self.class.default_config.merge(configuration)
+        @context = context
       end
 
       def smell_type
         self.class.smell_type
       end
 
-      def contexts
-        self.class.contexts
-      end
-
-      def run_for(context)
-        return [] unless enabled_for?(context)
-        return [] if exception?(context)
+      def run
+        return [] unless enabled?
+        return [] if exception?
 
-        sniff(context)
-      end
-
-      def exception?(context)
-        context.matches?(value(EXCLUDE_KEY, context))
+        sniff
       end
 
       def self.todo_configuration_for(smells)
@@ -59,7 +52,21 @@ module Reek
 
       private
 
-      def enabled_for?(context)
+      attr_reader :context
+
+      def expression
+        @expression ||= context.exp
+      end
+
+      def source_line
+        @source_line ||= expression.line
+      end
+
+      def exception?
+        context.matches?(value(EXCLUDE_KEY, context))
+      end
+
+      def enabled?
         config.enabled? && config_for(context)[SmellConfiguration::ENABLED_KEY] != false
       end
 
@@ -71,12 +78,9 @@ module Reek
         ctx.config_for(self.class)
       end
 
-      # :reek:FeatureEnvy
-      def smell_warning(options = {})
-        context = options.fetch(:context)
-        exp = context.exp
+      def smell_warning(**options)
         SmellWarning.new(self,
-                         source: exp.source,
+                         source: expression.source,
                          context: context.full_name,
                          lines: options.fetch(:lines),
                          message: options.fetch(:message),
@@ -92,7 +96,7 @@ module Reek
           [:def, :defs]
         end
 
-        # :reek:UtilityFunction
+        # @quality :reek:UtilityFunction
         def default_config
           {
             SmellConfiguration::ENABLED_KEY => true,
@@ -131,14 +135,14 @@ module Reek
         # Note that we assume a valid name - exceptions are not handled here.
         #
         # @param detector_name [String] the detector in question, e.g. 'DuplicateMethodCall'
-        # @return [SmellDetector] - this will return the class, not an instance
+        # @return [SmellDetector] this will return the class, not an instance
         #
         def to_detector(detector_name)
           SmellDetectors.const_get detector_name
         end
 
         #
-        # @return [Set<Symbol>] - all configuration keys that are available for this detector
+        # @return [Set<Symbol>] all configuration keys that are available for this detector
         #
         def configuration_keys
           Set.new(default_config.keys.map(&:to_sym))

data/lib/reek/smell_detectors/boolean_parameter.rb

@@ -19,14 +19,12 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        ctx.default_assignments.select do |_parameter, value|
+      def sniff
+        context.default_assignments.select do |_parameter, value|
           [:true, :false].include?(value.type)
         end.map do |parameter, _value|
           smell_warning(
-            context: ctx,
-            lines: [ctx.exp.line],
+            lines: [source_line],
             message: "has boolean parameter '#{parameter}'",
             parameters: { parameter: parameter.to_s })
         end

data/lib/reek/smell_detectors/class_variable.rb

@@ -24,10 +24,10 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        class_variables_in(ctx.exp).map do |variable, lines|
+      def sniff
+        class_variables_in_context.map do |variable, occurences|
+          lines = occurences.map(&:line)
           smell_warning(
-            context: ctx,
             lines: lines,
             message: "declares the class variable '#{variable}'",
             parameters: { name: variable.to_s })
@@ -38,17 +38,8 @@ module Reek
       # Collects the names of the class variables declared and/or used
       # in the given module.
       #
-      # :reek:TooManyStatements: { max_statements: 7 }
-      # :reek:FeatureEnvy
-      def class_variables_in(exp)
-        result = Hash.new { |hash, key| hash[key] = [] }
-        collector = proc do |cvar_node|
-          result[cvar_node.name].push(cvar_node.line)
-        end
-        [:cvar, :cvasgn, :cvdecl].each do |stmt_type|
-          exp.each_node(stmt_type, [:class, :module], &collector)
-        end
-        result
+      def class_variables_in_context
+        context.local_nodes([:cvar, :cvasgn, :cvdecl]).group_by(&:name)
       end
     end
   end

data/lib/reek/smell_detectors/control_parameter.rb

@@ -49,18 +49,32 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        ControlParameterCollector.new(ctx).control_parameters.map do |control_parameter|
+      def sniff
+        control_parameters.map do |control_parameter|
           argument = control_parameter.name.to_s
           smell_warning(
-            context: ctx,
             lines: control_parameter.lines,
             message: "is controlled by argument '#{argument}'",
             parameters: { argument: argument })
         end
       end
 
+      private
+
+      def control_parameters
+        potential_parameters.
+          map { |param| FoundControlParameter.new(param, find_matches(param)) }.
+          select(&:smells?)
+      end
+
+      def potential_parameters
+        expression.parameter_names
+      end
+
+      def find_matches(param)
+        ControlParameterFinder.new(expression, param).find_matches
+      end
+
       #
       # Collects information about a single control parameter.
       #
@@ -166,35 +180,6 @@ module Reek
       end
 
       private_constant :ControlParameterFinder
-
-      #
-      # Collects all control parameters in a given context.
-      #
-      class ControlParameterCollector
-        def initialize(context)
-          @context = context
-        end
-
-        def control_parameters
-          potential_parameters.
-            map { |param| FoundControlParameter.new(param, find_matches(param)) }.
-            select(&:smells?)
-        end
-
-        private
-
-        attr_reader :context
-
-        def potential_parameters
-          context.exp.parameter_names
-        end
-
-        def find_matches(param)
-          ControlParameterFinder.new(context.exp, param).find_matches
-        end
-      end
-
-      private_constant :ControlParameterCollector
     end
   end
 end

data/lib/reek/smell_detectors/data_clump.rb

@@ -24,7 +24,7 @@ module Reek
       # reported as a DataClump unless there are more than this many
       # methods containing those parameters.
       #
-      MAX_COPIES_KEY = 'max_copies'.freeze
+      MAX_COPIES_KEY = 'max_copies'
       DEFAULT_MAX_COPIES = 2
 
       #
@@ -32,7 +32,7 @@ module Reek
       # size. No group of common parameters will be reported as
       # a DataClump unless it contains at least this many parameters.
       #
-      MIN_CLUMP_SIZE_KEY = 'min_clump_size'.freeze
+      MIN_CLUMP_SIZE_KEY = 'min_clump_size'
       DEFAULT_MIN_CLUMP_SIZE = 2
 
       def self.contexts # :nodoc:
@@ -50,14 +50,10 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        max_copies = value(MAX_COPIES_KEY, ctx)
-        min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx)
-        MethodGroup.new(ctx, min_clump_size, max_copies).clumps.map do |clump, methods|
+      def sniff
+        MethodGroup.new(context, min_clump_size, max_copies).clumps.map do |clump, methods|
           methods_length = methods.length
           smell_warning(
-            context: ctx,
             lines: methods.map(&:line),
             message: "takes parameters #{DataClump.print_clump(clump)} " \
                      "to #{methods_length} methods",
@@ -72,6 +68,16 @@ module Reek
       def self.print_clump(clump)
         "[#{clump.map { |parameter| "'#{parameter}'" }.join(', ')}]"
       end
+
+      private
+
+      def max_copies
+        value(MAX_COPIES_KEY, context)
+      end
+
+      def min_clump_size
+        value(MIN_CLUMP_SIZE_KEY, context)
+      end
     end
   end
 
@@ -94,7 +100,7 @@ module Reek
       end.uniq
     end
 
-    # :reek:UtilityFunction
+    # @quality :reek:UtilityFunction
     def common_argument_names_for(methods)
       methods.map(&:arg_names).inject(:&)
     end

data/lib/reek/smell_detectors/duplicate_method_call.rb

@@ -21,13 +21,13 @@ module Reek
     class DuplicateMethodCall < BaseDetector
       # The name of the config field that sets the maximum number of
       # identical calls to be permitted within any single method.
-      MAX_ALLOWED_CALLS_KEY = 'max_calls'.freeze
+      MAX_ALLOWED_CALLS_KEY = 'max_calls'
       DEFAULT_MAX_CALLS = 1
 
       # The name of the config field that sets the names of any
       # methods for which identical calls should be to be permitted
       # within any single method.
-      ALLOW_CALLS_KEY = 'allow_calls'.freeze
+      ALLOW_CALLS_KEY = 'allow_calls'
       DEFAULT_ALLOW_CALLS = [].freeze
 
       def self.default_config
@@ -37,26 +37,32 @@ module Reek
       end
 
       #
-      # Looks for duplicate calls within the body of the method +ctx+.
+      # Looks for duplicate calls within the body of the method context.
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      # :reek:DuplicateMethodCall: { max_calls: 2 }
-      def sniff(ctx)
-        max_allowed_calls = value(MAX_ALLOWED_CALLS_KEY, ctx)
-        allow_calls = value(ALLOW_CALLS_KEY, ctx)
-
-        collector = CallCollector.new(ctx, max_allowed_calls, allow_calls)
+      def sniff
+        collector = CallCollector.new(context, max_allowed_calls, allow_calls)
         collector.smelly_calls.map do |found_call|
+          call = found_call.call
+          occurs = found_call.occurs
           smell_warning(
-            context: ctx,
             lines: found_call.lines,
-            message: "calls '#{found_call.call}' #{found_call.occurs} times",
-            parameters: { name: found_call.call, count: found_call.occurs })
+            message: "calls '#{call}' #{occurs} times",
+            parameters: { name: call, count: occurs })
         end
       end
 
+      private
+
+      def max_allowed_calls
+        value(MAX_ALLOWED_CALLS_KEY, context)
+      end
+
+      def allow_calls
+        value(ALLOW_CALLS_KEY, context)
+      end
+
       # Collects information about a single found call
       class FoundCall
         def initialize(call_node)
@@ -111,10 +117,10 @@ module Reek
 
         attr_reader :allow_calls, :max_allowed_calls
 
-        # :reek:TooManyStatements: { max_statements: 6 }
-        # :reek:DuplicateMethodCall: { max_calls: 2 }
+        # @quality :reek:TooManyStatements { max_statements: 6 }
+        # @quality :reek:DuplicateMethodCall { max_calls: 2 }
         def collect_calls(result)
-          context.each_node(:send, [:mlhs]) do |call_node|
+          context.local_nodes(:send, [:mlhs]) do |call_node|
             next if call_node.object_creation_call?
             next if simple_method_call? call_node
             result[call_node].record(call_node)
@@ -128,7 +134,7 @@ module Reek
           found_call.occurs > max_allowed_calls && !allow_calls?(found_call.call)
         end
 
-        # :reek:UtilityFunction
+        # @quality :reek:UtilityFunction
         def simple_method_call?(call_node)
           !call_node.receiver && call_node.args.empty?
         end

data/lib/reek/smell_detectors/feature_envy.rb

@@ -42,11 +42,11 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        return [] unless ctx.references_self?
-        envious_receivers(ctx).map do |name, lines|
+      def sniff
+        return [] if context.singleton_method? || context.module_function?
+        return [] unless context.references_self?
+        envious_receivers.map do |name, lines|
           smell_warning(
-            context: ctx,
             lines: lines,
             message: "refers to '#{name}' more than self (maybe move it to another class?)",
             parameters: { name: name.to_s })
@@ -55,9 +55,11 @@ module Reek
 
       private
 
-      # :reek:UtilityFunction
-      def envious_receivers(ctx)
-        refs = ctx.refs
+      def refs
+        @refs ||= context.refs
+      end
+
+      def envious_receivers
         return {} if refs.self_is_max?
         refs.most_popular
       end

data/lib/reek/smell_detectors/instance_variable_assumption.rb

@@ -19,32 +19,31 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        method_expressions = ctx.node_instance_methods
-
-        assumptions = (variables_from_context(method_expressions) -
-          variables_from_initialize(method_expressions)).uniq
+      def sniff
+        assumptions = (variables_from_context - variables_from_initialize).uniq
 
         assumptions.map do |assumption|
-          build_smell_warning(ctx, assumption)
+          build_smell_warning(assumption)
         end
       end
 
       private
 
-      def build_smell_warning(ctx, assumption)
+      def method_expressions
+        @method_expressions ||= context.node_instance_methods
+      end
+
+      def build_smell_warning(assumption)
         message = "assumes too much for instance variable '#{assumption}'"
 
         smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          lines: [source_line],
           message: message,
           parameters: { assumption: assumption.to_s })
       end
 
-      # :reek:UtilityFunction
-      def variables_from_initialize(instance_methods)
-        initialize_exp = instance_methods.detect do |method|
+      def variables_from_initialize
+        initialize_exp = method_expressions.detect do |method|
           method.name == :initialize
         end
 
@@ -53,19 +52,11 @@ module Reek
         initialize_exp.each_node(:ivasgn).map(&:name)
       end
 
-      def variables_from_context(instance_methods)
-        instance_methods.map do |method|
-          method.find_nodes(assumption_nodes, ignored_nodes).map(&:name)
+      def variables_from_context
+        method_expressions.map do |method|
+          method.each_node(:ivar, [:or_asgn]).map(&:name)
         end.flatten
       end
-
-      def assumption_nodes
-        [:ivar]
-      end
-
-      def ignored_nodes
-        [:or_asgn]
-      end
     end
   end
 end

data/lib/reek/smell_detectors/irresponsible_module.rb

@@ -19,24 +19,17 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        return [] if descriptive?(ctx) || ctx.namespace_module?
-        expression = ctx.exp
+      def sniff
+        return [] if descriptive_context? || context.namespace_module?
         [smell_warning(
-          context: ctx,
-          lines: [expression.line],
+          lines: [source_line],
           message: 'has no descriptive comment')]
       end
 
       private
 
-      def descriptive
-        @descriptive ||= {}
-      end
-
-      # :reek:FeatureEnvy
-      def descriptive?(ctx)
-        descriptive[ctx.full_name] ||= ctx.descriptively_commented?
+      def descriptive_context?
+        context.descriptively_commented?
       end
     end
   end

data/lib/reek/smell_detectors/long_parameter_list.rb

@@ -16,7 +16,7 @@ module Reek
     class LongParameterList < BaseDetector
       # The name of the config field that sets the maximum number of
       # parameters permitted in any method or block.
-      MAX_ALLOWED_PARAMS_KEY = 'max_params'.freeze
+      MAX_ALLOWED_PARAMS_KEY = 'max_params'
       DEFAULT_MAX_ALLOWED_PARAMS = 3
 
       def self.default_config
@@ -32,17 +32,20 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY, ctx)
-        exp = ctx.exp
-        count = exp.arg_names.length
+      def sniff
+        count = expression.arg_names.length
         return [] if count <= max_allowed_params
         [smell_warning(
-          context: ctx,
-          lines: [exp.line],
+          lines: [source_line],
           message: "has #{count} parameters",
           parameters: { count: count })]
       end
+
+      private
+
+      def max_allowed_params
+        value(MAX_ALLOWED_PARAMS_KEY, context)
+      end
     end
   end
 end

data/lib/reek/smell_detectors/long_yield_list.rb

@@ -12,7 +12,7 @@ module Reek
     class LongYieldList < BaseDetector
       # The name of the config field that sets the maximum number of
       # parameters permitted in any method or block.
-      MAX_ALLOWED_PARAMS_KEY = 'max_params'.freeze
+      MAX_ALLOWED_PARAMS_KEY = 'max_params'
       DEFAULT_MAX_ALLOWED_PARAMS = 3
 
       def self.default_config
@@ -24,21 +24,24 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      # :reek:DuplicateMethodCall: { max_calls: 2 }
-      def sniff(ctx)
-        max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY, ctx)
-        ctx.local_nodes(:yield).select do |yield_node|
+      # @quality :reek:DuplicateMethodCall { max_calls: 2 }
+      def sniff
+        context.local_nodes(:yield).select do |yield_node|
           yield_node.args.length > max_allowed_params
         end.map do |yield_node|
           count = yield_node.args.length
           smell_warning(
-            context: ctx,
             lines: [yield_node.line],
             message: "yields #{count} parameters",
             parameters: { count: count })
         end
       end
+
+      private
+
+      def max_allowed_params
+        value(MAX_ALLOWED_PARAMS_KEY, context)
+      end
     end
   end
 end

data/lib/reek/smell_detectors/manual_dispatch.rb

@@ -12,19 +12,18 @@ module Reek
     #
     # See {file:docs/Manual-Dispatch.md} for details.
     class ManualDispatch < BaseDetector
-      MESSAGE = 'manually dispatches method call'.freeze
+      MESSAGE = 'manually dispatches method call'
 
       #
       # Checks for +respond_to?+ usage within the given method
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        smelly_nodes = ctx.each_node(:send).select { |node| node.name == :respond_to? }
+      def sniff
+        smelly_nodes = context.local_nodes(:send).select { |node| node.name == :respond_to? }
         return [] if smelly_nodes.empty?
         lines = smelly_nodes.map(&:line)
-        [smell_warning(context: ctx, lines: lines, message: MESSAGE)]
+        [smell_warning(lines: lines, message: MESSAGE)]
       end
     end
   end