reek 1.2.6 → 1.2.8

data/lib/reek/smell_warning.rb

@@ -1,20 +1,78 @@
+
 module Reek
 
   #
   # Reports a warning that a smell has been found.
+  # This object is essentially a DTO, and therefore contains a :reek:attribute or two.
   #
   class SmellWarning
+
     include Comparable
 
-    def initialize(detector_class, context, line, message, masked)
-      @smell = detector_class.class.name.split(/::/)[-1]
-      @context = context
-      @line = line
-      @message = message
-      @is_masked = masked
+    MESSAGE_KEY = 'message'
+    SUBCLASS_KEY = 'subclass'
+    CLASS_KEY = 'class'
+
+    CONTEXT_KEY = 'context'
+    LINES_KEY = 'lines'
+    SOURCE_KEY = 'source'
+
+    ACTIVE_KEY = 'is_active'
+
+    def initialize(class_name, context, lines, message,
+        source = '', subclass_name = '', parameters = {})
+      @smell = {
+        CLASS_KEY => class_name,
+        SUBCLASS_KEY => subclass_name,
+        MESSAGE_KEY => message,
+      }
+      @smell.merge!(parameters)
+      @status = {
+        ACTIVE_KEY => true
+      }
+      @location = {
+        CONTEXT_KEY => context.to_s,
+        LINES_KEY => lines,
+        SOURCE_KEY => source
+      }
     end
 
-    def hash  # :nodoc:
+    #
+    # Details of the smell found, including its class ({CLASS_KEY}),
+    # subclass ({SUBCLASS_KEY}) and summary message ({MESSAGE_KEY})
+    #
+    # @return [Hash{String => String}]
+    #
+    attr_reader :smell
+
+    def smell_class() @smell[CLASS_KEY] end
+    def subclass() @smell[SUBCLASS_KEY] end
+    def message() @smell[MESSAGE_KEY] end
+
+    #
+    # Details of the smell's location, including its context ({CONTEXT_KEY}),
+    # the line numbers on which it occurs ({LINES_KEY}) and the source
+    # file ({SOURCE_KEY})
+    #
+    # @return [Hash{String => String, Array<Number>}]
+    #
+    attr_reader :location
+
+    def context() @location[CONTEXT_KEY] end
+    def lines() @location[LINES_KEY] end
+    def source() @location[SOURCE_KEY] end
+
+    #
+    # Details of the smell's status, including whether it is active ({ACTIVE_KEY})
+    # (as opposed to being masked by a config file)
+    #
+    # @return [Hash{String => Boolean}]
+    #
+    attr_reader :status
+
+    def is_active() @status[ACTIVE_KEY] end
+
+    def hash
       sort_key.hash
     end
 
@@ -28,29 +86,21 @@ module Reek
 
     def contains_all?(patterns)
       rpt = sort_key.to_s
-      return patterns.all? {|exp| exp === rpt}
+      return patterns.all? {|pattern| pattern === rpt}
     end
 
-    def sort_key
-      [@context, @message, smell_name]
+    def matches?(klass, patterns)
+      @smell.values.include?(klass.to_s) and contains_all?(patterns)
     end
 
-    protected :sort_key
-
-    def report(format)
-      format.gsub(/\%s/, smell_name).gsub(/\%c/, @context).gsub(/\%w/, @message).gsub(/\%m/, @is_masked ? '(masked) ' : '')
+    def report_on(listener)
+      listener.found_smell(self)
     end
 
-    def report_on(report)
-      if @is_masked
-        report.found_masked_smell(self)
-      else
-        report.found_smell(self)
-      end
-    end
+  protected
 
-    def smell_name
-      @smell.gsub(/([a-z])([A-Z])/) { |sub| "#{$1} #{$2}"}.split.join(' ')
+    def sort_key
+      [@location[CONTEXT_KEY], @smell[MESSAGE_KEY], @smell[CLASS_KEY]]
     end
   end
 end

data/lib/reek/smells/attribute.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
@@ -18,43 +20,46 @@ module Reek
     #
     class Attribute < SmellDetector
 
-      ATTRIBUTE_METHODS = [:attr, :attr_reader, :attr_writer, :attr_accessor]
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = SMELL_CLASS
+
+      ATTRIBUTE_KEY = 'attribute'
 
       def self.contexts      # :nodoc:
         [:class, :module]
       end
 
       def self.default_config
-        super.adopt(SmellConfiguration::ENABLED_KEY => false)
+        super.adopt(Core::SmellConfiguration::ENABLED_KEY => false)
       end
 
-      def initialize(config = Attribute.default_config)
-        super(config)
+      def initialize(source, config = Attribute.default_config)
+        super(source, config)
       end
 
       #
       # Checks whether the given class declares any attributes.
-      # Remembers any smells found.
       #
