pmdtester 1.0.0 → 1.2.0

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,58 @@
+# 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,
+        file: report_file,
+
+        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,25 +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)
-      return if violations.empty?
-
-      @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
@@ -46,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

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'pathname'
+
 module PmdTester
   # This class represents all the information about the project
   class Project
+    include PmdTesterUtils
+
     REPOSITORIES_PATH = 'target/repositories'
 
     attr_reader :name
@@ -10,29 +14,36 @@ module PmdTester
     attr_reader :connection
     attr_reader :webview_url
     attr_reader :tag
-    attr_reader :exclude_pattern
+    attr_reader :exclude_patterns
+    attr_reader :src_subpath
     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)
+    def initialize(project) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       @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
       @webview_url = webview_url_element.text unless webview_url_element.nil?
 
-      @exclude_pattern = []
+      @src_subpath = project.at_xpath('src-subpath')&.text || '.'
+      @exclude_patterns = []
       project.xpath('exclude-pattern').each do |ep|
-        @exclude_pattern.push(ep.text)
+        @exclude_patterns.push(ep.text)
       end
 
-      @report_diff = ReportDiff.new
+      @build_command = project.at_xpath('build-command')&.text
+      @auxclasspath_command = project.at_xpath('auxclasspath-command')&.text
+
+      @report_diff = nil
     end
 
     # Generate the default webview url for the projects
@@ -49,13 +60,17 @@ module PmdTester
     # Change the file path from 'LOCAL_DIR/SOURCE_CODE_PATH' to
     # 'WEB_VIEW_URL/SOURCE_CODE_PATH'
     def get_webview_url(file_path)
