reek 1.3.4 → 1.3.5

data/features/step_definitions/reek_steps.rb

@@ -44,6 +44,10 @@ Then /^stderr reports:$/ do |report|
   @last_stderr.should == report
 end
 
+Then /^it reports no errors$/ do
+  @last_stderr.chomp.should eq ""
+end
+
 Then /^it reports an error$/ do
   @last_stderr.chomp.should_not be_empty
 end

data/lib/reek/cli/application.rb

@@ -23,7 +23,7 @@ module Reek
         begin
           cmd = @options.parse
           cmd.execute(self)
-        rescue Exception => error
+        rescue OptionParser::InvalidOption, ConfigFileException => error
           $stderr.puts "Error: #{error}"
           @status = STATUS_ERROR
         end
@@ -42,11 +42,8 @@ module Reek
         @status = STATUS_SMELLS
       end
 
-      def output_smells_total(total_smells_count)
-        total_smells_message = "#{total_smells_count} total warning"
-        total_smells_message += 's' unless total_smells_count == 1
-        total_smells_message += "\n"
-        output total_smells_message
+      def update_status(reporter)
+        reporter.has_smells? ? report_smells : report_success
       end
     end
   end

data/lib/reek/cli/command_line.rb

@@ -17,10 +17,11 @@ module Reek
       def initialize(argv)
         @argv = argv
         @parser = OptionParser.new
-        @report_class = VerboseReport
+        @report_class = QuietReport
         @warning_formatter = WarningFormatterWithLineNumbers
         @command_class = ReekCommand
         @config_files = []
+        @sort_by_issue_count = false
         set_options
       end
 
@@ -72,15 +73,24 @@ EOB
         end
 
         @parser.separator "\nReport formatting:"
-        @parser.on("-q", "--[no-]quiet", "Suppress headings for smell-free source files") do |opt|
-          @report_class = opt ? QuietReport : VerboseReport
+        @parser.on("-q", "--quiet", "Suppress headings for smell-free source files (this is the default)") do |opt|
+          @report_class = QuietReport
         end
-        @parser.on("-n", "--line-number", "Suppress line number(s) from the output.") do 
+        @parser.on("-V", "--no-quiet", "--verbose", "Show headings for smell-free source files") do |opt|
+          @report_class = VerboseReport
+        end
+        @parser.on("-n", "--no-line-numbers", "Suppress line numbers from the output") do 
           @warning_formatter = SimpleWarningFormatter
         end
+        @parser.on("--line-numbers", "Show line numbers in the output (this is the default)") do 
+          @warning_formatter = WarningFormatterWithLineNumbers
+        end
         @parser.on("-s", "--single-line", "Show IDE-compatible single-line-per-warning") do 
           @warning_formatter = SingleLineWarningFormatter
         end        
+        @parser.on("-S", "--sort-by-issue-count", 'Sort by "issue-count", listing the "smelliest" files first') do
+          @sort_by_issue_count = true
+        end
         @parser.on("-y", "--yaml", "Report smells in YAML format") do
           @command_class = YamlCommand
           # SMELL: the args passed to the command should be tested, because it may
@@ -100,8 +110,8 @@ EOB
           if @command_class == YamlCommand
             YamlCommand.create(sources, @config_files)
           else
-            report = @report_class.new(@warning_formatter)
-            ReekCommand.create(sources, report, @config_files)
+            reporter = @report_class.new(@warning_formatter, ReportFormatter, @sort_by_issue_count)
+            ReekCommand.create(sources, reporter, @config_files)
           end
         end
       end

data/lib/reek/cli/reek_command.rb

@@ -18,20 +18,12 @@ module Reek
         @config_files = config_files
       end
 
-      def execute(view)
-        total_smells_count = 0
+      def execute(app)
         @sources.each do |source|
-          examiner = Examiner.new(source, @config_files)
-          total_smells_count += examiner.smells_count
-          view.output @reporter.report(examiner)
+          @reporter.add_examiner(Examiner.new(source, @config_files))
         end
-        if total_smells_count > 0
-          view.report_smells
-        else
-          view.report_success
-        end
-
-        view.output_smells_total(total_smells_count) if @sources.count > 1
+        app.update_status(@reporter)
+        @reporter.show
       end
     end
   end

data/lib/reek/cli/report.rb

@@ -31,36 +31,78 @@ module Reek
       def self.format(warning)
         "#{warning.source}:#{warning.lines.first}: #{SimpleWarningFormatter.format(warning)}"
       end
