reek 1.2.6 → 1.2.7

data/lib/reek/smell_warning.rb

@@ -1,19 +1,66 @@
+
 module Reek
 
   #
   # Reports a warning that a smell has been found.
   #
   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, masked,
+        source = '', subclass_name = '', parameters = {})
+      @smell = {
+        CLASS_KEY => class_name,
+        SUBCLASS_KEY => subclass_name,
+        MESSAGE_KEY => message,
+      }
+      @smell.merge!(parameters)
+      @status = {
+        ACTIVE_KEY => !masked
+      }
+      @location = {
+        CONTEXT_KEY => context,
+        LINES_KEY => lines,
+        SOURCE_KEY => source
+      }
     end
 
+    #
+    # 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
+
+    #
+    # 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
+
+    #
+    # 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 hash  # :nodoc:
       sort_key.hash
     end
@@ -28,29 +75,38 @@ module Reek
 
     def contains_all?(patterns)
       rpt = sort_key.to_s
-      return patterns.all? {|exp| exp === rpt}
+      return patterns.all? {|patt| patt === rpt}
+    end
+
+    def matches?(klass, patterns)
+      @smell.values.include?(klass.to_s) and contains_all?(patterns)
     end
 
     def sort_key
-      [@context, @message, smell_name]
+      [@location[CONTEXT_KEY], @smell[MESSAGE_KEY], smell_name]
     end
 
     protected :sort_key
 
     def report(format)
-      format.gsub(/\%s/, smell_name).gsub(/\%c/, @context).gsub(/\%w/, @message).gsub(/\%m/, @is_masked ? '(masked) ' : '')
+      format.gsub(/\%s/, smell_name).
+        gsub(/\%c/, @location[CONTEXT_KEY]).
+        gsub(/\%w/, @smell[MESSAGE_KEY]).
+        gsub(/\%m/, @status[ACTIVE_KEY] ? '' : '(masked) ')
     end
 
     def report_on(report)
-      if @is_masked
-        report.found_masked_smell(self)
-      else
+      if @status[ACTIVE_KEY]
         report.found_smell(self)
+      else
+        report.found_masked_smell(self)
       end
     end
 
+  private
+
     def smell_name
-      @smell.gsub(/([a-z])([A-Z])/) { |sub| "#{$1} #{$2}"}.split.join(' ')
+      @smell[CLASS_KEY].gsub(/([a-z])([A-Z])/) { |sub| "#{$1} #{$2}"}.split.join(' ')
     end
   end
 end

data/lib/reek/smells.rb

@@ -0,0 +1,29 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'attribute')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'boolean_parameter')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'class_variable')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'control_couple')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'data_clump')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'duplication')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'feature_envy')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'irresponsible_module')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'large_class')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'long_method')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'long_parameter_list')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'long_yield_list')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'nested_iterators')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'simulated_polymorphism')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_method_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_module_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_parameter_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_variable_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'utility_function')
+# SMELL: Duplication -- all these should be found automagically
+
+module Reek
+
+  #
+  # This module contains the various smell detectors.
+  #
+  module Smells
+  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
@@ -25,24 +27,21 @@ module Reek
       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}")
+      def examine_context(module_ctx)
+        attributes_in(module_ctx).each do |attr, line|
+          found(module_ctx, "declares the attribute #{attr}", '',
+            {'attribute' => attr.to_s}, [line])
         end
       end
 
@@ -50,11 +49,11 @@ module Reek
       # Collects the names of the class variables declared and/or used
       # in the given module.
       #
-      def attributes_in(mod)
+      def attributes_in(module_ctx)
         result = Set.new
-        mod.local_nodes(:call) do |call_node|
+        module_ctx.local_nodes(:call) do |call_node|
           if ATTRIBUTE_METHODS.include?(call_node.method_name)
-            call_node.arg_names.each {|arg| result << arg }
+            call_node.arg_names.each {|arg| result << [arg, call_node.line] }
           end
         end
         result

data/lib/reek/smells/boolean_parameter.rb

