pmdtester 1.0.0 → 1.2.0

data/lib/pmdtester/builders/pmd_report_builder.rb

@@ -8,92 +8,74 @@ module PmdTester
   # projects and branch of pmd source code
   class PmdReportBuilder
     include PmdTester
-    def initialize(branch_config, projects, local_git_repo, pmd_branch_name, threads = 1)
-      @branch_config = branch_config
+
+    def initialize(projects, options, branch_config, branch_name)
       @projects = projects
-      @local_git_repo = local_git_repo
-      @pmd_branch_name = pmd_branch_name
-      @threads = threads
+      @local_git_repo = options.local_git_repo
+      @threads = options.threads
+      @error_recovery = options.error_recovery
+      @branch_config = branch_config
+      @pmd_branch_name = 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 clone_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
-
-      logger.info 'Cloning projects completed'
+      @pmd_branch_details = PmdBranchDetail.new(@pmd_branch_name)
+      @project_builder = ProjectBuilder.new(@projects)
     end
 
     def get_pmd_binary_file
       logger.info "#{@pmd_branch_name}: Start packaging PMD"
       Dir.chdir(@local_git_repo) do
-        current_head_sha = Cmd.execute('git rev-parse HEAD')
-        current_branch_sha = Cmd.execute("git rev-parse #{@pmd_branch_name}")
+        build_branch_sha = Cmd.execute("git rev-parse #{@pmd_branch_name}^{commit}")
+
+        checkout_build_branch # needs a clean working tree, otherwise fails
 
-        @pmd_version = determine_pmd_version
+        raise "Wrong branch #{get_last_commit_sha}" unless build_branch_sha == get_last_commit_sha
 
-        # in case we are already on the correct branch
-        # and a binary zip already exists...
-        if current_head_sha == current_branch_sha &&
-           File.exist?("pmd-dist/target/pmd-bin-#{@pmd_version}.zip")
-          logger.warn "#{@pmd_branch_name}: Skipping packaging - zip for " \
-                      "#{@pmd_version} already exists"
+        distro_path = saved_distro_path(build_branch_sha)
+        logger.debug "#{@pmd_branch_name}: PMD Version is #{@pmd_version} " \
+                     "(sha=#{build_branch_sha})"
+        logger.debug "#{@pmd_branch_name}: distro_path=#{distro_path}"
+        if File.directory?(distro_path)
+          logger.info "#{@pmd_branch_name}: Skipping packaging - saved version exists " \
+                      " in #{distro_path}"
         else
-          build_pmd
+          build_pmd(into_dir: distro_path)
         end
 
-        @pmd_branch_details.branch_last_sha = get_last_commit_sha
+        # we're still on the build branch
+        @pmd_branch_details.branch_last_sha = build_branch_sha
         @pmd_branch_details.branch_last_message = get_last_commit_message
-
-        logger.info "#{@pmd_branch_name}: Extracting the zip"
-        unzip_cmd = "unzip -qo pmd-dist/target/pmd-bin-#{@pmd_version}.zip -d #{@pwd}/target"
-        Cmd.execute(unzip_cmd)
       end
       logger.info "#{@pmd_branch_name}: Packaging PMD completed"
     end
 
-    def build_pmd
-      logger.info "#{@pmd_branch_name}: Checking out the branch"
-      checkout_cmd = "git checkout #{@pmd_branch_name}"
-      Cmd.execute(checkout_cmd)
-
-      # determine the version again - it might be different in the other branch
-      @pmd_version = determine_pmd_version
+    # builds pmd on currently checked out branch
+    def build_pmd(into_dir:)
+      # in CI there might have been a build performed already. In that case
+      # we reuse the build result, otherwise we build PMD freshly
+      pmd_dist_target = "pmd-dist/target/pmd-bin-#{@pmd_version}.zip"
+      binary_exists = File.exist?(pmd_dist_target)
+      logger.debug "#{@pmd_branch_name}: Does the file #{pmd_dist_target} exist? #{binary_exists} (cwd: #{Dir.getwd})"
+      if binary_exists
+        # that's a warning, because we don't know, whether this build really
+        # belongs to the current branch or whether it's from a previous branch.
+        # In CI, that's not a problem, because the workspace is always fresh.
+        logger.warn "#{@pmd_branch_name}: Reusing already existing #{pmd_dist_target}"
+      else
+        logger.info "#{@pmd_branch_name}: Building PMD #{@pmd_version}..."
+        package_cmd = './mvnw clean package' \
+                      ' -Dmaven.test.skip=true' \
+                      ' -Dmaven.javadoc.skip=true' \
+                      ' -Dmaven.source.skip=true' \
+                      ' -Dcheckstyle.skip=true' \
+                      ' -Dpmd.skip=true' \
+                      ' -T1C -B'
+        Cmd.execute(package_cmd)
+      end
 
