pmdtester 1.0.0.pre.beta2

data/lib/pmdtester/builders/diff_report_builder.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative './html_report_builder'
+
+module PmdTester
+  # Building diff report for a single project
+  class DiffReportBuilder < HtmlReportBuilder
+    include PmdTester
+    NO_DIFFERENCES_MESSAGE = 'No differences found!'
+
+    def build(project)
+      @project = project
+      @report_diff = project.report_diff
+
+      index = File.new(project.diff_report_index_path, 'w')
+
+      html_report = build_html_report('pmd xml difference report')
+      copy_css(project.target_diff_report_path)
+
+      index.puts html_report
+      index.close
+
+      logger.info "Built difference report of #{project.name} successfully!"
+    end
+
+    def build_body(doc)
+      violation_diffs = @report_diff.violation_diffs
+      error_diffs = @report_diff.error_diffs
+      doc.body(class: 'composite') do
+        doc.div(id: 'contentBox') do
+          build_summary_section(doc)
+          build_violations_section(doc, violation_diffs)
+          build_errors_section(doc, error_diffs)
+        end
+      end
+    end
+
+    def build_summary_section(doc)
+      doc.div(class: 'section', id: 'Summary') do
+        doc.h2 'Summary:'
+        build_summary_table(doc)
+      end
+    end
+
+    def build_summary_table(doc)
+      doc.table(class: 'bodyTable', border: '0') do
+        doc.thead do
+          doc.tr do
+            doc.th 'Item'
+            doc.th 'Base'
+            doc.th 'Patch'
+            doc.th 'Difference'
+          end
+        end
+
+        build_summary_table_body(doc)
+      end
+    end
+
+    def build_summary_table_body(doc)
+      doc.tbody do
+        build_summary_row(doc, 'number of errors', @report_diff.base_errors_size,
+                          @report_diff.patch_errors_size, @report_diff.error_diffs_size)
+        build_summary_row(doc, 'number of violations', @report_diff.base_violations_size,
+                          @report_diff.patch_violations_size, @report_diff.violation_diffs_size)
+        build_summary_row(doc, 'execution time', @report_diff.base_execution_time,
+                          @report_diff.patch_execution_time, @report_diff.diff_execution_time)
+        build_summary_row(doc, 'timestamp', @report_diff.base_timestamp,
+                          @report_diff.patch_timestamp, '')
+      end
+    end
+
+    def build_summary_row(doc, item, base, patch, diff)
+      doc.tr do
+        doc.td(class: 'c') { doc.text item }
+        doc.td(class: 'a') { doc.text base }
+        doc.td(class: 'b') { doc.text patch }
+        doc.td(class: 'c') { doc.text diff }
+      end
+    end
+
+    def build_filename_h3(doc, filename)
+      doc.h3 do
+        doc.a(href: @project.get_webview_url(filename)) do
+          doc.text @project.get_path_inside_project(filename)
+        end
+      end
+    end
+
+    def build_violations_section(doc, violation_diffs)
+      doc.div(class: 'section', id: 'Violations') do
+        doc.h2 'Violations:'
+
+        doc.h3 NO_DIFFERENCES_MESSAGE if violation_diffs.empty?
+        violation_diffs.each do |key, value|
+          doc.div(class: 'section') do
+            build_filename_h3(doc, key)
+            build_violation_table(doc, key, value)
+          end
+        end
+      end
+    end
+
+    def build_violation_table(doc, key, value)
+      doc.table(class: 'bodyTable', border: '0') do
+        build_violation_table_head(doc)
+        build_violation_table_body(doc, key, value)
+      end
+    end
+
+    def build_violation_table_head(doc)
+      doc.thead do
+        doc.tr do
+          doc.th
+          doc.th 'priority'
+          doc.th 'Rule'
+          doc.th 'Message'
+          doc.th 'Line'
+        end
+      end
+    end
+
+    def build_violation_table_body(doc, key, value)
+      doc.tbody do
+        a_index = 1
+        value.each do |pmd_violation|
+          build_violation_table_row(doc, key, pmd_violation, a_index)
+          a_index += 1
+        end
+      end
+    end
+
+    def build_violation_table_row(doc, key, pmd_violation, a_index)
+      doc.tr(class: pmd_violation.branch == 'base' ? 'a' : 'b') do
+        # The anchor
+        doc.td do
+          doc.a(id: "A#{a_index}", href: "#A#{a_index}") { doc.text '#' }
+        end
+
+        violation = pmd_violation.attrs
+
+        # The priority of the rule
+        doc.td violation['priority']
+
+        # The rule that trigger the violation
+        doc.td do
+          doc.a(href: (violation['externalInfoUrl']).to_s) { doc.text violation['rule'] }
+        end
+
+        # The violation message
+        doc.td pmd_violation.text
+
+        # The begin line of the violation
+        line = violation['beginline']
+
+        # The link to the source file
+        doc.td do
+          link = get_link_to_source(violation, key)
+          doc.a(href: link.to_s) { doc.text line }
+        end
+      end
+    end
+
+    def get_link_to_source(violation, key)
+      l_str = @project.type == 'git' ? 'L' : 'l'
+      line_str = "##{l_str}#{violation['beginline']}"
+      @project.get_webview_url(key) + line_str
+    end
+
+    def build_errors_section(doc, error_diffs)
+      doc.div(class: 'section', id: 'Errors') do
+        doc.h2 do
+          doc.text 'Errors:'
+        end
+
+        doc.h3 NO_DIFFERENCES_MESSAGE if error_diffs.empty?
+        error_diffs.each do |key, value|
+          doc.div(class: 'section') do
+            build_filename_h3(doc, key)
+            build_errors_table(doc, value)
+          end
+        end
+      end
+    end
+
+    def build_errors_table(doc, errors)
+      doc.table(class: 'bodyTable', border: '0') do
+        build_errors_table_head(doc)
+        build_errors_table_body(doc, errors)
+      end
+    end
+
+    def build_errors_table_head(doc)
+      doc.thead do
+        doc.tr do
+          doc.th
+          doc.th 'Message'
+          doc.th 'Details'
+        end
+      end
+    end
+
+    def build_errors_table_body(doc, errors)
+      doc.tbody do
+        b_index = 1
+        errors.each do |pmd_error|
+          doc.tr(class: pmd_error.branch == 'base' ? 'a' : 'b') do
+            # The anchor
+            doc.td do
+              doc.a(id: "B#{b_index}", href: "#B#{b_index}") { doc.text '#' }
+            end
+
+            # The error message
+            doc.td pmd_error.msg
+
+            # Details of error
+            doc.td pmd_error.text
+
+            b_index += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pmdtester/builders/html_report_builder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../resource_locator'
+module PmdTester
+  # This class is the parent of all classes which is used to build html report
+  class HtmlReportBuilder
+    CSS_SRC_DIR = ResourceLocator.locate('resources/css')
+
+    def build_html_report(title_name)
+      html_builder = Nokogiri::HTML::Builder.new do |doc|
+        doc.html do
+          build_head(doc, title_name)
+          build_body(doc)
+        end
+      end
+      html_builder.to_html
+    end
+
+    def build_head(doc, title_name)
+      doc.head do
+        doc.title title_name
+
+        doc.style(type: 'text/css', media: 'all') do
+          doc.text '@import url("./css/maven-base.css");@import url("./css/maven-theme.css");'
+        end
+      end
+    end
+
+    def copy_css(report_dir)
+      css_dest_dir = "#{report_dir}/css"
+      FileUtils.copy_entry(CSS_SRC_DIR, css_dest_dir)
+    end
+  end
+end

