reek 4.6.0 → 5.0.0

data/lib/reek/smell_detectors/nested_iterators.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -19,12 +20,12 @@ module Reek
 
       # The name of the config field that sets the maximum depth
       # of nested iterators to be permitted within any single method.
-      MAX_ALLOWED_NESTING_KEY = 'max_allowed_nesting'.freeze
+      MAX_ALLOWED_NESTING_KEY = 'max_allowed_nesting'
       DEFAULT_MAX_ALLOWED_NESTING = 1
 
       # The name of the config field that sets the names of any
       # methods for which nesting should not be considered
-      IGNORE_ITERATORS_KEY = 'ignore_iterators'.freeze
+      IGNORE_ITERATORS_KEY = 'ignore_iterators'
       DEFAULT_IGNORE_ITERATORS = ['tap'].freeze
 
       def self.default_config
@@ -40,14 +41,10 @@ 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,
             lines: lines,
             message: "contains iterators nested #{depth} deep",
             parameters: { depth: depth })
@@ -56,8 +53,6 @@ module Reek
 
       private
 
-      attr_accessor :ignore_iterators
-
       # Finds the set of independent most deeply nested iterators that are
       # nested more deeply than allowed.
       #
@@ -68,10 +63,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
@@ -79,9 +72,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:
@@ -101,10 +93,11 @@ module Reek
       #
       # @return [Array<Iterator>]
       #
-      # :reek:TooManyStatements: { max_statements: 6 }
+      # @quality :reek:TooManyStatements { max_statements: 6 }
       def scout(exp:, depth:)
         return [] unless exp
-        exp.find_nodes([:block]).flat_map do |iterator|
+        # Find all non-nested blocks in this expression
+        exp.each_node([:block], [:block]).flat_map do |iterator|
           new_depth = increment_depth(iterator, depth)
           # 1st case: we recurse down the given block of the iterator. In this case
           # we need to check if we should increment the depth.
@@ -120,19 +113,19 @@ 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
+      # @quality :reek:FeatureEnvy
       def ignored_iterator?(exp)
         ignore_iterators.any? { |pattern| /#{pattern}/ =~ exp.call.name } ||
           exp.without_block_arguments?

data/lib/reek/smell_detectors/nil_check.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -8,11 +9,10 @@ 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,
             lines: lines,
             message: 'performs a nil-check')]
         else
@@ -20,19 +20,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/repeated_conditional.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../ast/node'
 require_relative 'base_detector'
 
@@ -27,7 +28,7 @@ module Reek
     class RepeatedConditional < BaseDetector
       # The name of the config field that sets the maximum number of
       # identical conditionals permitted within any single class.
-      MAX_IDENTICAL_IFS_KEY = 'max_ifs'.freeze
+      MAX_IDENTICAL_IFS_KEY = 'max_ifs'
       DEFAULT_MAX_IFS = 2
 
       BLOCK_GIVEN_CONDITION = ::Parser::AST::Node.new(:send, [nil, :block_given?])
@@ -45,38 +46,40 @@ 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|
+      # @quality :reek:DuplicateMethodCall { max_calls: 2 }
+      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,
             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)
+      # @quality :reek:TooManyStatements { max_statements: 9 }
+      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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -25,26 +26,25 @@ 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],
+          lines: [source_line],
           message: "inherits from core class '#{ancestor_name}'",
           parameters: { ancestor: ancestor_name }
         }

data/lib/reek/smell_detectors/too_many_constants.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -14,7 +15,7 @@ module Reek
     class TooManyConstants < BaseDetector
       # The name of the config field that sets the maximum number
       # of constants permitted in a class.
-      MAX_ALLOWED_CONSTANTS_KEY = 'max_constants'.freeze
+      MAX_ALLOWED_CONSTANTS_KEY = 'max_constants'
       DEFAULT_MAX_CONSTANTS = 5
       IGNORED_NODES = [:module, :class].freeze
 
@@ -33,22 +34,23 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        max_allowed_constants = value(MAX_ALLOWED_CONSTANTS_KEY, ctx)
-
-        count = ctx.each_node(:casgn, IGNORED_NODES).delete_if(&:defines_module?).length
+      def sniff
+        count = context.local_nodes(:casgn).reject(&:defines_module?).length
 
         return [] if count <= max_allowed_constants
 
-        build_smell_warning(ctx, count)
+        build_smell_warning(count)
       end
 
       private
 
-      def build_smell_warning(ctx, count)
+      def max_allowed_constants
+        value(MAX_ALLOWED_CONSTANTS_KEY, context)
+      end
+
+      def build_smell_warning(count)
         [smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          lines: [source_line],
           message: "has #{count} constants",
           parameters: { count: count })]
       end

data/lib/reek/smell_detectors/too_many_instance_variables.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -14,7 +15,7 @@ module Reek
     class TooManyInstanceVariables < BaseDetector
       # The name of the config field that sets the maximum number of instance
       # variables permitted in a class.
