pmdtester 1.0.0.pre.beta2 → 1.1.1

data/lib/pmdtester/builders/project_builder.rb

@@ -0,0 +1,100 @@
+# 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.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'
+    end
+
+    def build_projects
+      logger.info 'Building projects started'
+
+      @projects.each do |project|
+        path = project.local_source_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)
+      case type
+      when 'git'
+        reset_cmd = "git checkout #{tag}; git reset --hard #{tag}"
+      when 'hg'
+        reset_cmd = "hg up #{tag}"
+      end
+
+      Cmd.execute(reset_cmd)
+    end
+  end
+end

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.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 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

@@ -2,8 +2,6 @@
 
 require 'nokogiri'
 require 'set'
-require_relative '../cmd'
-require_relative '../resource_locator'
 
 module PmdTester
   # This class is responsible for generation dynamic configuration
@@ -11,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'
@@ -27,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
 
@@ -48,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 build_config_file(rule_sets)
-      if rule_sets.empty?
-        puts NO_JAVA_RULES_CHANGED_MESSAGE
-        exit 0
-      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
 
-      doc = Nokogiri::XML(File.read(PATH_TO_ALL_JAVA_RULES))
-      doc.search('rule').each do |rule|
-        rule.remove unless match_ref?(rule, rule_sets)
+    def build_config_file(rule_refs)
+      if rule_refs.empty?
+        logger.info NO_JAVA_RULES_CHANGED_MESSAGE
+        return
       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?
+      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
 
-      false
+      write_dynamic_file(rule_refs)
     end
 
-    def write_dynamic_file(doc)
+    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
+      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