reek 3.3.1 → 3.4.0

data/lib/reek/smells/nil_check.rb

@@ -7,7 +7,6 @@ module Reek
     # SimulatedPolymorphism.
     #
     # See {file:docs/Nil-Check.md} for details.
-    # @api private
     class NilCheck < SmellDetector
       def self.smell_category
         'SimulatedPolymorphism'
@@ -19,10 +18,10 @@ module Reek
         smelly_nodes = call_node_finder.smelly_nodes + case_node_finder.smelly_nodes
 
         smelly_nodes.map do |node|
-          SmellWarning.new self,
-                           context: ctx.full_name,
-                           lines: [node.line],
-                           message: 'performs a nil-check'
+          smell_warning(
+            context: ctx,
+            lines: [node.line],
+            message: 'performs a nil-check')
         end
       end
 

data/lib/reek/smells/prima_donna_method.rb

@@ -23,7 +23,6 @@ module Reek
     # Such a method is called PrimaDonnaMethod and is reported as a smell.
     #
     # See {file:docs/Prima-Donna-Method.md} for details.
-    # @api private
     class PrimaDonnaMethod < SmellDetector
       def self.contexts # :nodoc:
         [:class]
@@ -37,6 +36,7 @@ module Reek
 
       private
 
+      # :reek:FeatureEnvy
       def check_for_smells(method_sexp, ctx)
         return unless method_sexp.ends_with_bang?
 
@@ -46,10 +46,10 @@ module Reek
 
         return if version_without_bang
 
-        SmellWarning.new self,
-                         context: ctx.full_name,
-                         lines: [ctx.exp.line],
-                         message: "has prima donna method `#{method_sexp.name}`"
+        smell_warning(
+          context: ctx,
+          lines: [ctx.exp.line],
+          message: "has prima donna method `#{method_sexp.name}`")
       end
     end
   end

data/lib/reek/smells/repeated_conditional.rb

@@ -24,7 +24,6 @@ module Reek
     # testing the same value throughout a single class.
     #
     # See {file:docs/Repeated-Conditional.md} for details.
-    # @api private
     class RepeatedConditional < SmellDetector
       # The name of the config field that sets the maximum number of
       # identical conditionals permitted within any single class.
@@ -50,6 +49,8 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
+      # :reek:TooManyStatements: { max_statements: 6 }
+      # :reek:DuplicateMethodCall: { max_calls: 2 }
       def examine_context(ctx)
         max_identical_ifs = value(MAX_IDENTICAL_IFS_KEY, ctx, DEFAULT_MAX_IFS)
         conditional_counts(ctx).select do |_key, lines|
@@ -57,11 +58,11 @@ module Reek
         end.map do |key, lines|
           occurs = lines.length
           expression = key.format_to_ruby
-          SmellWarning.new self,
-                           context: ctx.full_name,
-                           lines: lines,
-                           message: "tests #{expression} at least #{occurs} times",
-                           parameters: { name: expression, count: occurs }
+          smell_warning(
+            context: ctx,
+            lines: lines,
+            message: "tests #{expression} at least #{occurs} times",
+            parameters: { name: expression, count: occurs })
         end
       end
 
@@ -70,6 +71,8 @@ module Reek
       # 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)
         result = Hash.new { |hash, key| hash[key] = [] }
         collector = proc do |node|

data/lib/reek/smells/smell_configuration.rb

@@ -5,7 +5,6 @@ module Reek
     #
     # Represents a single set of configuration options for a smell detector
     #
-    # @api private
     class SmellConfiguration
       # The name of the config field that specifies whether a smell is
       # enabled. Set to +true+ or +false+.
@@ -19,14 +18,10 @@ module Reek
         @options = hash
       end
 
-      def merge!(new_options)
+      def merge(new_options)
         options.merge!(new_options)
       end
 
-      #
-      # Is this smell detector active?
-      #--
-      #  SMELL: Getter
       def enabled?
         options[ENABLED_KEY]
       end
@@ -52,7 +47,6 @@ module Reek
     #
     # A set of context-specific overrides for smell detectors.
     #
-    # @api private
     class Overrides
       def initialize(hash)
         @hash = hash

data/lib/reek/smells/smell_detector.rb

@@ -12,10 +12,9 @@ module Reek
     #   - {file:README.md}
     # for details.
     #
-    # @api private
+    # :reek:TooManyMethods: { max_methods: 19 }
+    # :reek:TooManyInstanceVariables: { max_instance_variables: 5 }
     class SmellDetector
-      attr_reader :source
-
       # 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.
@@ -30,6 +29,7 @@ module Reek
           [:def, :defs]
         end
 
