reek 4.7.2 → 4.7.3

data/lib/reek/smell_detectors/instance_variable_assumption.rb

@@ -19,32 +19,32 @@ 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],
+          context: context,
+          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,8 +53,8 @@ module Reek
         initialize_exp.each_node(:ivasgn).map(&:name)
       end
 
-      def variables_from_context(instance_methods)
-        instance_methods.map do |method|
+      def variables_from_context
+        method_expressions.map do |method|
           method.find_nodes(assumption_nodes, ignored_nodes).map(&:name)
         end.flatten
       end

data/lib/reek/smell_detectors/irresponsible_module.rb

@@ -19,24 +19,18 @@ 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],
+          context: context,
+          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

@@ -32,17 +32,21 @@ 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],
+          context: context,
+          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

@@ -24,21 +24,25 @@ 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|
+      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,
+            context: context,
             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

@@ -19,12 +19,11 @@ module Reek
       #
       # @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.each_node(: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(context: context, lines: lines, message: MESSAGE)]
       end
     end
   end

data/lib/reek/smell_detectors/module_initialize.rb

@@ -20,13 +20,12 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        ctx.local_nodes(:def) do |node|
+      def sniff
+        context.local_nodes(:def) do |node|
           if node.name == :initialize
             return smell_warning(
-              context: ctx,
-              lines:   [ctx.exp.line],
+              context: context,
+              lines:   [source_line],
               message: 'has initialize method')
           end
         end

data/lib/reek/smell_detectors/nested_iterators.rb

@@ -41,14 +41,11 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        configure_ignore_iterators ctx
-        violations = find_violations ctx
-
-        violations.group_by(&:depth).map do |depth, group|
+      def sniff
+        find_violations.group_by(&:depth).map do |depth, group|
           lines = group.map(&:line)
           smell_warning(
-            context: ctx,
+            context: context,
             lines: lines,
             message: "contains iterators nested #{depth} deep",
             parameters: { depth: depth })
@@ -57,8 +54,6 @@ module Reek
 
       private
 
-      attr_accessor :ignore_iterators
-
       # Finds the set of independent most deeply nested iterators that are
       # nested more deeply than allowed.
       #
@@ -69,10 +64,8 @@ module Reek
       #
       # @return [Array<Iterator>]
       #
-      def find_violations(ctx)
-        candidates = find_candidates ctx
-        max_allowed_nesting = max_nesting(ctx)
-        candidates.select { |it| it.depth > max_allowed_nesting }
+      def find_violations
+        find_candidates.select { |it| it.depth > max_allowed_nesting }
       end
 
       # Finds the set of independent most deeply nested iterators regardless of
@@ -80,9 +73,8 @@ module Reek
       #
       # @return [Array<Iterator>]
       #
-      def find_candidates(ctx)
-        exp = ctx.exp
-        scout(exp: exp, depth: 0)
+      def find_candidates
+        scout(exp: expression, depth: 0)
       end
 
       # A little digression into parser's sexp is necessary here:
@@ -121,16 +113,16 @@ module Reek
         end
       end
 
-      def configure_ignore_iterators(ctx)
-        self.ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx)
+      def ignore_iterators
+        @ignore_iterators ||= value(IGNORE_ITERATORS_KEY, context)
       end
 
       def increment_depth(iterator, depth)
         ignored_iterator?(iterator) ? depth : depth + 1
       end
 
-      def max_nesting(ctx)
-        value(MAX_ALLOWED_NESTING_KEY, ctx)
+      def max_allowed_nesting
+        @max_allowed_nesting ||= value(MAX_ALLOWED_NESTING_KEY, context)
       end
 
       # :reek:FeatureEnvy

data/lib/reek/smell_detectors/nil_check.rb

@@ -9,11 +9,11 @@ module Reek
     #
     # See {file:docs/Nil-Check.md} for details.
     class NilCheck < BaseDetector
-      def sniff(ctx)
-        lines = NodeDetector.new(ctx).detect.map(&:line)
+      def sniff
+        lines = detect_nodes.map(&:line)
         if lines.any?
           [smell_warning(
-            context: ctx,
+            context: context,
             lines: lines,
             message: 'performs a nil-check')]
         else
@@ -21,19 +21,13 @@ module Reek
         end
       end
 
-      # Detect all nodes that smell of NilCheck
-      class NodeDetector
-        attr_reader :ctx
-        def initialize(ctx)
-          @ctx = ctx
-        end
+      private
 
-        def detect
-          finders = [NodeFinder.new(ctx, :send, NilCallNodeDetector),
-                     NodeFinder.new(ctx, :when, NilWhenNodeDetector),
-                     NodeFinder.new(ctx, :csend, SafeNavigationNodeDetector)]
-          finders.flat_map(&:smelly_nodes)
-        end
+      def detect_nodes
+        finders = [NodeFinder.new(context, :send, NilCallNodeDetector),
+                   NodeFinder.new(context, :when, NilWhenNodeDetector),
+                   NodeFinder.new(context, :csend, SafeNavigationNodeDetector)]
+        finders.flat_map(&:smelly_nodes)
       end
 
       #

data/lib/reek/smell_detectors/prima_donna_method.rb

@@ -30,7 +30,6 @@ module Reek
       end
 
       #
-      # @param ctx [Context::ModuleContext]
       # @return [Array<SmellWarning>]
       #
       # Given this code:
