reek 1.3.8 → 1.4.0

data/lib/reek/rake/task.rb

@@ -4,14 +4,12 @@ require 'rake'
 require 'rake/tasklib'
 
 module Reek
-
   #
   # Defines a task library for running reek.
   # (Classes here will be configured via the Rakefile, and therefore will
   # possess a :reek:attribute or two.)
   #
   module Rake
-
     # A Rake task that runs reek on a set of source files.
     #
     # Example:
@@ -33,7 +31,6 @@ module Reek
     #   rake reek REEK_OPTS=-s                   # sorts the report by smell
     #
     class Task < ::Rake::TaskLib
-
       # Name of reek task.
       # Defaults to :reek.
       attr_accessor :name
@@ -85,7 +82,7 @@ module Reek
         define
       end
 
-  private
+      private
 
       def define # :nodoc:
         desc 'Check for code smells' unless ::Rake.application.last_comment
@@ -97,7 +94,7 @@ module Reek
         return if source_file_list.empty?
         cmd = cmd_words.join(' ')
         puts cmd if @verbose
-        raise('Smells found!') if !system(cmd) and fail_on_error
+        raise('Smells found!') if !system(cmd) && fail_on_error
       end
 
       def self.reek_script
@@ -111,16 +108,16 @@ module Reek
       def cmd_words
         [Task.ruby_exe] +
             ruby_options +
-            [ %Q|"#{Task.reek_script}"| ] +
+            [%("#{Task.reek_script}")] +
             [sort_option] +
-            config_file_list.collect { |fn| ['-c', %["#{fn}"]] }.flatten +
-            source_file_list.collect { |fn| %["#{fn}"] }
+            config_file_list.map { |fn| ['-c', %("#{fn}")] }.flatten +
+            source_file_list.map { |fn| %("#{fn}") }
       end
 
       def config_file_list
         files = ENV['REEK_CFG'] || @config_files
         return [] unless files
-        return FileList[files]
+        FileList[files]
       end
 
       def ruby_options
@@ -143,7 +140,7 @@ module Reek
       def source_file_list # :nodoc:
         files = ENV['REEK_SRC'] || @source_files
         return [] unless files
-        return FileList[files]
+        FileList[files]
       end
     end
   end

data/lib/reek/smell_warning.rb

@@ -1,11 +1,9 @@
 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
 
     MESSAGE_KEY = 'message'
@@ -23,7 +21,7 @@ module Reek
       @smell = {
         CLASS_KEY => class_name,
         SUBCLASS_KEY => subclass_name,
-        MESSAGE_KEY => message,
+        MESSAGE_KEY => message
       }
       @smell.merge!(parameters)
       @status = {
@@ -69,8 +67,6 @@ module Reek
     #
     attr_reader :status
 
-    def is_active() @status[ACTIVE_KEY] end
-
     def hash
       sort_key.hash
     end
@@ -85,18 +81,18 @@ module Reek
 
     def contains_all?(patterns)
       rpt = sort_key.to_s
-      return patterns.all? {|pattern| pattern === rpt}
+      patterns.all? { |pattern| pattern =~ rpt }
     end
 
     def matches?(klass, patterns)
-      @smell.values.include?(klass.to_s) and contains_all?(patterns)
+      @smell.values.include?(klass.to_s) && contains_all?(patterns)
     end
 
     def report_on(listener)
       listener.found_smell(self)
     end
 
-  protected
+    protected
 
     def sort_key
       [@location[CONTEXT_KEY], @smell[MESSAGE_KEY], @smell[CLASS_KEY]]

data/lib/reek/smells.rb

@@ -24,7 +24,6 @@ require 'reek/smells/utility_function'
 # SMELL: Duplication -- all these should be found automagically
 
 module Reek
-
   #
   # This module contains the various smell detectors.
   #

data/lib/reek/smells/attribute.rb

@@ -4,7 +4,6 @@ require 'reek/core/smell_configuration'
 
 module Reek
   module Smells
-
     #
     # A class that publishes a getter or setter for an instance variable
     # invites client classes to become too intimate with its inner workings,
@@ -14,13 +13,11 @@ module Reek
     # +attr_reader+, +attr_writer+ and +attr_accessor+ -- including those
     # that are private.
     #
-    # TODO:
-    # * eliminate private attributes
-    # * catch attributes declared "by hand"
+    # TODO: Eliminate private attributes
+    # TODO: Catch attributes declared "by hand"
     #
     class Attribute < SmellDetector
-
-      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = name.split(/::/)[-1]
       SMELL_SUBCLASS = SMELL_CLASS
 
       ATTRIBUTE_KEY = 'attribute'
@@ -41,21 +38,21 @@ module Reek
       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})
+                                   "declares the attribute #{attr}",
+                                   @source, SMELL_SUBCLASS,
+                                   ATTRIBUTE_KEY => attr.to_s)
           smell
         end
       end
 
-    private
+      private
 
       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 attr_defn_methods.include?(call_node.method_name)
