reek 1.3.6 → 1.3.7

data/lib/reek/config_file_exception.rb

@@ -1,4 +1,7 @@
 module Reek
+  #
+  # An exception that occured when loading the configuration file.
+  #
   class ConfigFileException < RuntimeError
 
   end

data/lib/reek/core/code_context.rb

@@ -10,12 +10,11 @@ module Reek
     #
     class CodeContext
 
-      attr_reader :exp, :config
+      attr_reader :exp
 
       def initialize(outer, exp)
         @outer = outer
         @exp = exp
-        @config = local_config
       end
 
       def name
@@ -56,12 +55,23 @@ module Reek
         exp.full_name(outer)
       end
 
-      def local_config
-        return Hash.new if @exp.nil?
-        config = Source::CodeComment.new(@exp.comments || '').config
-        return config unless @outer
-        @outer.config.deep_copy.adopt!(config)
-        # no tests for this -----^
+      def config_for(detector_class)
+        outer_config_for(detector_class).merge(
+          config[detector_class.smell_class_name] || {})
+      end
+
+      private
+
+      def config
+        @config ||= if @exp
+                      Source::CodeComment.new(@exp.comments || '').config
+                    else
+                      {}
+                    end
+      end
+
+      def outer_config_for(detector_class)
+        @outer ? @outer.config_for(detector_class) : {}
       end
     end
   end

data/lib/reek/core/code_parser.rb

@@ -29,124 +29,128 @@ module Reek
       end
 
       def process_module(exp)
-        name = Source::SexpFormatter.format(exp[1])
-        scope = ModuleContext.new(@element, name, exp)
-        push(scope) do
-          process_default(exp) unless exp.superclass == [:const, :Struct]
-          check_smells(exp[0])
+        inside_new_context(ModuleContext, exp) do
+          process_default(exp)
         end
-        scope
       end
 
-      def process_class(exp)
-        process_module(exp)
-      end
+      alias process_class process_module
 
       def process_defn(exp)
-        handle_context(MethodContext, exp[0], exp)
+        inside_new_context(MethodContext, exp) do
+          count_statement_list(exp.body)
+          process_default(exp)
+        end
       end
 
       def process_defs(exp)
-        handle_context(SingletonMethodContext, exp[0], exp)
+        inside_new_context(SingletonMethodContext, exp) do
+          count_statement_list(exp.body)
+          process_default(exp)
+        end
       end
 
-      def process_args(exp) end
+      def process_args(_) end
 
-      def process_zsuper(exp)
-        @element.record_use_of_self
-      end
+      #
+      # Recording of calls to methods and self
+      #
 
-      def process_block(exp)
-        @element.count_statements(CodeParser.count_statements(exp[1..-1]))
+      def process_call(exp)
+        @element.record_call_to(exp)
         process_default(exp)
       end
 
-      def process_call(exp)
-        @element.record_call_to(exp)
+      alias process_attrasgn process_call
+      alias process_op_asgn1 process_call
+
+      def process_ivar(exp)
+        @element.record_use_of_self
         process_default(exp)
       end
 
-      def process_attrasgn(exp)
-        process_call(exp)
+      alias process_iasgn process_ivar
+
+      def process_self(_)
+        @element.record_use_of_self
+      end
+
+      alias process_zsuper process_self
+
+      #
+      # Statement counting
+      #
+
+      def process_iter(exp)
+        count_clause(exp[3])
+        process_default(exp)
       end
 
-      def process_op_asgn1(exp)
-        process_call(exp)
+      def process_block(exp)
+        count_statement_list(exp[1..-1])
+        @element.count_statements(-1)
+        process_default(exp)
       end
 
       def process_if(exp)
         count_clause(exp[2])
         count_clause(exp[3])
-        process_default(exp)
         @element.count_statements(-1)
+        process_default(exp)
       end
 
       def process_while(exp)
-        process_until(exp)
-      end
-
-      def process_until(exp)
         count_clause(exp[2])
-        process_case(exp)
+        @element.count_statements(-1)
+        process_default(exp)
       end
 
+      alias process_until process_while
+
       def process_for(exp)
         count_clause(exp[3])
-        process_case(exp)
+        @element.count_statements(-1)
+        process_default(exp)
       end
 
       def process_rescue(exp)
         count_clause(exp[1])
-        process_case(exp)
+        @element.count_statements(-1)
+        process_default(exp)
       end
 
       def process_resbody(exp)
-        process_when(exp)
+        count_statement_list(exp[2..-1].compact)
+        process_default(exp)
       end
 
       def process_case(exp)
-        process_default(exp)
+        count_statement_list(exp[2..-1].compact)
         @element.count_statements(-1)
-      end
-
-      def process_when(exp)
-        @element.count_statements(CodeParser.count_statements(exp[2..-1].compact))
         process_default(exp)
       end
 
-      def process_ivar(exp)
-        process_iasgn(exp)
-      end
-
-      def process_iasgn(exp)
-        @element.record_use_of_self
+      def process_when(exp)
+        count_statement_list(exp[2..-1].compact)
+        @element.count_statements(-1)
         process_default(exp)
       end
 
-      def process_self(exp)
-        @element.record_use_of_self
-      end
+      private
 
       def count_clause(sexp)
-        if sexp and !sexp.has_type?(:block)
-          @element.count_statements(1)
-        end
+        @element.count_statements(1) if sexp
       end
 
-      def self.count_statements(stmts)
-        ignore = 0
-        ignore += 1 if stmts[1] == s(:nil)
-        stmts.length - ignore
+      def count_statement_list(statement_list)
+        @element.count_statements statement_list.length
       end
 
-    private
-
-      def handle_context(klass, type, exp)
+      def inside_new_context(klass, exp)
         scope = klass.new(@element, exp)
         push(scope) do
