reek 1.5.1 → 1.6.0

data/lib/reek/smells/long_yield_list.rb

@@ -8,23 +8,17 @@ module Reek
     # passed to a block by a +yield+ call.
     #
     class LongYieldList < SmellDetector
-      SMELL_CLASS = 'LongParameterList'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-
       # 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
 
-      PARAMETER_COUNT_KEY = 'parameter_count'
+      def self.smell_category
+        'LongParameterList'
+      end
 
       def self.default_config
-        super.merge(
-          MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS
-        )
+        super.merge MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS
       end
 
       #
@@ -33,14 +27,18 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        @max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY, method_ctx, DEFAULT_MAX_ALLOWED_PARAMS)
+        @max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY,
+                                    method_ctx,
+                                    DEFAULT_MAX_ALLOWED_PARAMS)
         method_ctx.local_nodes(:yield).select do |yield_node|
           yield_node.args.length > @max_allowed_params
         end.map do |yield_node|
-          num_params = yield_node.args.length
-          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [yield_node.line],
-                           "yields #{num_params} parameters",
-                           @source, SMELL_SUBCLASS, PARAMETER_COUNT_KEY => num_params)
+          count = yield_node.args.length
+          SmellWarning.new self,
+                           context: method_ctx.full_name,
+                           lines: [yield_node.line],
+                           message: "yields #{count} parameters",
+                           parameters: { count: count }
         end
       end
     end

data/lib/reek/smells/module_initialize.rb

@@ -9,10 +9,7 @@ module Reek
     # in a module is usually a bad idea
     #
     class ModuleInitialize < SmellDetector
-      SMELL_CLASS = smell_class_name
-      SMELL_SUBCLASS = SMELL_CLASS
-
-      def self.contexts      # :nodoc:
+      def self.contexts # :nodoc:
         [:module]
       end
 
@@ -25,9 +22,9 @@ module Reek
         module_ctx.local_nodes(:def) do |node| # FIXME: also search for :defs?
           if node.name.to_s == 'initialize'
             return [
-              SmellWarning.new(SMELL_CLASS, module_ctx.full_name, [module_ctx.exp.line],
-                               'has initialize method',
-                               @source, SMELL_SUBCLASS, {})
+              SmellWarning.new(self, context: module_ctx.full_name,
+                                     lines:   [module_ctx.exp.line],
+                                     message: 'has initialize method')
             ]
           end
         end

data/lib/reek/smells/nested_iterators.rb

@@ -9,21 +9,14 @@ module Reek
     # +NestedIterators+ reports failing methods only once.
     #
     class NestedIterators < SmellDetector
-      SMELL_CLASS = name.split(/::/)[-1]
-      SMELL_SUBCLASS = SMELL_CLASS
-      # SMELL: should be a subclass of UnnecessaryComplexity
-      NESTING_DEPTH_KEY = 'depth'
-
       # 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'
-
       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'
-
       DEFAULT_IGNORE_ITERATORS = []
 
       def self.default_config
@@ -42,11 +35,11 @@ module Reek
         exp, depth = *find_deepest_iterator(ctx)
 
         if depth && depth > value(MAX_ALLOWED_NESTING_KEY, ctx, DEFAULT_MAX_ALLOWED_NESTING)
-          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [exp.line],
-                                   "contains iterators nested #{depth} deep",
-                                   @source, SMELL_SUBCLASS,
-                                   NESTING_DEPTH_KEY => depth)
-          [smell]
+          [SmellWarning.new(self,
+                            context: ctx.full_name,
+                            lines: [exp.line],
+                            message: "contains iterators nested #{depth} deep",
+                            parameters: { count: depth })]
         else
           []
         end
@@ -71,7 +64,7 @@ module Reek
       def find_iters_for_iter_node(exp, depth)
         ignored = ignored_iterator? exp
         result = find_iters(exp.call, depth) +
-          find_iters(exp.block, depth + (ignored ? 0 : 1))
+                 find_iters(exp.block, depth + (ignored ? 0 : 1))
         result << [exp, depth] unless ignored
         result
       end

data/lib/reek/smells/nil_check.rb

@@ -6,8 +6,9 @@ module Reek
     # Checking for nil is a special kind of type check, and therefore a case of
     # SimulatedPolymorphism.
     class NilCheck < SmellDetector
-      SMELL_CLASS = 'SimulatedPolymorphism'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
+      def self.smell_category
+        'SimulatedPolymorphism'
+      end
 
       def examine_context(ctx)
         call_node_finder = NodeFinder.new(ctx, :send, NilCallNodeDetector)
@@ -15,9 +16,10 @@ module Reek
         smelly_nodes = call_node_finder.smelly_nodes + case_node_finder.smelly_nodes
 
         smelly_nodes.map do |node|
-          SmellWarning.new(SMELL_CLASS, ctx.full_name, Array(node.line),
-                           'performs a nil-check.',
-                           @source, SMELL_SUBCLASS)
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: [node.line],
+                           message: 'performs a nil-check.'
         end
       end
 
