pmdtester 1.0.0.pre.beta2 → 1.1.1

data/lib/pmdtester/project.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative './pmd_branch_detail'
-
 module PmdTester
   # This class represents all the information about the project
   class Project
+    include PmdTesterUtils
+
     REPOSITORIES_PATH = 'target/repositories'
 
     attr_reader :name
@@ -15,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
@@ -34,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
 
@@ -60,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
@@ -76,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}"
@@ -87,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

data/lib/pmdtester/resource_locator.rb

@@ -6,5 +6,9 @@ module PmdTester
     def self.locate(resource_path)
       File.expand_path(File.dirname(__FILE__) + "/../../#{resource_path}")
     end
+
+    def self.resource(resource_path)
+      locate("resources/#{resource_path}")
+    end
   end
 end

data/lib/pmdtester/runner.rb

@@ -1,25 +1,18 @@
 # frozen_string_literal: true
 
-require_relative './builders/diff_builder.rb'
-require_relative './builders/diff_report_builder.rb'
-require_relative './builders/rule_set_builder'
-require_relative './builders/summary_report_builder.rb'
-require_relative './builders/pmd_report_builder.rb'
-require_relative './parsers/options'
-require_relative './parsers/projects_parser'
-require_relative './pmdtester'
-require_relative './pmd_branch_detail'
-
 module PmdTester
   # The Runner is a class responsible of organizing all PmdTester modules
   # and running the PmdTester
   class Runner
-    include PmdTester
+    include PmdTesterUtils
+
     def initialize(argv)
       @options = Options.new(argv)
     end
 
     def run
+      clean unless @options.keep_reports
+
       case @options.mode
       when Options::LOCAL
         run_local_mode
@@ -28,54 +21,74 @@ module PmdTester
       when Options::SINGLE
         run_single_mode
       end
+
+      summarize_diffs
+    end
+
+    def clean
+      clean_target = 'target/reports'
+      FileUtils.remove_dir(clean_target) if Dir.exist?(clean_target)
     end
 
     def run_local_mode
       logger.info "Mode: #{@options.mode}"
-      RuleSetBuilder.new(@options).build if @options.auto_config_flag
-
       get_projects(@options.project_list) unless @options.nil?
-      PmdReportBuilder
-        .new(@options.base_config, @projects, @options.local_git_repo, @options.base_branch)
-        .build
-      PmdReportBuilder
-        .new(@options.patch_config, @projects, @options.local_git_repo, @options.patch_branch)
-        .build
-
-      build_html_reports
+      rule_sets = RuleSetBuilder.new(@options).build if @options.auto_config_flag
+      return if rule_sets&.empty?
+
+      base_branch_details = create_pmd_report(config: @options.base_config, branch: @options.base_branch)
+      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch)
+
+      build_html_reports(@projects, base_branch_details, patch_branch_details)
     end
 
     def run_online_mode
       logger.info "Mode: #{@options.mode}"
 
-      baseline_path = download_baseline(@options.base_branch)
+      baseline_path = download_baseline(@options.baseline_download_url_prefix, @options.base_branch)
+
+      project_list = determine_project_list_for_online_mode(baseline_path)
+      get_projects(project_list)
 
       if @options.auto_config_flag
-        RuleSetBuilder.new(@options).build
-      else
+        return if RuleSetBuilder.new(@options).build.empty?
+      elsif @options.patch_config == Options::DEFAULT_CONFIG_PATH
         # patch branch build pmd reports with same configuration as base branch
+        # if not specified otherwise. This allows to use a different config (e.g. less rules)
+        # than used for creating the baseline. Use with care, though
         @options.patch_config = "#{baseline_path}/config.xml"
+      else
+        logger.info "Using config #{@options.patch_config} which might differ from baseline"
       end
 
-      # patch branch build pmd report with same list of projects as base branch
-      project_list = "#{baseline_path}/project-list.xml"
-      get_projects(project_list)
+      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch)
 
-      PmdReportBuilder
-        .new(@options.patch_config, @projects, @options.local_git_repo, @options.patch_branch)
-        .build
+      base_branch_details = PmdBranchDetail.load(@options.base_branch, logger)
+      build_html_reports(@projects, base_branch_details, patch_branch_details, @options.filter_set)
+    end
 
