pmdtester 1.0.1 → 1.1.0

data/lib/pmdtester/builders/project_hasher.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'differ'
+
+module PmdTester
+  # Turn a project report into a hash that can be rendered somewhere else
+  module ProjectHasher
+    include PmdTester
+
+    def report_diff_to_h(rdiff)
+      {
+        'violation_counts' => rdiff.violation_counts.to_h,
+        'error_counts' => rdiff.error_counts.to_h,
+        'configerror_counts' => rdiff.configerror_counts.to_h,
+
+        'base_execution_time' => PmdReportDetail.convert_seconds(rdiff.base_report.exec_time),
+        'patch_execution_time' => PmdReportDetail.convert_seconds(rdiff.patch_report.exec_time),
+        'diff_execution_time' => PmdReportDetail.convert_seconds(rdiff.patch_report.exec_time -
+                                                                   rdiff.base_report.exec_time),
+
+        'base_timestamp' => rdiff.base_report.timestamp,
+        'patch_timestamp' => rdiff.patch_report.timestamp,
+
+        'rule_diffs' => rdiff.rule_summaries
+      }
+    end
+
+    def errors_to_h(project)
+      errors = project.report_diff.error_diffs_by_file.values.flatten
+      errors.map { |e| error_to_hash(e, project) }
+    end
+
+    def configerrors_to_h(project)
+      configerrors = project.report_diff.configerror_diffs_by_rule.values.flatten
+      configerrors.map { |e| configerror_to_hash(e) }
+    end
+
+    def violations_to_hash(project)
+      filename_index = []
+      all_vs = []
+      project.report_diff.violation_diffs_by_file.each do |file, vs|
+        file_ref = filename_index.size
+        filename_index.push(project.get_local_path(file))
+        vs.each do |v|
+          all_vs.push(make_violation_hash(file_ref, v))
+        end
+      end
+
+      {
+        'file_index' => filename_index,
+        'violations' => all_vs
+      }
+    end
+
+    def link_template(project)
+      l_str = project.type == 'git' ? 'L' : 'l'
+      "#{project.webview_url}/{file}##{l_str}{line}"
+    end
+
+    def violation_type(violation)
+      if violation.changed?
+        '~'
+      elsif violation.branch == 'patch'
+        '+'
+      else
+        '-'
+      end
+    end
+
+    def make_violation_hash(file_ref, violation)
+      h = {
+        't' => violation_type(violation),
+        'l' => violation.line,
+        'f' => file_ref,
+        'r' => violation.rule_name,
+        'm' => violation.changed? ? diff_fragments(violation) : violation.message
+      }
+      h['ol'] = violation.old_line if violation.changed? && violation.line != violation.old_line
+      h
+    end
+
+    def diff_fragments(violation)
+      diff = Differ.diff_by_word(violation.message, violation.old_message)
+      diff.format_as(:html)
+    end
+
+    def error_to_hash(error, project)
+      escaped_stacktrace = sanitize_stacktrace(error)
+      old_stacktrace = error.old_error.nil? ? nil : sanitize_stacktrace(error.old_error)
+
+      {
+        'file_url' => project.get_webview_url(error.filename),
+        'stack_trace_html' => escaped_stacktrace,
+        'old_stack_trace_html' => old_stacktrace,
+        'short_message' => error.short_message,
+        'short_filename' => error.short_filename,
+        'filename' => error.filename,
+        'change_type' => change_type(error)
+      }
+    end
+
+    def sanitize_stacktrace(error)
+      CGI.escapeHTML(error.stack_trace)
+         .gsub(error.filename, '<span class="meta-var">$FILE</span>')
+         .gsub(/\w++(?=\(\w++\.java:\d++\))/, '<span class="stack-trace-method">\\0</span>')
+    end
+
+    def configerror_to_hash(configerror)
+      {
+        'rule' => configerror.rulename,
+        'message' => configerror.msg,
+        'change_type' => change_type(configerror)
+      }
+    end
+
+    def change_type(item)
+      if item.branch == BASE
+        'removed'
+      elsif item.changed?
+        'changed'
+      else
+        'added'
+      end
+    end
+  end
+end

