pmdtester 1.0.0.pre.beta3 → 1.1.2

data/lib/pmdtester/pmd_error.rb

@@ -1,30 +1,10 @@
 # frozen_string_literal: true
 
 module PmdTester
-  # This class is used to store pmd errors and its size.
-  class PmdErrors
-    attr_reader :errors
-    attr_reader :errors_size
-
-    def initialize
-      # key:filename as String => value:PmdError Array
-      @errors = {}
-      @errors_size = 0
-    end
-
-    def add_error_by_filename(filename, error)
-      if @errors.key?(filename)
-        @errors[filename].push(error)
-      else
-        @errors.store(filename, [error])
-      end
-      @errors_size += 1
-    end
-  end
-
   # This class represents a 'error' element of Pmd xml report
   # and which Pmd branch the 'error' is from
   class PmdError
+    include PmdTester
     # The pmd branch type, 'base' or 'patch'
     attr_reader :branch
 
@@ -37,31 +17,51 @@ module PmdTester
     #       </xs:extension>
     #     </xs:simpleContent>
     #  </xs:complexType>
-    attr_reader :attrs
-    attr_accessor :text
-
-    def initialize(attrs, branch)
-      @attrs = attrs
+    attr_accessor :stack_trace
+    attr_accessor :old_error
+    attr_reader :filename, :short_message
 
+    def initialize(branch:, filename:, short_message:)
       @branch = branch
-      @text = ''
+      @stack_trace = ''
+      @changed = false
+      @short_message = short_message
+      @filename = filename
     end
 
-    def filename
-      @attrs['filename']
+    def short_filename
+      filename.gsub(%r{([^/]*+/)+}, '')
     end
 
-    def msg
-      @attrs['msg']
+    def changed?
+      @changed
     end
 
     def eql?(other)
-      filename.eql?(other.filename) && msg.eql?(other.msg) &&
-        @text.eql?(other.text)
+      filename.eql?(other.filename) &&
+        short_message.eql?(other.short_message) &&
+        stack_trace.eql?(other.stack_trace)
     end
 
     def hash
-      [filename, msg, @text].hash
+      [filename, stack_trace].hash
+    end
+
+    def sort_key
+      filename
+    end
+
+    def try_merge?(other)
+      if branch != BASE &&
+         branch != other.branch &&
+         filename == other.filename &&
+         !changed? # not already changed
+        @changed = true
+        @old_error = other
+        true
+      else
+        false
+      end
     end
   end
 end

data/lib/pmdtester/pmd_report_detail.rb

@@ -7,12 +7,12 @@ module PmdTester
   class PmdReportDetail
     attr_accessor :execution_time
     attr_accessor :timestamp
-    attr_reader :working_dir
+    attr_accessor :working_dir
 
-    def initialize
-      @execution_time = 0
-      @timestamp = ''
-      @working_dir = Dir.getwd
+    def initialize(execution_time: 0, timestamp: '', working_dir: Dir.getwd)
+      @execution_time = execution_time
+      @timestamp = timestamp
+      @working_dir = working_dir
     end
 
     def save(report_info_path)
@@ -22,16 +22,13 @@ module PmdTester
       file.close
     end
 
-    def load(report_info_path)
+    def self.load(report_info_path)
       if File.exist?(report_info_path)
-        hash = JSON.parse(File.read(report_info_path))
-        @execution_time = hash['execution_time']
-        @timestamp = hash['timestamp']
-        @working_dir = hash['working_dir']
-        hash
+        hash = JSON.parse(File.read(report_info_path), symbolize_names: true)
+        PmdReportDetail.new(**hash)
       else
-        puts "#{report_info_path} doesn't exist"
-        {}
+        PmdTester.logger.warn("#{report_info_path} doesn't exist")
+        PmdReportDetail.new
       end
     end
 

