pmdtester 1.6.2 → 1.7.0

data/lib/pmdtester/pmd_violation.rb

@@ -27,16 +27,18 @@ module PmdTester
     #   </xs:simpleContent>
     # </xs:complexType>
 
-    attr_reader :fname, :info_url, :line, :old_line, :old_message, :rule_name, :ruleset_name, :language
+    attr_reader :fname, :info_url, :line, :old_line, :old_message, :rule_name, :ruleset_name, :language, :location,
+                :old_location
     attr_accessor :message
 
-    def initialize(branch:, fname:, info_url:, bline:, rule_name:, ruleset_name:)
+    def initialize(branch:, fname:, info_url:, bline:, rule_name:, ruleset_name:, location:)
       @branch = branch
       @fname = fname
       @message = ''
 
       @info_url = info_url
       @line = bline
+      @location = location
       @rule_name = rule_name
 
       @ruleset_name = ruleset_name
@@ -46,6 +48,7 @@ module PmdTester
       @changed = false
       @old_message = nil
       @old_line = nil
+      @old_location = nil
     end
 
     def line_move?(other)
@@ -55,10 +58,11 @@ module PmdTester
     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))
+         (location.eql?(other.location) || location_move?(other))
         @changed = true
         @old_message = other.message
         @old_line = other.line
+        @old_location = other.location
         true
       else
         false
@@ -81,18 +85,18 @@ module PmdTester
     end
 
     def sort_key
-      line
+      location.beginline
     end
 
     def eql?(other)
       rule_name.eql?(other.rule_name) &&
-        line.eql?(other.line) &&
+        location.eql?(other.location) &&
         fname.eql?(other.fname) &&
         message.eql?(other.message)
     end
 
     def hash
-      [line, rule_name, message].hash
+      [location, rule_name, message].hash
     end
 
     def to_liquid
@@ -109,5 +113,10 @@ module PmdTester
       m = @info_url.match(/pmd_rules_(\w+)_/)
       m[1]
     end
+
+    def location_move?(other)
+      message.eql?(other.message) &&
+        (location.beginline - other.location.beginline).abs <= 5
+    end
   end
 end

data/lib/pmdtester/project.rb

@@ -17,11 +17,13 @@ module PmdTester
     attr_reader :exclude_patterns
     attr_reader :src_subpath
     attr_accessor :report_diff
+    attr_accessor :cpd_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
+    attr_reader :cpd_options
 
     def initialize(project) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       @name = project.at_xpath('name').text
@@ -44,6 +46,7 @@ module PmdTester
       @auxclasspath_command = project.at_xpath('auxclasspath-command')&.text
 
       @report_diff = nil
+      @cpd_options = CpdOptions.new(project.at_xpath('cpd-options'))
     end
 
     # Generate the default webview url for the projects
@@ -83,11 +86,27 @@ module PmdTester
       end
     end
 
+    def get_cpd_report_path(branch_name)
+      if branch_name.nil?
+        nil
+      else
+        "#{get_project_target_dir(branch_name)}/cpd_report.xml"
+      end
+    end
+
     def get_report_info_path(branch_name)
       if branch_name.nil?
         nil
       else
-        "#{get_project_target_dir(branch_name)}/report_info.json"
+        "#{get_project_target_dir(branch_name)}/pmd_report_info.json"
+      end
+    end
+
+    def get_cpd_report_info_path(branch_name)
+      if branch_name.nil?
+        nil
+      else
+        "#{get_project_target_dir(branch_name)}/cpd_report_info.json"
       end
     end
 
@@ -119,15 +138,56 @@ module PmdTester
       dir
     end
 
-    def compute_report_diff(base_branch, patch_branch, filter_set)
+    def compute_report_diff(base_branch, patch_branch, filter_set, rules_changed:, impl_changed:)
       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)
+                                           filter_set, rules_changed: rules_changed)
 
       report_diff.base_report.report_folder = get_project_target_dir(base_branch)
       report_diff.patch_report.report_folder = get_project_target_dir(patch_branch)