-          @element.count_statements(CodeParser.count_statements(exp.body))
-          process_default(exp)
-          check_smells(type)
+          yield
+          check_smells(exp[0])
         end
         scope
       end
@@ -155,9 +159,9 @@ module Reek
         @sniffer.examine(@element, type)
       end
 
-      def push(context)
+      def push(scope)
         orig = @element
-        @element = context
+        @element = scope
         yield
         @element = orig
       end

data/lib/reek/core/method_context.rb

@@ -57,6 +57,10 @@ module Reek
         return [] if @refs.self_is_max?
         @refs.max_keys
       end
+
+      def uses_param?(param)
+        local_nodes(:lvar).include?(Sexp.new(:lvar, param.to_sym))
+      end
     end
   end
 end

data/lib/reek/core/module_context.rb

@@ -11,9 +11,9 @@ module Reek
     #
     class ModuleContext < CodeContext
 
-      def initialize(outer, name, exp)
+      def initialize(outer, exp)
         super(outer, exp)
-        @name = name
+        @name = Source::SexpFormatter.format(exp[1])
       end
     end
   end

data/lib/reek/core/smell_repository.rb

@@ -2,6 +2,9 @@ require 'reek/smells'
 
 module Reek
   module Core
+    #
+    # Contains all the existing smells and exposes operations on them.
+    #
     class SmellRepository
 
       def self.smell_classes

data/lib/reek/core/sniffer.rb

@@ -2,7 +2,6 @@ require 'reek/core/code_parser'
 require 'reek/core/smell_repository'
 require 'reek/source/config_file'
 require 'yaml'
-require 'reek/core/hash_extensions'
 
 module Reek
   module Core

data/lib/reek/core/stop_context.rb

@@ -14,7 +14,7 @@ module Reek
         nil
       end
 
-      def config
+      def config_for(_)
         {}
       end
 

data/lib/reek/smells/attribute.rb

@@ -30,7 +30,7 @@ module Reek
       end
 
       def self.default_config
-        super.adopt(Core::SmellConfiguration::ENABLED_KEY => false)
+        super.merge(Core::SmellConfiguration::ENABLED_KEY => false)
       end
 
       #

data/lib/reek/smells/control_parameter.rb

@@ -8,10 +8,10 @@ module Reek
     # Control Coupling occurs when a method or block checks the value of
     # a parameter in order to decide which execution path to take. The
     # offending parameter is often called a Control Couple.
-    # 
+    #
     # A simple example would be the <tt>quoted</tt> parameter
     # in the following method:
-    # 
+    #
     #  def write(quoted)
     #    if quoted
     #      write_quoted(@value)
@@ -19,15 +19,15 @@ module Reek
     #      puts @value
     #    end
     #  end
-    # 
+    #
     # Control Coupling is a kind of duplication, because the calling method
     # already knows which path should be taken.
-    # 
+    #
     # Control Coupling reduces the code's flexibility by creating a
     # dependency between the caller and callee:
     # any change to the possible values of the controlling parameter must
     # be reflected on both sides of the call.
-    # 
+    #
     # A Control Couple also reveals a loss of simplicity: the called
     # method probably has more than one responsibility,
     # because it includes at least two different code paths.
@@ -55,60 +55,94 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        control_parameters(ctx).map do |lvars, occurs|
-          param = lvars.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
+        ControlParameterCollector.new(ctx).control_parameters.map do |control_parameter|
+          SmellWarning.new(SMELL_CLASS, ctx.full_name, control_parameter.lines,
+                           control_parameter.smell_message,
+                           @source, SMELL_SUBCLASS,
+                           {PARAMETER_KEY => control_parameter.name})
         end
       end
 
-      private
+      #
+      # Collects information about a single control parameter.
+      #
+      class FoundControlParameter
+        def initialize(param)
+          @param = param
+          @occurences = []
+        end
 
-      def control_parameters(method_ctx)
-        result = Hash.new {|hash, key| hash[key] = []}
-        method_ctx.exp.parameter_names.each do |param|
-          next if used_outside_conditional?(method_ctx, param)
-          find_matchs(method_ctx, param).each {|match| result[match].push(match)}
+        def record(occurences)
+          @occurences.concat occurences
+        end
+
+        def smell_message
+          "is controlled by argument #{name}"
+        end
+
+        def lines
+          @occurences.map(&:line)
         end
-        result
-      end
 
-      # Returns wether the parameter is used outside of the conditional statement.
-      def used_outside_conditional?(method_ctx, param)
-        method_ctx.exp.each_node(:lvar, [:if, :case, :and, :or, :args]) do |node|
-          return true if node.value == param
+        def name
+          @param.to_s
         end
-        false
       end
 
-      # Find the use of the param that match the definition of a control parameter.
-      def find_matchs(method_ctx, param)
-        matchs = []
-        [:if, :case, :and, :or].each do |keyword|
-          method_ctx.local_nodes(keyword).each do |node|
-            return [] if used_besides_in_condition?(node, param)
-            node.each_node(:lvar, []) {|inner| matchs.push(inner) if inner.value == param}
+      #
+      # Collects all control parameters in a given context.
+      #
+      class ControlParameterCollector
+        def initialize(context)
+          @context = context
+        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
+        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}
+        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
-        matchs
-      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]) {|inner| times_total +=1 if inner[VALUE_POSITION] == param}
-        if node.condition
-          times_in_conditional += 1 if node.condition[VALUE_POSITION] == param
-          node.condition.each do |inner|
-            times_in_conditional += 1 if inner.class == Sexp && inner[VALUE_POSITION] == param
+        # 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
         end
-        return times_total > times_in_conditional
       end
     end
   end