pmdtester 1.1.2 → 1.4.0

data/lib/pmdtester/builders/liquid_renderer.rb

@@ -57,17 +57,74 @@ module PmdTester
       write_file("#{root}/index.html", render_liquid('project_diff_report.html', liquid_env))
       # generate array of violations in json
       write_file("#{root}/project_data.js", dump_violations_json(project))
+      # copy original pmd reports
+      copy_file("#{root}/base_pmd_report.xml", project.report_diff.base_report.file)
+      copy_file("#{root}/patch_pmd_report.xml", project.report_diff.patch_report.file)
+      # render full pmd reports
+      write_file("#{root}/base_pmd_report.html",
+                 render_liquid('project_pmd_report.html', pmd_report_liquid_env(project, BASE)))
+      write_file("#{root}/base_data.js", dump_violations_json(project, BASE))
+      write_file("#{root}/patch_pmd_report.html",
+                 render_liquid('project_pmd_report.html', pmd_report_liquid_env(project, PATCH)))
+      write_file("#{root}/patch_data.js", dump_violations_json(project, PATCH))
     end
 
-    def dump_violations_json(project)
+    def dump_violations_json(project, branch = 'diff')
+      violations_by_file = if branch == BASE
+                             project.report_diff.base_report.violations_by_file.to_h
+                           elsif branch == PATCH
+                             project.report_diff.patch_report.violations_by_file.to_h
+                           else
+                             project.report_diff.violation_diffs_by_file
+                           end
+
       h = {
         'source_link_base' => project.webview_url,
         'source_link_template' => link_template(project),
-        **violations_to_hash(project)
+        **violations_to_hash(project, violations_by_file, branch == 'diff')
       }
 
-      project_data = JSON.fast_generate(h)
+      project_data = JSON.fast_generate(h, indent: '    ', object_nl: "\n", array_nl: "\n")
       "let project = #{project_data}"
     end
+
+    private
+
+    def copy_file(target_file, source_file)
+      if File.exist? source_file
+        FileUtils.cp(source_file, target_file)
+        logger&.info "Written #{target_file}"
+      else
+        logger&.warn "File #{source_file} not found"
+      end
+    end
+
+    def pmd_report_liquid_env(project, branch)
+      report = if branch == BASE
+                 project.report_diff.base_report
+               else
+                 project.report_diff.patch_report
+               end
+      {
+        'project_name' => project.name,
+        'branch' => branch,
+        'report' => report_to_h(project, report)
+      }
+    end
+
+    def report_to_h(project, report)
+      {
+        'violation_counts' => report.violations_by_file.total_size,
+        'error_counts' => report.errors_by_file.total_size,
+        'configerror_counts' => report.configerrors_by_rule.values.flatten.length,
+
+        'execution_time' => PmdReportDetail.convert_seconds(report.exec_time),
+        'timestamp' => report.timestamp,
+
+        'rules' => report.rule_summaries,
+        'errors' => report.errors_by_file.all_values.map { |e| error_to_hash(e, project) },
+        'configerrors' => report.configerrors_by_rule.values.flatten.map { |e| configerror_to_hash(e) }
+      }
+    end
   end
 end

data/lib/pmdtester/builders/pmd_report_builder.rb

@@ -69,7 +69,7 @@ module PmdTester
                       ' -Dmaven.source.skip=true' \
                       ' -Dcheckstyle.skip=true' \
                       ' -Dpmd.skip=true' \
-                      ' -T1C'
+                      ' -T1C -B'
         Cmd.execute(package_cmd)
       end
 
@@ -97,11 +97,12 @@ module PmdTester
     def generate_pmd_report(project)
       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"
+      fail_on_violation = should_use_long_cli_options ? '--fail-on-violation false' : '-failOnViolation false'
       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} " \
+                "#{fail_on_violation} -t #{@threads} " \
                 "#{project.auxclasspath}"
       start_time = Time.now
       if File.exist?(project.get_pmd_report_path(@pmd_branch_name))
@@ -119,7 +120,7 @@ module PmdTester
       doc = Nokogiri::XML(File.read(@branch_config))
       ruleset = doc.at_css('ruleset')
       ruleset.add_child("\n")
-      project.exclude_pattern.each do |exclude_pattern|
+      project.exclude_patterns.each do |exclude_pattern|
         ruleset.add_child("    <exclude-pattern>#{exclude_pattern}</exclude-pattern>\n")
       end
 
@@ -194,5 +195,10 @@ module PmdTester
     def wd_has_dirty_git_changes
       !Cmd.execute('git status --porcelain').empty?
     end
+
+    def should_use_long_cli_options
+      logger.debug "PMD Version: #{@pmd_version}"
+      Semver.compare(@pmd_version, '6.41.0') >= 0
+    end
   end
 end

data/lib/pmdtester/builders/project_builder.rb

@@ -17,11 +17,19 @@ module PmdTester
 
       @projects.each do |project|
         logger.info "Start cloning #{project.name} repository"
-        path = project.local_source_path
-        clone_cmd = "#{project.type} clone #{project.connection} #{path}"
+        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
 
@@ -38,7 +46,7 @@ module PmdTester
       logger.info 'Building projects started'
 
       @projects.each do |project|
-        path = project.local_source_path
+        path = project.clone_root_path
         Dir.chdir(path) do
           progress_logger = SimpleProgressLogger.new("building #{project.name} in #{path}")
           progress_logger.start
@@ -87,12 +95,9 @@ module PmdTester
     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
+      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

data/lib/pmdtester/builders/project_hasher.rb

@@ -25,24 +25,14 @@ module PmdTester
       }
     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)
