reek 1.2.7.1 → 1.2.7.2

data/lib/reek/smell_warning.rb

@@ -44,6 +44,10 @@ module Reek
     #
     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
@@ -53,6 +57,10 @@ module Reek
     #
     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)

data/lib/reek/smells/attribute.rb

@@ -20,7 +20,8 @@ module Reek
     #
     class Attribute < SmellDetector
 
-      ATTRIBUTE_METHODS = [:attr, :attr_reader, :attr_writer, :attr_accessor]
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      ATTRIBUTE_KEY = 'attribute'
 
       def self.contexts      # :nodoc:
         [:class, :module]
@@ -51,8 +52,9 @@ module Reek
       #
       def attributes_in(module_ctx)
         result = Set.new
+        attr_defn_methods = [:attr, :attr_reader, :attr_writer, :attr_accessor]
         module_ctx.local_nodes(:call) do |call_node|
-          if ATTRIBUTE_METHODS.include?(call_node.method_name)
+          if attr_defn_methods.include?(call_node.method_name)
             call_node.arg_names.each {|arg| result << [arg, call_node.line] }
           end
         end

data/lib/reek/smells/class_variable.rb

@@ -24,7 +24,7 @@ module Reek
       # Remembers any smells found.
       #
       def examine_context(ctx)
-        class_variables_in(ctx).each do |cvar_name|
+        class_variables_in(ctx.exp).each do |cvar_name|
           found(ctx, "declares the class variable #{cvar_name}", '', {'variable' => cvar_name.to_s})
         end
       end
@@ -33,11 +33,11 @@ module Reek
       # Collects the names of the class variables declared and/or used
       # in the given module.
       #
-      def class_variables_in(ctx)
+      def class_variables_in(ast)
         result = Set.new
         collector = proc { |cvar_node| result << cvar_node.name }
         [:cvar, :cvasgn, :cvdecl].each do |stmt_type|
-          ctx.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 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
@@ -51,7 +50,7 @@ module Reek
       #
       def examine_context(method_ctx)
         control_parameters(method_ctx).each do |cond, occurs|
-          param = Source::SexpFormatter.format(cond)
+          param = cond.format
           lines = occurs.map {|exp| exp.line}
           found(method_ctx, "is controlled by argument #{param}",
             'ControlParameter', {'parameter' => param}, lines)

data/lib/reek/smells/data_clump.rb

@@ -2,6 +2,32 @@ 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 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 Smells
 
@@ -19,6 +45,12 @@ module Reek
     #
     class DataClump < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+
+      METHODS_KEY = 'methods'
+      OCCURRENCES_KEY = 'occurrences'
+      PARAMETERS_KEY = 'parameters'
+
       def self.contexts      # :nodoc:
         [:class, :module]
       end
@@ -50,11 +82,18 @@ module Reek
       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",
-            'DataClump', {'parameters' => clump.map {|name| name.to_s}, 'occurrences' => occurs})
+        MethodGroup.new(ctx, min_clump_size, max_copies).clumps.each do |clump, methods|
+          smell = SmellWarning.new('DataClump', ctx.full_name,
+            methods.map {|meth| meth.line},
+            "takes parameters #{DataClump.print_clump(clump)} to #{methods.length} methods", @masked,
+            @source, 'DataClump', {
+              PARAMETERS_KEY => clump.map {|name| name.to_s},
+              OCCURRENCES_KEY => methods.length,
+              METHODS_KEY => methods.map {|meth| meth.name}
+            })
+          @smells_found << smell
+          #SMELL: serious duplication
           # SMELL: name.to_s is becoming a nuisance
-          # TODO: record the methods in [lines] and in the hash
         end
       end
 
@@ -69,24 +108,62 @@ module Reek
   class MethodGroup   # :nodoc:
 
     def self.intersection_of_parameters_of(methods)
-      methods.map {|meth| meth.parameters.names.sort}.intersection
+      methods.map {|meth| meth.arg_names.sort {|a,b| a.to_s <=> b.to_s}}.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)}
+      prune_candidates
     end
 
     def clumps
-      results = Hash.new(0)
-      @ctx.parameterized_methods(@min_clump_size).bounded_power_set(@max_copies).each do |methods|
+      results = Hash.new([])
+      @candidate_methods.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
+          results[clump] = methods if methods.length > results[clump].length
         end
       end
       results
     end