data/lib/pmdtester/builders/rule_set_builder.rb

@@ -9,8 +9,9 @@ module PmdTester
   # Attention: we only consider java rulesets now.
   class RuleSetBuilder
     include PmdTester
-    ALL_RULE_SETS = Set['bestpractices', 'codestyle', 'design', 'documentation',
-                        'errorprone', 'multithreading', 'performance', 'security'].freeze
+    ALL_CATEGORIES = Set['bestpractices.xml', 'codestyle.xml', 'design.xml', 'documentation.xml',
+                         'errorprone.xml', 'multithreading.xml', 'performance.xml',
+                         'security.xml'].freeze
     PATH_TO_PMD_JAVA_BASED_RULES =
       'pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule'
     PATH_TO_PMD_XPATH_BASED_RULES = 'pmd-java/src/main/resources/category/java'
@@ -25,19 +26,35 @@ module PmdTester
 
     def build
       filenames = diff_filenames
-      rule_sets = get_rule_sets(filenames)
-      output_filter_set(rule_sets)
-      build_config_file(rule_sets)
-      logger.debug "Dynamic configuration: #{[rule_sets]}"
-      rule_sets
+      rule_refs = get_rule_refs(filenames)
+      output_filter_set(rule_refs)
+      build_config_file(rule_refs)
+      logger.debug "Dynamic configuration: #{[rule_refs]}"
+      rule_refs
     end
 
-    def output_filter_set(rule_sets)
-      if rule_sets == ALL_RULE_SETS
-        # if `rule_sets` contains all rule sets, than no need to filter the baseline
-        @options.filter_set = nil
+    def output_filter_set(rule_refs)
+      if rule_refs == ALL_CATEGORIES
+        if @options.mode == Options::ONLINE
+          @options.filter_set = Set[]
+          doc = File.open(@options.patch_config) { |f| Nokogiri::XML(f) }
+          rules = doc.css('ruleset rule')
+          rules.each do |r|
+            ref = r.attributes['ref'].content
+            ref.delete_prefix!('category/java/')
+            @options.filter_set.add(ref)
+          end
+
+          logger.debug "Using filter based on patch config #{@options.patch_config}: " \
+                       "#{@options.filter_set}"
+        else
+          # if `rule_refs` contains all categories, then no need to filter the baseline
+          logger.debug 'No filter when comparing patch to baseline'
+          @options.filter_set = nil
+        end
       else
-        @options.filter_set = rule_sets
+        logger.debug "Filter is now #{rule_refs}"
+        @options.filter_set = rule_refs
       end
     end
 
@@ -53,58 +70,86 @@ module PmdTester
       filenames.split("\n")
     end
 
-    def get_rule_sets(filenames)
-      rule_sets = Set[]
+    def get_rule_refs(filenames)
+      categories, rules = determine_categories_rules(filenames)
+      logger.debug "Categories: #{categories}"
+      logger.debug "Rules: #{rules}"
+
+      # filter out all individual rules that are already covered by a complete category
+      categories.each do |cat|
+        rules.delete_if { |e| e.start_with?(cat) }
+      end
+
+      refs = Set[]
+      refs.merge(categories)
+      refs.merge(rules)
+      refs
+    end
+
+    def determine_categories_rules(filenames)
+      categories = Set[]
+      rules = Set[]
       filenames.each do |filename|