-      MAX_ALLOWED_IVARS_KEY = 'max_instance_variables'.freeze
+      MAX_ALLOWED_IVARS_KEY = 'max_instance_variables'
       DEFAULT_MAX_IVARS = 4
 
       def self.contexts
@@ -32,17 +33,21 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        max_allowed_ivars = value(MAX_ALLOWED_IVARS_KEY, ctx)
-        variables = ctx.local_nodes(:ivasgn, [:or_asgn]).map(&:name)
+      def sniff
+        variables = context.local_nodes(:ivasgn, [:or_asgn]).map(&:name)
         count = variables.uniq.size
         return [] if count <= max_allowed_ivars
         [smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          lines: [source_line],
           message: "has at least #{count} instance variables",
           parameters: { count: count })]
       end
+
+      private
+
+      def max_allowed_ivars
+        value(MAX_ALLOWED_IVARS_KEY, context)
+      end
     end
   end
 end

data/lib/reek/smell_detectors/too_many_methods.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -16,7 +17,7 @@ module Reek
     class TooManyMethods < BaseDetector
       # The name of the config field that sets the maximum number of methods
       # permitted in a class.
-      MAX_ALLOWED_METHODS_KEY = 'max_methods'.freeze
+      MAX_ALLOWED_METHODS_KEY = 'max_methods'
       DEFAULT_MAX_METHODS = 15
 
       def self.contexts
@@ -30,21 +31,25 @@ module Reek
       end
 
       #
-      # Checks +ctx+ for too many methods
+      # Checks context for too many methods
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        max_allowed_methods = value(MAX_ALLOWED_METHODS_KEY, ctx)
+      def sniff
         # TODO: Only checks instance methods!
-        actual = ctx.node_instance_methods.length
+        actual = context.node_instance_methods.length
         return [] if actual <= max_allowed_methods
         [smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          lines: [source_line],
           message: "has at least #{actual} methods",
           parameters: { count: actual })]
       end
+
+      private
+
+      def max_allowed_methods
+        value(MAX_ALLOWED_METHODS_KEY, context)
+      end
     end
   end
 end

data/lib/reek/smell_detectors/too_many_statements.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -12,7 +13,7 @@ module Reek
     class TooManyStatements < BaseDetector
       # The name of the config field that sets the maximum number of
       # statements permitted in any method.
-      MAX_ALLOWED_STATEMENTS_KEY = 'max_statements'.freeze
+      MAX_ALLOWED_STATEMENTS_KEY = 'max_statements'
       DEFAULT_MAX_STATEMENTS = 5
 
       def self.default_config
@@ -26,16 +27,20 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        max_allowed_statements = value(MAX_ALLOWED_STATEMENTS_KEY, ctx)
-        count = ctx.number_of_statements
+      def sniff
+        count = context.number_of_statements
         return [] if count <= max_allowed_statements
         [smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          lines: [source_line],
           message: "has approx #{count} statements",
           parameters: { count: count })]
       end
+
+      private
+
+      def max_allowed_statements
+        value(MAX_ALLOWED_STATEMENTS_KEY, context)
+      end
     end
   end
 end

data/lib/reek/smell_detectors/uncommunicative_method_name.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -19,8 +20,8 @@ module Reek
     #
     # See {file:docs/Uncommunicative-Method-Name.md} for details.
     class UncommunicativeMethodName < BaseDetector
-      REJECT_KEY = 'reject'.freeze
-      ACCEPT_KEY = 'accept'.freeze
+      REJECT_KEY = 'reject'
+      ACCEPT_KEY = 'accept'
       DEFAULT_REJECT_PATTERNS = [/^[a-z]$/, /[0-9]$/, /[A-Z]/].freeze
       DEFAULT_ACCEPT_PATTERNS = [].freeze
 
@@ -35,29 +36,28 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(context)
+      def sniff
         name = context.name.to_s
-        return [] if acceptable_name?(name: name, context: context)
+        return [] if acceptable_name?(name)
 
         [smell_warning(
-          context: context,
-          lines: [context.exp.line],
+          lines: [source_line],
           message: "has the name '#{name}'",
           parameters: { name: name })]
       end
 
       private
 
-      def acceptable_name?(name:, context:)
-        accept_patterns(context).any? { |accept_pattern| name.match accept_pattern } ||
-          reject_patterns(context).none? { |reject_pattern| name.match reject_pattern }
+      def acceptable_name?(name)
+        accept_patterns.any? { |accept_pattern| name.match accept_pattern } ||
+          reject_patterns.none? { |reject_pattern| name.match reject_pattern }
       end
 
-      def reject_patterns(context)
+      def reject_patterns
         Array value(REJECT_KEY, context)
       end
 
-      def accept_patterns(context)
+      def accept_patterns
         Array value(ACCEPT_KEY, context)
       end
     end