+
+    def prune_candidates
+      @candidate_methods.each do |meth|
+        meth.arg_names.each do |param|
+          count = @candidate_methods.select {|cm| cm.arg_names.include?(param)}.length
+          meth.delete(param) if count <= @max_copies
+        end
+      end
+      @candidate_methods = @candidate_methods.select do |meth|
+        meth.arg_names.length >= @min_clump_size
+      end
+    end
+  end
+
+  class CandidateMethod
+    def initialize(defn_node)
+      @defn = defn_node
+      @params = defn_node.arg_names.clone
+    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 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,7 +37,7 @@ module Reek
         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)
+          call = call_exp.format
           multiple = occurs == 2 ? 'twice' : "#{occurs} times"
           found(method_ctx, "calls #{call} #{multiple}",
             'DuplicateMethodCall', {'call' => call, 'occurrences' => occurs},
@@ -53,7 +52,7 @@ module Reek
           result[call_node].push(call_node)
         end
         method_ctx.local_nodes(:attrasgn) do |asgn_node|
-          result[asgn_node].push(asgn_node)
+          result[asgn_node].push(asgn_node) unless asgn_node.args.length < 2
         end
         result
       end

data/lib/reek/smells/feature_envy.rb

@@ -1,6 +1,5 @@
 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
@@ -35,6 +34,12 @@ 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.
@@ -42,10 +47,10 @@ module Reek
       #
       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],
+          target = ref.format
+          smell = SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
             "refers to #{target} more than self", @masked,
-            @source, 'FeatureEnvy', {'receiver' => target, 'references' => occurs})
+            @source, SMELL_SUBCLASS, {RECEIVER_KEY => target, REFERENCES_KEY => occurs})
           @smells_found << smell
           #SMELL: serious duplication
         end

data/lib/reek/smells/simulated_polymorphism.rb

@@ -1,6 +1,5 @@
 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
@@ -50,7 +49,7 @@ module Reek
         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)
+          expr = key.format
           found(klass, "tests #{expr} at least #{occurs} times",
             'RepeatedConditional', {'expression' => expr, 'occurrences' => occurs}, lines)
         end

data/lib/reek/smells/smell_detector.rb

@@ -59,12 +59,6 @@ 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

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -19,11 +19,15 @@ module Reek
     #
     class UncommunicativeMethodName < SmellDetector
 
+      SMELL_CLASS = 'UncommunicativeName'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      METHOD_NAME_KEY = 'method_name'
+
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
       REJECT_KEY = 'reject'
 
-      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
+      DEFAULT_REJECT_SET = [/^[a-z]$/, /[0-9]$/, /[A-Z]/]
       
       # 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
@@ -57,11 +61,13 @@ module Reek
         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})
+          @source, 'UncommunicativeMethodName', {METHOD_NAME_KEY => name.to_s})
         @smells_found << smell
         #SMELL: serious duplication
       end
 
+    private
+
       def accept?(context)
         value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(context.full_name)
       end

data/lib/reek/smells/uncommunicative_parameter_name.rb

@@ -23,7 +23,7 @@ module Reek
       # smelly names to be reported.
       REJECT_KEY = 'reject'
 
-      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
+      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/, /[A-Z]/]
       
       # 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

data/lib/reek/smells/uncommunicative_variable_name.rb

@@ -23,7 +23,7 @@ module Reek
       # smelly names to be reported.
       REJECT_KEY = 'reject'
 
-      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
+      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/, /[A-Z]/]
       
       # 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

data/lib/reek/smells/utility_function.rb

@@ -1,5 +1,6 @@
 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', 'reference_collector')
 
 module Reek
   module Smells
@@ -42,8 +43,13 @@ module Reek
 
       DEFAULT_HELPER_CALLS_LIMIT = 1
 
-      def self.default_config
-        super.adopt(HELPER_CALLS_LIMIT_KEY => DEFAULT_HELPER_CALLS_LIMIT)
+      class << self
+        def contexts      # :nodoc:
+          [:defn]
+        end
+        def default_config
+          super.adopt(HELPER_CALLS_LIMIT_KEY => DEFAULT_HELPER_CALLS_LIMIT)
+        end
       end
 
       def initialize(source, config = UtilityFunction.default_config)
@@ -55,9 +61,9 @@ module Reek
       # Remembers any smells found.
       #
       def examine_context(method_ctx)