data/lib/pmdtester/pmd_tester_utils.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module PmdTester
+  # Some functions that that don't belong in a specific class,
+  module PmdTesterUtils
+    include PmdTester
+
+    # Parse the base and the patch report, compute their diff
+    # Returns a +ReportDiff+
+    def build_report_diff(base_report_file, patch_report_file, base_info, patch_info, filter_set = nil)
+      base_details = PmdReportDetail.load(base_info)
+      patch_details = PmdReportDetail.load(patch_info)
+
+      base_report = parse_pmd_report(base_report_file, BASE, base_details, filter_set)
+      patch_report = parse_pmd_report(patch_report_file, PATCH, patch_details)
+
+      logger.info 'Calculating diffs'
+      ReportDiff.new(base_report: base_report, patch_report: patch_report)
+    end
+
+    # Parse the +report_file+ to produce a +Report+.
+    # For the schema of xml reports, refer to http://pmd.sourceforge.net/report_2_0_0.xsd
+    def parse_pmd_report(report_file, branch, report_details, filter_set = nil)
+      require 'nokogiri'
+
+      logger.info "Parsing #{report_file}"
+      doc = PmdReportDocument.new(branch, report_details.working_dir, filter_set)
+      parser = Nokogiri::XML::SAX::Parser.new(doc)
+      parser.parse_file(report_file) if File.exist?(report_file)
+      Report.new(
+        report_document: doc,
+
+        timestamp: report_details.timestamp,
+        exec_time: report_details.execution_time
+      )
+    end
+
+    # Fill the report_diff field of every project
+    def compute_project_diffs(projects, base_branch, patch_branch, filter_set = nil)
+      projects.each do |project|
+        logger.info "Preparing report for #{project.name}"
+        logger.info "  with filter #{filter_set}" unless filter_set.nil?
+        project.compute_report_diff(base_branch, patch_branch, filter_set)
+      end
+    end
+
+    # Build the diff reports and write them all
+    def build_html_reports(projects, base_branch_details, patch_branch_details, filter_set = nil)
+      compute_project_diffs(projects, base_branch_details.branch_name, patch_branch_details.branch_name,
+                            filter_set)
+
+      SummaryReportBuilder.new.write_all_projects(projects,
+                                                  base_branch_details,
+                                                  patch_branch_details)
+    end
+  end
+end

data/lib/pmdtester/pmd_violation.rb

@@ -1,23 +1,6 @@
 # frozen_string_literal: true
 
 module PmdTester
-  # This class is used to store pmd violations and its size.
-  class PmdViolations
-    attr_reader :violations
-    attr_reader :violations_size
-
-    def initialize
-      # key:filename as String => value:PmdViolation Array
-      @violations = {}
-      @violations_size = 0
-    end
-
-    def add_violations_by_filename(filename, violations)
-      @violations.store(filename, violations)
-      @violations_size += violations.size
-    end
-  end
-
   # This class represents a 'violation' element of Pmd xml report
   # and which pmd branch the 'violation' is from
   class PmdViolation
@@ -44,23 +27,80 @@ module PmdTester
     #   </xs:simpleContent>
     # </xs:complexType>
 
-    attr_reader :attrs
-    attr_accessor :text
+    attr_reader :fname, :info_url, :line, :old_line, :old_message, :rule_name, :ruleset_name
+    attr_accessor :message
 
-    def initialize(attrs, branch)
-      @attrs = attrs
+    # rubocop:disable Metrics/ParameterLists
+    # Disable it: how is replacing a long parameter list with a single hash helping?
+    def initialize(branch:, fname:, info_url:, bline:, rule_name:, ruleset_name:)
       @branch = branch
-      @text = ''
+      @fname = fname
+      @message = ''
+
+      @info_url = info_url
+      @line = bline
+      @rule_name = rule_name
+
+      @ruleset_name = ruleset_name
+
+      @changed = false
+      @old_message = nil
+      @old_line = nil
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def line_move?(other)
+      message.eql?(other.message) && (line - other.line).abs <= 5
+    end
+
+    def try_merge?(other)
+      if branch != BASE && branch != other.branch && rule_name == other.rule_name &&
+         !changed? && # not already changed
+         (line == other.line || line_move?(other))
+        @changed = true
+        @old_message = other.message
+        @old_line = other.line
+        true
+      else
+        false
+      end
+    end
+
+    # only makes sense if this is a diff
+    def added?
+      branch != BASE && !changed?
+    end
+
+    # only makes sense if this is a diff
+    def changed?
+      @changed
+    end
+
+    # only makes sense if this is a diff
+    def removed?
+      branch == BASE
+    end
+
+    def sort_key
+      line
     end
 
     def eql?(other)
-      @attrs['beginline'].eql?(other.attrs['beginline']) &&
-        @attrs['rule'].eql?(other.attrs['rule']) &&
-        @text.eql?(other.text)
+      rule_name.eql?(other.rule_name) &&
+        line.eql?(other.line) &&
+        fname.eql?(other.fname) &&
+        message.eql?(other.message)
     end
 
     def hash
-      [@attrs['beginline'], @attrs['rule'], @text].hash
+      [line, rule_name, message].hash
+    end
+
+    def to_liquid
+      {
+        'branch' => branch,
+        'changed' => changed?
+      }
     end
   end
 end

