reek 1.2.7.3 → 1.2.8

data/lib/reek/smells/irresponsible_module.rb

@@ -1,7 +1,6 @@
 require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
 require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source')
 
-# Part of Reek's core
 module Reek
   module Smells
 
@@ -11,17 +10,27 @@ module Reek
     #
     class IrresponsibleModule < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = SMELL_CLASS
+
+      MODULE_NAME_KEY = 'module_name'
+
       def self.contexts      # :nodoc:
         [:class]
       end
 
       #
       # Checks the given class or module for a descriptive comment.
-      # Remembers any smells found.
+      #
+      # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
         comment = Source::CodeComment.new(ctx.exp.comments)
-        found(ctx, "has no descriptive comment") unless comment.is_descriptive?
+        return [] if comment.is_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]
       end
     end
   end

data/lib/reek/smells/large_class.rb

@@ -15,8 +15,12 @@ module Reek
     # included modules.
     #
     class LargeClass < SmellDetector
+
+      SMELL_CLASS = self.name.split(/::/)[-1]
       SUBCLASS_TOO_MANY_METHODS = 'TooManyMethods'
       SUBCLASS_TOO_MANY_IVARS = 'TooManyInstanceVariables'
+      METHOD_COUNT_KEY = 'method_count'
+      IVAR_COUNT_KEY = 'ivar_count'
 
       # The name of the config field that sets the maximum number of methods
       # permitted in a class.
@@ -46,25 +50,37 @@ module Reek
         super(source, config)
       end
 
-      def check_num_methods(klass)  # :nodoc:
-        actual = klass.local_nodes(:defn).length
-        return if actual <= value(MAX_ALLOWED_METHODS_KEY, klass, DEFAULT_MAX_METHODS)
-        found(klass, "has at least #{actual} methods", SUBCLASS_TOO_MANY_METHODS, {'method_count' => actual})
+      #
+      # Checks +klass+ for too many methods or too many instance variables.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @max_allowed_ivars = value(MAX_ALLOWED_IVARS_KEY, ctx, DEFAULT_MAX_IVARS)
+        @max_allowed_methods = value(MAX_ALLOWED_METHODS_KEY, ctx, DEFAULT_MAX_METHODS)
+        check_num_methods(ctx) + check_num_ivars(ctx)
       end
 
-      def check_num_ivars(klass)  # :nodoc:
-        count = klass.local_nodes(:iasgn).map {|iasgn| iasgn[1]}.uniq.length
-        return if count <= value(MAX_ALLOWED_IVARS_KEY, klass, DEFAULT_MAX_IVARS)
-        found(klass, "has at least #{count} instance variables", SUBCLASS_TOO_MANY_IVARS, {'ivar_count' => count})
+    private
+
+      def check_num_methods(ctx)  # :nodoc:
+        actual = ctx.local_nodes(:defn).length
+        return [] if actual <= @max_allowed_methods
+        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
+          "has at least #{actual} methods",
+          @source, SUBCLASS_TOO_MANY_METHODS,
+          {METHOD_COUNT_KEY => actual})
+        [smell]
       end
 
-      #
-      # Checks +klass+ for too many methods or too many instance variables.
-      # Remembers any smells found.
-      #
-      def examine_context(klass)
-        check_num_methods(klass)
-        check_num_ivars(klass)
+      def check_num_ivars(ctx)  # :nodoc:
+        count = ctx.local_nodes(:iasgn).map {|iasgn| iasgn[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, SUBCLASS_TOO_MANY_IVARS,
+          {IVAR_COUNT_KEY => count})
+        [smell]
       end
     end
   end

data/lib/reek/smells/long_method.rb

@@ -11,8 +11,12 @@ module Reek
     # 5 statements.
     #
     class LongMethod < SmellDetector
+
+      SMELL_CLASS = self.name.split(/::/)[-1]
       SUBCLASS_TOO_MANY_STATEMENTS = 'TooManyStatements'
 
+      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'
@@ -32,12 +36,18 @@ module Reek
 
       #
       # Checks the length of the given +method+.
-      # Remembers any smells found.
       #
-      def examine_context(method)
-        num = method.num_statements
-        return false if num <= value(MAX_ALLOWED_STATEMENTS_KEY, method, DEFAULT_MAX_STATEMENTS)
-        found(method, "has approx #{num} statements", SUBCLASS_TOO_MANY_STATEMENTS, {'statement_count' => num})
+      # @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, SUBCLASS_TOO_MANY_STATEMENTS,
+          {STATEMENT_COUNT_KEY => num})
+        [smell]
       end
     end
   end

