reek 1.5.1 → 1.6.0

data/lib/reek/smell_warning.rb

@@ -1,4 +1,4 @@
-require 'reek/smell_description'
+require 'forwardable'
 
 module Reek
   #
@@ -6,40 +6,21 @@ module Reek
   #
   class SmellWarning
     include Comparable
+    extend Forwardable
+    attr_accessor :smell_detector, :context, :lines, :message, :parameters
+    def_delegators :smell_detector, :smell_category, :smell_type, :source
 
-    def initialize(class_name, context, lines, message,
-        source = '', subclass_name = '', parameters = {})
-      @smell = SmellDescription.new(class_name, subclass_name, message, parameters)
-      @location = {
-        'context' => context.to_s,
-        'lines'   => lines,
-        'source'  => source
-      }
+    def initialize(smell_detector, options = {})
+      self.smell_detector = smell_detector
+      self.context        = options.fetch(:context, '').to_s
+      self.lines          = options.fetch(:lines)
+      self.message        = options.fetch(:message)
+      self.parameters     = options.fetch(:parameters, {})
     end
 
-    #
-    # Details of the smell found, including its class, subclass and summary message.
-    #
-    # @return [Hash{String => String}]
-    #
-    attr_reader :smell
-
-    def smell_classes() [smell_class, subclass] end
-    def smell_class() @smell.smell_class end
-    def subclass() @smell.smell_subclass end
-    def message() @smell.message end
-
-    #
-    # Details of the smell's location, including its context,
-    # the line numbers on which it occurs and the source file
-    #
-    # @return [Hash{String => String, Array<Number>}]
-    #
-    attr_reader :location
-
-    def context() @location.fetch('context') end
-    def lines() @location.fetch('lines') end
-    def source() @location.fetch('source') end
+    def smell_classes
+      [smell_detector.smell_category, smell_detector.smell_type]
+    end
 
     def hash
       sort_key.hash
@@ -61,16 +42,17 @@ module Reek
       listener.found_smell(self)
     end
 
-    def init_with(coder)
-      @location = coder['location']
-      smell_attributes = coder['smell']
-      smell_class = smell_attributes.delete('class')
-      smell_subclass = smell_attributes.delete('subclass')
-      smell_message = smell_attributes.delete('message')
-      @smell = SmellDescription.new(smell_class,
-                                    smell_subclass,
-                                    smell_message,
-                                    smell_attributes)
+    def encode_with(coder)
+      coder.tag = nil
+      coder['smell_category']  = smell_detector.smell_category
+      coder['smell_type']      = smell_detector.smell_type
+      coder['source']          = smell_detector.source
+      coder['context']         = context
+      coder['lines']           = lines
+      coder['message']         = message
+      parameters.each do |key, value|
+        coder[key.to_s] = value
+      end
     end
 
     protected
@@ -81,7 +63,7 @@ module Reek
     end
 
     def sort_key
-      [context, message, smell_class]
+      [context, message, smell_category]
     end
   end
 end

data/lib/reek/smells/attribute.rb

@@ -17,12 +17,7 @@ module Reek
     # TODO: Catch attributes declared "by hand"
     #
     class Attribute < SmellDetector
-      SMELL_CLASS = name.split(/::/)[-1]
-      SMELL_SUBCLASS = SMELL_CLASS
-
-      ATTRIBUTE_KEY = 'attribute'
-
-      def self.contexts      # :nodoc:
+      def self.contexts # :nodoc:
         [:class, :module]
       end
 
@@ -36,12 +31,12 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        attributes_in(ctx).map do |attr, line|
-          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [line],
-                                   "declares the attribute #{attr}",
-                                   @source, SMELL_SUBCLASS,
-                                   ATTRIBUTE_KEY => attr.to_s)
-          smell
+        attributes_in(ctx).map do |attribute, line|
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: [line],
+                           message:  "declares the attribute #{attribute}",
+                           parameters: { name: attribute.to_s }
         end
       end
 

