reek 1.2.6 → 1.2.8

data/lib/reek/smells/feature_envy.rb

@@ -1,6 +1,5 @@
-require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
-require 'reek/sexp_formatter'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
 
 module Reek
   module Smells
@@ -35,14 +34,24 @@ module Reek
     class FeatureEnvy < SmellDetector
       include ExcludeInitialize
 
+      SMELL_CLASS = 'LowCohesion'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+
+      RECEIVER_KEY = 'receiver'
+      REFERENCES_KEY = 'references'
+
       #
       # Checks whether the given +context+ includes any code fragment that
       # might "belong" on another class.
-      # Remembers any smells found.
       #
-      def examine_context(context)
-        context.envious_receivers.each do |ref|
-          found(context, "refers to #{SexpFormatter.format(ref)} more than self")
+      # @return [Array<SmellWarning>]
+      #
+      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})
         end
       end
     end

data/lib/reek/smells/irresponsible_module.rb

@@ -0,0 +1,37 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source')
+
+module Reek
+  module Smells
+
+    #
+    # It is considered good practice to annotate every class and module
+    # with a brief comment outlining its responsibilities.
+    #
+    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.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        comment = Source::CodeComment.new(ctx.exp.comments)
+        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
+end

data/lib/reek/smells/large_class.rb

@@ -1,5 +1,5 @@
-require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
 
 module Reek
   module Smells
@@ -16,6 +16,12 @@ module Reek
     #
     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.
       MAX_ALLOWED_METHODS_KEY = 'max_methods'
@@ -40,29 +46,41 @@ module Reek
           )
       end
 
-      def initialize(config = LargeClass.default_config)
-        super(config)
+      def initialize(source, config = LargeClass.default_config)
+        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")
+      #
+      # 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.variable_names.length
-        return if count <= value(MAX_ALLOWED_IVARS_KEY, klass, DEFAULT_MAX_IVARS)
-        found(klass, "has at least #{count} instance variables")
+    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

@@ -1,5 +1,5 @@
-require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
 
 module Reek
   module Smells
@@ -12,6 +12,11 @@ module Reek
     #
     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'
@@ -25,18 +30,24 @@ module Reek
         )
       end
 
-      def initialize(config = LongMethod.default_config)
-        super(config)
+      def initialize(source, config = LongMethod.default_config)
+        super(source, config)
       end
 
       #
       # 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")
+      # @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

@@ -1,4 +1,6 @@
-require 'reek/smells/smell_detector'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'core', 'smell_configuration')
 
 module Reek
   module Smells
@@ -13,6 +15,11 @@ module Reek
     #
     class LongParameterList < SmellDetector
 
+      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'
@@ -24,25 +31,30 @@ module Reek
       def self.default_config
         super.adopt(
           MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS,
-          SmellConfiguration::OVERRIDES_KEY => {
+          Core::SmellConfiguration::OVERRIDES_KEY => {
             "initialize" => {MAX_ALLOWED_PARAMS_KEY => 5}
             }
         )
       end
 
-      def initialize(config = LongParameterList.default_config)
-        super(config)
-        @action = 'has'
+      def initialize(source, config = LongParameterList.default_config)
+        super(source, config)
       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(ctx)
-        num_params = ctx.parameters.length
-        return false if num_params <= value(MAX_ALLOWED_PARAMS_KEY, ctx, DEFAULT_MAX_ALLOWED_PARAMS)
-        found(ctx, "#{@action} #{num_params} parameters")
+        @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

@@ -1,17 +1,53 @@
-require 'reek/smells/smell_detector'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
 
 module Reek
   module Smells
 
-    class LongYieldList < LongParameterList
+    #
+    # A variant on LongParameterList that checks the number of items
+    # passed to a block by a +yield+ call.
+    #
+    class LongYieldList < SmellDetector
 
-      def self.contexts      # :nodoc:
-        [:yield]
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = 'LongParameterList'
+
+      # 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.default_config
+        super.adopt(
+                MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS
+        )
+      end
+
+      def initialize(source, config = LongYieldList.default_config)
+        super(source, config)
       end
 
-      def initialize(config = LongYieldList.default_config)
-        super
-        @action = 'yields'
+      #
+      # Checks the number of parameters in the given scope.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(method_ctx)
+        @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})
+        end
       end
     end
   end

data/lib/reek/smells/nested_iterators.rb

@@ -1,5 +1,5 @@
-require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
 
 module Reek
   module Smells
@@ -11,17 +11,77 @@ module Reek
     #
     class NestedIterators < SmellDetector
 
-      def self.contexts      # :nodoc:
-        [:iter]
+      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(block)
-        return false unless block.nested_block?
-        found(block, 'is nested')
+      # @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]
+          SmellWarning.new(SMELL_CLASS, ctx.full_name, [iter[0].line],
+            "contains iterators nested #{depth} deep",
+            @source, SMELL_SUBCLASS,
+            {NESTING_DEPTH_KEY => depth})
+        end
+        # BUG: no longer reports nesting outside methods (eg. in Optparse)
+      end
+
+    private
+
+      def find_deepest_iterators(ctx)
+        result = []
+        find_iters(ctx.exp, 1, result)
+        result.select {|item| item[1] > @max_allowed_nesting}
+      end
+
+      def find_iters(exp, depth, result)
+        exp.each do |elem|
+          next unless Sexp === elem
+          case elem.first
+          when :iter
+            find_iters([elem.call], depth, result)
+            current = result.length
+            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
+            find_iters(elem, depth, result)
+          end
+        end
       end
     end
   end

