reek 1.1.3 → 1.2.0

data/lib/reek/detector_stack.rb

@@ -0,0 +1,39 @@
+
+module Reek
+  class DetectorStack
+
+    def initialize(default_detector)
+      @detectors = [default_detector]
+    end
+
+    def push(config)
+      clone = @detectors[-1].supersede_with(config)
+      @detectors << clone
+    end
+
+    def listen_to(hooks)
+      @detectors.each { |det| det.listen_to(hooks) }
+    end
+
+    def report_on(report)
+      @detectors.each { |det| det.report_on(report) }
+    end
+
+    def num_smells
+      total = 0
+      @detectors.each { |det| total += det.num_smells }
+      total
+    end
+
+    def has_smell?(patterns)
+      @detectors.each { |det| return true if det.has_smell?(patterns) }
+      false
+    end
+
+    def smelly?
+      # SMELL: Duplication: look at al those loops!
+      @detectors.each { |det| return true if det.smelly? }
+      false
+    end
+  end
+end

data/lib/reek/exceptions.reek

@@ -1,4 +1,7 @@
---- 
+---
+Duplication:
+  exclude:
+  - Reek::Options#set_options
 FeatureEnvy:
   exclude:
   - examine_context
@@ -8,6 +11,10 @@ LargeClass:
 LongMethod:
   exclude:
   - Reek::SexpFormatter#self.format
+  - Reek::Options#set_options
+UncommunicativeName:
+  accept:
+  - process_op_asgn1
 UtilityFunction:
   exclude:
   - Reek::Spec

data/lib/reek/method_context.rb

@@ -2,7 +2,55 @@ require 'reek/name'
 require 'reek/code_context'
 require 'reek/object_refs'
 
+class Array
+  def power_set
+    self.inject([[]]) { |cum, element| cum.cross(element) }
+  end
+
+  def bounded_power_set(lower_bound)
+    power_set.select {|ps| ps.length > lower_bound}
+  end
+
+  def cross(element)
+    result = []
+    self.each do |set|
+      result << set
+      result << (set + [element])
+    end
+    result
+  end
+
+  def intersection
+    self.inject { |res, elem| elem & res }
+  end
+end
+
 module Reek
+
+  module MethodParameters
+    def self.is_arg?(param)
+      return false if (Array === param and param[0] == :block)
+      return !(param.to_s =~ /^\&/)
+    end
+
+    def names
+      return @names if @names
+      @names = self[1..-1].select {|arg| MethodParameters.is_arg?(arg)}.map {|arg| Name.new(arg)}
+    end
+
+    def length
+      names.length
+    end
+
+    def include?(name)
+      names.include?(name)
+    end
+
+    def to_s
+      "[#{names.map{|nm| nm.to_s}.join(', ')}]"
+    end
+  end
+
   class MethodContext < CodeContext
     attr_reader :parameters
     attr_reader :calls
@@ -11,14 +59,16 @@ module Reek
 
     def initialize(outer, exp, record = true)
       super(outer, exp)
-      @parameters = []
+      @parameters = exp[exp[0] == :defn ? 2 : 3]  # SMELL: SimulatedPolymorphism
+      @parameters ||= []
+      @parameters.extend(MethodParameters)
       @local_variables = []
       @name = Name.new(exp[1])
       @num_statements = 0
       @calls = Hash.new(0)
       @depends_on_self = false
       @refs = ObjectRefs.new
-      @outer.record_method(@name)    # TODO: should be children of outer?
+      @outer.record_method(self)
     end
 
     def count_statements(num)
@@ -63,14 +113,6 @@ module Reek
       @local_variables << Name.new(sym)
     end
 
-    def self.is_block_arg?(param)
-      (Array === param and param[0] == :block) or (param.to_s =~ /^\&/)
-    end
-
-    def record_parameter(param)
-      @parameters << Name.new(param) unless MethodContext.is_block_arg?(param)
-    end
-
     def outer_name
       "#{@outer.outer_name}#{@name}/"
     end
@@ -85,7 +127,7 @@ module Reek
     end
 
     def variable_names
-      @parameters + @local_variables
+      @parameters.names + @local_variables
     end
   end
 end

data/lib/reek/module_context.rb

@@ -19,8 +19,7 @@ module Reek
 
     def find_module(modname)
       return nil unless myself
-      sym = modname.to_s
-      @myself.const_defined?(sym) ? @myself.const_get(sym) : nil
+      @myself.const_or_nil(modname.to_s)
     end
 
     def outer_name

data/lib/reek/name.rb

@@ -32,16 +32,22 @@ module Reek
       @name.hash
     end
 
+    def eql?(other)
+      self == other
+    end
+
     def <=>(other)  # :nodoc:
       @name <=> other.to_s
     end
 
-    alias eql? <=>
-
     def effective_name
       @name.gsub(/^@*/, '')
     end
 
+    def inspect
+      @name.inspect
+    end
+
     def to_s
       @name
     end

data/lib/reek/sexp_formatter.rb