-      logger.info "#{@pmd_branch_name}: Building PMD #{@pmd_version}..."
-      package_cmd = './mvnw clean package' \
-                    ' -Dmaven.test.skip=true' \
-                    ' -Dmaven.javadoc.skip=true' \
-                    ' -Dmaven.source.skip=true'
-      Cmd.execute(package_cmd)
+      logger.info "#{@pmd_branch_name}: Extracting the zip"
+      Cmd.execute("unzip -qo #{pmd_dist_target} -d pmd-dist/target/exploded")
+      Cmd.execute("mv pmd-dist/target/exploded/pmd-bin-#{@pmd_version} #{into_dir}")
     end
 
     def determine_pmd_version
@@ -103,7 +85,7 @@ module PmdTester
     end
 
     def get_last_commit_sha
-      get_last_commit_sha_cmd = 'git rev-parse HEAD'
+      get_last_commit_sha_cmd = 'git rev-parse HEAD^{commit}'
       Cmd.execute(get_last_commit_sha_cmd)
     end
 
@@ -113,27 +95,39 @@ module PmdTester
     end
 
     def generate_pmd_report(project)
-      run_path = "target/pmd-bin-#{@pmd_version}/bin/run.sh"
-      pmd_cmd = "#{run_path} pmd -d #{project.local_source_path} -f xml " \
+      error_recovery_options = @error_recovery ? 'PMD_JAVA_OPTS="-Dpmd.error_recovery -ea" ' : ''
+      run_path = "#{saved_distro_path(@pmd_branch_details.branch_last_sha)}/bin/run.sh"
+      pmd_cmd = "#{error_recovery_options}" \
+                "#{run_path} pmd -d #{project.local_source_path} -f xml " \
                 "-R #{project.get_config_path(@pmd_branch_name)} " \
                 "-r #{project.get_pmd_report_path(@pmd_branch_name)} " \
-                "-failOnViolation false -t #{@threads}"
+                "-failOnViolation false -t #{@threads} " \
+                "#{project.auxclasspath}"
       start_time = Time.now
-      Cmd.execute(pmd_cmd)
+      if File.exist?(project.get_pmd_report_path(@pmd_branch_name))
+        logger.warn "#{@pmd_branch_name}: Skipping PMD run - report " \
+                    "#{project.get_pmd_report_path(@pmd_branch_name)} already exists"
+      else
+        Cmd.execute(pmd_cmd)
+      end
       end_time = Time.now
       [end_time - start_time, end_time]
     end
 
     def generate_config_for(project)
+      logger.debug "Generating ruleset with excludes from #{@branch_config}"
       doc = Nokogiri::XML(File.read(@branch_config))
       ruleset = doc.at_css('ruleset')
-      project.exclude_pattern.each do |exclude_pattern|
-        ruleset.add_child("<exclude-pattern>#{exclude_pattern}</exclude-pattern>")
+      ruleset.add_child("\n")
+      project.exclude_patterns.each do |exclude_pattern|
+        ruleset.add_child("    <exclude-pattern>#{exclude_pattern}</exclude-pattern>\n")
       end
 
       File.open(project.get_config_path(@pmd_branch_name), 'w') do |x|
         x << doc.to_s
       end
+
+      logger.debug "Created file #{project.get_config_path(@pmd_branch_name)}"
     end
 
     def generate_pmd_reports
@@ -141,16 +135,14 @@ module PmdTester
 
       sum_time = 0
       @projects.each do |project|
-        progress_logger = SimpleProgressLogger.new(project.name)
+        progress_logger = SimpleProgressLogger.new("generating #{project.name}'s PMD report")
         progress_logger.start
         generate_config_for(project)
         execution_time, end_time = generate_pmd_report(project)
         progress_logger.stop
         sum_time += execution_time
 