+
+      self.cpd_report_diff = build_cpd_report_diff(get_cpd_report_path(base_branch),
+                                                   get_cpd_report_path(patch_branch),
+                                                   get_cpd_report_info_path(base_branch),
+                                                   get_cpd_report_info_path(patch_branch),
+                                                   impl_changed: impl_changed)
+    end
+
+    # Containts Cpd specific options from project-list.xml
+    class CpdOptions
+      attr_reader :language
+      attr_reader :minimum_tokens
+      attr_reader :max_memory
+      attr_reader :directories
+
+      def initialize(cpd_options_element)
+        # default values
+        @language = 'java'
+        @minimum_tokens = 150
+        @max_memory = '5g'
+        @directories = ['.']
+
+        return if cpd_options_element.nil?
+
+        @language = parse_text(cpd_options_element, 'language', @language)
+        @minimum_tokens = parse_text(cpd_options_element, 'minimum-tokens', @minimum_tokens).to_i
+        @max_memory = parse_text(cpd_options_element, 'max-memory', @max_memory)
+        @directories = parse_directories(cpd_options_element, @directories)
+      end
+
+      private
+
+      def parse_text(cpd_options_element, element_name, default_value)
+        element = cpd_options_element.at_xpath(element_name)
+        element.nil? ? default_value : element.text
+      end
+
+      def parse_directories(cpd_options_element, default_value)
+        directories = cpd_options_element.xpath('directories/directory').map(&:text)
+        directories.empty? ? default_value : directories
+      end
     end
   end
 end

data/lib/pmdtester/report_diff.rb

@@ -55,28 +55,20 @@ module PmdTester
     attr_reader :violations_by_file,
                 :errors_by_file,
                 :configerrors_by_rule,
-                :exec_time,
-                :timestamp,
-                :exit_code,
-                :file
+                :file,
+                :report_details
 
     attr_accessor :report_folder
 
-    def initialize(report_document: nil,
-                   file: '',
-                   exec_time: 0,
-                   timestamp: '0',
-                   exit_code: '?')
+    def initialize(report_details:, report_document:, file:)
       initialize_empty
       initialize_with_report_document report_document unless report_document.nil?
-      @exec_time = exec_time
-      @timestamp = timestamp
+      @report_details = report_details
       @file = file
-      @exit_code = exit_code
     end
 
     def self.empty
-      new
+      new(report_details: PmdTester::PmdReportDetail.empty, report_document: nil, file: '')
     end
 
     def rule_summaries

data/lib/pmdtester/runner.rb

@@ -22,7 +22,14 @@ module PmdTester
         run_single_mode
       end
 
-      summarize_diffs
+      summary = summarize_diffs
+      unless @options.html_flag
+        FileUtils.mkdir_p('target/reports/diff') unless File.directory?('target/reports/diff')
+        File.write('target/reports/diff/summary.txt', Runner.create_message(@options.base_branch, summary))
+        File.write('target/reports/diff/conclusion.txt', Runner.determine_conclusion(summary))
+      end
+
+      summary
     end
 
     def clean
@@ -33,16 +40,27 @@ module PmdTester
     def run_local_mode
       logger.info "Mode: #{@options.mode}"
       get_projects(@options.project_list) unless @options.nil?
-      if @options.auto_config_flag
-        run_required = RuleSetBuilder.new(@options).build?
-        logger.debug "Run required: #{run_required}"
-        return unless run_required
-      end
 
-      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)
+      rules_changed = true
+      rules_changed = RuleSetBuilder.new(@options).build? if @options.auto_config_flag
+      impl_changed = determine_impl_changed?
+
+      base_branch_details = create_pmd_report(config: @options.base_config, branch: @options.base_branch,
+                                              rules_changed: rules_changed, impl_changed: impl_changed)
+      # copy list of projects file to the base baseline
+      base_branch_dir = File.dirname(base_branch_details.target_branch_project_list_path)
+      FileUtils.mkdir_p(base_branch_dir) unless File.directory?(base_branch_dir)
+      FileUtils.cp(@options.project_list, base_branch_details.target_branch_project_list_path)
+
+      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch,
+                                               rules_changed: rules_changed, impl_changed: impl_changed)
+      # copy list of projects file to the patch baseline
+      patch_branch_dir = File.dirname(patch_branch_details.target_branch_project_list_path)
+      FileUtils.mkdir_p(patch_branch_dir) unless File.directory?(patch_branch_dir)
+      FileUtils.cp(@options.project_list, patch_branch_details.target_branch_project_list_path)
 