@@ -1,3 +1,5 @@
+require 'rubygems'
+require 'ruby_parser'
 require 'ruby2ruby'
 
 module Reek

data/lib/reek/smell_warning.rb

@@ -1,4 +1,4 @@
-require 'reek/options'
+require 'reek/command_line'    # SMELL: Global Variable used for options
 
 module Reek
 
@@ -8,18 +8,19 @@ module Reek
   class SmellWarning
     include Comparable
 
-    def initialize(smell, context, warning)
-      @smell = smell
+    def initialize(smell, context, warning, masked)
+      @detector = smell
       @context = context
       @warning = warning
+      @is_masked = masked
     end
 
     def hash  # :nodoc:
-      report.hash
+      basic_report.hash
     end
 
     def <=>(other)
-      report <=> other.report
+      basic_report <=> other.basic_report
     end
 
     alias eql? <=>  # :nodoc:
@@ -29,21 +30,38 @@ module Reek
     # +smell_class+ and its report string matches all of the +patterns+.
     #
     def matches?(smell_class, patterns)
-      return false unless smell_class.to_s == @smell.class.class_name
+      return false unless smell_class.to_s == @detector.class.class_name
+      contains_all?(patterns)
+    end
+
+    def contains_all?(patterns)
       rpt = report
       return patterns.all? {|exp| exp === rpt}
     end
 
+    def basic_report
+      Options[:format].gsub(/\%s/, @detector.smell_name).gsub(/\%c/, @context.to_s).gsub(/\%w/, @warning)
+    end
+
     #
     # Returns a copy of the current report format (see +Options+)
     # in which the following magic tokens have been substituted:
     #
-    # * %s <-- the name of the smell that was detected
     # * %c <-- a description of the +CodeContext+ containing the smell
+    # * %m <-- "(is_masked) " if this is a is_masked smell
+    # * %s <-- the name of the smell that was detected
     # * %w <-- the specific problem that was detected
     #
     def report
-      Options[:format].gsub(/\%s/, @smell.smell_name).gsub(/\%c/, @context.to_s).gsub(/\%w/, @warning)
+      basic_report.gsub(/\%m/, @is_masked ? '(masked) ' : '')
+    end
+
+    def report_on(report)
+      if @is_masked
+        report.record_masked_smell(self)
+      else
+        report << self
+      end
     end
   end
 end

data/lib/reek/smells/control_couple.rb

@@ -49,12 +49,16 @@ module Reek
 
       #
       # Checks whether the given conditional statement relies on a control couple.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(cond, report)
+      def examine_context(cond)
         return unless cond.tests_a_parameter?
-        report << SmellWarning.new(self, cond,
-                    "is controlled by argument #{SexpFormatter.format(cond.if_expr)}")
+        # SMELL: Duplication
+        # This smell is reported once for each conditional that tests the
+        # same parameter. Which means that the same smell can recur within
+        # a single sniffer. Which in turn means that the sniffer can't count
+        # its smells without knowing which are duplicates.
+        found(cond, "is controlled by argument #{SexpFormatter.format(cond.if_expr)}")
       end
     end
   end

data/lib/reek/smells/data_clump.rb

@@ -0,0 +1,88 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
+
+module Reek
+  module Smells
+
+    #
+    # A Data Clump occurs when the same two or three items frequently
+    # appear together in classes and parameter lists, or when a group
+    # of instance variable names start or end with similar substrings.
+    #
+    # The recurrence of the items often means there is duplicate code
+    # spread around to handle them. There may be an abstraction missing
+    # from the code, making the system harder to understand.
+    #
+    # Currently Reek looks for a group of two or more parameters with
+    # the same names that are expected by three or more methods of a class.
+    #
+    class DataClump < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:class]
+      end
+
+      # The name of the config field that sets the maximum allowed
+      # copies of any clump.
+      MAX_COPIES_KEY = 'max_copies'
+
+      DEFAULT_MAX_COPIES = 2
+
+      MIN_CLUMP_SIZE_KEY = 'min_clump_size'
+      DEFAULT_MIN_CLUMP_SIZE = 2
+
+      def self.default_config
+        super.adopt(
+          MAX_COPIES_KEY => DEFAULT_MAX_COPIES,
+          MIN_CLUMP_SIZE_KEY => DEFAULT_MIN_CLUMP_SIZE
+        )
+      end
+
+      def initialize(config = DataClump.default_config)
+        super(config)
+      end
+
+      #
+      # Checks the given ClassContext for multiple identical conditional tests.
+      # Remembers any smells found.
+      #
+      def examine_context(klass)
+        max_copies = value(MAX_COPIES_KEY, klass, DEFAULT_MAX_COPIES)
+        min_clump_size = value(MIN_CLUMP_SIZE_KEY, klass, DEFAULT_MIN_CLUMP_SIZE)
+        MethodGroup.new(klass, min_clump_size, max_copies).clumps.each do |clump, occurs|
+          found(klass, "takes parameters #{DataClump.print_clump(clump)} to #{occurs} methods")
+        end
+      end
+
+      def self.print_clump(clump)
+        "[#{clump.map {|name| name.to_s}.join(', ')}]"
+      end
+    end
+  end
+
+  # Represents a group of methods
+  class MethodGroup   # :nodoc:
+
+    def self.intersection_of_parameters_of(methods)
+      methods.map {|meth| meth.parameters.names.sort}.intersection
+    end
+
+    def initialize(klass, min_clump_size, max_copies)
+      @klass = klass
+      @min_clump_size = min_clump_size
+      @max_copies = max_copies
+    end
+
+    def clumps
+      results = Hash.new(0)
+      @klass.parameterized_methods(@min_clump_size).bounded_power_set(@max_copies).each do |methods|
+        clump = MethodGroup.intersection_of_parameters_of(methods)
+        if clump.length >= @min_clump_size
+          results[clump] = [methods.length, results[clump]].max
+        end
+      end
+      results
+    end
+  end
+end