-      file_path.gsub(%r{/#{local_source_path}}, @webview_url)
+      file_path.gsub(%r{/#{clone_root_path}}, @webview_url)
     end
 
     # Change the file path from 'LOCAL_DIR/SOURCE_CODE_PATH' to
     # 'PROJECT_NAME/SOURCE_CODE_PATH'
     def get_path_inside_project(file_path)
-      file_path.gsub(%r{/#{local_source_path}}, @name)
+      file_path.gsub(%r{/#{clone_root_path}}, @name)
+    end
+
+    def get_local_path(file_path)
+      file_path.sub(%r{/#{clone_root_path}/}, '')
     end
 
     def get_pmd_report_path(branch_name)
@@ -82,61 +97,32 @@ module PmdTester
       end
     end
 
-    def get_project_target_dir(branch_name)
-      branch_filename = PmdBranchDetail.branch_filename(branch_name)
-      dir = "target/reports/#{branch_filename}/#{@name}"
-      FileUtils.mkdir_p(dir) unless File.directory?(dir)
-      dir
+    ##
+    # Path to the sources to analyze (below or equal to clone_root_path)
+    def local_source_path
+      # normalize path
+      Pathname.new("#{clone_root_path}/#{src_subpath}").cleanpath
     end
 
-    def local_source_path
+    ##
+    # Path to the clone directory
+    def clone_root_path
       "#{REPOSITORIES_PATH}/#{@name}"
     end
 
-    def target_diff_report_path
-      dir = "target/reports/diff/#{@name}"
+    def get_project_target_dir(branch_name)
+      branch_filename = PmdBranchDetail.branch_filename(branch_name)
+      dir = "target/reports/#{branch_filename}/#{@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.nil? ? false : @report_diff.diffs_exist?
-    end
-
-    def introduce_new_errors?
-      @report_diff.nil? ? false : @report_diff.introduce_new_errors?
-    end
-
-    def removed_errors_size
-      @report_diff.removed_errors_size
-    end
-
-    def new_errors_size
-      @report_diff.new_errors_size
-    end
-
-    def removed_violations_size
-      @report_diff.removed_violations_size
-    end
-
-    def new_violations_size
-      @report_diff.new_violations_size
-    end
-
-    def removed_configerrors_size
-      @report_diff.removed_configerrors_size
-    end
-
-    def new_configerrors_size
-      @report_diff.new_configerrors_size
+    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,157 +1,251 @@
 # frozen_string_literal: true
 
 module PmdTester
-  # 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
-    include PmdTester
-
-    attr_accessor :base_violations_size
-    attr_accessor :patch_violations_size
-    attr_accessor :new_violations_size
-    attr_accessor :removed_violations_size
-    attr_accessor :violation_diffs_size
+  # A bunch of counters to summarize differences
+  class RunningDiffCounters
+    attr_accessor :changed, :new, :removed, :patch_total, :base_total
 
-    attr_accessor :base_errors_size
-    attr_accessor :patch_errors_size
-    attr_accessor :new_errors_size
-    attr_accessor :removed_errors_size
-    attr_accessor :error_diffs_size
+    def initialize(base_total)
+      @base_total = base_total
+      @patch_total = 0
 
-    attr_accessor :base_configerrors_size
-    attr_accessor :patch_configerrors_size
-    attr_accessor :new_configerrors_size
-    attr_accessor :removed_configerrors_size
-    attr_accessor :configerrors_diffs_size
-
-    attr_accessor :base_execution_time
-    attr_accessor :patch_execution_time
-    attr_accessor :diff_execution_time
+      @new = @removed = @changed = 0
+    end
 
-    attr_accessor :base_timestamp
-    attr_accessor :patch_timestamp
+    def changed_total
+      new + removed + changed
+    end
 
-    attr_accessor :violation_diffs
-    attr_accessor :error_diffs
-    attr_accessor :configerrors_diffs
+    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 initialize
-      init_violations
-      init_errors
-      init_configerrors
+    def to_h
+      {
+        changed: changed,
+        new: new,
+        removed: removed,
+        base_total: base_total,
+        patch_total: patch_total
+      }
+    end
 
-      @base_execution_time = 0
-      @patch_execution_time = 0
-      @diff_execution_time = 0
+    def to_s
+      "RunningDiffCounters[#{to_h}]"
+    end
+  end
 
-      @base_timestamp = ''
-      @patch_timestamp = ''
+  # Simple info about a rule, collected by the report xml parser
+  class RuleInfo
+    attr_reader :name, :info_url
 
-      @violation_diffs = {}
-      @error_diffs = {}
-      @configerrors_diffs = {}
+    def initialize(name, info_url)
+      @name = name
+      @info_url = info_url
     end
+  end
 
-    def init_violations
-      @base_violations_size = 0
-      @patch_violations_size = 0
-      @new_violations_size = 0
-      @removed_violations_size = 0
-      @violation_diffs_size = 0
+  # 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,
+                :file
+
+    def initialize(report_document: nil,
+                   file: '',
+                   exec_time: 0,
+                   timestamp: '0')
+      initialize_empty
+      initialize_with_report_document report_document unless report_document.nil?
+      @exec_time = exec_time
+      @timestamp = timestamp
+      @file = file
     end
 
-    def init_errors
-      @base_errors_size = 0
-      @patch_errors_size = 0
-      @new_errors_size = 0
-      @removed_errors_size = 0
-      @error_diffs_size = 0
+    def self.empty
+      new
     end
 
-    def init_configerrors
-      @base_configerrors_size = 0
-      @patch_configerrors_size = 0
-      @new_configerrors_size = 0
-      @removed_configerrors_size = 0
-      @configerrors_diffs_size = 0
+    def rule_summaries
+      summary = {}
+      @violations_by_file.each_value do |violation|
+        unless summary.key?(violation.rule_name)
+          summary[violation.rule_name] = {
+            'name' => violation.rule_name,
+            'info_url' => violation.info_url,
+            'count' => 0
+          }
+        end
+        summary[violation.rule_name]['count'] += 1
+      end
+
+      summary.values
     end
 
-    def self.comparable?(errors)
-      errors.size == 2 && errors[0].branch != errors[1].branch
+    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
+
+      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 diffs_exist?
-      !error_diffs_size.zero? || !violation_diffs_size.zero? || !configerrors_diffs_size.zero?
+    def initialize_empty
+      @violations_by_file = CollectionByFile.new
+      @errors_by_file = CollectionByFile.new
+      @configerrors_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
+    include PmdTester
+
+    attr_reader :error_counts
+    attr_reader :violation_counts
+    attr_reader :configerror_counts
+
+    attr_accessor :violation_diffs_by_file
+    attr_accessor :error_diffs_by_file
+    attr_accessor :configerror_diffs_by_rule
+
+    attr_accessor :rule_infos_union
+    attr_accessor :base_report
+    attr_accessor :patch_report
+
+    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)
 
-    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
-      @new_violations_size, @removed_violations_size = get_diffs_size(violation_diffs)
-      @violation_diffs_size = @new_violations_size + @removed_violations_size
+      @violation_diffs_by_file = {}
+      @error_diffs_by_file = {}
+      @configerror_diffs_by_rule = {}
+
+      @rule_infos_union = {}
+      @base_report = base_report
+      @patch_report = patch_report
+
+      @violation_diffs_by_rule = {}
+      diff_with(patch_report)
     end
 
-    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
-      @new_errors_size, @removed_errors_size = get_diffs_size(error_diffs)
-      @error_diffs_size = @new_errors_size + @removed_errors_size
+    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_configerrors(base_configerrors, patch_configerrors)
-      @base_configerrors_size = base_configerrors.size
-      @patch_configerrors_size = patch_configerrors.size
-      configerrors_diffs = build_diffs(base_configerrors.errors, patch_configerrors.errors)
-      @configerrors_diffs = configerrors_diffs
-      @new_configerrors_size, @removed_configerrors_size = get_diffs_size(configerrors_diffs)
-      @configerrors_diffs_size = @new_configerrors_size + @removed_configerrors_size
+    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)
+
+      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)
+
+      @rule_infos_union[violation.rule_name] = RuleInfo.new(violation.rule_name, violation.info_url)
+    end
 
-      @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)
+    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)
-      new_size = 0
-      removed_size = 0
-      diffs_hash.each_value do |value|
-        value.each do |item|
-          item.branch.eql?(BASE) ? removed_size += 1 : new_size += 1
+    # @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
-      [new_size, removed_size]
     end
 
-    def introduce_new_errors?
-      !@new_errors_size.zero? || !@new_configerrors_size.zero?
+    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
     end
   end
 end