pmdtester 1.0.0.pre.beta3 → 1.1.2

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,18 +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_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
 
@@ -46,64 +64,92 @@ module PmdTester
         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} -- pmd-core pmd-java"
+        diff_cmd = "git diff --name-only #{base}..#{patch} -- pmd-core/src/main pmd-java/src/main"
         filenames = Cmd.execute(diff_cmd)
       end
       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 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_sets)
-      if rule_sets.empty?
+    def build_config_file(rule_refs)
+      if rule_refs.empty?
         logger.info NO_JAVA_RULES_CHANGED_MESSAGE
-        exit 0
+        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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rufus-scheduler'
+
+module PmdTester
+  # Helper class that provides a simple progress logging
+  class SimpleProgressLogger
+    include PmdTester
+    def initialize(task_name)
+      @task_name = task_name
+    end
+
+    def start
+      logger.info "Starting #{@task_name}"
+      message_counter = 1
+      @scheduler = Rufus::Scheduler.new
+      @scheduler.every '2m' do
+        logger.info "Still #{@task_name} (#{message_counter})..."
+        message_counter += 1
+      end
+    end
+
+    def stop
+      @scheduler.shutdown
+    end
+  end
+end

data/lib/pmdtester/builders/summary_report_builder.rb

@@ -2,145 +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
-      details
-    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_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 'diff exist?'
-          doc.th 'introduce new errors?'
-        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 project.diffs_exist? ? 'Yes' : 'No'
-            doc.td project.introduce_new_errors? ? 'Yes' : 'No'
-          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

data/lib/pmdtester/cmd.rb

@@ -7,20 +7,34 @@ module PmdTester
   class Cmd
     extend PmdTester
     def self.execute(cmd)
+      stdout, _stderr, _status = internal_execute(cmd)
+      stdout&.chomp!
+      stdout
+    end
+
+    def self.stderr_of(cmd)
+      _stdout, stderr, _status = internal_execute(cmd)
+      stderr
+    end
+
+    def self.internal_execute(cmd)
       logger.debug "execute command '#{cmd}'"
 
       stdout, stderr, status = Open3.capture3("#{cmd};")
 
       logger.debug stdout
       unless status.success?
+        logger.error stdout
         logger.error stderr
         raise CmdException.new(cmd, stderr)
       end
 
       stdout&.chomp!
 
-      stdout
+      [stdout, stderr, status]
     end
+
+    private_class_method :internal_execute
   end
 
   # The exception should be raised when the shell command failed.