reek 4.7.2 → 4.7.3

data/lib/reek/smell_detectors/too_many_constants.rb

@@ -34,22 +34,24 @@ 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.each_node(:casgn, IGNORED_NODES).delete_if(&: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],
+          context: context,
+          lines: [source_line],
           message: "has #{count} constants",
           parameters: { count: count })]
       end

data/lib/reek/smell_detectors/too_many_instance_variables.rb

@@ -33,17 +33,22 @@ 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],
+          context: context,
+          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

@@ -31,21 +31,26 @@ 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],
+          context: context,
+          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

@@ -27,16 +27,21 @@ 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],
+          context: context,
+          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

@@ -36,29 +36,29 @@ 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

@@ -41,40 +41,37 @@ 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

@@ -38,17 +38,15 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(context)
-        expression = context.exp
-
+      def sniff
         params = expression.parameters.select do |param|
-          uncommunicative_parameter?(parameter: param, context: context)
+          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
@@ -56,22 +54,21 @@ module Reek
 
       private
 
-      def uncommunicative_parameter?(parameter:, context:)
-        !acceptable_name?(parameter: parameter, context: context) &&
+      def uncommunicative_parameter?(parameter)
+        !acceptable_name?(parameter.plain_name) &&
           (context.uses_param?(parameter) || !parameter.marked_unused?)
       end
 
-      def acceptable_name?(parameter:, context:)
-        name = parameter.plain_name
-        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_variable_name.rb

@@ -21,7 +21,6 @@ module Reek
     #
     # See {file:docs/Uncommunicative-Variable-Name.md} for details.
     #
-    # :reek:DataClump: { max_copies: 4 }
     class UncommunicativeVariableName < BaseDetector
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
@@ -53,14 +52,12 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def sniff(ctx)
-        self.reject_names = value(REJECT_KEY, ctx)
-        self.accept_names = value(ACCEPT_KEY, ctx)
-        variable_names(ctx.exp).select do |name, _lines|
+      def sniff
+        variable_names.select do |name, _lines|
           uncommunicative_variable_name?(name)
         end.map do |name, lines|
           smell_warning(
-            context: ctx,
+            context: context,
             lines: lines,
             message: "has the variable name '#{name}'",
             parameters: { name: name.to_s })
@@ -69,6 +66,14 @@ module Reek
 
       private
 
+      def reject_names
+        @reject_names ||= value(REJECT_KEY, context)
+      end
+
+      def accept_names
+        @accept_names ||= value(ACCEPT_KEY, context)
+      end
+
       def uncommunicative_variable_name?(name)
         sanitized_name = name.to_s.gsub(/^[@\*\&]*/, '')
         !acceptable_name?(sanitized_name)
@@ -79,34 +84,31 @@ module Reek
           Array(reject_names).none? { |reject_pattern| name.match reject_pattern }
       end
 
-      # :reek:TooManyStatements: { max_statements: 6 }
-      def variable_names(exp)
+      def variable_names
         result = Hash.new { |hash, key| hash[key] = [] }
-        find_assignment_variable_names(exp, result)
-        find_block_argument_variable_names(exp, result)
-        result.to_a.sort_by { |name, _| name.to_s }
+        find_assignment_variable_names(result)
+        find_block_argument_variable_names(result)
+        result
       end
 
-      # :reek:UtilityFunction
-      def find_assignment_variable_names(exp, accumulator)
-        assignment_nodes = exp.each_node(:lvasgn, [:class, :module, :defs, :def])
+      def find_assignment_variable_names(accumulator)
+        assignment_nodes = expression.each_node(:lvasgn, [:class, :module, :defs, :def])
 
-        case exp.type
+        case expression.type
         when :class, :module
-          assignment_nodes += exp.each_node(:ivasgn, [:class, :module])
+          assignment_nodes += expression.each_node(:ivasgn, [:class, :module])
         end
 
         assignment_nodes.each { |asgn| accumulator[asgn.children.first].push(asgn.line) }
       end
 
-      # :reek:FeatureEnvy
       # :reek:TooManyStatements: { max_statements: 6 }
-      def find_block_argument_variable_names(exp, accumulator)
-        arg_search_exp = case exp.type
+      def find_block_argument_variable_names(accumulator)
+        arg_search_exp = case expression.type
                          when :class, :module
-                           exp
+                           expression
                          when :defs, :def
