reek 1.2.7.2 → 1.2.7.3

data/lib/reek/rake/task.rb

@@ -14,6 +14,8 @@ module Reek
     #
     # Example:
     #
+    #   require 'reek/rake/task'
+    #
     #   Reek::Rake::Task.new do |t|
     #     t.fail_on_error = false
     #   end

data/lib/reek/smell_warning.rb

@@ -18,7 +18,7 @@ module Reek
 
     ACTIVE_KEY = 'is_active'
 
-    def initialize(class_name, context, lines, message, masked,
+    def initialize(class_name, context, lines, message,
         source = '', subclass_name = '', parameters = {})
       @smell = {
         CLASS_KEY => class_name,
@@ -27,10 +27,10 @@ module Reek
       }
       @smell.merge!(parameters)
       @status = {
-        ACTIVE_KEY => !masked
+        ACTIVE_KEY => true
       }
       @location = {
-        CONTEXT_KEY => context,
+        CONTEXT_KEY => context.to_s,
         LINES_KEY => lines,
         SOURCE_KEY => source
       }
@@ -69,6 +69,8 @@ module Reek
     #
     attr_reader :status
 
+    def is_active() @status[ACTIVE_KEY] end
+
     def hash  # :nodoc:
       sort_key.hash
     end
@@ -90,31 +92,14 @@ module Reek
       @smell.values.include?(klass.to_s) and contains_all?(patterns)
     end
 
-    def sort_key
-      [@location[CONTEXT_KEY], @smell[MESSAGE_KEY], smell_name]
-    end
-
-    protected :sort_key
-
-    def report(format)
-      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 @status[ACTIVE_KEY]
-        report.found_smell(self)
-      else
-        report.found_masked_smell(self)
-      end
+    def report_on(listener)
+      listener.found_smell(self)
     end
 
-  private
+  protected
 
-    def smell_name
-      @smell[CLASS_KEY].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/boolean_parameter.rb

@@ -22,7 +22,7 @@ module Reek
         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,
+            "has boolean parameter '#{param.to_s}'",
             @source, 'BooleanParameter', {'parameter' => param.to_s})
           @smells_found << smell
           #SMELL: serious duplication

data/lib/reek/smells/control_couple.rb

@@ -43,6 +43,9 @@ module Reek
     #
     class ControlCouple < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = 'ControlParameter'
+
       #
       # Checks whether the given method chooses its execution path
       # by testing the value of one of its parameters.
@@ -53,7 +56,7 @@ module Reek
           param = cond.format
           lines = occurs.map {|exp| exp.line}
           found(method_ctx, "is controlled by argument #{param}",
-            'ControlParameter', {'parameter' => param}, lines)
+            SMELL_SUBCLASS, {'parameter' => param}, lines)
         end
       end
 

data/lib/reek/smells/data_clump.rb

@@ -6,23 +6,6 @@ require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'sourc
 # 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
@@ -85,7 +68,7 @@ module Reek
         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,