data/lib/pmdtester/builders/pmd_report_builder.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../cmd'
+require_relative '../project'
+require_relative '../pmd_branch_detail'
+require_relative '../pmd_report_detail'
+
+module PmdTester
+  # Building pmd xml reports according to a list of standard
+  # projects and branch of pmd source code
+  class PmdReportBuilder
+    include PmdTester
+    def initialize(branch_config, projects, local_git_repo, pmd_branch_name)
+      @branch_config = branch_config
+      @projects = projects
+      @local_git_repo = local_git_repo
+      @pmd_branch_name = pmd_branch_name
+      @pwd = Dir.getwd
+
+      @pmd_branch_details = PmdBranchDetail.new(pmd_branch_name)
+    end
+
+    def execute_reset_cmd(type, tag)
+      case type
+      when 'git'
+        reset_cmd = "git reset --hard #{tag}"
+      when 'hg'
+        reset_cmd = "hg up #{tag}"
+      end
+
+      Cmd.execute(reset_cmd)
+    end
+
+    def get_projects
+      logger.info 'Cloning projects started'
+
+      @projects.each do |project|
+        logger.info "Start cloning #{project.name} repository"
+        path = project.local_source_path
+        clone_cmd = "#{project.type} clone #{project.connection} #{path}"
+        if File.exist?(path)
+          logger.warn "Skipping clone, project path #{path} already exists"
+        else
+          Cmd.execute(clone_cmd)
+        end
+
+        Dir.chdir(path) do
+          execute_reset_cmd(project.type, project.tag)
+        end
+        logger.info "Cloning #{project.name} completed"
+      end
+    end
+
+    def get_pmd_binary_file
+      logger.info 'Start packaging PMD'
+      Dir.chdir(@local_git_repo) do
+        checkout_cmd = "git checkout #{@pmd_branch_name}"
+        Cmd.execute(checkout_cmd)
+
+        @pmd_branch_details.branch_last_sha = get_last_commit_sha
+        @pmd_branch_details.branch_last_message = get_last_commit_message
+
+        package_cmd = './mvnw clean package -Dpmd.skip=true -Dmaven.test.skip=true' \
+                      ' -Dmaven.checkstyle.skip=true -Dmaven.javadoc.skip=true'
+        Cmd.execute(package_cmd)
+
+        version_cmd = "./mvnw -q -Dexec.executable=\"echo\" -Dexec.args='${project.version}' " \
+                      '--non-recursive org.codehaus.mojo:exec-maven-plugin:1.5.0:exec'
+        @pmd_version = Cmd.execute(version_cmd)
+
+        unzip_cmd = "unzip -qo pmd-dist/target/pmd-bin-#{@pmd_version}.zip -d #{@pwd}/target"
+        Cmd.execute(unzip_cmd)
+      end
+      logger.info 'Packaging PMD completed'
+    end
+
+    def get_last_commit_sha
+      get_last_commit_sha_cmd = 'git rev-parse HEAD'
+      Cmd.execute(get_last_commit_sha_cmd)
+    end
+
+    def get_last_commit_message
+      get_last_commit_message_cmd = 'git log -1 --pretty=%B'
+      Cmd.execute(get_last_commit_message_cmd)
+    end
+
+    def generate_pmd_report(src_root_dir, report_file)
+      run_path = "target/pmd-bin-#{@pmd_version}/bin/run.sh"
+      pmd_cmd = "#{run_path} pmd -d #{src_root_dir} -f xml -R #{@branch_config} " \
+                "-r #{report_file} -failOnViolation false"
+      start_time = Time.now
+      Cmd.execute(pmd_cmd)
+      end_time = Time.now
+      [end_time - start_time, end_time]
+    end
+
+    def generate_pmd_reports
+      logger.info "Generating PMD report started -- branch #{@pmd_branch_name}"
+      get_pmd_binary_file
+
+      sum_time = 0
+      @projects.each do |project|
+        logger.info "Generating #{project.name}'s PMD report'"
+        execution_time, end_time =
+          generate_pmd_report(project.local_source_path,
+                              project.get_pmd_report_path(@pmd_branch_name))
+        sum_time += execution_time
+
+        report_details = PmdReportDetail.new
+        report_details.execution_time = execution_time
+        report_details.timestamp = end_time
+        report_details.save(project.get_report_info_path(@pmd_branch_name))
+        logger.info "#{project.name}'s PMD report was generated successfully"
+      end
+
+      @pmd_branch_details.execution_time = sum_time
+      @pmd_branch_details.save
+      FileUtils.cp(@branch_config, @pmd_branch_details.target_branch_config_path)
+      @pmd_branch_details
+    end
+
+    def build
+      get_projects
+      generate_pmd_reports
+    end
+  end
+end