-        return false if method_ctx.num_statements == 0 or
-          method_ctx.depends_on_instance? or
-          num_helper_methods(method_ctx) <= value(HELPER_CALLS_LIMIT_KEY, method_ctx, DEFAULT_HELPER_CALLS_LIMIT)
+        return false if method_ctx.num_statements == 0
+        return false if depends_on_instance?(method_ctx.exp.body)
+        return false if num_helper_methods(method_ctx) <= value(HELPER_CALLS_LIMIT_KEY, method_ctx, DEFAULT_HELPER_CALLS_LIMIT)
           # SMELL: loads of calls to value{} with the above pattern
         smell = SmellWarning.new('LowCohesion', method_ctx.full_name, [method_ctx.exp.line],
           "doesn't depend on instance state", @masked,
@@ -66,6 +72,12 @@ module Reek
         #SMELL: serious duplication
       end
 
+    private
+
+      def depends_on_instance?(exp)
+        Reek::Source::ReferenceCollector.new(exp).num_refs_to_self > 0
+      end
+
       def num_helper_methods(method_ctx)
         method_ctx.local_nodes(:call).length
       end

data/lib/reek/source/reference_collector.rb

@@ -0,0 +1,21 @@
+
+module Reek
+  module Source
+    class ReferenceCollector
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def num_refs_to_self
+        result = 0
+        [:self, :zsuper, :ivar, :iasgn].each do |node_type|
+          @ast.look_for(node_type, [:class, :module, :defn, :defs]) { result += 1}
+        end
+        @ast.look_for(:call, [:class, :module, :defn, :defs]) do |call|
+          result += 1 unless call.receiver
+        end
+        result
+      end
+    end
+  end
+end

data/lib/reek/source/sexp_formatter.rb

@@ -8,6 +8,7 @@ module Reek
     #
     class SexpFormatter
       def self.format(sexp)
+        return sexp.to_s unless Array === sexp
         sexp = YAML::load(YAML::dump(sexp))
         Ruby2Ruby.new.process(sexp)
       end

data/lib/reek/source/tree_dresser.rb

@@ -14,6 +14,16 @@ module Reek
         is_language_node? and first == type
       end
 
+      def each_node(type, ignoring, &blk)
+        if block_given?
+          look_for(type, ignoring, &blk)
+        else
+          result = []
+          look_for(type, ignoring) {|exp| result << exp}
+          result
+        end
+      end
+
       #
       # Carries out a depth-first traversal of this syntax tree, yielding
       # every Sexp of type +target_type+. The traversal ignores any node
@@ -27,13 +37,22 @@ module Reek
         end
         blk.call(self) if first == target_type
       end
+      def format
+        return self[0].to_s unless Array === self
+        Ruby2Ruby.new.process(deep_copy)
+      end
+      def deep_copy
+        YAML::load(YAML::dump(self))
+      end
     end
 
     module SexpExtensions
+      module AttrasgnNode
+        def args() self[3] end
+      end
+
       module CaseNode
-        def condition
-          self[1]
-        end
+        def condition() self[1] end
       end
 
       module CallNode
@@ -45,6 +64,15 @@ module Reek
         end
       end
 
+      module ClassNode
+        def name() self[1] end
+        def superclass() self[2] end
+        def full_name(outer)
+          prefix = outer == '' ? '' : "#{outer}::"
+          "#{prefix}#{name}"
+        end
+      end
+
       module CvarNode
         def name() self[1] end
       end
@@ -53,29 +81,47 @@ module Reek
       CvdeclNode = CvarNode
 
       module DefnNode
-        def method_name() self[1] end
+        def name() self[1] end
+        def arg_names
+          unless @args
+            @args = self[2][1..-1].reject {|param| Sexp === param or param.to_s =~ /^&/}
+          end
+          @args
+        end
         def parameters()
-          self[2].reject {|param| Sexp === param}
+          unless @params
+            @params = self[2].reject {|param| Sexp === param}
+          end
+          @params
         end
         def parameter_names
           parameters[1..-1]
         end
+        def body() self[3] end
+        def full_name(outer)
+          prefix = outer == '' ? '' : "#{outer}#"
+          "#{prefix}#{name}"
+        end
       end
 
       module DefsNode
-        def method_name() self[2] end
+        def receiver() self[1] end
+        def name() self[2] end
         def parameters
           self[3].reject {|param| Sexp === param}
         end
         def parameter_names
           parameters[1..-1]
         end
+        def body() self[4] end
+        def full_name(outer)
+          prefix = outer == '' ? '' : "#{outer}#"
+          "#{prefix}#{receiver.format}.#{name}"
+        end
       end
 
       module IfNode
-        def condition
-          self[1]
-        end
+        def condition() self[1] end
       end
 
       module IterNode
@@ -96,6 +142,18 @@ module Reek
         end
       end
 
+      module LitNode
+        def value() self[1] end
+      end
+
+      module ModuleNode
+        def name() self[1] end
+        def full_name(outer)
+          prefix = outer == '' ? '' : "#{outer}::"
+          "#{prefix}#{name}"
+        end
+      end
+
       module YieldNode
         def args() self[1..-1] end
         def arg_names