-      build_html_reports(@projects, base_branch_details, patch_branch_details)
+      build_html_reports(@projects, base_branch_details, patch_branch_details, nil,
+                         rules_changed: rules_changed, impl_changed: impl_changed)
     end
 
     def run_online_mode
@@ -53,23 +71,27 @@ module PmdTester
       project_list = determine_project_list_for_online_mode(baseline_path)
       get_projects(project_list)
 
-      if @options.auto_config_flag
-        logger.info 'Autogenerating a dynamic ruleset based on source changes'
-        return unless RuleSetBuilder.new(@options).build?
-      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"
-        RuleSetBuilder.new(@options).calculate_filter_set if @options.filter_with_patch_config
+      rules_changed = determine_rule_changed_in_online_mode?(baseline_path)
+      impl_changed = determine_impl_changed?
+
+      # When neither PMD nor CPD is executed, we can abort directly
+      # No report will be generated then
+      if !rules_changed && !impl_changed
+        @skipped = true
+        logger.info 'No relevant source code has been changed, pmdtester skipped.'
+        return
       end
 
-      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch)
+      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch,
+                                               rules_changed: rules_changed, impl_changed: impl_changed)
+      # copy list of projects file to the patch baseline
+      patch_branch_dir = File.dirname(patch_branch_details.target_branch_project_list_path)
+      FileUtils.mkdir_p(patch_branch_dir) unless File.directory?(patch_branch_dir)
+      FileUtils.cp(project_list, patch_branch_details.target_branch_project_list_path)
 
       base_branch_details = PmdBranchDetail.load(@options.base_branch, logger)
-      build_html_reports(@projects, base_branch_details, patch_branch_details, @options.filter_set)
+      build_html_reports(@projects, base_branch_details, patch_branch_details, @options.filter_set,
+                         rules_changed: rules_changed, impl_changed: impl_changed)
     end
 
     def determine_project_list_for_online_mode(baseline_path)
@@ -101,6 +123,8 @@ module PmdTester
         Cmd.execute_successfully(unzip_cmd)
       end
 
+      make_baseline_compatible("#{target_path}/#{branch_filename}")
+
       "#{target_path}/#{branch_filename}"
     end
 
@@ -112,8 +136,11 @@ module PmdTester
       logger.info "Mode: #{@options.mode}"
 
       get_projects(@options.project_list) unless @options.nil?
-      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch)
+      patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch,
+                                               rules_changed: true, impl_changed: true)
       # copy list of projects file to the patch baseline
+      patch_branch_dir = File.dirname(patch_branch_details.target_branch_project_list_path)
+      FileUtils.mkdir_p(patch_branch_dir) unless File.directory?(patch_branch_dir)
       FileUtils.cp(@options.project_list, patch_branch_details.target_branch_project_list_path)
 
       # for creating a baseline, no html report is needed
@@ -121,7 +148,8 @@ module PmdTester
 
       # 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)
+      build_html_reports(@projects, empty_base_branch_details, patch_branch_details, nil,
+                         rules_changed: true, impl_changed: true)
     end
 
     def get_projects(file_path)
@@ -129,32 +157,152 @@ module PmdTester
     end
 
     def summarize_diffs
-      error_total = RunningDiffCounters.new(0)
-      violations_total = RunningDiffCounters.new(0)
-      configerrors_total = RunningDiffCounters.new(0)
+      pmd_error_total = RunningDiffCounters.new(0)
+      pmd_violations_total = RunningDiffCounters.new(0)
+      pmd_configerrors_total = RunningDiffCounters.new(0)
+      cpd_error_total = RunningDiffCounters.new(0)
+      cpd_duplications_total = RunningDiffCounters.new(0)
 
       @projects.each do |project|
         diff = project.report_diff