-      def examine_context(mod)
-        # SMELL: Duplication
-        # MethodContext, ClassContext and ModuleContext all know which
-        # calls constitute attribute declarations. Need a method on
-        # ModuleContext: each_public_call.select [names] {...}
-        attributes_in(mod).each do |attr|
-          found(mod, "declares the attribute #{attr}")
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        attributes_in(ctx).map do |attr, line|
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [line],
+            "declares the attribute #{attr}",
+            @source, SMELL_SUBCLASS,
+            {ATTRIBUTE_KEY => attr.to_s})
+          smell
         end
       end
 
-      #
-      # Collects the names of the class variables declared and/or used
-      # in the given module.
-      #
-      def attributes_in(mod)
+    private
+      
+      def attributes_in(module_ctx)
         result = Set.new
-        mod.local_nodes(:call) do |call_node|
-          if ATTRIBUTE_METHODS.include?(call_node.method_name)
-            call_node.arg_names.each {|arg| result << arg }
+        attr_defn_methods = [:attr, :attr_reader, :attr_writer, :attr_accessor]
+        module_ctx.local_nodes(:call) do |call_node|
+          if attr_defn_methods.include?(call_node.method_name)
+            call_node.arg_names.each {|arg| result << [arg, call_node.line] }
           end
         end
         result

data/lib/reek/smells/boolean_parameter.rb

@@ -0,0 +1,38 @@
+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
+
+    #
+    # A Boolean parameter effectively permits a method's caller
+    # to decide which execution path to take. The
+    # offending parameter is a kind of Control Couple.
+    # 
+    # Currently Reek can only detect a Boolean parameter when it has a
+    # default initializer.
+    #
+    class BooleanParameter < SmellDetector
+
+      SMELL_CLASS = 'ControlCouple'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+
+      PARAMETER_KEY = 'parameter'
+
+      #
+      # Checks whether the given method has any Boolean parameters.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(method_ctx)
+        method_ctx.parameters.default_assignments.select do |param, value|
+          [:true, :false].include?(value[0])
+        end.map do |param, value|
+          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
+                           "has boolean parameter '#{param.to_s}'",
+                           @source, SMELL_SUBCLASS, {PARAMETER_KEY => param.to_s})
+        end
+      end
+    end
+  end
+end

data/lib/reek/smells/class_variable.rb

@@ -1,4 +1,6 @@
-require 'reek/smells/smell_detector'
+require 'set'
+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
@@ -13,17 +15,26 @@ module Reek
     #
     class ClassVariable < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = SMELL_CLASS
+      VARIABLE_KEY = 'variable'
+
       def self.contexts      # :nodoc:
         [:class, :module]
       end
 
       #
       # Checks whether the given class or module declares any class variables.
-      # Remembers any smells found.
       #
-      def examine_context(mod)
-        class_variables_in(mod).each do |cvar_name|
-          found(mod, "declares the class variable #{cvar_name}")
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        class_variables_in(ctx.exp).map do |attr_name, lines|
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
+            "declares the class variable #{attr_name.to_s}",
+            @source, SMELL_SUBCLASS,
+            {VARIABLE_KEY => attr_name.to_s})
+          smell
         end
       end
 
@@ -31,11 +42,13 @@ module Reek
       # Collects the names of the class variables declared and/or used
       # in the given module.
       #
-      def class_variables_in(mod)
-        result = Set.new
-        collector = proc { |cvar_node| result << cvar_node.name }
+      def class_variables_in(ast)
+        result = Hash.new {|hash,key| hash[key] = []}
+        collector = proc do |cvar_node|
+          result[cvar_node.name].push(cvar_node.line)
+        end
         [:cvar, :cvasgn, :cvdecl].each do |stmt_type|
-          mod.local_nodes(stmt_type, &collector)
+          ast.each_node(stmt_type, [:class, :module], &collector)
         end
         result
       end

data/lib/reek/smells/control_couple.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
@@ -33,27 +32,52 @@ module Reek
     # method probably has more than one responsibility,
     # because it includes at least two different code paths.
     #
+    # One possible solution is to use the Strategy Pattern
+    # to pass into the callee what must be done.  This is
+    # not considered to be control coupling because the
+    # callee will do the same thing with the strategy,
+    # whatever it happens to be.  Sometimes in Ruby the
+    # strategy may actually just be a block passed in, and
+    # that remains next to where the caller invokes it in
+    # the source code.
+    #
     class ControlCouple < SmellDetector
 
-      def self.contexts      # :nodoc:
-        [:if, :defn, :defs]
-      end
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = 'ControlParameter'
+      PARAMETER_KEY = 'parameter'
 
       #