data/lib/reek/smells/long_parameter_list.rb

@@ -18,6 +18,8 @@ module Reek
       SMELL_CLASS = self.name.split(/::/)[-1]
       SMELL_SUBCLASS = 'LongParameterList'
 
+      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'
@@ -40,14 +42,19 @@ module Reek
       end
 
       #
-      # Checks the number of parameters in the given scope.
-      # Remembers any smells found.
+      # Checks the number of parameters in the given method.
+      #
+      # @return [Array<SmellWarning>]
       #
-      def examine_context(method_ctx)
-        num_params = method_ctx.parameters.length
-        return false if num_params <= value(MAX_ALLOWED_PARAMS_KEY, method_ctx, DEFAULT_MAX_ALLOWED_PARAMS)
-        found(method_ctx, "has #{num_params} parameters",
-          SMELL_SUBCLASS, {'parameter_count' => num_params})
+      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]
       end
     end
   end

data/lib/reek/smells/long_yield_list.rb

@@ -21,9 +21,11 @@ module Reek
       # value.
       DEFAULT_MAX_ALLOWED_PARAMS = 3
 
+      PARAMETER_COUNT_KEY = 'parameter_count'
+
       def self.default_config
         super.adopt(
-          MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS
+                MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS
         )
       end
 
@@ -33,17 +35,18 @@ module Reek
 
       #
       # Checks the number of parameters in the given scope.
-      # Remembers any smells found.
+      #
+      # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        method_ctx.local_nodes(:yield).each do |yield_node|
+        @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
-          next if num_params <= value(MAX_ALLOWED_PARAMS_KEY, method_ctx, DEFAULT_MAX_ALLOWED_PARAMS)
-          smell = SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [yield_node.line],
-            "yields #{num_params} parameters",
-            @source, SMELL_SUBCLASS, {'parameter_count' => num_params})
-          @smells_found << smell
-          #SMELL: serious duplication
+          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [yield_node.line],
+                           "yields #{num_params} parameters",
+                           @source, SMELL_SUBCLASS, {PARAMETER_COUNT_KEY => num_params})
         end
       end
     end

data/lib/reek/smells/nested_iterators.rb

@@ -10,26 +10,59 @@ module Reek
     # +NestedIterators+ reports failing methods only once.
     #
     class NestedIterators < SmellDetector
+
+      SMELL_CLASS = self.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
+        super.adopt(
+          MAX_ALLOWED_NESTING_KEY => DEFAULT_MAX_ALLOWED_NESTING,
+          IGNORE_ITERATORS_KEY => DEFAULT_IGNORE_ITERATORS
+        )
+      end
+
+      def initialize(source, config = NestedIterators.default_config)
+        super(source, config)
+      end
 
       #
       # Checks whether the given +block+ is inside another.
-      # Remembers any smells found.
       #
-      def examine_context(method_ctx)
-        find_deepest_iterators(method_ctx).each do |iter|
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx, DEFAULT_IGNORE_ITERATORS)
+        @max_allowed_nesting = value(MAX_ALLOWED_NESTING_KEY, ctx, DEFAULT_MAX_ALLOWED_NESTING)
+        find_deepest_iterators(ctx).map do |iter|
           depth = iter[1]