@@ -50,10 +52,10 @@ module Reek
         end
 
         def nil_comparison?(call)
-          is_comparison_call?(call) && involves_nil?(call)
+          comparison_call?(call) && involves_nil?(call)
         end
 
-        def is_comparison_call?(call)
+        def comparison_call?(call)
           comparison_methods.include? call.method_name
         end
 

data/lib/reek/smells/prima_donna_method.rb

@@ -23,10 +23,7 @@ module Reek
     # Such a method is called PrimaDonnaMethod and is reported as a smell.
     #
     class PrimaDonnaMethod < SmellDetector
-      SMELL_CLASS    = smell_class_name
-      SMELL_SUBCLASS = smell_class_name
-
-      def self.contexts
+      def self.contexts # :nodoc:
         [:class]
       end
 
@@ -39,9 +36,10 @@ module Reek
           end
           next if version_without_bang
 
-          SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-                           "has prima donna method `#{method_sexp.name}`",
-                           @source, SMELL_SUBCLASS)
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: [ctx.exp.line],
+                           message: "has prima donna method `#{method_sexp.name}`"
         end.compact
       end
     end

data/lib/reek/smells/repeated_conditional.rb

@@ -6,8 +6,10 @@ module Reek
     #
     # Simulated Polymorphism occurs when
     # * code uses a case statement (especially on a type field);
-    # * or code has several if statements in a row (especially if they're comparing against the same value);
-    # * or code uses instance_of?, kind_of?, is_a?, or === to decide what type it's working with;
+    # * or code has several if statements in a row
+    #   (especially if they're comparing against the same value);
+    # * or code uses instance_of?, kind_of?, is_a?, or ===
+    #   to decide what type it's working with;
     # * or multiple conditionals in different places test the same value.
     #
     # Conditional code is hard to read and understand, because the reader must
@@ -21,20 +23,21 @@ module Reek
     # testing the same value throughout a single class.
     #
     class RepeatedConditional < SmellDetector
-      SMELL_CLASS = 'SimulatedPolymorphism'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
+      # 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'
+      DEFAULT_MAX_IFS = 2
+
+      def self.smell_category
+        'SimulatedPolymorphism'
+      end
+
       BLOCK_GIVEN_CONDITION = AST::Node.new(:send, [nil, :block_given?])
 
       def self.contexts      # :nodoc:
         [:class]
       end
 
-      # 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'
-
-      DEFAULT_MAX_IFS = 2
-
       def self.default_config
         super.merge(MAX_IDENTICAL_IFS_KEY => DEFAULT_MAX_IFS)
       end
@@ -50,11 +53,12 @@ module Reek
           lines.length > @max_identical_ifs
         end.map do |key, lines|
           occurs = lines.length
-          expr = key.format_ruby
-          SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
-                           "tests #{expr} at least #{occurs} times",
-                           @source, SMELL_SUBCLASS,
-                           'expression' => expr, 'occurrences' => occurs)
+          expression = key.format_ruby
+          SmellWarning.new self,
+                           context: ctx.full_name,
+                           lines: lines,
+                           message: "tests #{expression} at least #{occurs} times",
+                           parameters: { name: expression, count: occurs }
         end
       end
 

data/lib/reek/smells/smell_detector.rb

@@ -14,6 +14,8 @@ module Reek
     # Shared responsibilities of all smell detectors.
     #
     class SmellDetector
+      attr_reader :source, :smell_category, :smell_type
+
       # 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.
@@ -34,8 +36,26 @@ module Reek
             EXCLUDE_KEY => DEFAULT_EXCLUDE_SET.dup
           }
         end
+      end
+
+      def smell_category
+        self.class.smell_category
+      end
+
+      def smell_type
+        self.class.smell_type
+      end
+
+      class << self
+        def smell_category
+          @smell_category ||= default_smell_category
+        end
+
+        def smell_type
+          @smell_type ||= default_smell_category
+        end
 
-        def smell_class_name
+        def default_smell_category
           name.split(/::/)[-1]
         end
       end

data/lib/reek/smells/too_many_instance_variables.rb

@@ -11,16 +11,15 @@ module Reek
     # configurable number of instance variables.
     #
     class TooManyInstanceVariables < SmellDetector
-      SMELL_CLASS = 'LargeClass'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-      IVAR_COUNT_KEY = 'ivar_count'
-
       # 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'
-
       DEFAULT_MAX_IVARS = 9
 
+      def self.smell_category
+        'LargeClass'
+      end
+
       def self.contexts      # :nodoc:
         [:class]
       end
@@ -39,19 +38,13 @@ module Reek
       #
       def examine_context(ctx)
         @max_allowed_ivars = value(MAX_ALLOWED_IVARS_KEY, ctx, DEFAULT_MAX_IVARS)
-        check_num_ivars(ctx)
-      end
-
-      private
-
-      def check_num_ivars(ctx)  # :nodoc:
         count = ctx.local_nodes(:ivasgn).map { |ivasgn| ivasgn[1] }.uniq.length
         return [] if count <= @max_allowed_ivars