-      # Checks whether the given conditional statement relies on a control couple.
-      # Remembers any smells found.
+      # Checks whether the given method chooses its execution path
+      # by testing the value of one of its parameters.
+      #
+      # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        case ctx
-        when IfContext
-          return unless ctx.tests_a_parameter?
-          found(ctx, "is controlled by argument #{SexpFormatter.format(ctx.if_expr)}")
-        else
-          ctx.parameters.default_assignments.each do |param, value|
-            next unless [:true, :false].include?(value[0])
-            found(ctx, "is controlled by argument #{param.to_s}")
+        control_parameters(ctx).map do |cond, occurs|
+          param = cond.format_ruby
+          lines = occurs.map {|exp| exp.line}
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
+            "is controlled by argument #{param}",
+            @source, SMELL_SUBCLASS,
+            {PARAMETER_KEY => param})
+          smell
+        end
+      end
+
+    private
+
+      def control_parameters(method_ctx)
+        params = method_ctx.exp.parameter_names
+        result = Hash.new {|hash,key| hash[key] = []}
+        return result if params.empty?
+        method_ctx.local_nodes(:if) do |if_node|
+          cond = if_node[1]
+          if cond[0] == :lvar and params.include?(cond[1])
+            result[cond].push(cond)
           end
         end
+        result
       end
     end
   end

data/lib/reek/smells/data_clump.rb

@@ -1,6 +1,15 @@
-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')
+
+#
+# Extensions to +Array+ needed by Reek.
+#
+class Array
+  def intersection
+    self.inject { |res, elem| elem & res }
+  end
+end
 
 module Reek
   module Smells
@@ -19,42 +28,66 @@ module Reek
     #
     class DataClump < SmellDetector
 
-      def self.contexts      # :nodoc:
+      SMELL_CLASS = self.name.split(/::/)[-1]
+
+      METHODS_KEY = 'methods'
+      OCCURRENCES_KEY = 'occurrences'
+      PARAMETERS_KEY = 'parameters'
+
+      # @private
+      def self.contexts
         [:class, :module]
       end
 
+      #
       # The name of the config field that sets the maximum allowed
-      # copies of any clump.
+      # copies of any clump. No group of common parameters will be
+      # reported as a DataClump unless there are more than this many
+      # methods containing those parameters.
+      #
       MAX_COPIES_KEY = 'max_copies'
-
       DEFAULT_MAX_COPIES = 2
 
+      #
+      # The name of the config field that sets the minimum clump
+      # size. No group of common parameters will be reported as
+      # a DataClump unless it contains at least this many parameters.
+      #
       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
+                MAX_COPIES_KEY => DEFAULT_MAX_COPIES,
+                MIN_CLUMP_SIZE_KEY => DEFAULT_MIN_CLUMP_SIZE
         )
       end
 
-      def initialize(config = DataClump.default_config)
-        super(config)
+      def initialize(source, config = DataClump.default_config)
+        super(source, config)
       end
 
       #
       # Checks the given class or module for multiple identical parameter sets.
-      # Remembers any smells found.
+      #
+      # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
-        min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
-        MethodGroup.new(ctx, min_clump_size, max_copies).clumps.each do |clump, occurs|
-          found(ctx, "takes parameters #{DataClump.print_clump(clump)} to #{occurs} methods")
+        @max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
+        @min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
+        MethodGroup.new(ctx, @min_clump_size, @max_copies).clumps.map do |clump, methods|
+          SmellWarning.new('DataClump', ctx.full_name,
+                           methods.map {|meth| meth.line},
+                           "takes parameters #{DataClump.print_clump(clump)} to #{methods.length} methods",
+                           @source, 'DataClump', {
+                          PARAMETERS_KEY => clump.map {|name| name.to_s},
+                          OCCURRENCES_KEY => methods.length,
+                          METHODS_KEY => methods.map {|meth| meth.name}
+                  })
         end
       end
 
+      # @private
       def self.print_clump(clump)
         "[#{clump.map {|name| name.to_s}.join(', ')}]"
       end
@@ -62,27 +95,85 @@ module Reek
   end
 
   # Represents a group of methods
-  class MethodGroup   # :nodoc:
+  # @private
+  class MethodGroup
 
     def self.intersection_of_parameters_of(methods)
-      methods.map {|meth| meth.parameters.names.sort}.intersection
+      methods.map {|meth| meth.arg_names}.intersection
     end
 
     def initialize(ctx, min_clump_size, max_copies)
-      @ctx = ctx
       @min_clump_size = min_clump_size
       @max_copies = max_copies
+      @candidate_methods = ctx.local_nodes(:defn).select do |meth|
+        meth.arg_names.length >= @min_clump_size
+      end.map {|defn_node| CandidateMethod.new(defn_node)}
+      delete_infrequent_parameters
+      delete_small_methods
     end
 