-        match_data = %r{#{PATH_TO_PMD_JAVA_BASED_RULES}/([^/]+)/[^/]+Rule.java}.match(filename)
-        if match_data.nil?
-          match_data = %r{#{PATH_TO_PMD_XPATH_BASED_RULES}/([^/]+).xml}.match(filename)
+        match_data = check_single_filename(filename)
+
+        unless match_data.nil?
+          if match_data.size == 2
+            categories.add("#{match_data[1]}.xml")
+          else
+            rules.add("#{match_data[1]}.xml/#{match_data[2]}")
+          end
         end
 
-        category = if match_data.nil?
-                     nil
-                   else
-                     match_data[1]
-                   end
+        next unless match_data.nil?
 
-        if category.nil?
-          rule_sets = ALL_RULE_SETS
-          break
-        else
-          rule_sets.add(category)
-        end
+        logger.debug "Change doesn't match specific rule/category - enable all rules"
+        categories = ALL_CATEGORIES
+        rules.clear
+        break
       end
-      rule_sets
+      [categories, rules]
     end
 
-    def build_config_file(rule_sets)
-      if rule_sets.empty?
+    def check_single_filename(filename)
+      logger.debug "Checking #{filename}"
+      match_data = %r{#{PATH_TO_PMD_JAVA_BASED_RULES}/([^/]+)/([^/]+)Rule.java}.match(filename)
+      match_data = %r{#{PATH_TO_PMD_XPATH_BASED_RULES}/([^/]+).xml}.match(filename) if match_data.nil?
+      logger.debug "Matches: #{match_data.inspect}"
+      match_data
+    end
+
+    def build_config_file(rule_refs)
+      if rule_refs.empty?
         logger.info NO_JAVA_RULES_CHANGED_MESSAGE
         return
       end
 
-      doc = Nokogiri::XML(File.read(PATH_TO_ALL_JAVA_RULES))
-      doc.search('rule').each do |rule|
-        rule.remove unless match_ref?(rule, rule_sets)
+      if rule_refs == ALL_CATEGORIES
+        logger.debug 'All rules are used. Not generating a dynamic ruleset.'
+        logger.debug "Using the configured/default ruleset base_config=#{@options.base_config} "\
+                     "patch_config=#{@options.patch_config}"
+        return
       end
 
-      description = doc.at_css('description')
-      description.content = 'The ruleset generated by PmdTester dynamically'
-
-      write_dynamic_file(doc)
+      write_dynamic_file(rule_refs)
     end
 
-    def match_ref?(rule_node, rule_sets)
-      rule_sets.each do |rule_set|
-        return true unless rule_node['ref'].index(rule_set).nil?
+    def write_dynamic_file(rule_refs)
+      logger.debug "Generating dynamic configuration for: #{[rule_refs]}"
+      builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+        xml.ruleset('xmlns' => 'http://pmd.sourceforge.net/ruleset/2.0.0',
+                    'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                    'xsi:schemaLocation' => 'http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.io/ruleset_2_0_0.xsd',
+                    'name' => 'Dynamic PmdTester Ruleset') do
+          xml.description 'The ruleset generated by PmdTester dynamically'
+          rule_refs.each do |entry|
+            xml.rule('ref' => "category/java/#{entry}")
+          end
+        end
       end
-
-      false
-    end
-
-    def write_dynamic_file(doc)
+      doc = builder.to_xml(indent: 4, encoding: 'UTF-8')
       File.open(PATH_TO_DYNAMIC_CONFIG, 'w') do |x|
-        x << doc.to_s.gsub(/\n\s+\n/, "\n")
+        x << doc.gsub(/\n\s+\n/, "\n")
       end
       @options.base_config = PATH_TO_DYNAMIC_CONFIG
       @options.patch_config = PATH_TO_DYNAMIC_CONFIG

data/lib/pmdtester/builders/simple_progress_logger.rb

@@ -6,16 +6,16 @@ module PmdTester
   # Helper class that provides a simple progress logging
   class SimpleProgressLogger
     include PmdTester
-    def initialize(project_name)
-      @project_name = project_name
+    def initialize(task_name)
+      @task_name = task_name
     end
 
     def start
-      logger.info "Starting to generate #{@project_name}'s PMD report"
+      logger.info "Starting #{@task_name}"
       message_counter = 1
       @scheduler = Rufus::Scheduler.new
       @scheduler.every '2m' do
-        logger.info "Still generating #{@project_name}'s PMD report (#{message_counter})..."
+        logger.info "Still #{@task_name} (#{message_counter})..."
         message_counter += 1
       end
     end

data/lib/pmdtester/builders/summary_report_builder.rb

@@ -2,159 +2,90 @@
 
 module PmdTester
   # Building summary report to show the details about projects and pmd branchs
-  class SummaryReportBuilder < HtmlReportBuilder
+  class SummaryReportBuilder
     include PmdTester
-    REPORT_DIR = 'target/reports/diff'
-    BASE_CONFIG_PATH = 'target/reports/diff/base_config.xml'
-    PATCH_CONFIG_PATH = 'target/reports/diff/patch_config.xml'
-    INDEX_PATH = 'target/reports/diff/index.html'
-
-    def build(projects, base_name, patch_name)
-      @projects = projects
-      @base_details = get_branch_details(base_name)
-      @patch_details = get_branch_details(patch_name)
-
-      FileUtils.mkdir_p(REPORT_DIR) unless File.directory?(REPORT_DIR)
-      index = File.new(INDEX_PATH, 'w')
-
-      html_report = build_html_report('Summary report')
-      copy_css(REPORT_DIR)
-
-      index.puts html_report
-      index.close
-
-      logger.info 'Built summary report successfully!'
-    end
-
-    def get_branch_details(branch_name)
-      details = PmdBranchDetail.new(branch_name)
-      details.load
-    end
+    include LiquidRenderer
+    include ProjectHasher
 
-    def build_body(doc)
-      build_branch_details_section(doc)
-      build_projects_section(doc)
-    end
+    REPORT_DIR = 'target/reports/diff'
+    BASE_CONFIG_NAME = 'base_config.xml'
+    PATCH_CONFIG_NAME = 'patch_config.xml'
 
-    def build_branch_details_section(doc)
-      doc.div(class: 'section', id: 'branchdetails') do
-        doc.h2 'Branch details:'
-        build_branch_details_table(doc)
+    def write_all_projects(projects, base_details, patch_details)
+      projects.each do |project|
+        process_project(project, "#{REPORT_DIR}/#{project.name}")
       end
-    end
+      logger.info 'Built all difference reports successfully!'
 
-    def build_branch_details_table(doc)
-      doc.table(class: 'bodyTable', border: '0') do
-        build_branch_table_head(doc)
-        build_branch_table_body(doc)
-      end
+      FileUtils.mkdir_p(REPORT_DIR)
+      write_structure(REPORT_DIR)
+      copy_configs(REPORT_DIR, base_details, patch_details)
+      write_index(REPORT_DIR, base_details, patch_details, projects)
+      logger.info "Built summary report successfully in #{REPORT_DIR}!"
     end
 
-    def build_branch_table_head(doc)
-      doc.thead do
-        doc.tr do
-          doc.th 'Item'
-          doc.th 'base'
-          doc.th 'patch'
-        end
-      end
-    end
+    private
 
-    def build_branch_table_body(doc)
-      doc.tbody do
-        build_branch_table_row(doc, 'branch name', @base_details.branch_name,
-                               @patch_details.branch_name)
-        build_branch_table_row(doc, 'branch last commit sha', @base_details.branch_last_sha,
-                               @patch_details.branch_last_sha)
-        build_branch_table_row(doc, 'branch last commit message', @base_details.branch_last_message,
-                               @patch_details.branch_last_message)
-        build_branch_table_row(doc, 'total execution time', @base_details.format_execution_time,
-                               @patch_details.format_execution_time)
-        build_branch_table_row(doc, 'jdk version', @base_details.jdk_version,
-                               @patch_details.jdk_version)
-        build_branch_table_row(doc, 'language', @base_details.language,
-                               @patch_details.language)
-        build_branch_config_table_row(doc)
-      end
+    def process_project(project, dir)
+      logger.info "Rendering #{project.name}..."
+      LiquidProjectRenderer.new.write_project_index(project, dir)
     end
 
-    def build_branch_config_table_row(doc)
-      doc.tr do
-        doc.td(class: 'c') { doc.text 'branch configuration' }
-        base_config_src_path = @base_details.target_branch_config_path
-        copy_branch_config_file(base_config_src_path, BASE_CONFIG_PATH)
-        doc.td(class: 'a') do
-          doc.a(href: './base_config.xml') { doc.text 'base config' }
-        end
-        patch_config_stc_path = @patch_details.target_branch_config_path
-        FileUtils.cp(patch_config_stc_path, PATCH_CONFIG_PATH)
-        doc.td(class: 'b') do
-          doc.a(href: './patch_config.xml') { doc.text 'patch config' }
-        end
-      end
+    def write_structure(target_root)
+      logger.info 'Copying resources...'
+      copy_resource('css', target_root)
+      copy_resource('js', target_root)
     end
 
-    def copy_branch_config_file(src, dest)
-      FileUtils.cp(src, dest) if File.exist?(src)
+    def copy_configs(target_root, base_details, patch_details)
+      copy_file(base_details.target_branch_config_path, "#{target_root}/#{BASE_CONFIG_NAME}")
+      copy_file(patch_details.target_branch_config_path, "#{target_root}/#{PATCH_CONFIG_NAME}")
     end
 
-    def build_branch_table_row(doc, item, base, patch)
-      doc.tr do
-        doc.td(class: 'c') { doc.text item }
-        doc.td(class: 'a') { doc.text base }
-        doc.td(class: 'b') { doc.text patch }
-      end
+    def copy_file(src, dest)
+      FileUtils.cp(src, dest) if File.exist?(src)
     end
 
-    def build_projects_section(doc)
-      doc.div(class: 'section', id: 'projects') do
-        doc.h2 'Projects:'
-        build_projects_table(doc)
+    def write_index(target_root, base_details, patch_details, projects)
+      projects = projects.map do |p|
+        {
+          'name' => p.name,
+          'tag' => p.tag,
+          'report_url' => "./#{p.name}/index.html",
+          **report_diff_to_h(p.report_diff)
+        }
       end
-    end
 
-    def build_projects_table(doc)
-      doc.table(class: 'bodyTable', border: '0') do
-        build_projects_table_head(doc)
-        build_projects_table_body(doc)
-      end
+      env = {
+        'comparison_url' => create_comparison_url(base_details, patch_details),
+        'base' => to_liquid(base_details, BASE_CONFIG_NAME),
+        'patch' => to_liquid(patch_details, PATCH_CONFIG_NAME),
+        'projects' => projects
+      }
+      logger.info 'Writing /index.html...'
+      render_and_write('project_index.html', "#{target_root}/index.html", env)
     end
 
-    def build_projects_table_head(doc)
-      doc.thead do
-        doc.tr do
-          doc.th 'project name'
-          doc.th 'project branch/tag'
-          doc.th 'removed|new errors size'
-          doc.th 'removed|new violations size'
-          doc.th 'removed|new configerrors size'
-        end
-      end
+    def create_comparison_url(base_details, patch_details)
+      base = CGI.escape(base_details.branch_name)
+      patch = CGI.escape(patch_details.branch_last_sha)
+      "https://github.com/pmd/pmd/compare/#{base}...#{patch}"
     end
 
-    def build_projects_table_body(doc)
-      doc.tbody do
-        @projects.each do |project|
-          doc.tr do
-            doc.td do
-              doc.a(href: project.diff_report_index_ref_path) { doc.text project.name }
-            end
-            doc.td project.tag
-            doc.td do
-              build_table_content_for(doc, project.removed_errors_size,
-                                      project.new_errors_size)
-            end
-            doc.td do
-              build_table_content_for(doc, project.removed_violations_size,
-                                      project.new_violations_size)
-            end
-            doc.td do
-              build_table_content_for(doc, project.removed_configerrors_size,
-                                      project.new_configerrors_size)
-            end
-          end
-        end
-      end
+    def to_liquid(details, config_name)
+      {
+        'tree_url' => "https://github.com/pmd/pmd/tree/#{CGI.escape(details.branch_last_sha)}",
+        'name' => details.branch_name,
+        'tip' => {
+          'sha' => details.branch_last_sha,
+          'message' => details.branch_last_message
+        },
+        'execution_time' => PmdReportDetail.convert_seconds(details.execution_time),
+        'jdk_info' => details.jdk_version,
+        'locale' => details.language,
+        'config_url' => config_name,
+        'pr_number' => details.pull_request
+      }
     end
   end
 end