data/lib/pmdtester/builders/rule_set_builder.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'set'
+require_relative '../cmd'
+require_relative '../resource_locator'
+
+module PmdTester
+  # This class is responsible for generation dynamic configuration
+  # according to the difference between base and patch branch of Pmd.
+  # Attention: we only consider java rulesets now.
+  class RuleSetBuilder
+    include PmdTester
+    ALL_RULE_SETS = Set['bestpractices', 'codestyle', 'design', 'documentation',
+                        'errorprone', 'multithreading', 'performance', 'security'].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'
+    PATH_TO_ALL_JAVA_RULES =
+      ResourceLocator.locate('config/all-java.xml')
+    PATH_TO_DYNAMIC_CONFIG = 'target/dynamic-config.xml'
+    NO_JAVA_RULES_CHANGED_MESSAGE = 'No java rules have been changed!'
+
+    def initialize(options)
+      @options = options
+    end
+
+    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]}"
+    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
+      else
+        @options.filter_set = rule_sets
+      end
+    end
+
+    def diff_filenames
+      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} -- pmd/core pmd/java"
+        filenames = Cmd.execute(diff_cmd)
+      end
+      filenames.split("\n")
+    end
+
+    def get_rule_sets(filenames)
+      rule_sets = 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)
+        end
+
+        category = if match_data.nil?
+                     nil
+                   else
+                     match_data[1]
+                   end
+
+        if category.nil?
+          rule_sets = ALL_RULE_SETS
+          break
+        else
+          rule_sets.add(category)
+        end
+      end
+      rule_sets
+    end
+
+    def build_config_file(rule_sets)
+      if rule_sets.empty?
+        puts NO_JAVA_RULES_CHANGED_MESSAGE
+        exit 0
+      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)
+      end
+
+      description = doc.at_css('description')
+      description.content = 'The ruleset generated by PmdTester dynamically'
+
+      write_dynamic_file(doc)
+    end
+
+    def match_ref?(rule_node, rule_sets)
+      rule_sets.each do |rule_set|
+        return true unless rule_node['ref'].index(rule_set).nil?
+      end
+
+      false
+    end
+
+    def write_dynamic_file(doc)
+      File.open(PATH_TO_DYNAMIC_CONFIG, 'w') do |x|
+        x << doc.to_s.gsub(/\n\s+\n/, "\n")
+      end
+      @options.base_config = PATH_TO_DYNAMIC_CONFIG
+      @options.patch_config = PATH_TO_DYNAMIC_CONFIG
+    end
+  end
+end