+        cpd_diff = project.cpd_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)
+        # or if only pmd or only cpd is has been run
+        sum_pmd_counters(diff, pmd_error_total, pmd_violations_total, pmd_configerrors_total) unless diff.nil?
+        sum_cpd_counters(cpd_diff, cpd_error_total, cpd_duplications_total) unless cpd_diff.nil?
       end
 
       {
-        errors: error_total.to_h,
-        violations: violations_total.to_h,
-        configerrors: configerrors_total.to_h
+        pmd_errors: pmd_error_total.to_h,
+        pmd_violations: pmd_violations_total.to_h,
+        pmd_configerrors: pmd_configerrors_total.to_h,
+        cpd_errors: cpd_error_total.to_h,
+        cpd_duplications: cpd_duplications_total.to_h,
+        skipped: @skipped
       }
     end
 
+    def self.create_message(base_branch, summary)
+      return 'No relevant source code has been changed, pmdtester skipped.' if summary[:skipped]
+
+      "Compared to #{base_branch}:\n" \
+        'This changeset ' \
+        "changes #{summary[:pmd_violations][:changed]} violations,\n" \
+        "introduces #{summary[:pmd_violations][:new]} new violations, " \
+        "#{summary[:pmd_errors][:new]} new errors and " \
+        "#{summary[:pmd_configerrors][:new]} new configuration errors,\n" \
+        "removes #{summary[:pmd_violations][:removed]} violations, " \
+        "#{summary[:pmd_errors][:removed]} errors and " \
+        "#{summary[:pmd_configerrors][:removed]} configuration errors.\n" \
+        "There are #{summary[:cpd_duplications][:changed]} changed duplications, " \
+        "#{summary[:cpd_duplications][:new]} new duplications and " \
+        "#{summary[:cpd_duplications][:removed]} removed duplications.\n" \
+        "There are #{summary[:cpd_errors][:changed]} changed CPD errors, " \
+        "#{summary[:cpd_errors][:new]} new CPD errors and " \
+        "#{summary[:cpd_errors][:removed]} removed CPD errors.\n"
+    end
+
+    def self.determine_conclusion(summary)
+      return 'skipped' if summary[:skipped]
+
+      total_changes = summary[:pmd_violations][:changed] \
+        + summary[:pmd_violations][:new] \
+        + summary[:pmd_violations][:removed] \
+        + summary[:pmd_errors][:new] \
+        + summary[:pmd_configerrors][:new] \
+        + summary[:cpd_duplications][:changed] \
+        + summary[:cpd_duplications][:new] \
+        + summary[:cpd_duplications][:removed] \
+        + summary[:cpd_errors][:new]
+      if total_changes.positive?
+        'neutral'
+      else
+        'success'
+      end
+    end
+
     private
 