-      build_html_reports
+    def determine_project_list_for_online_mode(baseline_path)
+      # patch branch build pmd report with same list of projects as base branch
+      # if not specified otherwise. This allows to use a different project list
+      # than used for creating the baseline. Use with care, though
+      if @options.project_list == Options::DEFAULT_LIST_PATH
+        project_list = "#{baseline_path}/project-list.xml"
+      else
+        logger.info "Using project list #{@options.project_list} which might differ from baseline"
+        project_list = @options.project_list
+      end
+      project_list
     end
 
-    def download_baseline(branch_name)
+    def download_baseline(url_prefix, branch_name)
       branch_filename = PmdBranchDetail.branch_filename(branch_name)
       zip_filename = "#{branch_filename}-baseline.zip"
       target_path = 'target/reports'
       FileUtils.mkdir_p(target_path) unless File.directory?(target_path)
 
-      url = get_baseline_url(zip_filename)
-      wget_cmd = "wget #{url}"
+      url = get_baseline_url(url_prefix, zip_filename)
+      logger.info "Downloading baseline for branch #{branch_name} from #{url}"
+      wget_cmd = "wget --timestamping #{url}"
       unzip_cmd = "unzip -qo #{zip_filename}"
 
       Dir.chdir(target_path) do
@@ -86,45 +99,57 @@ module PmdTester
       "#{target_path}/#{branch_filename}"
     end
 
-    def get_baseline_url(zip_filename)
-      "https://sourceforge.net/projects/pmd/files/pmd-regression-tester/#{zip_filename}"
+    def get_baseline_url(url_prefix, zip_filename)
+      "#{url_prefix}#{zip_filename}"
     end
 
     def run_single_mode
       logger.info "Mode: #{@options.mode}"
 
       get_projects(@options.project_list) unless @options.nil?
-      branch_details = PmdReportBuilder
-                       .new(@options.patch_config, @projects,
-                            @options.local_git_repo, @options.patch_branch)
-                       .build
+      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch)
       # copy list of projects file to the patch baseline
-      FileUtils.cp(@options.project_list, branch_details.target_branch_project_list_path)
+      FileUtils.cp(@options.project_list, patch_branch_details.target_branch_project_list_path)
 
-      build_html_reports unless @options.html_flag
+      # for creating a baseline, no html report is needed
+      return if @options.html_flag
+
+      # in single mode, we don't have a base branch, only a patch branch...
+      empty_base_branch_details = PmdBranchDetail.load('single-mode', logger)
+      build_html_reports(@projects, empty_base_branch_details, patch_branch_details)
     end
 
-    def build_html_reports
-      build_diff_html_reports
-      SummaryReportBuilder.new.build(@projects, @options.base_branch, @options.patch_branch)
+    def get_projects(file_path)
+      @projects = ProjectsParser.new.parse(file_path)
     end
 
-    def build_diff_html_reports
+    def summarize_diffs
+      error_total = RunningDiffCounters.new(0)
+      violations_total = RunningDiffCounters.new(0)
+      configerrors_total = RunningDiffCounters.new(0)
+
       @projects.each do |project|
-        logger.info "Preparing report for #{project.name}"
-        report_diffs = DiffBuilder.new.build(project.get_pmd_report_path(@options.base_branch),
-                                             project.get_pmd_report_path(@options.patch_branch),
-                                             project.get_report_info_path(@options.base_branch),
-                                             project.get_report_info_path(@options.patch_branch),
-                                             @options.filter_set)
-        project.report_diff = report_diffs
-        DiffReportBuilder.new.build(project)
+        diff = project.report_diff
+
+        # in case we are in single mode, there might be no diffs (only the patch branch is available)
+        next if diff.nil?
+
+        error_total.merge!(diff.error_counts)
+        violations_total.merge!(diff.violation_counts)
+        configerrors_total.merge!(diff.configerror_counts)
       end
-      logger.info 'Built all difference reports successfully!'
+
+      {
+        errors: error_total.to_h,
+        violations: violations_total.to_h,
+        configerrors: configerrors_total.to_h
+      }
     end
 
-    def get_projects(file_path)
-      @projects = ProjectsParser.new.parse(file_path)
+    private
+
+    def create_pmd_report(config:, branch:)
+      PmdReportBuilder.new(@projects, @options, config, branch).build
     end
   end
 end