pmdtester 1.0.0.pre.beta2

data/lib/pmdtester/parsers/options.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'slop'
+require_relative '../pmdtester'
+
+module PmdTester
+  class MissRequiredOptionError < StandardError; end
+  class InvalidModeError < StandardError; end
+
+  # The Options is a class responsible of parsing all the
+  # command line options
+  class Options
+    include PmdTester
+    ANY = 'any'
+    LOCAL = 'local'
+    ONLINE = 'online'
+    SINGLE = 'single'
+    VERSION = '1.0.0-beta2'
+
+    attr_reader :local_git_repo
+    attr_reader :base_branch
+    attr_reader :patch_branch
+    attr_accessor :base_config
+    attr_accessor :patch_config
+    attr_reader :config
+    attr_reader :project_list
+    attr_reader :mode
+    attr_reader :html_flag
+    attr_reader :auto_config_flag
+    attr_reader :debug_flag
+    attr_accessor :filter_set
+
+    def initialize(argv)
+      options = parse(argv)
+      @local_git_repo = options[:r]
+      @base_branch = options[:b]
+      @patch_branch = options[:p]
+      @base_config = options[:bc]
+      @patch_config = options[:pc]
+      @config = options[:c]
+      @project_list = options[:l]
+      @mode = options[:m]
+      @html_flag = options[:f]
+      @auto_config_flag = options[:a]
+      @debug_flag = options[:d]
+      @filter_set = nil
+
+      # if the 'config' option is selected then `config` overrides `base_config` and `patch_config`
+      @base_config = @config if !@config.nil? && @mode == 'local'
+      @patch_config = @config if !@config.nil? && @mode == 'local'
+
+      logger.level = @debug_flag ? Logger::DEBUG : Logger::INFO
+      check_options
+    end
+
+    private
+
+    def parse(argv)
+      mode_message = <<-DOC
+        the mode of the tool: 'local', 'online' or 'single'
+          single: Set this option to 'single' if your patch branch contains changes
+            for any option that can't work on master/base branch
+          online: Set this option to 'online' if you want to download
+            'the PMD report of master/base branch rather than generating it locally
+          local: Default option is 'local'
+      DOC
+
+      Slop.parse argv do |o|
+        o.string '-r', '--local-git-repo', 'path to the local PMD repository'
+        o.string '-b', '--base-branch', 'name of the base branch in local PMD repository'
+        o.string '-p', '--patch-branch',
+                 'name of the patch branch in local PMD repository'
+        o.string '-bc', '--base-config', 'path to the base PMD configuration file'
+        o.string '-pc', '--patch-config', 'path to the patch PMD configuration file'
+        o.string '-c', '--config', 'path to the base and patch PMD configuration file'
+        o.string '-l', '--list-of-project',
+                 'path to the file which contains the list of standard projects'
+        o.string '-m', '--mode', mode_message, default: 'local'
+        o.bool '-f', '--html-flag',
+               'whether to not generate the html diff report in single mode'
+        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 '-d', '--debug',
+               'whether change log level to DEBUG to see more information'
+        o.on '-v', '--version' do
+          puts VERSION
+          exit
+        end
+        o.on '-h', '--help' do
+          puts o
+          exit
+        end
+      end
+    end
+
+    def check_options
+      check_common_options
+      case @mode
+      when LOCAL
+        check_local_options
+      when SINGLE
+        check_single_options
+      when ONLINE
+        check_online_options
+      else
+        msg = "The mode '#{@mode}' is invalid!"
+        logger.error msg
+        raise InvalidModeError, msg
+      end
+    end
+
+    def check_local_options
+      check_option(LOCAL, 'base branch name', @base_branch)
+      check_option(LOCAL, 'base branch config path', @base_config) unless @auto_config_flag
+      check_option(LOCAL, 'patch branch name', @patch_branch)
+      check_option(LOCAL, 'patch branch config path', @patch_config) unless @auto_config_flag
+      check_option(LOCAL, 'list of projects file path', @project_list)
+    end
+
+    def check_single_options
+      check_option(SINGLE, 'patch branch name', @patch_branch)
+      check_option(SINGLE, 'patch branch config path', @patch_config)
+      check_option(SINGLE, 'list of projects file path', @project_list)
+    end
+
+    def check_online_options
+      check_option(ONLINE, 'base branch name', @base_branch)
+      check_option(ONLINE, 'patch branch name', @patch_branch)
+    end
+
+    def check_common_options
+      check_option(ANY, 'local git repository path', @local_git_repo)
+      check_option(ANY, 'patch branch name', @patch_branch)
+    end
+
+    def check_option(mode, option_name, option)
+      if option.nil?
+        msg = "#{option_name} is required in #{mode} mode."
+        logger.error msg
+        raise MissRequiredOptionError, msg
+      else
+        logger.info "#{option_name}: #{option}"
+      end
+    end
+  end
+end