data/lib/reek/smells/duplication.rb

@@ -24,26 +24,28 @@ module Reek
       # identical calls to be permitted within any single method.
       MAX_ALLOWED_CALLS_KEY = 'max_calls'
 
+      DEFAULT_MAX_CALLS = 1
+
       def self.default_config
-        super.adopt(MAX_ALLOWED_CALLS_KEY => 1)
+        super.adopt(MAX_ALLOWED_CALLS_KEY => DEFAULT_MAX_CALLS)
       end
 
       def initialize(config = Duplication.default_config)
-        super
-        @max_calls = config[MAX_ALLOWED_CALLS_KEY]
+        super(config)
       end
 
-      def examine_context(method, report)
-        smelly_calls(method).each do |call|
-          report << SmellWarning.new(self, method,
-                      "calls #{SexpFormatter.format(call)} multiple times")
+      def examine_context(method)
+        smelly_calls(method).each do |call_data|
+          num = call_data[1]
+          multiple = num == 2 ? 'twice' : "#{num} times"
+          found(method, "calls #{SexpFormatter.format(call_data[0])} #{multiple}")
         end
       end
       
       def smelly_calls(method)   # :nodoc:
         method.calls.select do |key,val|
-          val > @max_calls and key[2] != :new
-        end.map { |call_exp| call_exp[0] }
+          val > value(MAX_ALLOWED_CALLS_KEY, method, DEFAULT_MAX_CALLS) and key[2] != :new
+        end
       end
     end
   end

data/lib/reek/smells/feature_envy.rb

@@ -45,12 +45,11 @@ module Reek
       #
       # Checks whether the given +context+ includes any code fragment that
       # might "belong" on another class.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(context, report)
+      def examine_context(context)
         context.envious_receivers.each do |ref|
-          report << SmellWarning.new(self, context,
-                      "refers to #{SexpFormatter.format(ref)} more than self")
+          found(context, "refers to #{SexpFormatter.format(ref)} more than self")
         end
       end
     end

data/lib/reek/smells/large_class.rb

@@ -20,49 +20,49 @@ module Reek
       # permitted in a class.
       MAX_ALLOWED_METHODS_KEY = 'max_methods'
 
+      DEFAULT_MAX_METHODS = 25
+
       # 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.contexts      # :nodoc:
         [:class]
       end
 
       def self.default_config
         super.adopt(
-          MAX_ALLOWED_METHODS_KEY => 25,
-          MAX_ALLOWED_IVARS_KEY => 9,
+          MAX_ALLOWED_METHODS_KEY => DEFAULT_MAX_METHODS,
+          MAX_ALLOWED_IVARS_KEY => DEFAULT_MAX_IVARS,
           EXCLUDE_KEY => []
           )
       end
 
       def initialize(config = LargeClass.default_config)
-        super
-        @max_methods = config[MAX_ALLOWED_METHODS_KEY]
-        @max_instance_variables = config[MAX_ALLOWED_IVARS_KEY]
+        super(config)
       end
 
-      def check_num_methods(klass, report)  # :nodoc:
+      def check_num_methods(klass)  # :nodoc:
         count = klass.num_methods
-        return if count <= @max_methods
-        report << SmellWarning.new(self, klass,
-                    "has at least #{count} methods")
+        return if count <= value(MAX_ALLOWED_METHODS_KEY, klass, DEFAULT_MAX_METHODS)
+        found(klass, "has at least #{count} methods")
       end
 
-      def check_num_ivars(klass, report)  # :nodoc:
+      def check_num_ivars(klass)  # :nodoc:
         count = klass.variable_names.length
-        return if count <= @max_instance_variables
-        report << SmellWarning.new(self, klass,
-                    "has at least #{count} instance variables")
+        return if count <= value(MAX_ALLOWED_IVARS_KEY, klass, DEFAULT_MAX_IVARS)
+        found(klass, "has at least #{count} instance variables")
       end
 
       #
       # Checks +klass+ for too many methods or too many instance variables.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(klass, report)
-        check_num_methods(klass, report)
-        check_num_ivars(klass, report)
+      def examine_context(klass)
+        check_num_methods(klass)
+        check_num_ivars(klass)
       end
     end
   end