-        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-                                 "has at least #{count} instance variables",
-                                 @source, SMELL_SUBCLASS,
-                                 IVAR_COUNT_KEY => count)
-        [smell]
+        [SmellWarning.new(self,
+                          context: ctx.full_name,
+                          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,17 +13,16 @@ module Reek
     # modules.
     #
     class TooManyMethods < SmellDetector
-      SMELL_CLASS = 'LargeClass'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-      METHOD_COUNT_KEY = 'method_count'
-
       # The name of the config field that sets the maximum number of methods
       # permitted in a class.
       MAX_ALLOWED_METHODS_KEY = 'max_methods'
-
       DEFAULT_MAX_METHODS = 25
 
-      def self.contexts      # :nodoc:
+      def self.smell_category
+        'LargeClass'
+      end
+
+      def self.contexts # :nodoc:
         [:class]
       end
 
@@ -41,19 +40,13 @@ module Reek
       #
       def examine_context(ctx)
         @max_allowed_methods = value(MAX_ALLOWED_METHODS_KEY, ctx, DEFAULT_MAX_METHODS)
-        check_num_methods(ctx)
-      end
-
-      private
-
-      def check_num_methods(ctx)  # :nodoc:
         actual = ctx.node_instance_methods.length
         return [] if actual <= @max_allowed_methods
-        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-                                 "has at least #{actual} methods",
-                                 @source, SMELL_SUBCLASS,
-                                 METHOD_COUNT_KEY => actual)
-        [smell]
+        [SmellWarning.new(self,
+                          context: ctx.full_name,
+                          lines: [ctx.exp.line],
+                          message:  "has at least #{actual} methods",
+                          parameters: { count: actual })]
       end
     end
   end

data/lib/reek/smells/too_many_statements.rb

@@ -9,17 +9,15 @@ module Reek
     # +TooManyStatements+ reports any method with more than 5 statements.
     #
     class TooManyStatements < SmellDetector
-      SMELL_CLASS = 'LongMethod'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-
-      STATEMENT_COUNT_KEY = 'statement_count'
-
       # The name of the config field that sets the maximum number of
       # statements permitted in any method.
       MAX_ALLOWED_STATEMENTS_KEY = 'max_statements'
-
       DEFAULT_MAX_STATEMENTS = 5
 
+      def self.smell_category
+        'LongMethod'
+      end
+
       def self.default_config
         super.merge(
           MAX_ALLOWED_STATEMENTS_KEY => DEFAULT_MAX_STATEMENTS,
@@ -33,14 +31,16 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_allowed_statements = value(MAX_ALLOWED_STATEMENTS_KEY, ctx, DEFAULT_MAX_STATEMENTS)
-        num = ctx.num_statements
-        return [] if num <= @max_allowed_statements
-        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-                                 "has approx #{num} statements",
-                                 @source, SMELL_SUBCLASS,
-                                 STATEMENT_COUNT_KEY => num)
-        [smell]
+        @max_allowed_statements = value(MAX_ALLOWED_STATEMENTS_KEY,
+                                        ctx,
+                                        DEFAULT_MAX_STATEMENTS)
+        count = ctx.num_statements
+        return [] if count <= @max_allowed_statements
+        [SmellWarning.new(self,
+                          context: ctx.full_name,
+                          lines: [ctx.exp.line],
+                          message: "has approx #{count} statements",
+                          parameters: { count: count })]
       end
     end
   end

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -17,23 +17,21 @@ module Reek
     # * names ending with a number
     #
     class UncommunicativeMethodName < SmellDetector
-      SMELL_CLASS = 'UncommunicativeName'
-      SMELL_SUBCLASS = name.split(/::/)[-1]
-      METHOD_NAME_KEY = 'method_name'
-
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
       REJECT_KEY = 'reject'
-
       DEFAULT_REJECT_SET = [/^[a-z]$/, /[0-9]$/, /[A-Z]/]
 
       # 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'
-
       DEFAULT_ACCEPT_SET = []
 
+      def self.smell_category
+        'UncommunicativeName'
+      end
+
       def self.default_config
         super.merge(
           REJECT_KEY => DEFAULT_REJECT_SET,
@@ -54,10 +52,11 @@ module Reek
         var = name.gsub(/^[@\*\&]*/, '')
         return [] if @accept_names.include?(var)
         return [] unless @reject_names.find { |patt| patt =~ var }
-        smell = SmellWarning.new('UncommunicativeName', ctx.full_name, [ctx.exp.line],
-                                 "has the name '#{name}'",
-                                 @source, 'UncommunicativeMethodName', METHOD_NAME_KEY => name)
-        [smell]
+        [SmellWarning.new(self,
+                          context: ctx.full_name,
+                          lines: [ctx.exp.line],
+                          message: "has the name '#{name}'",
+                          parameters: { name: name })]
       end
     end
   end