@@ -40,21 +39,21 @@ module Reek
       #   end
       # end
       #
-      # An example `ctx` could look like this:
+      # An example context could look like this:
       #
       # s(:class,
       #   s(:const, nil, :Alfa), nil,
       #     s(:def, :bravo!,
       #       s(:args), nil))
       #
-      def sniff(ctx)
-        ctx.node_instance_methods.select do |method_sexp|
-          prima_donna_method?(method_sexp, ctx)
+      def sniff
+        context.node_instance_methods.select do |method_sexp|
+          prima_donna_method?(method_sexp)
         end.map do |method_sexp|
           name = method_sexp.name
           smell_warning(
-            context: ctx,
-            lines: [ctx.exp.line],
+            context: context,
+            lines: [method_sexp.line],
             message: "has prima donna method '#{name}'",
             parameters: { name: name.to_s })
         end
@@ -62,16 +61,15 @@ module Reek
 
       private
 
-      def prima_donna_method?(method_sexp, ctx)
+      def prima_donna_method?(method_sexp)
         return false unless method_sexp.ends_with_bang?
-        return false if ignore_method?(method_sexp, ctx)
-        return false if version_without_bang_exists?(method_sexp, ctx)
+        return false if ignore_method? method_sexp
+        return false if version_without_bang_exists? method_sexp
         true
       end
 
-      # :reek:UtilityFunction
-      def version_without_bang_exists?(method_sexp, ctx)
-        ctx.node_instance_methods.find do |sexp_item|
+      def version_without_bang_exists?(method_sexp)
+        context.node_instance_methods.find do |sexp_item|
           sexp_item.name.to_s == method_sexp.name_without_bang
         end
       end
@@ -79,13 +77,16 @@ module Reek
       #
       # @param method_node [Reek::AST::Node],
       #   e.g. s(:def, :bravo!, s(:args), nil)
-      # @param ctx [Context::ModuleContext]
       # @return [Boolean]
       #
-      def ignore_method?(method_node, ctx)
-        ignore_method_names = value(EXCLUDE_KEY, ctx) # e.g. ["bravo!"]
+      def ignore_method?(method_node)
         ignore_method_names.include? method_node.name.to_s # method_node.name is e.g.: :bravo!
       end
+
+      # e.g. ["bravo!"]
+      def ignore_method_names
+        @ignore_method_names ||= value(EXCLUDE_KEY, context)
+      end
     end
   end
 end

data/lib/reek/smell_detectors/repeated_conditional.rb

@@ -46,38 +46,41 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:TooManyStatements: { max_statements: 6 }
       # :reek:DuplicateMethodCall: { max_calls: 2 }
-      def sniff(ctx)
-        max_identical_ifs = value(MAX_IDENTICAL_IFS_KEY, ctx)
-        conditional_counts(ctx).select do |_key, lines|
+      def sniff
+        conditional_counts.select do |_key, lines|
           lines.length > max_identical_ifs
         end.map do |key, lines|
           occurs = lines.length
           expression = key.format_to_ruby
           smell_warning(
-            context: ctx,
+            context: context,
             lines: lines,
             message: "tests '#{expression}' at least #{occurs} times",
             parameters: { name: expression, count: occurs })
         end
       end
 
+      private
+
+      def max_identical_ifs
+        @max_identical_ifs ||= value(MAX_IDENTICAL_IFS_KEY, context)
+      end
+
       #
       # Returns a Hash listing all of the conditional expressions in
       # the given syntax tree together with the number of times each
       # occurs. Ignores nested classes and modules.
       #
       # :reek:TooManyStatements: { max_statements: 9 }
-      # :reek:FeatureEnvy
-      def conditional_counts(sexp)
+      def conditional_counts
         result = Hash.new { |hash, key| hash[key] = [] }
         collector = proc do |node|
           next unless (condition = node.condition)
           next if condition == BLOCK_GIVEN_CONDITION
           result[condition].push(condition.line)
         end
-        [:if, :case].each { |stmt| sexp.local_nodes(stmt, &collector) }
+        [:if, :case].each { |stmt| context.local_nodes(stmt, &collector) }
         result
       end
     end

data/lib/reek/smell_detectors/subclassed_from_core_class.rb

@@ -26,26 +26,26 @@ module Reek
       # class Foo < Bar; end;
       #
       # @return [Array<SmellWarning>]
-      def sniff(ctx)
-        superclass = ctx.exp.superclass
+      def sniff
+        superclass = expression.superclass
 
         return [] unless superclass
 
-        sniff_superclass(ctx, superclass.name)
+        sniff_superclass superclass.name
       end
 
       private
 
-      def sniff_superclass(ctx, superclass_name)
+      def sniff_superclass(superclass_name)
         return [] unless CORE_CLASSES.include?(superclass_name)
 
-        [build_smell_warning(ctx, superclass_name)]
+        [build_smell_warning(superclass_name)]
       end
 
-      def build_smell_warning(ctx, ancestor_name)
+      def build_smell_warning(ancestor_name)
         smell_attributes = {
-          context: ctx,
-          lines: [ctx.exp.line],
+          context: context,
+          lines: [source_line],
           message: "inherits from core class '#{ancestor_name}'",
           parameters: { ancestor: ancestor_name }
         }