@@ -0,0 +1,33 @@
+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
+
+      #
+      # Checks whether the given method has a Boolean parameter.
+      # Remembers any smells found.
+      #
+      def examine_context(method_ctx)
+        method_ctx.parameters.default_assignments.each do |param, value|
+          next unless [:true, :false].include?(value[0])
+          smell = SmellWarning.new('ControlCouple', method_ctx.full_name, [method_ctx.exp.line],
+            "has boolean parameter '#{param.to_s}'", @masked,
+            @source, 'BooleanParameter', {'parameter' => param.to_s})
+          @smells_found << smell
+          #SMELL: serious duplication
+        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
@@ -21,9 +23,9 @@ module Reek
       # 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}")
+      def examine_context(ctx)
+        class_variables_in(ctx).each do |cvar_name|
+          found(ctx, "declares the class variable #{cvar_name}", '', {'variable' => cvar_name.to_s})
         end
       end
 
@@ -31,11 +33,11 @@ module Reek
       # Collects the names of the class variables declared and/or used
       # in the given module.
       #
-      def class_variables_in(mod)
+      def class_variables_in(ctx)
         result = Set.new
         collector = proc { |cvar_node| result << cvar_node.name }
         [:cvar, :cvasgn, :cvdecl].each do |stmt_type|
-          mod.local_nodes(stmt_type, &collector)
+          ctx.local_nodes(stmt_type, &collector)
         end
         result
       end

data/lib/reek/smells/control_couple.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
@@ -33,27 +33,43 @@ 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
-
       #
-      # Checks whether the given conditional statement relies on a control couple.
+      # Checks whether the given method chooses its execution path
+      # by testing the value of one of its parameters.
       # Remembers any smells found.
       #
-      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}")
+      def examine_context(method_ctx)
+        control_parameters(method_ctx).each do |cond, occurs|
+          param = Source::SexpFormatter.format(cond)
+          lines = occurs.map {|exp| exp.line}
+          found(method_ctx, "is controlled by argument #{param}",
+            'ControlParameter', {'parameter' => param}, lines)
+        end
+      end
+
+    private
+
+      def control_parameters(method_ctx)
+        params = method_ctx.exp.parameter_names
+        result = Hash.new {|hash,key| hash[key] = []}
+        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,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
@@ -39,8 +39,8 @@ module Reek
         )
       end
 
-      def initialize(config = DataClump.default_config)
-        super(config)
+      def initialize(source, config = DataClump.default_config)
+        super(source, config)
       end
 
       #
@@ -51,7 +51,10 @@ module Reek
         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")
+          found(ctx, "takes parameters #{DataClump.print_clump(clump)} to #{occurs} methods",
+            'DataClump', {'parameters' => clump.map {|name| name.to_s}, 'occurrences' => occurs})
+          # SMELL: name.to_s is becoming a nuisance
+          # TODO: record the methods in [lines] and in the hash
         end
       end
 
@@ -62,6 +65,7 @@ module Reek
   end
 
   # Represents a group of methods
+  # @private
   class MethodGroup   # :nodoc:
 
     def self.intersection_of_parameters_of(methods)

data/lib/reek/smells/duplication.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
@@ -30,22 +30,32 @@ module Reek
         super.adopt(MAX_ALLOWED_CALLS_KEY => DEFAULT_MAX_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}")
+      def examine_context(method_ctx)
+        calls(method_ctx).each do |call_exp, copies|
+          occurs = copies.length
+          next if occurs <= value(MAX_ALLOWED_CALLS_KEY, method_ctx, DEFAULT_MAX_CALLS)
+          call = Source::SexpFormatter.format(call_exp)
+          multiple = occurs == 2 ? 'twice' : "#{occurs} times"
+          found(method_ctx, "calls #{call} #{multiple}",
+            'DuplicateMethodCall', {'call' => call, 'occurrences' => occurs},
+            copies.map {|exp| exp.line})
         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
+
+      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)
         end
+        result
       end
     end
   end

data/lib/reek/smells/feature_envy.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
@@ -40,9 +40,14 @@ module Reek
       # 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")
+      def examine_context(method_ctx)
+        method_ctx.envious_receivers.each do |ref, occurs|
+          target = Source::SexpFormatter.format(ref)
+          smell = SmellWarning.new('LowCohesion', method_ctx.full_name, [method_ctx.exp.line],
+            "refers to #{target} more than self", @masked,
+            @source, 'FeatureEnvy', {'receiver' => target, 'references' => occurs})
+          @smells_found << smell
+          #SMELL: serious duplication
         end
       end
     end