-          found(method_ctx, "contains iterators nested #{depth} deep", '',
-            {'depth' => depth}, [iter[0].line])
+          SmellWarning.new(SMELL_CLASS, ctx.full_name, [iter[0].line],
+            "contains iterators nested #{depth} deep",
+            @source, SMELL_SUBCLASS,
+            {NESTING_DEPTH_KEY => depth})
         end
-        # TODO: report the nesting depth and the innermost line
         # BUG: no longer reports nesting outside methods (eg. in Optparse)
       end
 
-      def find_deepest_iterators(method_ctx)
+    private
+
+      def find_deepest_iterators(ctx)
         result = []
-        find_iters(method_ctx.exp, 1, result)
-        result.select {|item| item[1] >= 2}
+        find_iters(ctx.exp, 1, result)
+        result.select {|item| item[1] > @max_allowed_nesting}
       end
 
       def find_iters(exp, depth, result)
@@ -39,8 +72,10 @@ module Reek
           when :iter
             find_iters([elem.call], depth, result)
             current = result.length
-            find_iters([elem.block], depth+1, result)
-            result << [elem, depth] if result.length == current
+            call = Source::SexpFormatter.format(elem.call)
+            ignored = @ignore_iterators.any? { |ignore| /#{ignore}/ === call }
+            find_iters([elem.block], depth + (ignored ? 0 : 1), result)
+            result << [elem, depth] if result.length == current unless ignored
           when :class, :defn, :defs, :module
             next
           else

data/lib/reek/smells/simulated_polymorphism.rb

@@ -23,6 +23,9 @@ module Reek
     #
     class SimulatedPolymorphism < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = 'RepeatedConditional'
+
       def self.contexts      # :nodoc:
         [:class]
       end
@@ -43,15 +46,20 @@ module Reek
 
       #
       # Checks the given class for multiple identical conditional tests.
-      # Remembers any smells found.
       #
-      def examine_context(klass)
-        conditional_counts(klass).each do |key, lines|
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @max_identical_ifs = value(MAX_IDENTICAL_IFS_KEY, ctx, DEFAULT_MAX_IFS)
+        conditional_counts(ctx).select do |key, lines|
+          lines.length > @max_identical_ifs
+        end.map do |key, lines|
           occurs = lines.length
-          next unless occurs > value(MAX_IDENTICAL_IFS_KEY, klass, DEFAULT_MAX_IFS)
-          expr = key.format
-          found(klass, "tests #{expr} at least #{occurs} times",
-            'RepeatedConditional', {'expression' => expr, 'occurrences' => occurs}, lines)
+          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})
         end
       end
 
@@ -61,7 +69,7 @@ module Reek
       # occurs. Ignores nested classes and modules.
       #
       def conditional_counts(sexp)
