pmdtester 1.0.1 → 1.1.0

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

@@ -16,6 +16,7 @@ module PmdTester
     SINGLE = 'single'
     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
@@ -30,6 +31,9 @@ module PmdTester
     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)
@@ -46,6 +50,14 @@ module PmdTester
       @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'
@@ -88,8 +100,15 @@ module PmdTester
         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

data/lib/pmdtester/parsers/pmd_report_document.rb

@@ -8,80 +8,125 @@ module PmdTester
     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
-      @configerrors = PmdConfigErrors.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_configerror = nil
-      @current_element = ''
-      @filename = ''
       @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'
-        @current_configerror = PmdConfigError.new(attrs, @branch_name)
+        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
+    def cdata_block(string)
+      @cur_text << remove_work_dir!(string)
     end
 
     def end_element(name)
       case name
       when 'file'
-        @violations.add_violations_by_filename(@current_filename, @current_violations)
+        @violations.add_all(@current_filename, @current_violations)
         @current_filename = nil
       when 'violation'
-        @current_violation.text.strip!
-        @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.add_error(@current_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
+    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

data/lib/pmdtester/parsers/projects_parser.rb

@@ -11,9 +11,7 @@ module PmdTester
       document = Nokogiri::XML(File.read(list_file))
 
       errors = schema.validate(document)
-      unless errors.empty?
-        raise ProjectsParserException.new(errors), "Schema validate failed: In #{list_file}"
-      end
+      raise ProjectsParserException.new(errors), "Schema validate failed: In #{list_file}" unless errors.empty?
 
       projects = []
       document.xpath('//project').each do |project|
@@ -23,7 +21,7 @@ module PmdTester
     end
 
     def schema_file_path
-      ResourceLocator.locate('config/projectlist_1_0_0.xsd')
+      ResourceLocator.locate('config/projectlist_1_1_0.xsd')
     end
   end
 

data/lib/pmdtester/pmd_branch_detail.rb

@@ -12,8 +12,9 @@ module PmdTester
     attr_accessor :branch_name
     # The branch's execution time on all standard projects
     attr_accessor :execution_time
-    attr_reader :jdk_version
-    attr_reader :language
+    attr_accessor :jdk_version
+    attr_accessor :language
+    attr_accessor :pull_request
 
     def self.branch_filename(branch_name)
       branch_name&.tr('/', '_')
@@ -28,24 +29,29 @@ module PmdTester
       @execution_time = 0
       # the result of command 'java -version' is going to stderr
       @jdk_version = Cmd.stderr_of('java -version')
-      @language = ENV['LANG']
+      @language = ENV['LANG'] # the locale
+
+      prnum = ENV[PR_NUM_ENV_VAR]
+      @pull_request = prnum == 'false' ? nil : prnum
     end
 
-    def load
-      if File.exist?(branch_details_path)
-        hash = JSON.parse(File.read(branch_details_path))
-        @branch_last_sha = hash['branch_last_sha']
-        @branch_last_message = hash['branch_last_message']
-        @branch_name = hash['branch_name']
-        @execution_time = hash['execution_time']
-        @jdk_version = hash['jdk_version']
-        @language = hash['language']
+    def self.load(branch_name, logger)
+      details = PmdBranchDetail.new(branch_name)
+      if File.exist?(details.path_to_save_file)
+        hash = JSON.parse(File.read(details.path_to_save_file))
+        details.branch_last_sha = hash['branch_last_sha']
+        details.branch_last_message = hash['branch_last_message']
+        details.branch_name = hash['branch_name']
+        details.execution_time = hash['execution_time']
+        details.jdk_version = hash['jdk_version']
+        details.language = hash['language']
+        details.pull_request = hash['pull_request']
       else
-        @jdk_version = ''
-        @language = ''
-        logger.warn "#{branch_details_path} doesn't exist!"
+        details.jdk_version = ''
+        details.language = ''
+        logger&.warn "#{details.path_to_save_file} doesn't exist!"
       end
-      self
+      details
     end
 
     def save
@@ -54,14 +60,18 @@ module PmdTester
                branch_name: @branch_name,
                execution_time: @execution_time,
                jdk_version: @jdk_version,
-               language: @language }
-      file = File.new(branch_details_path, 'w')
+               language: @language,
+               pull_request: @pull_request }
+
+      FileUtils.mkdir_p(@base_branch_dir) unless File.directory?(@base_branch_dir)
+
+      file = File.new(path_to_save_file, 'w')
       file.puts JSON.generate(hash)
       file.close
       self
     end
 
