pmdtester 1.0.0.pre.beta2 → 1.1.1

data/lib/pmdtester/builders/summary_report_builder.rb

@@ -1,149 +1,91 @@
 # frozen_string_literal: true
 
-require_relative './html_report_builder'
-require_relative '../pmd_branch_detail'
-
 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')
+    include LiquidRenderer
+    include ProjectHasher
 
-      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
-
-    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.

data/lib/pmdtester/collection_by_file.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PmdTester
+  # A collection of things, grouped by file.
+  #
+  # (Note: this replaces PmdErrors and PmdViolations)
+  class CollectionByFile
+    def initialize
+      # a hash of filename -> [list of items]
+      @hash = Hash.new([])
+      @total = 0
+    end
+
+    def add_all(filename, values)
+      return if values.empty?
+
+      if @hash.key?(filename)
+        @hash[filename].concat(values)
+      else
+        @hash[filename] = values
+      end
+      @total += values.size
+    end
+
+    def total_size
+      @total
+    end
+
+    def all_files
+      @hash.keys
+    end
+
+    def num_files
+      @hash.size
+    end
+
+    def all_values
+      @hash.values.flatten
+    end
+
+    def each_value(&block)
+      @hash.each_value do |vs|
+        vs.each(&block)
+      end
+    end
+
+    def [](fname)
+      @hash[fname]
+    end
+
+    def to_h
+      @hash
+    end
+  end
+end

data/lib/pmdtester/parsers/options.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'slop'
-require_relative '../pmdtester'
 
 module PmdTester
   class MissRequiredOptionError < StandardError; end
@@ -15,7 +14,9 @@ module PmdTester
     LOCAL = 'local'
     ONLINE = 'online'
     SINGLE = 'single'
-    VERSION = '1.0.0-beta2'
+    DEFAULT_CONFIG_PATH = ResourceLocator.locate('config/all-java.xml')
+    DEFAULT_LIST_PATH = ResourceLocator.locate('config/project-list.xml')
+    DEFAULT_BASELINE_URL_PREFIX = 'https://sourceforge.net/projects/pmd/files/pmd-regression-tester/'
 
     attr_reader :local_git_repo
     attr_reader :base_branch
@@ -25,10 +26,14 @@ module PmdTester
     attr_reader :config
     attr_reader :project_list
     attr_reader :mode
+    attr_reader :threads
     attr_reader :html_flag
     attr_reader :auto_config_flag
     attr_reader :debug_flag
     attr_accessor :filter_set
+    attr_reader :keep_reports
+    attr_reader :error_recovery
+    attr_reader :baseline_download_url_prefix
 
     def initialize(argv)
       options = parse(argv)
@@ -40,10 +45,19 @@ module PmdTester
       @config = options[:c]
       @project_list = options[:l]
       @mode = options[:m]
+      @threads = options[:t]
       @html_flag = options[:f]
       @auto_config_flag = options[:a]
       @debug_flag = options[:d]
       @filter_set = nil
+      @keep_reports = options.keep_reports?
+      @error_recovery = options.error_recovery?
+      url = options[:baseline_download_url]
+      @baseline_download_url_prefix = if url[-1] == '/'
+                                        url
+                                      else
+                                        "#{url}/"
+                                      end
 
       # if the 'config' option is selected then `config` overrides `base_config` and `patch_config`
       @base_config = @config if !@config.nil? && @mode == 'local'
@@ -61,8 +75,8 @@ module PmdTester
           single: Set this option to 'single' if your patch branch contains changes
             for any option that can't work on master/base branch
           online: Set this option to 'online' if you want to download
-            'the PMD report of master/base branch rather than generating it locally
-          local: Default option is 'local'
+            the PMD report of master/base branch rather than generating it locally
+          local: Default option is 'local', PMD reports for the base and patch branches are generated locally.
       DOC
 
       Slop.parse argv do |o|