data/lib/pmdtester/project.rb

@@ -3,6 +3,8 @@
 module PmdTester
   # This class represents all the information about the project
   class Project
+    include PmdTesterUtils
+
     REPOSITORIES_PATH = 'target/repositories'
 
     attr_reader :name
@@ -13,15 +15,17 @@ module PmdTester
     attr_reader :exclude_pattern
     attr_accessor :report_diff
     # key: pmd branch name as String => value: local path of pmd report
+    attr_reader :build_command
+    attr_reader :auxclasspath_command
+    # stores the auxclasspath calculated after cloning/preparing the project
+    attr_accessor :auxclasspath
 
     def initialize(project)
       @name = project.at_xpath('name').text
       @type = project.at_xpath('type').text
       @connection = project.at_xpath('connection').text
 
-      @tag = 'master'
-      tag_element = project.at_xpath('tag')
-      @tag = tag_element.text unless tag_element.nil?
+      @tag = project.at_xpath('tag')&.text || 'master'
 
       webview_url_element = project.at_xpath('webview-url')
       @webview_url = default_webview_url
@@ -32,6 +36,9 @@ module PmdTester
         @exclude_pattern.push(ep.text)
       end
 
+      @build_command = project.at_xpath('build-command')&.text
+      @auxclasspath_command = project.at_xpath('auxclasspath-command')&.text
+
       @report_diff = nil
     end
 