-    end    
+    end
+
+    class Report
+      def initialize(warning_formatter = SimpleWarningFormatter, report_formatter = ReportFormatter, sort_by_issue_count = false)
+        @warning_formatter   = warning_formatter
+        @report_formatter    = report_formatter
+        @examiners           = []
+        @total_smell_count   = 0
+        @sort_by_issue_count = sort_by_issue_count
+      end
+
+      def add_examiner(examiner)
+        @total_smell_count += examiner.smells_count
+        @examiners << examiner
+        self
+      end
+
+      def show
+        sort_examiners
+        display_summary
+        display_total_smell_count
+      end
+
+      def has_smells?
+        @total_smell_count > 0
+      end
+
+    private
+
+      def sort_examiners
+        @examiners.sort! {|a, b| b.smells_count <=> a.smells_count } if @sort_by_issue_count
+      end
 
-    #
-    # A report that lists every source, including those that have no smells.
-    #
-    class VerboseReport
-      def initialize(warning_formatter = SimpleWarningFormatter, report_formatter = ReportFormatter)
-        @warning_formatter = warning_formatter
-        @report_formatter = report_formatter
+      def display_summary
+        print gather_results.reject(&:empty?).join("\n")
       end
 
-      def report(examiner)
+      def display_total_smell_count
+        if @examiners.size > 1
+          print "\n"
+          print total_smell_count_message
+        end
+      end
+
+      def total_smell_count_message
+        "#{@total_smell_count} total warning#{'s' unless @total_smell_count == 1 }\n"
+      end
+
+      def summarize_single_examiner(examiner)
         result = @report_formatter.header examiner
         if examiner.smelly?
           formatted_list = @report_formatter.format_list examiner.smells, @warning_formatter
           result += ":\n#{formatted_list}"
         end
-        result + "\n"
+        result
       end
     end
 
-    #
-    # A report that lists a section for each source that has smells.
-    #
-    class QuietReport < VerboseReport
-      def report(examiner)
-        if examiner.smelly?
-          super
-        else
-          ''
+    class VerboseReport < Report
+      def gather_results
+        @examiners.each_with_object([]) do |examiner, result|
+          result << summarize_single_examiner(examiner)
+        end
+      end
+    end
+
+    class QuietReport < Report
+      def gather_results
+        @examiners.each_with_object([]) do |examiner, result|
+          if examiner.smelly?
+            result << summarize_single_examiner(examiner)
+          end
         end
       end
     end

data/lib/reek/config_file_exception.rb

@@ -0,0 +1,5 @@
+module Reek
+  class ConfigFileException < RuntimeError
+
+  end
+end

data/lib/reek/smells/control_parameter.rb

@@ -46,6 +46,7 @@ module Reek
       SMELL_CLASS = 'ControlCouple'
       SMELL_SUBCLASS = self.name.split(/::/)[-1]
       PARAMETER_KEY = 'parameter'
+      VALUE_POSITION = 1
 
       #
       # Checks whether the given method chooses its execution path
@@ -54,31 +55,61 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        control_parameters(ctx).map do |cond, occurs|
-          param = cond.format_ruby
+        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})
+                                   "is controlled by argument #{param}",
+                                   @source, SMELL_SUBCLASS,
+                                   {PARAMETER_KEY => param})
           smell
         end
       end
 
-    private
+      private
 
       def control_parameters(method_ctx)
-        params = method_ctx.exp.parameter_names
-        result = Hash.new {|hash,key| hash[key] = []}
-        return result if params.empty?
-        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
+        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)}
         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
+        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}
+          end
+        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
+          end
+        end
+        return times_total > times_in_conditional
+      end
     end
   end
 end

data/lib/reek/smells/data_clump.rb

@@ -89,49 +89,29 @@ module Reek
     def initialize(ctx, min_clump_size, max_copies)
       @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)}
-      delete_infrequent_parameters
-      delete_small_methods
+      @candidate_methods = ctx.local_nodes(:defn).map {|defn_node|
+        CandidateMethod.new(defn_node)}
     end
 
-    def clumps_containing(method, methods, results)
-      methods.each do |other_method|
-        clump = method.arg_names & other_method.arg_names
-        if clump.length >= @min_clump_size
-          others = methods.select { |other| clump - other.arg_names == [] }
-          results[clump] += [method] + others
-        end
-      end
+    def candidate_clumps
+      @candidate_methods.each_cons(@max_copies + 1).map do |methods|
+        common_argument_names_for(methods)
+      end.select do |clump|
+        clump.length >= @min_clump_size
+      end.uniq
     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 { |key| results[key].uniq! }
-      results
+    def common_argument_names_for(methods)
+      methods.collect(&:arg_names).inject(:&)
     end
 
-    def delete_small_methods
-      @candidate_methods = @candidate_methods.select do |meth|
-        meth.arg_names.length >= @min_clump_size
-      end
+    def methods_containing_clump(clump)
+      @candidate_methods.select { |method| clump & method.arg_names == clump }
     end
 