-        report_details = PmdReportDetail.new
-        report_details.execution_time = execution_time
-        report_details.timestamp = end_time
+        report_details = PmdReportDetail.new(execution_time: execution_time, 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
@@ -161,10 +153,46 @@ module PmdTester
       @pmd_branch_details
     end
 
+    # returns the branch details
     def build
-      clone_projects
+      @project_builder.clone_projects
+      @project_builder.build_projects
       get_pmd_binary_file
       generate_pmd_reports
     end
+
+    private
+
+    def checkout_build_branch
+      logger.info "#{@pmd_branch_name}: Checking out the branch"
+      # note that this would fail if the tree is dirty
+      Cmd.execute("git checkout #{@pmd_branch_name}")
+
+      # determine the version
+      @pmd_version = determine_pmd_version
+
+      return unless wd_has_dirty_git_changes
+
+      # working dir is dirty....
+      # we don't allow this because we need the SHA to address the zip file
+      logger.error "#{@pmd_branch_name}: Won\'t build without a clean working tree, " \
+                   'commit your changes'
+    end
+
+    def work_dir
+      "#{@pwd}/target"
+    end
+
+    # path to the unzipped distribution
+    # e.g. <cwd>/pmd-bin-<version>-<branch>-<sha>
+    def saved_distro_path(build_sha)
+      "#{work_dir}/pmd-bin-#{@pmd_version}" \
+      "-#{PmdBranchDetail.branch_filename(@pmd_branch_name)}" \
+      "-#{build_sha}"
+    end
+
+    def wd_has_dirty_git_changes
+      !Cmd.execute('git status --porcelain').empty?
+    end
   end
 end

data/lib/pmdtester/builders/project_builder.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tempfile'
+
+module PmdTester
+  # Clones and builds the projects, that are configured in the project-list.xml
+  class ProjectBuilder
+    include PmdTester
+
+    def initialize(projects)
+      @projects = projects
+    end
+
+    def clone_projects
+      logger.info 'Cloning projects started'
+
+      @projects.each do |project|
+        logger.info "Start cloning #{project.name} repository"
+        path = project.clone_root_path
+
+        if File.exist?(path)
+          logger.warn "Skipping clone, project path #{path} already exists"
+        else
+          raise "Unsupported project type '#{project.type}' - only git is supported" unless project.type == 'git'
+
+          # git:
+          # Don't download whole history
+          # Note we don't use --single-branch, because the repo is downloaded
+          # once but may be used with several tags.
+          clone_cmd = "git clone --no-single-branch --depth 1 #{project.connection} #{path}"
+
+          Cmd.execute(clone_cmd)
+        end
+
+        Dir.chdir(path) do
+          execute_reset_cmd(project.type, project.tag)
+        end
+        logger.info "Cloning #{project.name} completed"
+      end
+
+      logger.info 'Cloning projects completed'
+    end
+
+    def build_projects
+      logger.info 'Building projects started'
+
+      @projects.each do |project|
+        path = project.clone_root_path
+        Dir.chdir(path) do
+          progress_logger = SimpleProgressLogger.new("building #{project.name} in #{path}")
+          progress_logger.start
+          prepare_project(project)
+          progress_logger.stop
+        end
+        logger.info "Building #{project.name} completed"
+      end
+
+      logger.info 'Building projects completed'
+    end
+
+    private
+
+    def prepare_project(project)
+      # Note: current working directory is the project directory,
+      # where the source code has been cloned to
+      if project.build_command
+        logger.debug "Executing build-command: #{project.build_command}"
+        run_as_script(Dir.getwd, project.build_command)
+      end
+      if project.auxclasspath_command
+        logger.debug "Executing auxclasspath-command: #{project.auxclasspath_command}"
+        auxclasspath = run_as_script(Dir.getwd, project.auxclasspath_command)
+        project.auxclasspath = "-auxclasspath #{auxclasspath}"
+      else
+        project.auxclasspath = ''
+      end
+    end
+
+    def run_as_script(path, command)
+      script = Tempfile.new(['pmd-regression-', '.sh'], path)
+      logger.debug "Creating script #{script.path}"
+      begin
+        script.write(command)
+        script.close
+        shell = 'sh -xe'
+        if command.start_with?('#!')
+          shell = command.lines[0].chomp[2..] # remove leading "#!"
+        end
+        stdout = Cmd.execute("#{shell} #{script.path}")
+      ensure
+        script.unlink
+      end
+      stdout
+    end
+
+    def execute_reset_cmd(type, tag)
+      raise "Unsupported project type '#{type}' - only git is supported" unless type == 'git'
+
+      reset_cmd = "git checkout #{tag}; git reset --hard #{tag}"
+
+      Cmd.execute(reset_cmd)
+    end
+  end
+end

data/lib/pmdtester/builders/project_hasher.rb

@@ -0,0 +1,128 @@
+# 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.transform_keys(&:to_s),
+        'error_counts' => rdiff.error_counts.to_h.transform_keys(&:to_s),
+        'configerror_counts' => rdiff.configerror_counts.to_h.transform_keys(&:to_s),
+
+        '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 violations_to_hash(project, violations_by_file, is_diff)
+      filename_index = []
+      all_vs = []
+      violations_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, is_diff))
+        end
+      end
+
+      {
+        'file_index' => filename_index,
+        'violations' => all_vs
+      }
+    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 link_template(project)
+      l_str = project.type == 'git' ? 'L' : 'l'
+      "#{project.webview_url}/{file}##{l_str}{line}"
+    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
+
+    private
+
+    def violation_type(violation)
+      if violation.changed?
+        '~'
+      elsif violation.branch == PATCH
+        '+'
+      else
+        '-'
+      end
+    end
+
+    def make_violation_hash(file_ref, violation, is_diff = TRUE)
+      h = {
+        't' => is_diff ? violation_type(violation) : '+',
+        'l' => violation.line,
+        'f' => file_ref,
+        'r' => violation.rule_name,
+        'm' => is_diff && violation.changed? ? diff_fragments(violation) : violation.message
+      }
+      h['ol'] = violation.old_line if is_diff && 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
+  end
+end