reek 4.7.1 → 5.0.0

data/lib/reek/smell_detectors/{prima_donna_method.rb → missing_safe_method.rb}

@@ -21,16 +21,15 @@ module Reek
     #   gets distorted and diluted, and ! ceases to convey any information
     #   whatsoever.
     #
-    # Such a method is called PrimaDonnaMethod and is reported as a smell.
+    # Such a method is called MissingSafeMethod and is reported as a smell.
     #
-    # See {file:docs/Prima-Donna-Method.md} for details.
-    class PrimaDonnaMethod < BaseDetector
+    # See {file:docs/Missing-Safe-Method.md} for details.
+    class MissingSafeMethod < BaseDetector
       def self.contexts # :nodoc:
         [:class]
       end
 
       #
-      # @param ctx [Context::ModuleContext]
       # @return [Array<SmellWarning>]
       #
       # Given this code:
@@ -40,38 +39,36 @@ 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|
+          missing_safe_method?(method_sexp)
         end.map do |method_sexp|
           name = method_sexp.name
           smell_warning(
-            context: ctx,
-            lines: [ctx.exp.line],
-            message: "has prima donna method '#{name}'",
+            lines: [method_sexp.line],
+            message: "has missing safe method '#{name}'",
             parameters: { name: name.to_s })
         end
       end
 
       private
 
-      def prima_donna_method?(method_sexp, ctx)
+      def missing_safe_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 +76,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/module_initialize.rb

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

data/lib/reek/smell_detectors/nested_iterators.rb

@@ -20,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
@@ -41,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 })
@@ -57,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.
       #
@@ -69,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
@@ -80,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:
@@ -102,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.
@@ -121,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

@@ -9,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
@@ -21,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

@@ -28,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?])
@@ -46,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

@@ -26,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

@@ -15,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
 
@@ -34,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

@@ -15,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
@@ -33,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

@@ -17,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
@@ -31,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

@@ -13,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
@@ -27,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

@@ -20,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
 
@@ -36,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

@@ -21,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
@@ -41,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