data/lib/pmdtester/builders/summary_report_builder.rb

@@ -0,0 +1,149 @@
+# 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
+    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
+
+    def build_body(doc)
+      build_branch_details_section(doc)
+      build_projects_section(doc)
+    end
+
+    def build_branch_details_section(doc)
+      doc.div(class: 'section', id: 'branchdetails') do
+        doc.h2 'Branch details:'
+        build_branch_details_table(doc)
+      end
+    end
+
+    def build_branch_details_table(doc)
+      doc.table(class: 'bodyTable', border: '0') do
+        build_branch_table_head(doc)
+        build_branch_table_body(doc)
+      end
+    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
+
+    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
+    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
+    end
+
+    def copy_branch_config_file(src, dest)
+      FileUtils.cp(src, dest) if File.exist?(src)
+    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
+    end
+
+    def build_projects_section(doc)
+      doc.div(class: 'section', id: 'projects') do
+        doc.h2 'Projects:'
+        build_projects_table(doc)
+      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
+    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
+    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
+    end
+  end
+end

data/lib/pmdtester/cmd.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module PmdTester
+  # Containing the common method for executing shell command
+  class Cmd
+    extend PmdTester
+    def self.execute(cmd)
+      logger.debug "execute command '#{cmd}'"
+
+      stdout, stderr, status = Open3.capture3("#{cmd};")
+
+      logger.debug stdout
+      unless status.success?
+        logger.error stderr
+        raise CmdException.new(cmd, stderr)
+      end
+
+      stdout&.chomp!
+
+      stdout
+    end
+  end
+
+  # The exception should be raised when the shell command failed.
+  class CmdException < StandardError
+    attr_reader :cmd
+    attr_reader :error
+    attr_reader :message
+
+    COMMON_MSG = 'An error occurred while executing the shell command'
+
+    def initialize(cmd, error)
+      @cmd = cmd
+      @error = error
+      @message = "#{COMMON_MSG} '#{cmd}'"
+    end
+  end
+end