Merge pull request #103 from adangel:auto-gen-config-all

Support other languages besides java #103

Author: adangel

History.md

@@ -4,6 +4,8 @@
 
 ## Enhancements
 
+*   [#103](https://github.com/pmd/pmd-regression-tester/pull/103): Support other languages besides java
+
 ## Fixed Issues
 
 ## External Contributions

Rakefile

@@ -19,18 +19,23 @@ hoe = Hoe.spec 'pmdtester' do
   developer 'Clément Fournier', '[email protected]'
 
   self.clean_globs = %w[target/reports/**/* target/test/**/* target/dynamic-config.xml Gemfile.lock]
-  self.extra_deps += [['nokogiri', '>= 1.11.0.rc4'], ['slop', '~> 4.6'], ['differ', '~> 0.1'],
-                      ['rufus-scheduler', '~> 3.5'], ['logger-colors', '~> 1.0'],
-                      ['liquid', '>= 4.0']]
+  self.extra_deps += [
+    ['nokogiri',        '~> 1.13'],
+    ['slop',            '~> 4.6'],
+    ['differ',          '~> 0.1'],
+    ['rufus-scheduler', '~> 3.8'],
+    ['logger-colors',   '~> 1.0'],
+    ['liquid',          '~> 5.2']
+  ]
   self.extra_dev_deps += [
     ['hoe-bundler',   '~> 1.5'],
     ['hoe-git',       '~> 1.6'],
     ['minitest',      '~> 5.10'],
     ['mocha',         '~> 1.5'],
     # use the same version of rubocop as codacy
-    ['rubocop',       '~> 0.81'],
-    ['test-unit',     '~> 3.2'],
-    ['rdoc',          ['>= 4.0', '< 7']]
+    ['rubocop',       '~> 0.93'],
+    ['test-unit',     '~> 3.5'],
+    ['rdoc',          '~> 6.4']
   ]
   spec_extras[:required_ruby_version] = '>= 2.7'
 

lib/pmdtester/builders/rule_set_builder.rb

@@ -9,73 +9,70 @@ module PmdTester
   # Attention: we only consider java rulesets now.
   class RuleSetBuilder
     include PmdTester
-    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'
-    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!'
+    NO_RULES_CHANGED_MESSAGE = 'No regression tested rules have been changed!'
 
     def initialize(options)
       @options = options
     end
 
-    def build
-      filenames = diff_filenames
-      rule_refs = get_rule_refs(filenames)
-      output_filter_set(rule_refs)
-      build_config_file(rule_refs)
-      logger.debug "Dynamic configuration: #{[rule_refs]}"
-      rule_refs
+    #
+    # Creates a dynamic ruleset based on the changed sources.
+    # Returns true, when rules are affected by the changed sources.
+    # Returns false, when no rules are affected and regression tester can be skipped.
+    #
+    def build?
+      languages = determine_languages
+      filenames = diff_filenames(languages)
+      run_required, rule_refs = get_rule_refs(filenames)
+      if run_required
+        output_filter_set(rule_refs)
+        build_config_file(rule_refs)
+        logger.debug "Dynamic configuration: #{[rule_refs]}"
+      else
+        logger.info NO_RULES_CHANGED_MESSAGE
+      end
+      run_required
     end
 
     def calculate_filter_set
-      output_filter_set(ALL_CATEGORIES)
+      output_filter_set([])
     end
 
     def output_filter_set(rule_refs)
-      if rule_refs == ALL_CATEGORIES
-        if @options.mode == Options::ONLINE
+      if rule_refs.empty?
+        if @options.mode == Options::ONLINE && @options.filter_with_patch_config
           @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/')
+            ref.delete_prefix!('category/')
             @options.filter_set.add(ref)
           end
 
-          logger.debug "Using filter based on patch config #{@options.patch_config}: " \
+          logger.info "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'
+          # if `rule_refs` is empty, then no filter can be used when comparing to the baseline
+          logger.info 'No filter when comparing patch to baseline'
           @options.filter_set = nil
         end
       else
-        logger.debug "Filter is now #{rule_refs}"
+        logger.info "Filter is now #{rule_refs}"
         @options.filter_set = rule_refs
       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/src/main pmd-java/src/main"
-        filenames = Cmd.execute(diff_cmd)
-      end
-      filenames.split("\n")
-    end
-
+    #
+    # Determines the rules or category rulesets, that are potentially affected by the change.
+    # Returns an empty set, if all rules are affected and there is no
+    # filtering possible or if no rules are affected.
+    # Whether to run the regression test is returned as an additional boolean flag.
+    #
     def get_rule_refs(filenames)
-      categories, rules = determine_categories_rules(filenames)
+      run_required, categories, rules = determine_categories_rules(filenames)
+      logger.debug "Regression test required: #{run_required}"
       logger.debug "Categories: #{categories}"
       logger.debug "Rules: #{rules}"
 
@@ -87,48 +84,11 @@ def get_rule_refs(filenames)
       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 = 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
-
-        next unless match_data.nil?
-
-        logger.debug "Change doesn't match specific rule/category - enable all rules"
-        categories = ALL_CATEGORIES
-        rules.clear
-        break
-      end
-      [categories, rules]
-    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
+      [run_required, refs]
     end
 
     def build_config_file(rule_refs)
       if rule_refs.empty?
-        logger.info NO_JAVA_RULES_CHANGED_MESSAGE
-        return
-      end
-
-      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}"
@@ -147,7 +107,7 @@ def write_dynamic_file(rule_refs)
                     'name' => 'Dynamic PmdTester Ruleset') do
           xml.description 'The ruleset generated by PmdTester dynamically'
           rule_refs.each do |entry|