-            call_node.arg_names.each {|arg| result << [arg, call_node.line] }
+            call_node.arg_names.each { |arg| result << [arg, call_node.line] }
           end
         end
         result

data/lib/reek/smells/boolean_parameter.rb

@@ -3,19 +3,17 @@ require 'reek/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]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       PARAMETER_KEY = 'parameter'
 
@@ -25,13 +23,13 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        method_ctx.parameters.default_assignments.select do |param, value|
+        method_ctx.parameters.default_assignments.select do |_param, value|
           [:true, :false].include?(value[0])
-        end.map do |param, value|
+        end.map do |param, _value|
           param_name = param.to_s
           SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
                            "has boolean parameter '#{param_name}'",
-                           @source, SMELL_SUBCLASS, {PARAMETER_KEY => param_name})
+                           @source, SMELL_SUBCLASS, PARAMETER_KEY => param_name)
         end
       end
     end

data/lib/reek/smells/class_variable.rb

@@ -4,7 +4,6 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # Class variables form part of the global runtime state, and as such make
     # it easy for one part of the system to accidentally or inadvertently
@@ -14,8 +13,7 @@ module Reek
     # the context of the test includes all global state).
     #
     class ClassVariable < SmellDetector
-
-      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = name.split(/::/)[-1]
       SMELL_SUBCLASS = SMELL_CLASS
 
       VARIABLE_KEY = 'variable'
@@ -31,10 +29,11 @@ module Reek
       #
       def examine_context(ctx)
         class_variables_in(ctx.exp).map do |attr_name, lines|
+          attr_name = attr_name.to_s
           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})
+                                   "declares the class variable #{attr_name}",
+                                   @source, SMELL_SUBCLASS,
+                                   VARIABLE_KEY => attr_name)
           smell
         end
       end
@@ -44,7 +43,7 @@ module Reek
       # in the given module.
       #
       def class_variables_in(ast)
-        result = Hash.new {|hash,key| hash[key] = []}
+        result = Hash.new { |hash, key| hash[key] = [] }
         collector = proc do |cvar_node|
           result[cvar_node.name].push(cvar_node.line)
         end

data/lib/reek/smells/control_parameter.rb

@@ -3,7 +3,6 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # Control Coupling occurs when a method or block checks the value of
     # a parameter in order to decide which execution path to take. The
@@ -42,11 +41,9 @@ module Reek
     # the source code.
     #
     class ControlParameter < SmellDetector
-
       SMELL_CLASS = 'ControlCouple'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
       PARAMETER_KEY = 'parameter'
-      VALUE_POSITION = 1
 
       #
       # Checks whether the given method chooses its execution path
@@ -59,7 +56,7 @@ module Reek
           SmellWarning.new(SMELL_CLASS, ctx.full_name, control_parameter.lines,
                            control_parameter.smell_message,
                            @source, SMELL_SUBCLASS,
-                           {PARAMETER_KEY => control_parameter.name})
+                           PARAMETER_KEY => control_parameter.name)
         end
       end
 
@@ -67,13 +64,13 @@ module Reek
       # Collects information about a single control parameter.
       #
       class FoundControlParameter
-        def initialize(param)
+        def initialize(param, occurences)
           @param = param
-          @occurences = []
+          @occurences = occurences
         end
 
-        def record(occurences)
-          @occurences.concat occurences
+        def smells?
+          @occurences.any?
         end
 
         def smell_message
@@ -89,6 +86,73 @@ module Reek
         end
       end
 
+      # Finds cases of ControlParameter in a particular node for a particular parameter
+      class ControlParameterFinder
+        def initialize(node, param)
+          @node = node
+          @param = param
+        end
+
+        def find_matches
+          return [] if legitimite_uses?
+          nested_finders.flat_map(&:find_matches) + uses_of_param_in_condition
+        end
+
+        def legitimite_uses?
+          return true if uses_param_in_body?
+          return true if uses_param_in_call_in_condition?
+          return true if nested_finders.any?(&:legitimite_uses?)
+          false
+        end
+
+        private
+
+        def conditional_nodes
+          @node.body.unnested_nodes([:if, :case, :and, :or])
+        end
+
+        def nested_finders
+          @nested_finders ||= conditional_nodes.flat_map do |node|
+            self.class.new(node, @param)
+          end
+        end
+
+        def uses_param_in_call_in_condition?
+          return false unless (condition = @node.condition)
+          condition.each_node(:call) do |inner|
+            next unless regular_call_involving_param? inner
+            return true
+          end
+          false
+        end
+
+        def uses_of_param_in_condition
+          return [] unless (condition = @node.condition)
+          condition.each_node(:lvar).select { |inner| inner.var_name == @param }
+        end
+
+        def regular_call_involving_param?(call_node)
+          call_involving_param?(call_node) && !comparison_call?(call_node)
+        end
+
+        def comparison_call?(call_node)
+          comparison_method_names.include? call_node.method_name
+        end
+
+        def comparison_method_names
+          [:==, :!=]
+        end
+
+        def call_involving_param?(call_node)
+          call_node.participants.any? { |it| it.var_name == @param }
+        end
+
+        def uses_param_in_body?
+          nodes = @node.body.each_node(:lvar, [:if, :case, :and, :or])
+          nodes.any? { |lvar_node| lvar_node.var_name == @param }
+        end
+      end
+
       #
       # Collects all control parameters in a given context.
       #