data/lib/reek/smells/simulated_polymorphism.rb

@@ -1,6 +1,5 @@
-require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
-require 'reek/sexp_formatter'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
 
 module Reek
   module Smells
@@ -24,6 +23,9 @@ module Reek
     #
     class SimulatedPolymorphism < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = 'RepeatedConditional'
+
       def self.contexts      # :nodoc:
         [:class]
       end
@@ -38,17 +40,26 @@ module Reek
         super.adopt(MAX_IDENTICAL_IFS_KEY => DEFAULT_MAX_IFS)
       end
 
-      def initialize(config = SimulatedPolymorphism.default_config)
-        super(config)
+      def initialize(source, config = SimulatedPolymorphism.default_config)
+        super(source, config)
       end
 
       #
-      # Checks the given ClassContext for multiple identical conditional tests.
-      # Remembers any smells found.
+      # Checks the given class for multiple identical conditional tests.
+      #
+      # @return [Array<SmellWarning>]
       #
-      def examine_context(klass)
-        conditional_counts(klass).each do |key, val|
-          found(klass, "tests #{SexpFormatter.format(key)} at least #{val} times") if val > value(MAX_IDENTICAL_IFS_KEY, klass, DEFAULT_MAX_IFS)
+      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
+          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
 
@@ -57,14 +68,14 @@ module Reek
       # the given syntax tree together with the number of times each
       # occurs. Ignores nested classes and modules.
       #
-      def conditional_counts(klass)
-        result = Hash.new(0)
+      def conditional_counts(sexp)
+        result = Hash.new {|hash, key| hash[key] = []}
         collector = proc { |node|
           condition = node.condition
-          result[condition] += 1 unless condition == s(:call, nil, :block_given?, s(:arglist))
+          next if condition.nil? or condition == s(:call, nil, :block_given?, s(:arglist))
+          result[condition].push(condition.line)
         }
-        klass.local_nodes(:if, &collector)
-        klass.local_nodes(:case, &collector)
+        [:if, :case].each {|stmt| sexp.local_nodes(stmt, &collector) }
         result
       end
     end

data/lib/reek/smells/smell_detector.rb

@@ -1,4 +1,6 @@
-require 'reek/configuration'
+require 'set'
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'core', 'smell_configuration')
 
 module Reek
   module Smells
@@ -7,11 +9,14 @@ module Reek
       def self.default_config
         super.adopt(EXCLUDE_KEY => ['initialize'])
       end
-      def initialize(config = self.class.default_config)
-        super
+      def initialize(source, config = self.class.default_config)
+        super(source, config)
       end
     end
 
+    #
+    # Shared responsibilities of all smell detectors.
+    #
     class SmellDetector
 
       # The name of the config field that lists the names of code contexts
@@ -24,25 +29,28 @@ module Reek
       DEFAULT_EXCLUDE_SET = []
 
       class << self
-        def contexts      # :nodoc:
+        def contexts
           [:defn, :defs]
         end
 
         def default_config
           {
-            SmellConfiguration::ENABLED_KEY => true,
+            Core::SmellConfiguration::ENABLED_KEY => true,
             EXCLUDE_KEY => DEFAULT_EXCLUDE_SET
           }
         end
       end
 
-      def initialize(config = self.class.default_config)
-        @config = SmellConfiguration.new(config)
-        @smells_found = Set.new
-        @masked = false
+      attr_reader :smells_found   # SMELL: only published for tests
+
+      def initialize(source, config = self.class.default_config)
+        @source = source
+        @config = Core::SmellConfiguration.new(config)
+        @smells_found = []
       end
 
-      def listen_to(hooks)
+      def register(hooks)
+        return unless @config.enabled?
         self.class.contexts.each { |ctx| hooks[ctx] << self }
       end
 
@@ -51,66 +59,36 @@ module Reek
         @config.enabled?
       end
 
-      def configure(config)
-        my_part = config[self.class.name.split(/::/)[-1]]
-        return unless my_part
-        configure_with(my_part)
-      end
-
       def configure_with(config)
         @config.adopt!(config)
       end
 
-      def copy
-        self.class.new(@config.deep_copy)
-      end
-
-      def supersede_with(config)
-        clone = self.copy
-        @masked = true
-        clone.configure_with(config)
-        clone
-      end
-
       def examine(context)
-        before = @smells_found.size
-        examine_context(context) if @config.enabled? and !exception?(context)
-        @smells_found.length > before
+        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)
       end
-      
+
       def exception?(context)
         context.matches?(value(EXCLUDE_KEY, context, DEFAULT_EXCLUDE_SET))
       end
 
-      def found(context, message)
-        smell = SmellWarning.new(self, context.full_name, context.exp.line, message, @masked)
-        @smells_found << smell
-        smell
-      end
-
-      def has_smell?(patterns)
-        return false if @masked
-        @smells_found.each { |warning| return true if warning.contains_all?(patterns) }
-        false
-      end
-
       def report_on(report)
         @smells_found.each { |smell| smell.report_on(report) }
       end
 
-      def num_smells
-        @masked ? 0 : @smells_found.length
-      end
-
-      def smelly?
-        (not @masked) and (@smells_found.length > 0)
+      def value(key, ctx, fall_back)
+        config_for(ctx)[key] || @config.value(key, ctx, fall_back)
       end
 
-      def value(key, ctx, fall_back)
-        @config.value(key, ctx, fall_back)
+      def config_for(ctx)
+        ctx.config[self.class.name.split(/::/)[-1]] || {}
+        # BUG: needs to consider smell class AND subclass
       end
     end
   end