-                           exp.body
+                           expression.body
                          end
 
         return unless arg_search_exp
@@ -135,8 +137,6 @@ module Reek
         var = varname.to_sym
         accumulator[var].push(exp.line)
       end
-
-      attr_accessor :accept_names, :reject_names
     end
   end
 end

data/lib/reek/smell_detectors/unused_parameters.rb

@@ -14,14 +14,13 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        return [] if ctx.uses_super_with_implicit_arguments?
-        ctx.unused_params.map do |param|
+      def sniff
+        return [] if context.uses_super_with_implicit_arguments?
+        context.unused_params.map do |param|
           name = param.name.to_s
           smell_warning(
-            context: ctx,
-            lines: [ctx.exp.line],
+            context: context,
+            lines: [source_line],
             message: "has unused parameter '#{name}'",
             parameters: { name: name })
         end

data/lib/reek/smell_detectors/unused_private_method.rb

@@ -32,15 +32,13 @@ module Reek
       end
 
       #
-      # @param ctx [Context::ClassContext]
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      def sniff(ctx)
-        hits(ctx).map do |hit|
+      def sniff
+        hits.map do |hit|
           name = hit.name
           smell_warning(
-            context: ctx,
+            context: context,
             lines: [hit.line],
             message: "has the unused private instance method '#{name}'",
             parameters: { name: name.to_s })
@@ -50,23 +48,20 @@ module Reek
       private
 
       #
-      # @param ctx [Context::ClassContext]
       # @return [Array<Hit>]
       #
-      def hits(ctx)
-        unused_private_methods(ctx).map do |defined_method|
-          Hit.new(defined_method) unless ignore_method?(ctx, defined_method)
+      def hits
+        unused_private_methods.map do |defined_method|
+          Hit.new(defined_method) unless ignore_method?(defined_method)
         end.compact
       end
 
       #
-      # @param ctx [Context::ClassContext]
       # @return [Array<Context::MethodContext]
       #
-      # :reek:UtilityFunction
-      def unused_private_methods(ctx)
-        defined_private_methods = ctx.defined_instance_methods(visibility: :private)
-        called_method_names     = ctx.instance_method_calls.map(&:name)
+      def unused_private_methods
+        defined_private_methods = context.defined_instance_methods(visibility: :private)
+        called_method_names     = context.instance_method_calls.map(&:name)
 
         defined_private_methods.reject do |defined_method|
           called_method_names.include?(defined_method.name)
@@ -74,14 +69,12 @@ module Reek
       end
 
       #
-      # @param ctx [Context::ClassContext]
       # @param method [Context::MethodContext]
       # @return [Boolean]
       #
-      # :reek:FeatureEnvy
-      def ignore_method?(ctx, method)
+      def ignore_method?(method)
         # ignore_contexts will be e.g. ["Foo::Smelly#my_method", "..."]
-        ignore_contexts = value(EXCLUDE_KEY, ctx)
+        ignore_contexts = value(EXCLUDE_KEY, context)
         ignore_contexts.any? do |ignore_context|
           full_name = "#{method.parent.full_name}##{method.name}"
           full_name[ignore_context]

data/lib/reek/smell_detectors/utility_function.rb

@@ -56,30 +56,27 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:FeatureEnvy
-      # :reek:TooManyStatements: { max_statements: 6 }
-      def sniff(ctx)
-        return [] if ctx.singleton_method? || ctx.module_function?
-        return [] if ctx.references_self?
-        return [] if num_helper_methods(ctx).zero?
-        return [] if ignore_method?(ctx)
+      def sniff
+        return [] if context.singleton_method? || context.module_function?
+        return [] if context.references_self?
+        return [] if num_helper_methods.zero?
+        return [] if ignore_method?
 
         [smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          context: context,
+          lines: [source_line],
           message: "doesn't depend on instance state (maybe move it to another class?)")]
       end
 
       private
 
-      # :reek:UtilityFunction
-      def num_helper_methods(method_ctx)
-        method_ctx.local_nodes(:send).length
+      def num_helper_methods
+        context.local_nodes(:send).length
       end
 
-      def ignore_method?(method_ctx)
-        method_ctx.non_public_visibility? &&
-          value(PUBLIC_METHODS_ONLY_KEY, method_ctx)
+      def ignore_method?
+        context.non_public_visibility? &&
+          value(PUBLIC_METHODS_ONLY_KEY, context)
       end
     end
   end