-    def clumps
-      results = Hash.new(0)
-      @ctx.parameterized_methods(@min_clump_size).bounded_power_set(@max_copies).each do |methods|
-        clump = MethodGroup.intersection_of_parameters_of(methods)
+    def clumps_containing(method, methods, results)
+      methods.each do |other_method|
+        clump = [method.arg_names, other_method.arg_names].intersection
         if clump.length >= @min_clump_size
-          results[clump] = [methods.length, results[clump]].max
+          others = methods.select { |other| clump - other.arg_names == [] }
+          results[clump] += [method] + others
         end
       end
+    end
+
+    def collect_clumps_in(methods, results)
+      return if methods.length <= @max_copies
+      tail = methods[1..-1]
+      clumps_containing(methods[0], tail, results)
+      collect_clumps_in(tail, results)
+    end
+
+    def clumps
+      results = Hash.new([])
+      collect_clumps_in(@candidate_methods, results)
+      results.each_key { |key| results[key].uniq! }
       results
     end
+
+    def delete_small_methods
+      @candidate_methods = @candidate_methods.select do |meth|
+        meth.arg_names.length >= @min_clump_size
+      end
+    end
+
+    def delete_infrequent_parameters
+      @candidate_methods.each do |meth|
+        meth.arg_names.each do |param|
+          occurs = @candidate_methods.inject(0) {|sum, cm| cm.arg_names.include?(param) ? sum+1 : sum}
+          meth.delete(param) if occurs <= @max_copies
+        end
+      end
+    end
+  end
+
+  # A method definition and a copy of its parameters
+  # @private
+  class CandidateMethod
+    def initialize(defn_node)
+      @defn = defn_node
+      @params = defn_node.arg_names.clone.sort {|first, second| first.to_s <=> second.to_s}
+    end
+
+    def arg_names
+      @params
+    end
+
+    def delete(param)
+      @params.delete(param)
+    end
+
+    def line
+      @defn.line
+    end
+
+    def name
+      @defn.name.to_s     # BUG: should report the symbols!
+    end
   end
 end

data/lib/reek/smells/duplication.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
@@ -20,32 +19,73 @@ module Reek
     #
     class Duplication < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = 'DuplicateMethodCall'
+      CALL_KEY = 'call'
+      OCCURRENCES_KEY = 'occurrences'
+
       # The name of the config field that sets the maximum number of
       # identical calls to be permitted within any single method.
       MAX_ALLOWED_CALLS_KEY = 'max_calls'
 
       DEFAULT_MAX_CALLS = 1
 
+      # The name of the config field that sets the names of any
+      # methods for which identical calls should be to be permitted
+      # within any single method.
+      ALLOW_CALLS_KEY = 'allow_calls'
+
+      DEFAULT_ALLOW_CALLS = []
+
       def self.default_config
-        super.adopt(MAX_ALLOWED_CALLS_KEY => DEFAULT_MAX_CALLS)
+        super.adopt(
+          MAX_ALLOWED_CALLS_KEY => DEFAULT_MAX_CALLS,
+          ALLOW_CALLS_KEY => DEFAULT_ALLOW_CALLS
+        )
       end
 
-      def initialize(config = Duplication.default_config)
-        super(config)
+      def initialize(source, config = Duplication.default_config)
+        super(source, config)
       end
 
-      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}")
+      #
+      # Looks for duplicate calls within the body of the method +ctx+.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @max_allowed_calls = value(MAX_ALLOWED_CALLS_KEY, ctx, DEFAULT_MAX_CALLS)
+        @allow_calls = value(ALLOW_CALLS_KEY, ctx, DEFAULT_ALLOW_CALLS)
+        calls(ctx).select do |call_exp, copies|
+          copies.length > @max_allowed_calls and not allow_calls?(call_exp.format_ruby)
+        end.map do |call_exp, copies|
+          occurs = copies.length
+          call = call_exp.format_ruby
+          multiple = occurs == 2 ? 'twice' : "#{occurs} times"
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, copies.map {|exp| exp.line},
+            "calls #{call} #{multiple}",
+            @source, SMELL_SUBCLASS,
+            {CALL_KEY => call, OCCURRENCES_KEY => occurs})
+          smell
         end
       end
-      
-      def smelly_calls(method)   # :nodoc:
-        method.calls.select do |key,val|
-          val > value(MAX_ALLOWED_CALLS_KEY, method, DEFAULT_MAX_CALLS) and key[2] != :new
+
+    private
+
+      def calls(method_ctx)
+        result = Hash.new {|hash,key| hash[key] = []}
+        method_ctx.local_nodes(:call) do |call_node|
+          next if call_node.method_name == :new
+          result[call_node].push(call_node)
+        end
+        method_ctx.local_nodes(:attrasgn) do |asgn_node|
+          result[asgn_node].push(asgn_node) unless asgn_node.args.length < 2
         end
+        result
+      end
+
+      def allow_calls?(method)
+        @allow_calls.any? { |allow| /#{allow}/ === method }
       end
     end
   end