-    def create_pmd_report(config:, branch:)
-      PmdReportBuilder.new(@projects, @options, config, branch).build
+    def sum_pmd_counters(diff, pmd_error_total, pmd_violations_total, pmd_configerrors_total)
+      pmd_error_total.merge!(diff.error_counts)
+      pmd_violations_total.merge!(diff.violation_counts)
+      pmd_configerrors_total.merge!(diff.configerror_counts)
+    end
+
+    def sum_cpd_counters(diff, cpd_error_total, cpd_duplications_total)
+      cpd_error_total.merge!(diff.error_counts)
+      cpd_duplications_total.merge!(diff.duplication_counts)
+    end
+
+    def create_pmd_report(config:, branch:, rules_changed:, impl_changed:)
+      PmdReportBuilder.new(@projects, @options, config, branch)
+                      .with_changes(rules_changed, impl_changed)
+                      .build
+    end
+
+    # for compatibility with old baselines, create empty CPD reports if they are missing in the baseline
+    # also create empty JFR recording files.
+    # this allows to run the regression tester with baselines created with an old regression tester version
+    def make_baseline_compatible(branch_path)
+      Dir.each_child(branch_path) do |project_path|
+        next unless File.directory?("#{branch_path}/#{project_path}")
+
+        unless File.exist?("#{branch_path}/#{project_path}/cpd_report_info.json")
+          File.write("#{branch_path}/#{project_path}/cpd_report_info.json", '{}')
+        end
+        unless File.exist?("#{branch_path}/#{project_path}/cpd_report.xml")
+          FileUtils.touch("#{branch_path}/#{project_path}/cpd_report.xml")
+        end
+        unless File.exist?("#{branch_path}/#{project_path}/pmd_report_info.json")
+          FileUtils.cp("#{branch_path}/#{project_path}/report_info.json",
+                       "#{branch_path}/#{project_path}/pmd_report_info.json")
+        end
+        add_jfr_recording_for_old_baseline("#{branch_path}/#{project_path}", true)
+        add_jfr_recording_for_old_baseline("#{branch_path}/#{project_path}", false)
+      end
+    end
+
+    def add_jfr_recording_for_old_baseline(path, pmd_or_cpd)
+      prefix = pmd_or_cpd ? 'pmd' : 'cpd'
+      recording_path = "#{path}/#{prefix}_recording.jfr"
+      return if File.exist?(recording_path)
+
+      FileUtils.touch(recording_path)
+      report_info = JSON.parse(File.read("#{path}/#{prefix}_report_info.json"))
+      report_info['jfr_summary'] = { 'recording_path' => recording_path }
+      File.write("#{path}/#{prefix}_report_info.json", JSON.pretty_generate(report_info))
+    end
+
+    def determine_impl_changed?
+      filenames = nil
+      Dir.chdir(@options.local_git_repo) do
+        base = @options.base_branch
+        patch = @options.patch_branch
+
+        # We only need to support git here, since PMD's repo is using git.
+        diff_cmd = "git diff --name-only #{base}..#{patch}"
+        filenames = Cmd.execute_successfully(diff_cmd)
+      end
+      result = filenames.split("\n").any? { |filename| filename.include?('/src/main/') }
+      logger.debug "PMD impl changed: #{result}"
+      result
+    end
+
+    def determine_rule_changed_in_online_mode?(baseline_path)
+      rules_changed = true
+      if @options.auto_config_flag
+        rules_changed = RuleSetBuilder.new(@options).build?
+      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"
+        RuleSetBuilder.new(@options).calculate_filter_set if @options.filter_with_patch_config
+      end
+      rules_changed
     end
   end
 end

data/lib/pmdtester/system_info.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module PmdTester
+  # Utility to deal with semantic versions
+  class SystemInfo
+    def physical_memory
+      meminfo = File.read('/proc/meminfo')
+      mem_total_line = meminfo.lines.find { |line| line.start_with?('MemTotal:') }
+      mem_total_kb = mem_total_line.split[1].to_i # Get the value in kB
+      mem_total_gb = mem_total_kb / 1024.0 / 1024.0 # Convert kB to GB
+      mem_total_gb = mem_total_gb.round(1)
+      "#{mem_total_gb} GB"
+    end
+
+    def uname
+      info = Etc.uname
+      "#{info[:sysname]} #{info[:release]}"
+    end
+
+    def cpu_info
+      cpuinfo = File.read('/proc/cpuinfo')
+      cpus = parse_cpuinfo(cpuinfo)
+      model_name = cpus.map { |cpu| cpu[:model_name] }.uniq.join(', ')
+      sockets = cpus.map { |cpu| cpu[:physical_id] }.uniq.count
+      cores = cpus.map { |cpu| cpu[:core_id] }.uniq.count
+      threads = cpus.count
+
+      "#{model_name} (sockets: #{sockets}, cores: #{cores}, hardware threads: #{threads})"
+    end
+
+    private
+
+    def parse_cpuinfo(cpuinfo)
+      cpus = []
+      cpu_index = -1
+
+      cpuinfo.lines.each do |line|
+        if line.start_with?('processor')
+          cpu_index = line.split(':')[1].strip.to_i
+          cpus[cpu_index] = {}
+        end
+        if line.start_with?('model name')
+          model_name = line.split(':')[1].strip
+          cpus[cpu_index][:model_name] = model_name
+        end
+        if line.start_with?('physical id')
+          physical_id = line.split(':')[1].strip.to_i
+          cpus[cpu_index][:physical_id] = physical_id
+        end
+        if line.start_with?('core id')
+          core_id = line.split(':')[1].strip.to_i
+          cpus[cpu_index][:core_id] = core_id
+        end
+      end
+      cpus
+    end
+  end
+end