-    def branch_details_path
+    def path_to_save_file
       "#{@base_branch_dir}/branch_info.json"
     end
 

data/lib/pmdtester/pmd_configerror.rb

@@ -1,28 +1,6 @@
 # frozen_string_literal: true
 
 module PmdTester
-  # This class is used to store pmd config errors and its size.
-  class PmdConfigErrors
-    attr_reader :errors
-    attr_reader :size
-
-    def initialize
-      # key:rulename as String => value:PmdConfigError Array
-      @errors = {}
-      @size = 0
-    end
-
-    def add_error(error)
-      rulename = error.rulename
-      if @errors.key?(rulename)
-        @errors[rulename].push(error)
-      else
-        @errors.store(rulename, [error])
-      end
-      @size += 1
-    end
-  end
-
   # This class represents a 'configerror' element of Pmd xml report
   # and which Pmd branch the 'configerror' is from
   class PmdConfigError
@@ -35,13 +13,13 @@ module PmdTester
     #   <xs:attribute name="msg" type="xs:string" use="required" />
     # </xs:complexType>
     attr_reader :attrs
-    attr_accessor :text
+    attr_accessor :old_error
 
     def initialize(attrs, branch)
       @attrs = attrs
 
+      @changed = false
       @branch = branch
-      @text = ''
     end
 
     def rulename
@@ -52,10 +30,31 @@ module PmdTester
       @attrs['msg']
     end
 
+    def sort_key
+      rulename
+    end
+
+    def changed?
+      @changed
+    end
+
     def eql?(other)
       rulename.eql?(other.rulename) && msg.eql?(other.msg)
     end
 
+    def try_merge?(other)
+      if branch != BASE &&
+         branch != other.branch &&
+         rulename == other.rulename &&
+         !changed? # not already changed
+        @changed = true
+        @old_error = other
+        true
+      end
+
+      false
+    end
+
     def hash
       [rulename, msg].hash
     end

data/lib/pmdtester/pmd_error.rb

@@ -1,30 +1,10 @@
 # frozen_string_literal: true
 
 module PmdTester
-  # This class is used to store pmd errors and its size.
-  class PmdErrors
-    attr_reader :errors
-    attr_reader :errors_size
-
-    def initialize
-      # key:filename as String => value:PmdError Array
-      @errors = {}
-      @errors_size = 0
-    end
-
-    def add_error_by_filename(filename, error)
-      if @errors.key?(filename)
-        @errors[filename].push(error)
-      else
-        @errors.store(filename, [error])
-      end
-      @errors_size += 1
-    end
-  end
-
   # This class represents a 'error' element of Pmd xml report
   # and which Pmd branch the 'error' is from
   class PmdError
+    include PmdTester
     # The pmd branch type, 'base' or 'patch'
     attr_reader :branch
 
@@ -37,31 +17,51 @@ module PmdTester
     #       </xs:extension>
     #     </xs:simpleContent>
     #  </xs:complexType>
-    attr_reader :attrs
-    attr_accessor :text
-
-    def initialize(attrs, branch)
-      @attrs = attrs
+    attr_accessor :stack_trace
+    attr_accessor :old_error
+    attr_reader :filename, :short_message
 
+    def initialize(branch:, filename:, short_message:)
       @branch = branch
-      @text = ''
+      @stack_trace = ''
+      @changed = false
+      @short_message = short_message
+      @filename = filename
     end
 
-    def filename
-      @attrs['filename']
+    def short_filename
+      filename.gsub(%r{([^/]*+/)+}, '')
     end
 
-    def msg
-      @attrs['msg']
+    def changed?
+      @changed
     end
 
     def eql?(other)
-      filename.eql?(other.filename) && msg.eql?(other.msg) &&
-        @text.eql?(other.text)
+      filename.eql?(other.filename) &&
+        short_message.eql?(other.short_message) &&
+        stack_trace.eql?(other.stack_trace)
     end
 
     def hash
-      [filename, msg, @text].hash
+      [filename, stack_trace].hash
+    end
+
+    def sort_key
+      filename
+    end
+
+    def try_merge?(other)
+      if branch != BASE &&
+         branch != other.branch &&
+         filename == other.filename &&
+         !changed? # not already changed
+        @changed = true
+        @old_error = other
+        true
+      else
+        false
+      end
     end
   end
 end