-    def delete_infrequent_parameters
-      @candidate_methods.each do |meth|
-        meth.arg_names.each do |param|
-          occurs = @candidate_methods.inject(0) {|sum, cm| cm.arg_names.include?(param) ? sum+1 : sum}
-          meth.delete(param) if occurs <= @max_copies
-        end
+    def clumps
+      candidate_clumps.map do |clump|
+        [clump, methods_containing_clump(clump)]
       end
     end
   end
@@ -148,10 +128,6 @@ module Reek
       @params
     end
 
-    def delete(param)
-      @params.delete(param)
-    end
-
     def line
       @defn.line
     end

data/lib/reek/smells/duplicate_method_call.rb

@@ -18,7 +18,6 @@ module Reek
     #   end
     #
     class DuplicateMethodCall < SmellDetector
-
       SMELL_CLASS = 'Duplication'
       SMELL_SUBCLASS = self.name.split(/::/)[-1]
 
@@ -51,39 +50,90 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_allowed_calls = value(MAX_ALLOWED_CALLS_KEY, ctx, DEFAULT_MAX_CALLS)
-        @allow_calls = value(ALLOW_CALLS_KEY, ctx, DEFAULT_ALLOW_CALLS)
-        calls(ctx).select do |call_exp, copies|
-          copies.length > @max_allowed_calls and not allow_calls?(call_exp.format_ruby)
-        end.map do |call_exp, copies|
-          occurs = copies.length
-          call = call_exp.format_ruby
-          multiple = occurs == 2 ? 'twice' : "#{occurs} times"
-          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, copies.map {|exp| exp.line},
-            "calls #{call} #{multiple}",
-            @source, SMELL_SUBCLASS,
-            {CALL_KEY => call, OCCURRENCES_KEY => occurs})
-          smell
+        max_allowed_calls = value(MAX_ALLOWED_CALLS_KEY, ctx, DEFAULT_MAX_CALLS)
+        allow_calls = value(ALLOW_CALLS_KEY, ctx, DEFAULT_ALLOW_CALLS)
+
+        CallCollector.new(ctx, max_allowed_calls, allow_calls).smelly_calls.map do |found_call|
+          SmellWarning.new(SMELL_CLASS, ctx.full_name, found_call.lines,
+                           found_call.smell_message,
+                           @source, SMELL_SUBCLASS,
+                           {CALL_KEY => found_call.call, OCCURRENCES_KEY => found_call.occurs})
         end
       end
 
-    private
+      # Collects information about a single found call
+      class FoundCall
+        def initialize(call_node)
+          @call_node = call_node
+          @occurences = []
+        end
+
+        def record(occurence)
+          @occurences.push occurence
+        end
+
+        def smell_message
+          multiple = occurs == 2 ? 'twice' : "#{occurs} times"
+          "calls #{call} #{multiple}"
+        end
 
-      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
-          next if call_node.receiver.nil? && call_node.args.empty?
-          result[call_node].push(call_node)
+        def call
+          @call ||= @call_node.format_ruby
         end
-        method_ctx.local_nodes(:attrasgn) do |asgn_node|
-          result[asgn_node].push(asgn_node) unless asgn_node.args.nil?
+
+        def occurs
+          @occurences.length
+        end
+
+        def lines
+          @occurences.map {|exp| exp.line}
         end
-        result.to_a.sort_by {|call_exp, _| call_exp.format_ruby}
       end
 
-      def allow_calls?(method)
-        @allow_calls.any? { |allow| /#{allow}/ === method }
+      # Collects all calls in a given context
+      class CallCollector
+        attr_reader :context
+
+        def initialize(context, max_allowed_calls, allow_calls)
+          @context = context
+          @max_allowed_calls = max_allowed_calls
+          @allow_calls = allow_calls
+        end
+
+        def calls
+          result = Hash.new {|hash,key| hash[key] = FoundCall.new(key)}
+          collect_calls(result)
+          collect_assignments(result)
+          result.values.sort_by {|found_call| found_call.call}
+        end
+
+        def smelly_calls
+          calls.select {|found_call| smelly_call? found_call }
+        end
+
+        private
+
+        def collect_assignments(result)
+          context.local_nodes(:attrasgn) do |asgn_node|
+            result[asgn_node].record(asgn_node) if asgn_node.args
+          end
+        end
+
+        def collect_calls(result)
+          context.local_nodes(:call) do |call_node|
+            next if call_node.method_name == :new
+            next if !call_node.receiver && call_node.args.empty?
+            result[call_node].record(call_node)
+          end
+        end
+
+        def smelly_call?(found_call)
+          found_call.occurs > @max_allowed_calls and not allow_calls?(found_call.call)
+        end
+
+        def allow_calls?(method)
+          @allow_calls.any? { |allow| /#{allow}/ === method }
+        end
       end
     end
   end