data/lib/reek/smell_detectors/uncommunicative_module_name.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -20,13 +21,13 @@ module Reek
     class UncommunicativeModuleName < BaseDetector
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
-      REJECT_KEY = 'reject'.freeze
+      REJECT_KEY = 'reject'
       DEFAULT_REJECT_PATTERNS = [/^.$/, /[0-9]$/].freeze
 
       # The name of the config field that lists the specific names that are
       # to be treated as exceptions; these names will not be reported as
       # uncommunicative.
-      ACCEPT_KEY = 'accept'.freeze
+      ACCEPT_KEY = 'accept'
       DEFAULT_ACCEPT_PATTERNS = [].freeze
 
       def self.default_config
@@ -40,40 +41,36 @@ module Reek
       end
 
       #
-      # Checks the given +context+ for uncommunicative names.
+      # Checks the detector's context for uncommunicative names.
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(context)
+      def sniff
         fully_qualified_name = context.full_name
-        exp                  = context.exp
-        module_name          = exp.simple_name
+        module_name          = expression.simple_name
 
-        return [] if acceptable_name?(context: context,
-                                      module_name: module_name,
+        return [] if acceptable_name?(module_name: module_name,
                                       fully_qualified_name: fully_qualified_name)
 
         [smell_warning(
-          context: context,
-          lines: [exp.line],
+          lines: [source_line],
           message: "has the name '#{module_name}'",
           parameters: { name: module_name })]
       end
 
       private
 
-      # :reek:ControlParameter
-      def acceptable_name?(context:, module_name:, fully_qualified_name:)
-        accept_patterns(context).any? { |accept_pattern| fully_qualified_name.match accept_pattern } ||
-          reject_patterns(context).none? { |reject_pattern| module_name.match reject_pattern }
+      def acceptable_name?(module_name:, fully_qualified_name:)
+        accept_patterns.any? { |accept_pattern| fully_qualified_name.match accept_pattern } ||
+          reject_patterns.none? { |reject_pattern| module_name.match reject_pattern }
       end
 
-      def reject_patterns(context)
-        Array value(REJECT_KEY, context)
+      def reject_patterns
+        @reject_patterns ||= Array value(REJECT_KEY, context)
       end
 
-      def accept_patterns(context)
-        Array value(ACCEPT_KEY, context)
+      def accept_patterns
+        @accept_patterns ||= Array value(ACCEPT_KEY, context)
       end
     end
   end

data/lib/reek/smell_detectors/uncommunicative_parameter_name.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'base_detector'
 
 module Reek
@@ -20,10 +21,10 @@ module Reek
     #
     # See {file:docs/Uncommunicative-Parameter-Name.md} for details.
     class UncommunicativeParameterName < BaseDetector
-      REJECT_KEY = 'reject'.freeze
+      REJECT_KEY = 'reject'
       DEFAULT_REJECT_PATTERNS = [/^.$/, /[0-9]$/, /[A-Z]/, /^_/].freeze
 
-      ACCEPT_KEY = 'accept'.freeze
+      ACCEPT_KEY = 'accept'
       DEFAULT_ACCEPT_PATTERNS = [].freeze
 
       def self.default_config
@@ -37,15 +38,14 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(context)
-        expression = context.exp
-        expression.parameter_names.select do |name|
-          sanitized_name = sanitize name
-          uncommunicative_parameter_name?(name: sanitized_name, context: context)
-        end.map do |name|
+      def sniff
+        params = expression.parameters.select do |param|
+          uncommunicative_parameter?(param)
+        end
+
+        params.map(&:name).map do |name|
           smell_warning(
-            context: context,
-            lines: [expression.line],
+            lines: [source_line],
             message: "has the parameter name '#{name}'",
             parameters: { name: name.to_s })
         end
@@ -53,27 +53,23 @@ module Reek
 
       private
 
-      def uncommunicative_parameter_name?(name:, context:)
-        !acceptable_name?(name: name, context: context) && context.uses_param?(name)
+      def uncommunicative_parameter?(parameter)
+        !acceptable_name?(parameter.plain_name) &&
+          (context.uses_param?(parameter) || !parameter.marked_unused?)
       end
 
-      def acceptable_name?(name:, context:)
-        accept_patterns(context).any? { |accept_pattern| name.match accept_pattern } ||
-          reject_patterns(context).none? { |reject_pattern| name.match reject_pattern }
+      def acceptable_name?(name)
+        accept_patterns.any? { |accept_pattern| name.match accept_pattern } ||
+          reject_patterns.none? { |reject_pattern| name.match reject_pattern }
       end
 
-      def reject_patterns(context)
+      def reject_patterns
         Array value(REJECT_KEY, context)
       end
 
-      def accept_patterns(context)
+      def accept_patterns
         Array value(ACCEPT_KEY, context)
       end
-
-      # :reek:UtilityFunction
-      def sanitize(name)
-        name.to_s.gsub(/^[@\*\&]*/, '')
-      end
     end
   end
 end