@@ -98,50 +162,19 @@ module Reek
         end
 
         def control_parameters
-          result = Hash.new {|hash, key| hash[key] = FoundControlParameter.new(key)}
-          potential_parameters.each do |param|
-            matches = find_matches(param)
-            result[param].record(matches) if matches.any?
-          end
-          result.values
+          potential_parameters.
+            map { |param| FoundControlParameter.new(param, find_matches(param)) }.
+            select(&:smells?)
         end
 
         private
 
-        # Returns parameters that aren't used outside of a conditional statements and that
-        # could be good candidates for being a control parameter.
         def potential_parameters
-          @context.exp.parameter_names.select {|param| !used_outside_conditional?(param)}
-        end
-
-        # Returns wether the parameter is used outside of the conditional statement.
-        def used_outside_conditional?(param)
-          nodes = @context.exp.each_node(:lvar, [:if, :case, :and, :or, :args])
-          nodes.any? {|node| node.value == param}
+          @context.exp.parameter_names
         end
 
-        # Find the use of the param that match the definition of a control parameter.
         def find_matches(param)
-          matches = []
-          [:if, :case, :and, :or].each do |keyword|
-            @context.local_nodes(keyword).each do |node|
-              return [] if used_besides_in_condition?(node, param)
-              node.each_node(:lvar, []) {|inner| matches.push(inner) if inner.value == param}
-            end
-          end
-          matches
-        end
-
-        # Returns wether the parameter is used somewhere besides in the condition of the
-        # conditional statement.
-        def used_besides_in_condition?(node, param)
-          times_in_conditional, times_total = 0, 0
-          node.each_node(:lvar, [:if, :case]) {|lvar| times_total +=1 if lvar.value == param}
-          if node.condition
-            times_in_conditional += 1 if node.condition[VALUE_POSITION] == param
-            times_in_conditional += node.condition.count {|inner| inner.class == Sexp && inner[VALUE_POSITION] == param}
-          end
-          return times_total > times_in_conditional
+          ControlParameterFinder.new(@context.exp, param).find_matches
         end
       end
     end

data/lib/reek/smells/data_clump.rb

@@ -4,7 +4,6 @@ require 'reek/source'
 
 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
@@ -18,9 +17,8 @@ module Reek
     # the same names that are expected by three or more methods of a class.
     #
     class DataClump < SmellDetector
-
-      SMELL_CLASS = self.name.split(/::/)[-1]
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       METHODS_KEY = 'methods'
       OCCURRENCES_KEY = 'occurrences'
@@ -65,19 +63,18 @@ module Reek
         @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(SMELL_CLASS, ctx.full_name,
-                           methods.map {|meth| meth.line},
+                           methods.map(&:line),
                            "takes parameters #{DataClump.print_clump(clump)} to #{methods.length} methods",
-                           @source, SMELL_SUBCLASS, {
-                             PARAMETERS_KEY => clump.map {|name| name.to_s},
-                             OCCURRENCES_KEY => methods.length,
-                             METHODS_KEY => methods.map {|meth| meth.name}
-                           })
+                           @source, SMELL_SUBCLASS,
+                           PARAMETERS_KEY => clump.map(&:to_s),
+                           OCCURRENCES_KEY => methods.length,
+                           METHODS_KEY => methods.map(&:name))
         end
       end
 
       # @private
       def self.print_clump(clump)
-        "[#{clump.map {|name| name.to_s}.join(', ')}]"
+        "[#{clump.map(&:to_s).join(', ')}]"
       end
     end
   end
@@ -85,12 +82,12 @@ module Reek
   # Represents a group of methods
   # @private
   class MethodGroup
-
     def initialize(ctx, min_clump_size, max_copies)
       @min_clump_size = min_clump_size
       @max_copies = max_copies
-      @candidate_methods = ctx.local_nodes(:defn).map {|defn_node|
-        CandidateMethod.new(defn_node)}
+      @candidate_methods = ctx.local_nodes(:defn).map do |defn_node|
+        CandidateMethod.new(defn_node)
+      end
     end
 
     def candidate_clumps
@@ -102,7 +99,7 @@ module Reek
     end
 
     def common_argument_names_for(methods)
-      methods.collect(&:arg_names).inject(:&)
+      methods.map(&:arg_names).inject(:&)
     end
 
     def methods_containing_clump(clump)
@@ -121,7 +118,7 @@ module Reek
   class CandidateMethod
     def initialize(defn_node)
       @defn = defn_node
-      @params = defn_node.arg_names.clone.sort {|first, second| first.to_s <=> second.to_s}
+      @params = defn_node.arg_names.clone.sort { |first, second| first.to_s <=> second.to_s }
     end
 
     def arg_names