@@ -70,19 +84,31 @@ module PmdTester
         o.string '-b', '--base-branch', 'name of the base branch in local PMD repository'
         o.string '-p', '--patch-branch',
                  'name of the patch branch in local PMD repository'
-        o.string '-bc', '--base-config', 'path to the base PMD configuration file'
-        o.string '-pc', '--patch-config', 'path to the patch PMD configuration file'
+        o.string '-bc', '--base-config', 'path to the base PMD configuration file',
+                 default: DEFAULT_CONFIG_PATH
+        o.string '-pc', '--patch-config', 'path to the patch PMD configuration file',
+                 default: DEFAULT_CONFIG_PATH
         o.string '-c', '--config', 'path to the base and patch PMD configuration file'
         o.string '-l', '--list-of-project',
-                 'path to the file which contains the list of standard projects'
+                 'path to the file which contains the list of standard projects',
+                 default: DEFAULT_LIST_PATH
         o.string '-m', '--mode', mode_message, default: 'local'
+        o.integer '-t', '--threads', 'Sets the number of threads used by PMD.' \
+              ' Set threads to 0 to disable multi-threading processing.', default: 1
         o.bool '-f', '--html-flag',
                'whether to not generate the html diff report in single mode'
         o.bool '-a', '--auto-gen-config',
                'whether to generate configurations automatically based on branch differences,' \
                'this option only works in online and local mode'
+        o.bool '--keep-reports',
+               'whether to keep old reports and skip running PMD again if possible'
         o.bool '-d', '--debug',
                'whether change log level to DEBUG to see more information'
+        o.bool '--error-recovery',
+               'enable error recovery mode when executing PMD. Might help to analyze errors.'
+        o.string '--baseline-download-url',
+                 'download url prefix from where to download the baseline in online mode',
+                 default: DEFAULT_BASELINE_URL_PREFIX
         o.on '-v', '--version' do
           puts VERSION
           exit
@@ -113,20 +139,17 @@ module PmdTester
     def check_local_options
       check_option(LOCAL, 'base branch name', @base_branch)
       check_option(LOCAL, 'base branch config path', @base_config) unless @auto_config_flag
-      check_option(LOCAL, 'patch branch name', @patch_branch)
       check_option(LOCAL, 'patch branch config path', @patch_config) unless @auto_config_flag
       check_option(LOCAL, 'list of projects file path', @project_list)
     end
 
     def check_single_options
-      check_option(SINGLE, 'patch branch name', @patch_branch)
       check_option(SINGLE, 'patch branch config path', @patch_config)
       check_option(SINGLE, 'list of projects file path', @project_list)
     end
 
     def check_online_options
       check_option(ONLINE, 'base branch name', @base_branch)
-      check_option(ONLINE, 'patch branch name', @patch_branch)
     end
 
     def check_common_options

data/lib/pmdtester/parsers/pmd_report_document.rb

@@ -1,82 +1,132 @@
 # frozen_string_literal: true
 
 require 'nokogiri'
-require_relative '../pmd_violation'
-require_relative '../pmd_error'
 module PmdTester
   # This class is used for registering types of events you are interested in handling.
   # Also see: https://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/SAX/Document
   class PmdReportDocument < Nokogiri::XML::SAX::Document
     attr_reader :violations
     attr_reader :errors
+    attr_reader :configerrors
+    attr_reader :infos_by_rules
+
     def initialize(branch_name, working_dir, filter_set = nil)
-      @violations = PmdViolations.new
-      @errors = PmdErrors.new
+      @violations = CollectionByFile.new
+      @errors = CollectionByFile.new
+      @configerrors = Hash.new { |hash, key| hash[key] = [] }
+
+      @infos_by_rules = {}
       @current_violations = []
       @current_violation = nil
       @current_error = nil
-      @current_element = ''
-      @filename = ''
+      @current_configerror = nil
       @filter_set = filter_set
       @working_dir = working_dir
       @branch_name = branch_name