+        # :reek:UtilityFunction
         def default_config
           {
             SmellConfiguration::ENABLED_KEY => true,
@@ -74,10 +74,8 @@ module Reek
         end
       end
 
-      attr_reader :smells_found # SMELL: only published for tests
-
-      def initialize(source, config = self.class.default_config)
-        @source = source
+      def initialize(config = {})
+        config = self.class.default_config.merge(config)
         @config = SmellConfiguration.new(config)
         @smells_found = []
       end
@@ -87,15 +85,6 @@ module Reek
         self.class.contexts.each { |ctx| hooks[ctx] << self }
       end
 
-      # SMELL: Getter (only used in 1 test)
-      def enabled?
-        config.enabled?
-      end
-
-      def configure_with(new_config)
-        config.merge!(new_config)
-      end
-
       def examine(context)
         return unless enabled_for? context
         return if exception?(context)
@@ -104,16 +93,23 @@ module Reek
         self.smells_found += sm
       end
 
-      def enabled_for?(context)
-        enabled? && config_for(context)[SmellConfiguration::ENABLED_KEY] != false
+      def report_on(report)
+        smells_found.each { |smell| smell.report_on(report) }
       end
 
       def exception?(context)
         context.matches?(value(EXCLUDE_KEY, context, DEFAULT_EXCLUDE_SET))
       end
 
-      def report_on(report)
-        smells_found.each { |smell| smell.report_on(report) }
+      protected
+
+      # NOTE: Needs to be protected so += works for Ruby < 2.2
+      attr_accessor :smells_found
+
+      private
+
+      def enabled_for?(context)
+        config.enabled? && config_for(context)[SmellConfiguration::ENABLED_KEY] != false
       end
 
       def value(key, ctx, fall_back)
@@ -124,11 +120,18 @@ module Reek
         ctx.config_for(self.class)
       end
 
-      protected
-
-      attr_writer :smells_found
-
-      private
+      # :reek:FeatureEnvy
+      def smell_warning(options = {})
+        context = options.fetch(:context)
+        exp = context.exp
+        ctx_source = exp.loc.expression.source_buffer.name
+        SmellWarning.new(self,
+                         source: ctx_source,
+                         context: context.full_name,
+                         lines: options.fetch(:lines),
+                         message: options.fetch(:message),
+                         parameters: options.fetch(:parameters, {}))
+      end
 
       private_attr_reader :config
     end

data/lib/reek/smells/smell_repository.rb

@@ -7,50 +7,49 @@ module Reek
     #
     # Contains all the existing smells and exposes operations on them.
     #
-    # @api private
     class SmellRepository
       def self.smell_types
         Reek::Smells::SmellDetector.descendants.sort_by(&:name)
       end
 
-      def initialize(source_description: nil,
-                     smell_types: self.class.smell_types,
-                     configuration: Configuration::AppConfiguration.default)
-        @source_via    = source_description
-        @configuration = configuration
-        @smell_types   = smell_types
-
-        configuration.directive_for(source_via).each do |klass, config|
-          configure klass, config
+      def self.eligible_smell_types(filter_by_smells = [])
+        return smell_types if filter_by_smells.empty?
+        smell_types.select do |klass|
+          filter_by_smells.include? klass.smell_type
         end
       end
 
-      def configure(klass, config)
-        detector = detectors[klass]
-        raise ArgumentError, "Unknown smell type #{klass} found in configuration" unless detector
-        detector.configure_with(config)
+      def initialize(smell_types: self.class.smell_types,
+                     configuration: {})
+        @configuration = configuration
+        @smell_types   = smell_types
       end
 
       def report_on(listener)
         detectors.each_value { |detector| detector.report_on(listener) }
       end
 
-      def examine(scope)
-        smell_listeners[scope.type].each do |detector|
-          detector.examine(scope)
+      def examine(context)
+        smell_listeners[context.type].each do |detector|
+          detector.examine(context)
         end
       end
 
       def detectors
         @initialized_detectors ||= smell_types.map do |klass|
-          { klass => klass.new(source_via) }
+          { klass => klass.new(source_configuration_for(klass)) }
         end.reduce({}, :merge)
       end
 
       private
 
-      private_attr_reader :configuration, :source_via, :smell_types
+      private_attr_reader :configuration, :smell_types
+
+      def source_configuration_for(klass)
+        configuration[klass] || {}
+      end
 
+      # TODO: Make a method smell_detectors_for(scope)
       def smell_listeners
         @smell_listeners ||= Hash.new { |hash, key| hash[key] = [] }.tap do |listeners|
           detectors.each_value { |detector| detector.register(listeners) }

data/lib/reek/smells/smell_warning.rb

@@ -1,53 +1,71 @@
 require 'forwardable'
 
 module Reek
+  # @public
   module Smells
     #
     # Reports a warning that a smell has been found.
     #
+    # @public
+    #
+    # :reek:TooManyInstanceVariables: { max_instance_variables: 6 }
     class SmellWarning
       include Comparable
       extend Forwardable
-      attr_reader :context, :lines, :message, :parameters, :smell_detector
-      def_delegators :smell_detector, :smell_category, :smell_type, :source
 
+      # @public
+      attr_reader :context, :lines, :message, :parameters, :smell_detector, :source
+      def_delegators :smell_detector, :smell_category, :smell_type
+
+      # @note When using reek's public API, you should not create SmellWarning
+      #   objects yourself. This is why the initializer is not part of the
+      #   public API.
+      #
       # FIXME: switch to required kwargs when dropping Ruby 2.0 compatibility
+      #
+      # :reek:LongParameterList: { max_params: 6 }
       def initialize(smell_detector, context: '', lines: raise, message: raise,
-                                     parameters: {})
+                                     source: raise, parameters: {})
         @smell_detector = smell_detector