data/lib/reek/smells/boolean_parameter.rb

@@ -12,10 +12,9 @@ module Reek
     # default initializer.
     #
     class BooleanParameter < SmellDetector
-      SMELL_CLASS = 'ControlCouple'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-
-      PARAMETER_KEY = 'parameter'
+      def self.smell_category
+        'ControlCouple'
+      end
 
       #
       # Checks whether the given method has any Boolean parameters.
@@ -25,11 +24,12 @@ module Reek
       def examine_context(method_ctx)
         method_ctx.parameters.default_assignments.select do |_param, value|
           [:true, :false].include?(value[0])
-        end.map do |param, _value|
-          param_name = param.to_s
-          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
-                           "has boolean parameter '#{param_name}'",
-                           @source, SMELL_SUBCLASS, PARAMETER_KEY => param_name)
+        end.map do |parameter, _value|
+          SmellWarning.new self,
+                           context: method_ctx.full_name,
+                           lines: [method_ctx.exp.line],
+                           message: "has boolean parameter '#{parameter}'",
+                           parameters: { name: parameter.to_s }
         end
       end
     end

data/lib/reek/smells/class_variable.rb

@@ -13,12 +13,7 @@ module Reek
     # the context of the test includes all global state).
     #
     class ClassVariable < SmellDetector
-      SMELL_CLASS = name.split(/::/)[-1]
-      SMELL_SUBCLASS = SMELL_CLASS
-
-      VARIABLE_KEY = 'variable'
-
-      def self.contexts      # :nodoc:
+      def self.contexts # :nodoc:
         [:class, :module]
       end
 
@@ -28,13 +23,12 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        class_variables_in(ctx.exp).map do |attr_name, lines|
-          attr_name = attr_name.to_s
-          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
-                                   "declares the class variable #{attr_name}",
-                                   @source, SMELL_SUBCLASS,
-                                   VARIABLE_KEY => attr_name)
-          smell
+        class_variables_in(ctx.exp).map do |variable, lines|
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: lines,
+                           message: "declares the class variable #{variable}",
+                           parameters: { name: variable.to_s }
         end
       end
 

data/lib/reek/smells/control_parameter.rb

@@ -41,9 +41,9 @@ module Reek
     # the source code.
     #
     class ControlParameter < SmellDetector
-      SMELL_CLASS = 'ControlCouple'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-      PARAMETER_KEY = 'parameter'
+      def self.smell_category
+        'ControlCouple'
+      end
 
       #
       # Checks whether the given method chooses its execution path
@@ -53,10 +53,11 @@ module Reek
       #
       def examine_context(ctx)
         ControlParameterCollector.new(ctx).control_parameters.map do |control_parameter|
-          SmellWarning.new(SMELL_CLASS, ctx.full_name, control_parameter.lines,
-                           control_parameter.smell_message,
-                           @source, SMELL_SUBCLASS,
-                           PARAMETER_KEY => control_parameter.name)
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: control_parameter.lines,
+                           message: "is controlled by argument #{control_parameter.name}",
+                           parameters: { name: control_parameter.name.to_s }
         end
       end
 
@@ -73,10 +74,6 @@ module Reek
           @occurences.any?
         end
 
-        def smell_message
-          "is controlled by argument #{name}"
-        end
-
         def lines
           @occurences.map(&:line)
         end

data/lib/reek/smells/data_clump.rb

@@ -17,18 +17,6 @@ module Reek
     # the same names that are expected by three or more methods of a class.
     #
     class DataClump < SmellDetector
-      SMELL_CLASS = name.split(/::/)[-1]
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-
-      METHODS_KEY = 'methods'
-      OCCURRENCES_KEY = 'occurrences'
-      PARAMETERS_KEY = 'parameters'
-
-      # @private
-      def self.contexts
-        [:class, :module]
-      end
-
       #
       # The name of the config field that sets the maximum allowed
       # copies of any clump. No group of common parameters will be