+            "takes parameters #{DataClump.print_clump(clump)} to #{methods.length} methods",
             @source, 'DataClump', {
               PARAMETERS_KEY => clump.map {|name| name.to_s},
               OCCURRENCES_KEY => methods.length,
@@ -105,10 +88,10 @@ module Reek
 
   # Represents a group of methods
   # @private
-  class MethodGroup   # :nodoc:
+  class MethodGroup
 
     def self.intersection_of_parameters_of(methods)
-      methods.map {|meth| meth.arg_names.sort {|a,b| a.to_s <=> b.to_s}}.intersection
+      methods.map {|meth| meth.arg_names}.intersection
     end
 
     def initialize(ctx, min_clump_size, max_copies)
@@ -117,37 +100,61 @@ module Reek
       @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
+      delete_infrequent_parameters
+      delete_small_methods
     end
 
-    def clumps
-      results = Hash.new([])
-      @candidate_methods.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 if methods.length > results[clump].length
+          others = methods.select do |other|    # BUG: early ones have already been eliminated
+            clump - other.arg_names == []
+          end
+          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 do |key|
+        results[key].uniq!
+      end
       results
     end
 
-    def prune_candidates
+    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|
-          count = @candidate_methods.select {|cm| cm.arg_names.include?(param)}.length
-          meth.delete(param) if count <= @max_copies
+          occurs = @candidate_methods.inject(0) {|sum, cm| cm.arg_names.include?(param) ? sum+1 : sum}
+          meth.delete(param) if occurs <= @max_copies
         end
       end
-      @candidate_methods = @candidate_methods.select do |meth|
-        meth.arg_names.length >= @min_clump_size
-      end
     end
   end
 
+  #
+  # A method definition and a copy of its parameters
+  #
   class CandidateMethod
     def initialize(defn_node)
       @defn = defn_node
-      @params = defn_node.arg_names.clone
+      @params = defn_node.arg_names.clone.sort {|a,b| a.to_s <=> b.to_s}
     end
 
     def arg_names

data/lib/reek/smells/feature_envy.rb

@@ -49,7 +49,7 @@ module Reek
         method_ctx.envious_receivers.each do |ref, occurs|
           target = ref.format
           smell = SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
-            "refers to #{target} more than self", @masked,
+            "refers to #{target} more than self",
             @source, SMELL_SUBCLASS, {RECEIVER_KEY => target, REFERENCES_KEY => occurs})
           @smells_found << smell
           #SMELL: serious duplication

data/lib/reek/smells/long_parameter_list.rb

@@ -15,6 +15,9 @@ module Reek
     #
     class LongParameterList < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = 'LongParameterList'
+
       # 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'
@@ -44,7 +47,7 @@ module Reek
         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})
+          SMELL_SUBCLASS, {'parameter_count' => num_params})
       end
     end
   end

data/lib/reek/smells/long_yield_list.rb

@@ -10,6 +10,9 @@ module Reek
     #
     class LongYieldList < SmellDetector
 
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = 'LongParameterList'
+
       # 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'
@@ -36,9 +39,9 @@ module Reek
         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})
+          smell = SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [yield_node.line],
+            "yields #{num_params} parameters",
+            @source, SMELL_SUBCLASS, {'parameter_count' => num_params})
           @smells_found << smell
           #SMELL: serious duplication
         end

data/lib/reek/smells/simulated_polymorphism.rb

@@ -42,7 +42,7 @@ module Reek
       end
 
       #
-      # Checks the given ClassContext for multiple identical conditional tests.
+      # Checks the given class for multiple identical conditional tests.
       # Remembers any smells found.
       #
       def examine_context(klass)

data/lib/reek/smells/smell_detector.rb

@@ -47,10 +47,10 @@ module Reek
         @source = source
         @config = Core::SmellConfiguration.new(config)
         @smells_found = Set.new
-        @masked = false
       end
 
-      def listen_to(hooks)
+      def register(hooks)
+        return unless @config.enabled?
         self.class.contexts.each { |ctx| hooks[ctx] << self }
       end
 
@@ -63,17 +63,6 @@ module Reek
         @config.adopt!(config)
       end
 
-      def copy
-        self.class.new(@source, @config.deep_copy)
-      end
-
-      def supersede_with(config)
-        clone = self.copy
-        @masked = true
-        clone.configure_with(config)
-        clone
-      end
-
       def examine(context)
         examine_context(context) if @config.enabled? and !exception?(context)
       end
@@ -87,34 +76,17 @@ module Reek
 
       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,
+        smell = SmellWarning.new(self.class.name.split(/::/)[-1], context.full_name,
+          lines, message,
           @source, subclass, parameters)
         @smells_found << smell
         smell
       end
 
-      def has_smell?(patterns)
-        return false if @masked
-        @smells_found.each { |warning| return true if warning.contains_all?(patterns) }
-        false
-      end
-
-      def smell_type
-        self.class.name.split(/::/)[-1]
-      end
-
       def report_on(report)
         @smells_found.each { |smell| smell.report_on(report) }
       end
 
