reek 1.2.6 → 1.2.7

data/lib/reek/smells/irresponsible_module.rb

@@ -0,0 +1,28 @@
+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
+
+    #
+    # It is considered good practice to annotate every class and module
+    # with a brief comment outlining its responsibilities.
+    #
+    class IrresponsibleModule < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:class]
+      end
+
+      #
+      # Checks the given class or module for a descriptive comment.
+      # Remembers any smells found.
+      #
+      def examine_context(ctx)
+        comment = Source::CodeComment.new(ctx.exp.comments)
+        found(ctx, "has no descriptive comment") unless comment.is_descriptive?
+      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
@@ -15,6 +15,8 @@ module Reek
     # included modules.
     #
     class LargeClass < SmellDetector
+      SUBCLASS_TOO_MANY_METHODS = 'TooManyMethods'
+      SUBCLASS_TOO_MANY_IVARS = 'TooManyInstanceVariables'
 
       # The name of the config field that sets the maximum number of methods
       # permitted in a class.
@@ -40,20 +42,20 @@ 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")
+        found(klass, "has at least #{actual} methods", SUBCLASS_TOO_MANY_METHODS, {'method_count' => actual})
       end
 
       def check_num_ivars(klass)  # :nodoc:
-        count = klass.variable_names.length
+        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")
+        found(klass, "has at least #{count} instance variables", SUBCLASS_TOO_MANY_IVARS, {'ivar_count' => count})
       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
@@ -11,6 +11,7 @@ module Reek
     # 5 statements.
     #
     class LongMethod < SmellDetector
+      SUBCLASS_TOO_MANY_STATEMENTS = 'TooManyStatements'
 
       # The name of the config field that sets the maximum number of
       # statements permitted in any method.
@@ -25,8 +26,8 @@ module Reek
         )
       end
 
-      def initialize(config = LongMethod.default_config)
-        super(config)
+      def initialize(source, config = LongMethod.default_config)
+        super(source, config)
       end
 
       #
@@ -36,7 +37,7 @@ module Reek
       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")
+        found(method, "has approx #{num} statements", SUBCLASS_TOO_MANY_STATEMENTS, {'statement_count' => num})
       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
@@ -24,25 +26,25 @@ 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.
       #
-      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")
+      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",
+          'LongParameterList', {'parameter_count' => num_params})
       end
     end
   end

data/lib/reek/smells/long_yield_list.rb

@@ -1,17 +1,47 @@
-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]
+      # 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
+        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.
+      # Remembers any smells found.
+      #
+      def examine_context(method_ctx)
+        method_ctx.local_nodes(:yield).each 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('LongParameterList', method_ctx.full_name, [yield_node.line],
+            "yields #{num_params} parameters", @masked,
+            @source, 'LongYieldList', {'parameter_count' => num_params})
+          @smells_found << smell
+          #SMELL: serious duplication
+        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
@@ -10,18 +10,43 @@ module Reek
     # +NestedIterators+ reports failing methods only once.
     #
     class NestedIterators < SmellDetector
-
-      def self.contexts      # :nodoc:
-        [:iter]
-      end
+      # SMELL: should be a subclass of UnnecessaryComplexity
 
       #
       # 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')
+      def examine_context(method_ctx)
+        find_deepest_iterators(method_ctx).each do |iter|
+          depth = iter[1]
+          found(method_ctx, "contains iterators nested #{depth} deep", '',
+            {'depth' => depth}, [iter[0].line])
+        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)
+        result = []
+        find_iters(method_ctx.exp, 1, result)
+        result.select {|item| item[1] >= 2}
+      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
+            find_iters([elem.block], depth+1, result)
+            result << [elem, depth] if result.length == current
+          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,6 @@
-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')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source')
 
 module Reek
   module Smells
@@ -38,8 +38,8 @@ 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
 
       #
@@ -47,8 +47,12 @@ module Reek
       # Remembers any smells found.
       #
       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)
+        conditional_counts(klass).each do |key, lines|
+          occurs = lines.length
+          next unless occurs > value(MAX_IDENTICAL_IFS_KEY, klass, DEFAULT_MAX_IFS)
+          expr = Source::SexpFormatter.format(key)
+          found(klass, "tests #{expr} at least #{occurs} times",
+            'RepeatedConditional', {'expression' => expr, 'occurrences' => occurs}, lines)
         end
       end
 
@@ -58,13 +62,13 @@ module Reek
       # occurs. Ignores nested classes and modules.
       #
       def conditional_counts(klass)
-        result = Hash.new(0)
+        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 == 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| klass.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
@@ -30,14 +35,17 @@ module Reek
 
         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)
+      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 = Set.new
         @masked = false
       end
@@ -62,7 +70,7 @@ module Reek
       end
 
       def copy
-        self.class.new(@config.deep_copy)
+        self.class.new(@source, @config.deep_copy)
       end
 
       def supersede_with(config)
@@ -73,20 +81,20 @@ module Reek
       end
 
       def examine(context)
-        before = @smells_found.size
         examine_context(context) if @config.enabled? and !exception?(context)
-        @smells_found.length > before
       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)
+      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, @masked,
+          @source, subclass, parameters)
         @smells_found << smell
         smell
       end
@@ -97,6 +105,10 @@ module Reek
         false
       end
 
+      def smell_type
+        self.class.name.split(/::/)[-1]
+      end
+
       def report_on(report)
         @smells_found.each { |smell| smell.report_on(report) }
       end

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -0,0 +1,76 @@
+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
+
+    #
+    # An Uncommunicative Name is a name that doesn't communicate its intent
+    # well enough.
+    # 
+    # Poor names make it hard for the reader to build a mental picture
+    # of what's going on in the code. They can also be mis-interpreted;
+    # and they hurt the flow of reading, because the reader must slow
+    # down to interpret the names.
+    #
+    # Currently +UncommunicativeMethodName+ checks for
+    # * 1-character names
+    # * names ending with a number
+    #
+    class UncommunicativeMethodName < SmellDetector
+
+      # The name of the config field that lists the regexps of
+      # smelly names to be reported.
+      REJECT_KEY = 'reject'
+
+      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
+      
+      # 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.default_config
+        super.adopt(
+          REJECT_KEY => DEFAULT_REJECT_SET,
+          ACCEPT_KEY => DEFAULT_ACCEPT_SET
+        )
+      end
+
+      def self.contexts      # :nodoc:
+        [:defn, :defs]
+      end
+
+      def initialize(source, config = UncommunicativeMethodName.default_config)
+        super(source, config)
+      end
+
+      #
+      # 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],
+          "has the name '#{name}'", @masked,
+          @source, 'UncommunicativeMethodName', {'method_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:
+        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}
+      end
+    end
+  end
+end