+    def violations_to_hash(project, violations_by_file, is_diff)
       filename_index = []
       all_vs = []
-      project.report_diff.violation_diffs_by_file.each do |file, 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))
+          all_vs.push(make_violation_hash(file_ref, v, is_diff))
         end
       end
 
@@ -52,36 +42,19 @@ module PmdTester
       }
     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
+    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 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
+    def configerrors_to_h(project)
+      configerrors = project.report_diff.configerror_diffs_by_rule.values.flatten
+      configerrors.map { |e| configerror_to_hash(e) }
     end
 
-    def diff_fragments(violation)
-      diff = Differ.diff_by_word(violation.message, violation.old_message)
-      diff.format_as(:html)
+    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)
@@ -122,5 +95,34 @@ module PmdTester
         '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

data/lib/pmdtester/builders/rule_set_builder.rb

@@ -9,69 +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([])
     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}"
 
@@ -83,48 +84,11 @@ module PmdTester
       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}"
@@ -143,7 +107,7 @@ module PmdTester
                     '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
@@ -154,5 +118,82 @@ module PmdTester
       @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

data/lib/pmdtester/builders/summary_report_builder.rb

@@ -80,6 +80,7 @@ module PmdTester
           'sha' => details.branch_last_sha,
           'message' => details.branch_last_message
         },
+        'timestamp' => details.timestamp,
         'execution_time' => PmdReportDetail.convert_seconds(details.execution_time),
         'jdk_info' => details.jdk_version,
         'locale' => details.language,

data/lib/pmdtester/parsers/options.rb

@@ -29,6 +29,7 @@ module PmdTester
     attr_reader :threads
     attr_reader :html_flag
     attr_reader :auto_config_flag
+    attr_reader :filter_with_patch_config
     attr_reader :debug_flag
     attr_accessor :filter_set
     attr_reader :keep_reports
@@ -48,6 +49,7 @@ module PmdTester
       @threads = options[:t]
       @html_flag = options[:f]
       @auto_config_flag = options[:a]
+      @filter_with_patch_config = options.filter_with_patch_config?
       @debug_flag = options[:d]
       @filter_set = nil
       @keep_reports = options.keep_reports?
@@ -100,6 +102,9 @@ 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 '--filter-with-patch-config',
+               'whether to use patch config to filter baseline result as if --auto-gen-config ' \
+               'has been used. This option only works in online mode.'
         o.bool '--keep-reports',
                'whether to keep old reports and skip running PMD again if possible'
         o.bool '-d', '--debug',

data/lib/pmdtester/parsers/pmd_report_document.rb

@@ -8,14 +8,12 @@ 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 = CollectionByFile.new
       @errors = CollectionByFile.new
       @configerrors = Hash.new { |hash, key| hash[key] = [] }
 
-      @infos_by_rules = {}
       @current_violations = []
       @current_violation = nil
       @current_error = nil
@@ -94,7 +92,7 @@ module PmdTester
       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

data/lib/pmdtester/parsers/projects_parser.rb

@@ -21,7 +21,7 @@ module PmdTester
     end
 
     def schema_file_path
-      ResourceLocator.locate('config/projectlist_1_1_0.xsd')
+      ResourceLocator.locate('config/projectlist_1_2_0.xsd')
     end
   end
 

data/lib/pmdtester/pmd_branch_detail.rb

@@ -10,6 +10,8 @@ module PmdTester
     attr_accessor :branch_last_sha
     attr_accessor :branch_last_message
     attr_accessor :branch_name
+    # Start of the regression report
+    attr_accessor :timestamp
     # The branch's execution time on all standard projects
     attr_accessor :execution_time
     attr_accessor :jdk_version
@@ -26,6 +28,7 @@ module PmdTester
       @branch_name = branch_name
       branch_filename = PmdBranchDetail.branch_filename(branch_name)
       @base_branch_dir = "target/reports/#{branch_filename}" unless @branch_name.nil?
+      @timestamp = Time.now
       @execution_time = 0
       # the result of command 'java -version' is going to stderr
       @jdk_version = Cmd.stderr_of('java -version')
@@ -42,11 +45,13 @@ module PmdTester
         details.branch_last_sha = hash['branch_last_sha']
         details.branch_last_message = hash['branch_last_message']
         details.branch_name = hash['branch_name']
+        details.timestamp = hash['timestamp']
         details.execution_time = hash['execution_time']
         details.jdk_version = hash['jdk_version']
         details.language = hash['language']
         details.pull_request = hash['pull_request']
       else
+        details.timestamp = Time.now
         details.jdk_version = ''
         details.language = ''
         logger&.warn "#{details.path_to_save_file} doesn't exist!"
@@ -58,6 +63,7 @@ module PmdTester
       hash = { branch_last_sha: @branch_last_sha,
                branch_last_message: @branch_last_message,
                branch_name: @branch_name,
+               timestamp: @timestamp,
                execution_time: @execution_time,
                jdk_version: @jdk_version,
                language: @language,

data/lib/pmdtester/pmd_tester_utils.rb

@@ -29,6 +29,7 @@ module PmdTester
       parser.parse_file(report_file) if File.exist?(report_file)
       Report.new(
         report_document: doc,
+        file: report_file,
 
         timestamp: report_details.timestamp,
         exec_time: report_details.execution_time

data/lib/pmdtester/pmd_violation.rb

@@ -27,7 +27,7 @@ module PmdTester
     #   </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 @@ module PmdTester
 
       @ruleset_name = ruleset_name
 
+      @language = determine_language_from_info_url
+
       @changed = false
       @old_message = nil
       @old_line = nil
@@ -102,5 +104,13 @@ module PmdTester
         '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