-      def num_smells
-        @masked ? 0 : @smells_found.length
-      end
-
-      def smelly?
-        (not @masked) and (@smells_found.length > 0)
-      end
-
       def value(key, ctx, fall_back)
         @config.value(key, ctx, fall_back)
       end

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -60,7 +60,7 @@ module Reek
         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,
+          "has the name '#{name}'",
           @source, 'UncommunicativeMethodName', {METHOD_NAME_KEY => name.to_s})
         @smells_found << smell
         #SMELL: serious duplication

data/lib/reek/smells/uncommunicative_module_name.rb

@@ -56,7 +56,7 @@ module Reek
         return false if accept?(module_ctx)
         return false unless is_bad_name?(name, module_ctx)
         smell = SmellWarning.new('UncommunicativeName', module_ctx.full_name, [module_ctx.exp.line],
-          "has the name '#{name}'", @masked,
+          "has the name '#{name}'",
           @source, 'UncommunicativeModuleName', {'module_name' => name.to_s})
         @smells_found << smell
         #SMELL: serious duplication

data/lib/reek/smells/uncommunicative_parameter_name.rb

@@ -30,7 +30,7 @@ module Reek
       # uncommunicative.
       ACCEPT_KEY = 'accept'
 
-      DEFAULT_ACCEPT_SET = ['Inline::C']
+      DEFAULT_ACCEPT_SET = []
 
       def self.default_config
         super.adopt(
@@ -55,7 +55,7 @@ module Reek
         context.exp.parameter_names.each do |name|
           next unless is_bad_name?(name, context)
           smell = SmellWarning.new('UncommunicativeName', context.full_name, [context.exp.line],
-            "has the parameter name '#{name}'", @masked,
+            "has the parameter name '#{name}'",
             @source, 'UncommunicativeParameterName', {'parameter_name' => name.to_s})
           @smells_found << smell
           #SMELL: serious duplication

data/lib/reek/smells/uncommunicative_variable_name.rb

@@ -30,7 +30,7 @@ module Reek
       # uncommunicative.
       ACCEPT_KEY = 'accept'
 
-      DEFAULT_ACCEPT_SET = ['Inline::C']
+      DEFAULT_ACCEPT_SET = []
 
       def self.default_config
         super.adopt(
@@ -52,10 +52,10 @@ module Reek
       # Remembers any smells found.
       #
       def examine_context(context)
-        variable_names(context).each do |name, lines|
+        variable_names(context.exp).each do |name, lines|
           next unless is_bad_name?(name, context)
           smell = SmellWarning.new('UncommunicativeName', context.full_name, lines,
-            "has the variable name '#{name}'", @masked,
+            "has the variable name '#{name}'",
             @source, 'UncommunicativeVariableName', {'variable_name' => name.to_s})
           @smells_found << smell
           #SMELL: serious duplication
@@ -64,25 +64,18 @@ module Reek
 
       def is_bad_name?(name, context)  # :nodoc:
         var = name.to_s.gsub(/^[@\*\&]*/, '')
-        return false if var == '*' or value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(var)
+        return false if value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(var)
         value(REJECT_KEY, context, DEFAULT_REJECT_SET).detect {|patt| patt === var}
       end
 
-      def variable_names(context)
-        result = Hash.new {|hash,key| hash[key] = []}
-        case context
-        when Core::MethodContext
-          context.local_nodes(:lasgn).each do |asgn|
-            result[asgn[1]].push(asgn.line)
-          end
-        else
-          context.local_nodes(:iasgn).each do |asgn|
-            result[asgn[1]].push(asgn.line)
-          end
-          context.each_node(:lasgn, [:class, :module, :defs, :defn]).each do |asgn|
-            result[asgn[1]].push(asgn.line)
-          end
+      def variable_names(exp)
+        assignment_nodes = exp.each_node(:lasgn, [:class, :module, :defs, :defn])
+        case exp.first
+        when :class, :module
+          assignment_nodes += exp.each_node(:iasgn, [:class, :module])
         end
+        result = Hash.new {|hash,key| hash[key] = []}
+        assignment_nodes.each {|asgn| result[asgn[1]].push(asgn.line) }
         result
       end
     end