data/lib/pmdtester/parsers/pmd_report_document.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative '../pmd_violation'
+require_relative '../pmd_error'
+module PmdTester
+  # This class is used for registering types of events you are interested in handling.
+  # Also see: https://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/SAX/Document
+  class PmdReportDocument < Nokogiri::XML::SAX::Document
+    attr_reader :violations
+    attr_reader :errors
+    def initialize(branch_name, working_dir, filter_set = nil)
+      @violations = PmdViolations.new
+      @errors = PmdErrors.new
+      @current_violations = []
+      @current_violation = nil
+      @current_error = nil
+      @current_element = ''
+      @filename = ''
+      @filter_set = filter_set
+      @working_dir = working_dir
+      @branch_name = branch_name
+    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'])
+      when 'violation'
+        @current_violation = PmdViolation.new(attrs, @branch_name)
+      when 'error'
+        @current_filename = remove_work_dir!(attrs['filename'])
+        remove_work_dir!(attrs['msg'])
+        @current_error = PmdError.new(attrs, @branch_name)
+      end
+    end
+
+    def remove_work_dir!(str)
+      str.sub!(/#{@working_dir}/, '')
+    end
+
+    def characters(string)
+      @current_violation.text = string unless @current_violation.nil?
+    end
+
+    def end_element(name)
+      case name
+      when 'file'
+        unless @current_violations.empty?
+          @violations.add_violations_by_filename(@current_filename, @current_violations)
+        end
+        @current_filename = nil
+      when 'violation'
+        @current_violations.push(@current_violation) if match_filter_set?(@current_violation)
+        @current_violation = nil
+      when 'error'
+        @errors.add_error_by_filename(@current_filename, @current_error)
+        @current_filename = nil
+        @current_error = nil
+      end
+    end
+
+    def cdata_block(string)
+      remove_work_dir!(string)
+      @current_error.text = string unless @current_error.nil?
+    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
+
+      false
+    end
+  end
+end

data/lib/pmdtester/parsers/projects_parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative '../project'
+require_relative '../resource_locator'
+
+module PmdTester
+  # The ProjectsParser is a class responsible of parsing
+  # the projects XML file to get the Project object array
+  class ProjectsParser
+    def parse(list_file)
+      schema = Nokogiri::XML::Schema(File.read(schema_file_path))
+      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
+
+      projects = []
+      document.xpath('//project').each do |project|
+        projects.push(Project.new(project))
+      end
+      projects
+    end
+
+    def schema_file_path
+      ResourceLocator.locate('config/projectlist_1_0_0.xsd')
+    end
+  end
+
+  # When this exception is raised, it means that
+  # schema validate of 'project-list' xml file failed
+  class ProjectsParserException < RuntimeError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+    end
+  end
+end

data/lib/pmdtester/pmd_branch_detail.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative './pmd_report_detail'
+
+module PmdTester
+  # This class represents all details about branch of pmd
+  class PmdBranchDetail
+    attr_accessor :branch_last_sha
+    attr_accessor :branch_last_message
+    attr_accessor :branch_name
+    # The branch's execution time on all standard projects
+    attr_accessor :execution_time
+
+    def self.branch_filename(branch_name)
+      branch_name&.tr('/', '_')
+    end
+
+    def initialize(branch_name)
+      @branch_last_sha = ''
+      @branch_last_message = ''
+      @branch_name = branch_name
+      branch_filename = PmdBranchDetail.branch_filename(branch_name)
+      @base_branch_dir = "target/reports/#{branch_filename}" unless @branch_name.nil?
+      @execution_time = 0
+    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']
+        hash
+      else
+        {}
+      end
+    end
+
+    def save
+      hash = { branch_last_sha: @branch_last_sha,
+               branch_last_message: @branch_last_message,
+               branch_name: @branch_name,
+               execution_time: @execution_time }
+      file = File.new(branch_details_path, 'w')
+      file.puts JSON.generate(hash)
+      file.close
+    end
+
+    def branch_details_path
+      "#{@base_branch_dir}/branch_info.json"
+    end
+
+    def target_branch_config_path
+      "#{@base_branch_dir}/config.xml"
+    end
+
+    def target_branch_project_list_path
+      "#{@base_branch_dir}/project-list.xml"
+    end
+
+    def format_execution_time
+      PmdReportDetail.convert_seconds(@execution_time)
+    end
+  end
+end

data/lib/pmdtester/pmd_error.rb

@@ -0,0 +1,67 @@
+# 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
+    # The pmd branch type, 'base' or 'patch'
+    attr_reader :branch
+
+    # The schema of 'error' node:
+    #   <xs:complexType name="error">
+    #     <xs:simpleContent>
+    #       <xs:extension base="xs:string">
+    #         <xs:attribute name="filename" type="xs:string" use="required"/>
+    #         <xs:attribute name="msg" type="xs:string" use="required"/>
+    #       </xs:extension>
+    #     </xs:simpleContent>
+    #  </xs:complexType>
+    attr_reader :attrs
+    attr_accessor :text
+
+    def initialize(attrs, branch)
+      @attrs = attrs
+
+      @branch = branch
+      @text = ''
+    end
+
+    def filename
+      @attrs['filename']
+    end
+
+    def msg
+      @attrs['msg']
+    end
+
+    def eql?(other)
+      filename.eql?(other.filename) && msg.eql?(other.msg) &&
+        @text.eql?(other.text)
+    end
+
+    def hash
+      [filename, msg, @text].hash
+    end
+  end
+end

data/lib/pmdtester/pmd_report_detail.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PmdTester
+  # This class represents all details about report of pmd
+  class PmdReportDetail
+    attr_accessor :execution_time
+    attr_accessor :timestamp
+    attr_reader :working_dir
+
+    def initialize
+      @execution_time = 0
+      @timestamp = ''
+      @working_dir = Dir.getwd
+    end
+
+    def save(report_info_path)
+      hash = { execution_time: @execution_time, timestamp: @timestamp, working_dir: @working_dir }
+      file = File.new(report_info_path, 'w')
+      file.puts JSON.generate(hash)
+      file.close
+    end
+
+    def load(report_info_path)
+      if File.exist?(report_info_path)
+        hash = JSON.parse(File.read(report_info_path))
+        @execution_time = hash['execution_time']
+        @timestamp = hash['timestamp']
+        @working_dir = hash['working_dir']
+        hash
+      else
+        puts "#{report_info_path} doesn't exist"
+        {}
+      end
+    end
+
+    def format_execution_time
+      self.class.convert_seconds(@execution_time)
+    end
+
+    # convert seconds into HH::MM::SS
+    def self.convert_seconds(seconds)
+      Time.at(seconds.abs).utc.strftime('%H:%M:%S')
+    end
+  end
+end

data/lib/pmdtester/pmd_violation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module PmdTester
+  # This class is used to store pmd violations and its size.
+  class PmdViolations
+    attr_reader :violations
+    attr_reader :violations_size
+
+    def initialize
+      # key:filename as String => value:PmdViolation Array
+      @violations = {}
+      @violations_size = 0
+    end
+
+    def add_violations_by_filename(filename, violations)
+      @violations.store(filename, violations)
+      @violations_size += violations.size
+    end
+  end
+
+  # This class represents a 'violation' element of Pmd xml report
+  # and which pmd branch the 'violation' is from
+  class PmdViolation
+    # The pmd branch type, 'base' or 'patch'
+    attr_reader :branch
+
+    # The schema of 'violation' element:
+    # <xs:complexType name="violation">
+    #   <xs:simpleContent>
+    #     <xs:extension base="xs:string">
+    #       <xs:attribute name="beginline" type="xs:integer" use="required" />
+    #       <xs:attribute name="endline" type="xs:integer" use="required" />
+    #       <xs:attribute name="begincolumn" type="xs:integer" use="required" />
+    #       <xs:attribute name="endcolumn" type="xs:integer" use="required" />
+    #       <xs:attribute name="rule" type="xs:string" use="required" />
+    #       <xs:attribute name="ruleset" type="xs:string" use="required" />
+    #       <xs:attribute name="package" type="xs:string" use="optional" />
+    #       <xs:attribute name="class" type="xs:string" use="optional" />
+    #       <xs:attribute name="method" type="xs:string" use="optional" />
+    #       <xs:attribute name="variable" type="xs:string" use="optional" />
+    #       <xs:attribute name="externalInfoUrl" type="xs:string" use="optional" />
+    #       <xs:attribute name="priority" type="xs:string" use="required" />
+    #     </xs:extension>
+    #   </xs:simpleContent>
+    # </xs:complexType>
+
+    attr_reader :attrs
+    attr_accessor :text
+
+    def initialize(attrs, branch)
+      @attrs = attrs
+      @branch = branch
+      @text = ''
+    end
+
+    def eql?(other)
+      @attrs['beginline'].eql?(other.attrs['beginline']) &&
+        @attrs['rule'].eql?(other.attrs['rule']) &&
+        @text.eql?(other.text)
+    end
+
+    def hash
+      [@attrs['beginline'], @attrs['rule'], @text].hash
+    end
+  end
+end

data/lib/pmdtester/pmdtester.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+# PmdTester is a regression testing tool ensure that new problems
+# and unexpected behaviors will not be introduced to PMD project
+# after fixing an issue , and new rules can work as expected.
+module PmdTester
+  def logger
+    PmdTester.logger
+  end
+
+  # Global, memoized, lazy initialized instance of a logger
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+end

data/lib/pmdtester/project.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative './pmd_branch_detail'
+
+module PmdTester
+  # This class represents all the information about the project
+  class Project
+    REPOSITORIES_PATH = 'target/repositories'
+
+    attr_reader :name
+    attr_reader :type
+    attr_reader :connection
+    attr_reader :webview_url
+    attr_reader :tag
+    attr_reader :exclude_pattern
+    attr_accessor :report_diff
+    # key: pmd branch name as String => value: local path of pmd report
+
+    def initialize(project)
+      @name = project.at_xpath('name').text
+      @type = project.at_xpath('type').text
+      @connection = project.at_xpath('connection').text
+
+      @tag = 'master'
+      tag_element = project.at_xpath('tag')
+      @tag = tag_element.text unless tag_element.nil?
+
+      webview_url_element = project.at_xpath('webview-url')
+      @webview_url = default_webview_url
+      @webview_url = webview_url_element.text unless webview_url_element.nil?
+
+      @exclude_pattern = []
+      project.xpath('exclude-pattern').each do |ep|
+        @exclude_pattern.push(ep.text)
+      end
+
+      @report_diff = nil
+    end
+
+    # Generate the default webview url for the projects
+    # stored on github.
+    # For other projects return value is `connection`.
+    def default_webview_url
+      if @type.eql?('git') && @connection.include?('github.com')
+        "#{@connection}/tree/#{@tag}"
+      else
+        @connection
+      end
+    end
+
+    # Change the file path from 'LOCAL_DIR/SOURCE_CODE_PATH' to
+    # 'WEB_VIEW_URL/SOURCE_CODE_PATH'
+    def get_webview_url(file_path)
+      file_path.gsub(%r{/#{local_source_path}}, @webview_url)
+    end
+
+    # Change the file path from 'LOCAL_DIR/SOURCE_CODE_PATH' to
+    # 'PROJECT_NAME/SOURCE_CODE_PATH'
+    def get_path_inside_project(file_path)
+      file_path.gsub(%r{/#{local_source_path}}, @name)
+    end
+
+    def get_pmd_report_path(branch_name)
+      if branch_name.nil?
+        nil
+      else
+        "#{get_project_target_dir(branch_name)}/pmd_report.xml"
+      end
+    end
+
+    def get_report_info_path(branch_name)
+      if branch_name.nil?
+        nil
+      else
+        "#{get_project_target_dir(branch_name)}/report_info.json"
+      end
+    end
+
+    def get_project_target_dir(branch_name)
+      branch_filename = PmdBranchDetail.branch_filename(branch_name)
+      dir = "target/reports/#{branch_filename}/#{@name}"
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      dir
+    end
+
+    def local_source_path
+      "#{REPOSITORIES_PATH}/#{@name}"
+    end
+
+    def target_diff_report_path
+      dir = "target/reports/diff/#{@name}"
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      dir
+    end
+
+    def diff_report_index_path
+      "#{target_diff_report_path}/index.html"
+    end
+
+    def diff_report_index_ref_path
+      "./#{name}/index.html"
+    end
+
+    def diffs_exist?
+      @report_diff.diffs_exist?
+    end
+
+    def introduce_new_errors?
+      @report_diff.introduce_new_errors?
+    end
+  end
+end