-            xml.rule('ref' => "category/java/#{entry}")
+            xml.rule('ref' => "category/#{entry}")
           end
         end
       end
@@ -158,5 +118,82 @@ def write_dynamic_file(rule_refs)
       @options.base_config = PATH_TO_DYNAMIC_CONFIG
       @options.patch_config = PATH_TO_DYNAMIC_CONFIG
     end
+
+    private
+
+    def determine_categories_rules(filenames)
+      regression_test_required = false
+      categories = Set[]
+      rules = Set[]
+      filenames.each do |filename|
+        matched = check_single_filename(filename, categories, rules)
+        regression_test_required = true if matched
+
+        next if matched
+
+        logger.info "Change in file #{filename} doesn't match specific rule/category - enable all rules"
+        regression_test_required = true
+        categories.clear
+        rules.clear
+        break
+      end
+      [regression_test_required, categories, rules]
+    end
+
+    def check_single_filename(filename, categories, rules)
+      logger.debug "Checking #{filename}"
+
+      # matches Java-based rule implementations
+      match_data = %r{.+/src/main/java/.+/lang/([^/]+)/rule/([^/]+)/([^/]+)Rule.java}.match(filename)
+      unless match_data.nil?
+        logger.debug "Matches: #{match_data.inspect}"
+        rules.add("#{match_data[1]}/#{match_data[2]}.xml/#{match_data[3]}")
+        return true
+      end
+
+      # matches xpath rules
+      match_data = %r{.+/src/main/resources/category/([^/]+)/([^/]+).xml}.match(filename)
+      unless match_data.nil?
+        logger.debug "Matches: #{match_data.inspect}"
+        categories.add("#{match_data[1]}/#{match_data[2]}.xml")
+        return true
+      end
+
+      false
+    end
+
+    def diff_filenames(languages)
+      filenames = nil
+      Dir.chdir(@options.local_git_repo) do
+        base = @options.base_branch
+        patch = @options.patch_branch
+
+        filepath_filter = ''
+        unless languages.empty?
+          filepath_filter = '-- pmd-core/src/main'
+          languages.each { |l| filepath_filter = "#{filepath_filter} pmd-#{l}/src/main" }
+        end
+
+        # We only need to support git here, since PMD's repo is using git.
+        diff_cmd = "git diff --name-only #{base}..#{patch} #{filepath_filter}"
+        filenames = Cmd.execute(diff_cmd)
+      end
+      filenames.split("\n")
+    end
+
+    #
+    # Determines all languages, that are part of the regression test.
+    # This is based on the configured rules/rulesets.
+    #
+    def determine_languages
+      languages = 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
+        languages.add(ref.split('/')[1])
+      end
+      languages
+    end
   end
 end

lib/pmdtester/parsers/pmd_report_document.rb

@@ -92,7 +92,7 @@ def match_filter_set?(violation)
       ruleset_attr = violation.ruleset_name.delete(' ').downcase! << '.xml'
       return true if @filter_set.include?(ruleset_attr)
 
-      rule_ref = "#{ruleset_attr}/#{violation.rule_name}"
+      rule_ref = "#{violation.language}/#{ruleset_attr}/#{violation.rule_name}"
 
       @filter_set.include?(rule_ref)
     end

lib/pmdtester/pmd_violation.rb

@@ -27,7 +27,7 @@ class PmdViolation
     #   </xs:simpleContent>
     # </xs:complexType>
 
-    attr_reader :fname, :info_url, :line, :old_line, :old_message, :rule_name, :ruleset_name
+    attr_reader :fname, :info_url, :line, :old_line, :old_message, :rule_name, :ruleset_name, :language
     attr_accessor :message
 
     # rubocop:disable Metrics/ParameterLists
@@ -43,6 +43,8 @@ def initialize(branch:, fname:, info_url:, bline:, rule_name:, ruleset_name:)
 
       @ruleset_name = ruleset_name
 
+      @language = determine_language_from_info_url
+
       @changed = false
       @old_message = nil
       @old_line = nil
@@ -102,5 +104,13 @@ def to_liquid
         'changed' => changed?
       }
     end
+
+    private
+
+    def determine_language_from_info_url
+      # @info_url is e.g. http://pmd.sourceforge.net/snapshot/pmd_rules_java_codestyle.html#fielddeclarationsshouldbeatstartofclass
+      m = @info_url.match(/pmd_rules_(\w+)_/)
+      m[1]
+    end
   end
 end

lib/pmdtester/runner.rb

@@ -33,8 +33,11 @@ def clean
     def run_local_mode
       logger.info "Mode: #{@options.mode}"
       get_projects(@options.project_list) unless @options.nil?
-      rule_sets = RuleSetBuilder.new(@options).build if @options.auto_config_flag
-      return if rule_sets&.empty?
+      if @options.auto_config_flag
+        run_required = RuleSetBuilder.new(@options).build?
+        logger.debug "Run required: #{run_required}"
+        return unless run_required
+      end
 
       base_branch_details = create_pmd_report(config: @options.base_config, branch: @options.base_branch)
       patch_branch_details = create_pmd_report(config: @options.patch_config, branch: @options.patch_branch)
@@ -51,7 +54,8 @@ def run_online_mode
       get_projects(project_list)
 
       if @options.auto_config_flag
-        return if RuleSetBuilder.new(@options).build.empty?
+        logger.info 'Autogenerating a dynamic ruleset based on source changes'
+        return unless RuleSetBuilder.new(@options).build?
       elsif @options.patch_config == Options::DEFAULT_CONFIG_PATH
         # patch branch build pmd reports with same configuration as base branch
         # if not specified otherwise. This allows to use a different config (e.g. less rules)