-        result = Hash.new {|hash,key| hash[key] = []}
+        result = Hash.new {|hash, key| hash[key] = []}
         collector = proc { |node|
           condition = node.condition
           next if condition.nil? or condition == s(:call, nil, :block_given?, s(:arglist))

data/lib/reek/smells/smell_detector.rb

@@ -29,7 +29,7 @@ module Reek
       DEFAULT_EXCLUDE_SET = []
 
       class << self
-        def contexts      # :nodoc:
+        def contexts
           [:defn, :defs]
         end
 
@@ -46,7 +46,7 @@ module Reek
       def initialize(source, config = self.class.default_config)
         @source = source
         @config = Core::SmellConfiguration.new(config)
-        @smells_found = Set.new
+        @smells_found = []
       end
 
       def register(hooks)
@@ -64,7 +64,11 @@ module Reek
       end
 
       def examine(context)
-        examine_context(context) if @config.enabled? and !exception?(context)
+        enabled = @config.enabled? && config_for(context)[Core::SmellConfiguration::ENABLED_KEY] != false
+        if enabled && !exception?(context)
+          sm = examine_context(context)
+          @smells_found += sm
+        end
       end
 
       def examine_context(context)
@@ -74,21 +78,17 @@ module Reek
         context.matches?(value(EXCLUDE_KEY, context, DEFAULT_EXCLUDE_SET))
       end
 
-      def found(context, message, subclass = '', parameters = {}, lines = nil)
-        lines ||= [context.exp.line]        # SMELL: nil?!?!?! Yuk
-        smell = SmellWarning.new(self.class.name.split(/::/)[-1], context.full_name,
-          lines, message,
-          @source, subclass, parameters)
-        @smells_found << smell
-        smell
-      end
-
       def report_on(report)
         @smells_found.each { |smell| smell.report_on(report) }
       end
 
       def value(key, ctx, fall_back)
-        @config.value(key, ctx, fall_back)
+        config_for(ctx)[key] || @config.value(key, ctx, fall_back)
+      end
+
+      def config_for(ctx)
+        ctx.config[self.class.name.split(/::/)[-1]] || {}
+        # BUG: needs to consider smell class AND subclass
       end
     end
   end

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -53,29 +53,21 @@ module Reek
 
       #
       # Checks the given +context+ for uncommunicative names.
-      # Remembers any smells found.
       #
-      def examine_context(method_ctx)
-        name = method_ctx.name
-        return false if accept?(method_ctx)
-        return false unless is_bad_name?(name, method_ctx)
-        smell = SmellWarning.new('UncommunicativeName', method_ctx.full_name, [method_ctx.exp.line],
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
+        @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
+        name = ctx.name
+        return [] if @accept_names.include?(ctx.full_name)
+        var = name.to_s.gsub(/^[@\*\&]*/, '')
+        return [] if @accept_names.include?(var)
+        return [] unless @reject_names.detect {|patt| patt === var}
+        smell = SmellWarning.new('UncommunicativeName', ctx.full_name, [ctx.exp.line],
           "has the name '#{name}'",
           @source, 'UncommunicativeMethodName', {METHOD_NAME_KEY => name.to_s})
-        @smells_found << smell
-        #SMELL: serious duplication
-      end
-
-    private
-
-      def accept?(context)
-        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(context.full_name)
-      end
-
-      def is_bad_name?(name, context)  # :nodoc:
-        var = name.to_s.gsub(/^[@\*\&]*/, '')
-        return false if value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(var)
-        value(REJECT_KEY, context, DEFAULT_REJECT_SET).detect {|patt| patt === var}
+        [smell]
       end
     end
   end

data/lib/reek/smells/uncommunicative_module_name.rb

@@ -19,6 +19,10 @@ module Reek
     #
     class UncommunicativeModuleName < SmellDetector
 
+      SMELL_CLASS = 'UncommunicativeName'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      MODULE_NAME_KEY = 'module_name'
+
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
       REJECT_KEY = 'reject'
@@ -49,27 +53,21 @@ module Reek
 
       #
       # Checks the given +context+ for uncommunicative names.
-      # Remembers any smells found.
       #
-      def examine_context(module_ctx)
-        name = module_ctx.name
-        return false if accept?(module_ctx)
-        return false unless is_bad_name?(name, module_ctx)
-        smell = SmellWarning.new('UncommunicativeName', module_ctx.full_name, [module_ctx.exp.line],
-          "has the name '#{name}'",
-          @source, 'UncommunicativeModuleName', {'module_name' => name.to_s})
-        @smells_found << smell
-        #SMELL: serious duplication
-      end
-
-      def accept?(context)
-        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(context.full_name)
-      end
-
-      def is_bad_name?(name, context)  # :nodoc:
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
+        @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
+        name = ctx.exp.simple_name
+        return [] if @accept_names.include?(ctx.full_name)
         var = name.to_s.gsub(/^[@\*\&]*/, '')
-        return false if value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(var)
-        value(REJECT_KEY, context, DEFAULT_REJECT_SET).detect {|patt| patt === var}
+        return [] if @accept_names.include?(var)
+        return [] unless @reject_names.detect {|patt| patt === var}
+        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
+          "has the name '#{name}'",
+          @source, SMELL_SUBCLASS, {MODULE_NAME_KEY => name.to_s})
+        [smell]
       end
     end
   end