+
+      @cur_text = String.new(capacity: 200)
     end
 
     def start_element(name, attrs = [])
       attrs = attrs.to_h
-      @current_element = name
 
       case name
       when 'file'
-        @current_violations = []
-        @current_filename = remove_work_dir!(attrs['name'])
+        handle_start_file attrs
       when 'violation'
-        @current_violation = PmdViolation.new(attrs, @branch_name)
+        handle_start_violation attrs
       when 'error'
-        @current_filename = remove_work_dir!(attrs['filename'])
-        remove_work_dir!(attrs['msg'])
-        @current_error = PmdError.new(attrs, @branch_name)
+        handle_start_error attrs
+      when 'configerror'
+        handle_start_configerror attrs
       end
     end
 
-    def remove_work_dir!(str)
-      str.sub!(/#{@working_dir}/, '')
+    def characters(string)
+      @cur_text << remove_work_dir!(string)
     end
 
-    def characters(string)
-      @current_violation.text = string unless @current_violation.nil?
+    def cdata_block(string)
+      @cur_text << remove_work_dir!(string)
     end
 
     def end_element(name)
       case name
       when 'file'
-        unless @current_violations.empty?
-          @violations.add_violations_by_filename(@current_filename, @current_violations)
-        end
+        @violations.add_all(@current_filename, @current_violations)
         @current_filename = nil
       when 'violation'
-        @current_violations.push(@current_violation) if match_filter_set?(@current_violation)
+        if match_filter_set?(@current_violation)
+          @current_violation.message = finish_text!
+          @current_violations.push(@current_violation)
+        end
         @current_violation = nil
       when 'error'
-        @errors.add_error_by_filename(@current_filename, @current_error)
+        @current_error.stack_trace = finish_text!
+        @errors.add_all(@current_filename, [@current_error])
         @current_filename = nil
         @current_error = nil
+      when 'configerror'
+        @configerrors[@current_configerror.rulename].push(@current_configerror)
+        @current_configerror = nil
       end
+      @cur_text.clear
     end
 
-    def cdata_block(string)
-      remove_work_dir!(string)
-      @current_error.text = string unless @current_error.nil?
+    private
+
+    # Modifies the string in place and returns it
+    # (this is what sub! does, except it returns nil if no replacement occurred)
+    def remove_work_dir!(str)
+      str.sub!(/#{@working_dir}/, '')
+      str
+    end
+
+    def finish_text!
+      res = @cur_text.strip!.dup.freeze
+      @cur_text.clear
+      res
     end
 
     def match_filter_set?(violation)
       return true if @filter_set.nil?
 
-      @filter_set.each do |ruleset|
-        return true if ruleset.eql?(violation.attrs['ruleset'].delete(' ').downcase)
-      end
+      ruleset_attr = violation.ruleset_name.delete(' ').downcase! << '.xml'
+      return true if @filter_set.include?(ruleset_attr)
+
+      rule_ref = "#{ruleset_attr}/#{violation.rule_name}"
+
+      @filter_set.include?(rule_ref)
+    end
+
+    def handle_start_file(attrs)
+      @current_filename = remove_work_dir!(attrs['name'])
+      @current_violations = []
+    end
+
+    def handle_start_violation(attrs)
+      @current_violation = PmdViolation.new(
+        branch: @branch_name,
+        fname: @current_filename,
+        info_url: attrs['externalInfoUrl'],
+        bline: attrs['beginline'].to_i,
+        rule_name: attrs['rule'],
+        ruleset_name: attrs['ruleset'].freeze
+      )
+    end
+
+    def handle_start_error(attrs)
+      @current_filename = remove_work_dir!(attrs['filename'])
+
+      @current_error = PmdError.new(
+        branch: @branch_name,
+        filename: @current_filename,
+        short_message: remove_work_dir!(attrs['msg'])
+      )
+    end
 
-      false
+    def handle_start_configerror(attrs)
+      @current_configerror = PmdConfigError.new(attrs, @branch_name)
     end
   end
 end