@@ -46,6 +34,10 @@ module Reek
       MIN_CLUMP_SIZE_KEY = 'min_clump_size'
       DEFAULT_MIN_CLUMP_SIZE = 2
 
+      def self.contexts # :nodoc:
+        [:class, :module]
+      end
+
       def self.default_config
         super.merge(
           MAX_COPIES_KEY => DEFAULT_MAX_COPIES,
@@ -62,13 +54,17 @@ module Reek
         @max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
         @min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
         MethodGroup.new(ctx, @min_clump_size, @max_copies).clumps.map do |clump, methods|
-          SmellWarning.new(SMELL_CLASS, ctx.full_name,
-                           methods.map(&:line),
-                           "takes parameters #{DataClump.print_clump(clump)} to #{methods.length} methods",
-                           @source, SMELL_SUBCLASS,
-                           PARAMETERS_KEY => clump.map(&:to_s),
-                           OCCURRENCES_KEY => methods.length,
-                           METHODS_KEY => methods.map(&:name))
+          print_clump = DataClump.print_clump(clump)
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: methods.map(&:line),
+                           message: "takes parameters #{print_clump} " \
+                                    "to #{methods.length} methods",
+                           parameters: {
+                             parameters: clump.map(&:to_s),
+                             count: methods.length,
+                             methods: methods.map(&:name)
+                           }
         end
       end
 
@@ -118,11 +114,10 @@ module Reek
   class CandidateMethod
     def initialize(defn_node)
       @defn = defn_node
-      @params = defn_node.arg_names.clone.sort { |first, second| first.to_s <=> second.to_s }
     end
 
     def arg_names
-      @params
+      @arg_names ||= @defn.arg_names.compact.sort
     end
 
     def line

data/lib/reek/smells/duplicate_method_call.rb

@@ -17,25 +17,21 @@ module Reek
     #   end
     #
     class DuplicateMethodCall < SmellDetector
-      SMELL_CLASS = 'Duplication'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-
-      CALL_KEY = 'call'
-      OCCURRENCES_KEY = 'occurrences'
-
       # The name of the config field that sets the maximum number of
       # identical calls to be permitted within any single method.
       MAX_ALLOWED_CALLS_KEY = 'max_calls'
-
       DEFAULT_MAX_CALLS = 1
 
       # The name of the config field that sets the names of any
       # methods for which identical calls should be to be permitted
       # within any single method.
       ALLOW_CALLS_KEY = 'allow_calls'
-
       DEFAULT_ALLOW_CALLS = []
 
+      def self.smell_category
+        'Duplication'
+      end
+
       def self.default_config
         super.merge(
           MAX_ALLOWED_CALLS_KEY => DEFAULT_MAX_CALLS,
@@ -52,11 +48,13 @@ module Reek
         max_allowed_calls = value(MAX_ALLOWED_CALLS_KEY, ctx, DEFAULT_MAX_CALLS)
         allow_calls = value(ALLOW_CALLS_KEY, ctx, DEFAULT_ALLOW_CALLS)
 
-        CallCollector.new(ctx, max_allowed_calls, allow_calls).smelly_calls.map do |found_call|
-          SmellWarning.new(SMELL_CLASS, ctx.full_name, found_call.lines,
-                           found_call.smell_message,
-                           @source, SMELL_SUBCLASS,
-                           CALL_KEY => found_call.call, OCCURRENCES_KEY => found_call.occurs)
+        collector = CallCollector.new(ctx, max_allowed_calls, allow_calls)
+        collector.smelly_calls.map do |found_call|
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: found_call.lines,
+                           message: "calls #{found_call.call} #{found_call.occurs} times",
+                           parameters: { name: found_call.call, count: found_call.occurs }
         end
       end
 
@@ -71,11 +69,6 @@ module Reek
           @occurences.push occurence
         end
 
-        def smell_message
-          multiple = occurs == 2 ? 'twice' : "#{occurs} times"
-          "calls #{call} #{multiple}"
-        end
-
         def call
           @call ||= @call_node.format_ruby
         end

data/lib/reek/smells/feature_envy.rb

@@ -33,11 +33,9 @@ module Reek
     class FeatureEnvy < SmellDetector
       include ExcludeInitialize
 
-      SMELL_CLASS = 'LowCohesion'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-
-      RECEIVER_KEY = 'receiver'
-      REFERENCES_KEY = 'references'
+      def self.smell_category
+        'LowCohesion'
+      end
 
       #
       # Checks whether the given +context+ includes any code fragment that
@@ -48,9 +46,11 @@ module Reek
       def examine_context(method_ctx)
         method_ctx.envious_receivers.map do |ref, occurs|
           target = ref.format_ruby
-          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
-                           "refers to #{target} more than self",
-                           @source, SMELL_SUBCLASS, RECEIVER_KEY => target, REFERENCES_KEY => occurs)
+          SmellWarning.new self,
+                           context: method_ctx.full_name,
+                           lines: [method_ctx.exp.line],
+                           message: "refers to #{target} more than self",
+                           parameters: { name: target, count: occurs }
         end
       end
     end

data/lib/reek/smells/irresponsible_module.rb

@@ -9,12 +9,7 @@ module Reek
     # with a brief comment outlining its responsibilities.
     #
     class IrresponsibleModule < SmellDetector
-      SMELL_CLASS = name.split(/::/)[-1]
-      SMELL_SUBCLASS = SMELL_CLASS
-
-      MODULE_NAME_KEY = 'module_name'
-
-      def self.contexts      # :nodoc:
+      def self.contexts # :nodoc:
         [:class]
       end
 
@@ -30,10 +25,11 @@ module Reek
       def examine_context(ctx)
         comment = Source::CodeComment.new(ctx.exp.comments)
         return [] if self.class.descriptive[ctx.full_name] ||= comment.descriptive?
-        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-                                 'has no descriptive comment',
-                                 @source, SMELL_SUBCLASS, MODULE_NAME_KEY => ctx.exp.text_name)
-        [smell]
+        [SmellWarning.new(self,
+                          context: ctx.full_name,
+                          lines: [ctx.exp.line],
+                          message: 'has no descriptive comment',
+                          parameters: {  name: ctx.exp.text_name })]
       end
     end
   end