+        @source         = source
         @context        = context.to_s
         @lines          = lines
         @message        = message
         @parameters     = parameters
       end
 
+      # @public
       def hash
         sort_key.hash
       end
 
+      # @public
       def <=>(other)
         sort_key <=> other.sort_key
       end
 
+      # @public
       def eql?(other)
         (self <=> other) == 0
       end
 
-      # @api private
       def matches?(klass, other_parameters = {})
         smell_classes.include?(klass.to_s) && common_parameters_equal?(other_parameters)
       end
 
-      # @api private
       def report_on(listener)
         listener.found_smell(self)
       end
 
-      def yaml_hash(warning_formatter = nil)
+      # @public
+      def yaml_hash
         stringified_params = Hash[parameters.map { |key, val| [key.to_s, val] }]
         core_yaml_hash.
-          merge(stringified_params).
-          merge(wiki_link_hash(warning_formatter))
+          merge(stringified_params)
+      end
+
+      def base_message
+        "#{context} #{message} (#{smell_type})"
       end
 
       protected
@@ -63,7 +81,10 @@ module Reek
       end
 
       def common_parameters_equal?(other_parameters)
-        other_parameters.keys.each do |key|
+        other_keys   = other_parameters.keys
+        other_values = other_parameters.values
+
+        other_keys.each do |key|
           unless parameters.key?(key)
             raise ArgumentError, "The parameter #{key} you want to check for doesn't exist"
           end
@@ -77,7 +98,7 @@ module Reek
         # So in this spec we are just specifying the "name" parameter but not the "count".
         # In order to allow for this kind of leniency we just test for common parameter equality,
         # not for a strict one.
-        parameters.values_at(*other_parameters.keys) == other_parameters.values
+        parameters.values_at(*other_keys) == other_values
       end
 
       def core_yaml_hash
@@ -85,19 +106,11 @@ module Reek
           'context'        => context,
           'lines'          => lines,
           'message'        => message,
-          'smell_category' => smell_detector.smell_category,
-          'smell_type'     => smell_detector.smell_type,
-          'source'         => smell_detector.source
+          'smell_category' => smell_category,
+          'smell_type'     => smell_type,
+          'source'         => source
         }
       end
-
-      def wiki_link_hash(warning_formatter)
-        if warning_formatter.respond_to?(:explanatory_link)
-          { 'wiki_link' => warning_formatter.explanatory_link(smell_detector) }
-        else
-          {}
-        end
-      end
     end
   end
 end

data/lib/reek/smells/too_many_instance_variables.rb

@@ -11,7 +11,6 @@ module Reek
     # configurable number of instance variables.
     #
     # See {file:docs/Too-Many-Instance-Variables.md} for details.
-    # @api private
     class TooManyInstanceVariables < SmellDetector
       # The name of the config field that sets the maximum number of instance
       # variables permitted in a class.
@@ -42,11 +41,11 @@ module Reek
         max_allowed_ivars = value(MAX_ALLOWED_IVARS_KEY, ctx, DEFAULT_MAX_IVARS)
         count = ctx.local_nodes(:ivasgn).map { |ivasgn| ivasgn[1] }.uniq.length
         return [] if count <= max_allowed_ivars
-        [SmellWarning.new(self,
-                          context: ctx.full_name,
-                          lines: [ctx.exp.line],
-                          message: "has at least #{count} instance variables",
-                          parameters: { count: count })]
+        [smell_warning(
+          context: ctx,
+          lines: [ctx.exp.line],
+          message: "has at least #{count} instance variables",
+          parameters: { count: count })]
       end
     end
   end

data/lib/reek/smells/too_many_methods.rb

@@ -13,7 +13,6 @@ module Reek
     # modules.
     #
     # See {file:docs/Too-Many-Methods.md} for details.
-    # @api private
     class TooManyMethods < SmellDetector
       # The name of the config field that sets the maximum number of methods
       # permitted in a class.
@@ -42,13 +41,14 @@ module Reek
       #
       def examine_context(ctx)
         max_allowed_methods = value(MAX_ALLOWED_METHODS_KEY, ctx, DEFAULT_MAX_METHODS)
+        # TODO: Only checks instance methods!
         actual = ctx.node_instance_methods.length
         return [] if actual <= max_allowed_methods
-        [SmellWarning.new(self,
-                          context: ctx.full_name,
-                          lines: [ctx.exp.line],
-                          message: "has at least #{actual} methods",
-                          parameters: { count: actual })]
+        [smell_warning(
+          context: ctx,
+          lines: [ctx.exp.line],
+          message: "has at least #{actual} methods",
+          parameters: { count: actual })]
       end
     end
   end