@@ -58,6 +65,10 @@ module PmdTester
       file_path.gsub(%r{/#{local_source_path}}, @name)
     end
 
+    def get_local_path(file_path)
+      file_path.sub(%r{/#{local_source_path}/}, '')
+    end
+
     def get_pmd_report_path(branch_name)
       if branch_name.nil?
         nil
@@ -74,6 +85,14 @@ module PmdTester
       end
     end
 
+    def get_config_path(branch_name)
+      if branch_name.nil?
+        nil
+      else
+        "#{get_project_target_dir(branch_name)}/config.xml"
+      end
+    end
+
     def get_project_target_dir(branch_name)
       branch_filename = PmdBranchDetail.branch_filename(branch_name)
       dir = "target/reports/#{branch_filename}/#{@name}"
@@ -85,26 +104,12 @@ module PmdTester
       "#{REPOSITORIES_PATH}/#{@name}"
     end
 
-    def target_diff_report_path
-      dir = "target/reports/diff/#{@name}"
-      FileUtils.mkdir_p(dir) unless File.directory?(dir)
-      dir
-    end
-
-    def diff_report_index_path
-      "#{target_diff_report_path}/index.html"
-    end
-
-    def diff_report_index_ref_path
-      "./#{name}/index.html"
-    end
-
-    def diffs_exist?
-      @report_diff.diffs_exist?
-    end
-
-    def introduce_new_errors?
-      @report_diff.introduce_new_errors?
+    def compute_report_diff(base_branch, patch_branch, filter_set)
+      self.report_diff = build_report_diff(get_pmd_report_path(base_branch),
+                                           get_pmd_report_path(patch_branch),
+                                           get_report_info_path(base_branch),
+                                           get_report_info_path(patch_branch),
+                                           filter_set)
     end
   end
 end

data/lib/pmdtester/report_diff.rb

@@ -1,111 +1,235 @@
 # frozen_string_literal: true
 
 module PmdTester
+  # A bunch of counters to summarize differences
+  class RunningDiffCounters
+    attr_accessor :changed, :new, :removed, :patch_total, :base_total
+
+    def initialize(base_total)
+      @base_total = base_total
+      @patch_total = 0
+
+      @new = @removed = @changed = 0
+    end
+
+    def changed_total
+      new + removed + changed
+    end
+
+    def merge!(other)
+      self.changed += other.changed
+      self.new += other.new
+      self.removed += other.removed
+      self.base_total += other.base_total
+      self.patch_total += other.patch_total
+    end
+
+    def to_h
+      {
+        changed: changed,
+        new: new,
+        removed: removed,
+        base_total: base_total,
+        patch_total: patch_total
+      }
+    end
+
+    def to_s
+      "RunningDiffCounters[#{to_h}]"
+    end
+  end
+
+  # Simple info about a rule, collected by the report xml parser
+  class RuleInfo
+    attr_reader :name, :info_url
+
+    def initialize(name, info_url)
+      @name = name
+      @info_url = info_url
+    end
+  end
+
+  # A full report, created by the report XML parser,
+  # can be diffed with another report into a ReportDiff
+  class Report
+    attr_reader :violations_by_file,
+                :errors_by_file,
+                :configerrors_by_rule,
+                :exec_time,
+                :timestamp,
+                :infos_by_rule
+
+    def initialize(report_document: nil,
+                   exec_time: 0,
+                   timestamp: '0')
+      initialize_empty
+      initialize_with_report_document report_document unless report_document.nil?
+      @exec_time = exec_time
+      @timestamp = timestamp
+    end
+
+    def self.empty
+      new
+    end
+
+    private
+
+    def initialize_with_report_document(report_document)
+      @violations_by_file = report_document.violations
+      @errors_by_file = report_document.errors
+      @configerrors_by_rule = report_document.configerrors
+      @infos_by_rule = report_document.infos_by_rules
+
+      PmdTester.logger.debug("Loaded #{@violations_by_file.total_size} violations " \
+                             "in #{@violations_by_file.num_files} files")
+      PmdTester.logger.debug("Loaded #{@errors_by_file.total_size} errors " \
+                             "in #{@errors_by_file.num_files} files")
+      PmdTester.logger.debug("Loaded #{@configerrors_by_rule.size} config errors")
+    end
+
+    def initialize_empty
+      @violations_by_file = CollectionByFile.new
+      @errors_by_file = CollectionByFile.new
+      @configerrors_by_rule = {}
+      @infos_by_rule = {}
+    end
+  end
+
   # This class represents all the diff report information,
   # including the summary information of the original pmd reports,
   # as well as the specific information of the diff report.
   class ReportDiff
-    attr_accessor :base_violations_size
-    attr_accessor :patch_violations_size
-    attr_accessor :violation_diffs_size
-
-    attr_accessor :base_errors_size
-    attr_accessor :patch_errors_size
-    attr_accessor :error_diffs_size
+    include PmdTester
 
-    attr_accessor :base_execution_time
-    attr_accessor :patch_execution_time
-    attr_accessor :diff_execution_time
+    attr_reader :error_counts
+    attr_reader :violation_counts
+    attr_reader :configerror_counts
 
-    attr_accessor :base_timestamp
-    attr_accessor :patch_timestamp
+    attr_accessor :violation_diffs_by_file
+    attr_accessor :error_diffs_by_file
+    attr_accessor :configerror_diffs_by_rule
 
-    attr_accessor :violation_diffs
-    attr_accessor :error_diffs
+    attr_accessor :rule_infos_union
+    attr_accessor :base_report
+    attr_accessor :patch_report
 
-    def initialize
-      @base_violations_size = 0
-      @patch_violations_size = 0
-      @violation_diffs_size = 0
+    def initialize(base_report:, patch_report:)
+      @violation_counts = RunningDiffCounters.new(base_report.violations_by_file.total_size)
+      @error_counts = RunningDiffCounters.new(base_report.errors_by_file.total_size)
+      @configerror_counts = RunningDiffCounters.new(base_report.configerrors_by_rule.values.flatten.length)
 
-      @base_errors_size = 0
-      @patch_errors_size = 0
-      @error_diffs_size = 0
+      @violation_diffs_by_file = {}
+      @error_diffs_by_file = {}
+      @configerror_diffs_by_rule = {}
 
-      @base_execution_time = 0
-      @patch_execution_time = 0
-      @diff_execution_time = 0
+      @rule_infos_union = base_report.infos_by_rule.dup
+      @base_report = base_report
+      @patch_report = patch_report
 
-      @base_timestamp = ''
-      @patch_timestamp = ''
-
-      @violation_diffs = {}
-      @error_diffs = {}
+      @violation_diffs_by_rule = {}
+      diff_with(patch_report)
     end
 
-    def diffs_exist?
-      !error_diffs_size.zero? || !violation_diffs_size.zero?
+    def rule_summaries
+      @violation_diffs_by_rule.map do |(rule, counters)|
+        {
+          'name' => rule,
+          'info_url' => @rule_infos_union[rule].info_url,
+          **counters.to_h.transform_keys(&:to_s)
+        }
+      end
     end
 
-    def calculate_violations(base_violations, patch_violations)
-      @base_violations_size = base_violations.violations_size
-      @patch_violations_size = patch_violations.violations_size
-      violation_diffs = build_diffs(base_violations.violations, patch_violations.violations)
-      @violation_diffs = violation_diffs
-      @violation_diffs_size = get_diffs_size(violation_diffs)
-    end
+    private
+
+    def diff_with(patch_report)
+      @violation_counts.patch_total = patch_report.violations_by_file.total_size
+      @error_counts.patch_total = patch_report.errors_by_file.total_size
+      @configerror_counts.patch_total = patch_report.configerrors_by_rule.values.flatten.length
+
+      @violation_diffs_by_file = build_diffs(@violation_counts, &:violations_by_file)
+      count(@violation_diffs_by_file) { |v| getvdiff(v.rule_name) } # record the diffs in the rule counter
+
+      @error_diffs_by_file = build_diffs(@error_counts, &:errors_by_file)
+      @configerror_diffs_by_rule = build_diffs(@configerror_counts, &:configerrors_by_rule)
 
-    def calculate_errors(base_errors, patch_errors)
-      @base_errors_size = base_errors.errors_size
-      @patch_errors_size = patch_errors.errors_size
-      error_diffs = build_diffs(base_errors.errors, patch_errors.errors)
-      @error_diffs = error_diffs
-      @error_diffs_size = get_diffs_size(error_diffs)
+      count_by_rule(@base_report.violations_by_file, base: true)
+      count_by_rule(@patch_report.violations_by_file, base: false)
+      self
     end
 
-    def calculate_details(base_info, patch_info)
-      base_details = PmdReportDetail.new
-      base_details.load(base_info) unless base_info.nil?
-      patch_details = PmdReportDetail.new
-      patch_details.load(patch_info) unless patch_info.nil?
+    def record_rule_info(violation)
+      return if @rule_infos_union.key?(violation.rule_name)
 
-      @base_execution_time = base_details.format_execution_time
-      @patch_execution_time = patch_details.format_execution_time
-      @diff_execution_time =
-        PmdReportDetail.convert_seconds(base_details.execution_time -
-                                          patch_details.execution_time)
+      @rule_infos_union[violation.rule_name] = RuleInfo.new(violation.rule_name, violation.info_url)
+    end
+
+    def getvdiff(rule_name)
+      @violation_diffs_by_rule.fetch(rule_name) do |_|
+        @violation_diffs_by_rule[rule_name] = RunningDiffCounters.new(0)
+      end
+    end
 
-      @base_timestamp = base_details.timestamp
-      @patch_timestamp = patch_details.timestamp
-      [base_details, patch_details]
+    def count_by_rule(violations_h, base:)
+      violations_h.each_value do |v|
+        record_rule_info(v)
+        rule_diff = getvdiff(v.rule_name)
+        if base
+          rule_diff.base_total += 1
+        else
+          rule_diff.patch_total += 1
+        end
+      end
     end
 
-    def build_diffs(base_hash, patch_hash)
-      diffs = base_hash.merge(patch_hash) do |_key, base_value, patch_value|
+    def build_diffs(counters, &getter)
+      base_hash = getter.yield(@base_report)
+      patch_hash = getter.yield(@patch_report)
+      # Keys are filenames
+      # Values are lists of violations/errors
+      diffs = base_hash.to_h.merge(patch_hash.to_h) do |_key, base_value, patch_value|
+        # make the difference of values
         (base_value | patch_value) - (base_value & patch_value)
       end
 
       diffs.delete_if do |_key, value|
         value.empty?
       end
+
+      merge_changed_items(diffs)
+      count(diffs) { |_| counters }
+      diffs
     end
 
-    def get_diffs_size(diffs_hash)
-      size = 0
-      diffs_hash.keys.each do |key|
-        size += diffs_hash[key].size
+    # @param diff_h a hash { filename => list[violation]}, containing those that changed
+    # in case of config errors it's a hash { rulename => list[configerror] }
+    def merge_changed_items(diff_h)
+      diff_h.each do |fname, different|
+        different.sort_by!(&:sort_key)
+        diff_h[fname] = different.delete_if do |v|
+          v.branch == BASE &&
+            # try_merge will set v2.changed = true if it succeeds
+            different.any? { |v2| v2.try_merge?(v) }
+        end
       end
-      size
     end
 
-    def introduce_new_errors?
-      @error_diffs.values.each do |pmd_errors|
-        pmd_errors.each do |pmd_error|
-          return true if pmd_error.branch.eql?('patch')
+    def count(item_h)
+      item_h = { '' => item_h } if item_h.is_a?(Array)
+
+      item_h.each do |_k, items|
+        items.each do |item|
+          counter = yield item
+
+          if item.changed?
+            counter.changed += 1
+          elsif item.branch.eql?(BASE)
+            counter.removed += 1
+          else
+            counter.new += 1
+          end
         end
       end
-
-      false
     end
   end
 end