data/lib/reek/smells/long_parameter_list.rb

@@ -13,17 +13,9 @@ module Reek
     # many parameters.
     #
     class LongParameterList < SmellDetector
-      SMELL_CLASS = 'LongParameterList'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-
-      PARAMETER_COUNT_KEY = 'parameter_count'
-
       # The name of the config field that sets the maximum number of
       # parameters permitted in any method or block.
       MAX_ALLOWED_PARAMS_KEY = 'max_params'
-
-      # The default value of the +MAX_ALLOWED_PARAMS_KEY+ configuration
-      # value.
       DEFAULT_MAX_ALLOWED_PARAMS = 3
 
       def self.default_config
@@ -42,13 +34,13 @@ module Reek
       #
       def examine_context(ctx)
         @max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY, ctx, DEFAULT_MAX_ALLOWED_PARAMS)
-        num_params = ctx.exp.arg_names.length
-        return [] if num_params <= @max_allowed_params
-        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-                                 "has #{num_params} parameters",
-                                 @source, SMELL_SUBCLASS,
-                                 PARAMETER_COUNT_KEY => num_params)
-        [smell]
+        count = ctx.exp.arg_names.length
+        return [] if count <= @max_allowed_params
+        [SmellWarning.new(self,
+                          context: ctx.full_name,
+                          lines: [ctx.exp.line],
+                          message: "has #{count} parameters",
+                          parameters: { count: count })]
       end
     end
   end