codeowner_validator 0.1.1

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/codeowner_validator.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'codeowner_validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'codeowner_validator'
+  spec.version       = CodeownerValidator::VERSION
+  spec.authors       = ['Greg Howdeshell']
+  spec.email         = ['greg.howdeshell@gmail.com']
+
+  spec.summary       = 'Write a short summary, because RubyGems requires one.'
+  spec.description = <<~DESC
+    GitHub CODEOWNERS validator
+  DESC
+  spec.homepage      = 'https://github.com/cerner/codeowner_validator'
+  spec.license       = 'Apache-2.0'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         =
+    Dir.chdir(File.expand_path(__dir__)) do
+      `git ls-files -z`.split("\x0").reject { |f| f.match(/^(test|spec|features)\//) }
+    end
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.6.2'
+
+  spec.add_dependency 'rainbow', '>= 2.0', '< 4.0.0'
+  spec.add_dependency 'thor', '~> 0.19'
+
+  spec.add_dependency 'tty-prompt', '~> 0.12'
+  spec.add_dependency 'tty-spinner', '~> 0.4'
+  spec.add_dependency 'tty-table', '~> 0.8'
+
+  spec.add_dependency 'codeowners-checker', '~> 1.1'
+  spec.add_dependency 'git', '~> 1.0'
+end

data/lib/codeowner_validator/cli/validator_cli.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/validator'
+
+module CodeownerValidator
+  # Public: Class utilized for housing all validator executions
+  class ValidatorCLI < Thor
+    REPO_PATH_DESC = 'Absolute path to repository location for evaluation'
+    VERBOSE_DESC   = 'Verbose output'
+
+    default_task :validate
+    desc '', 'validates the codeowners file'
+
+    method_option :repo_path, aliases: %w[-p --repo-path], desc: REPO_PATH_DESC
+    method_option :verbose, aliases: %w[-v --verbose], desc: VERBOSE_DESC, type: :boolean, default: false
+    # Public: Entry point execution to being the codeowner validation
+    def validate
+      get_user_input(options)
+
+      validator = Validator.new options
+      validator.validate
+    end
+
+    no_commands do
+      # combination of options from input and environment variables
+      def options
+        return @new_options if @new_options
+
+        original_options = super
+
+        # add any environment variables as overrides
+        @new_options =
+          {}.tap do |h|
+            original_options.each do |key, value|
+              h[key.to_sym] = value
+            end
+
+            h[:verbose] = ENV['VERBOSE'] unless ENV['VERBOSE'].nil?
+            h[:repo_path] = ENV['REPO_PATH'] unless ENV['REPO_PATH'].nil?
+          end
+
+        # setup initial configuration
+        CodeownerValidator.configure! @new_options
+
+        @new_options
+      end
+
+      # steps needed to ask for input that is deemed missing
+      def get_user_input(options = {})
+        return if options[:repo_path]
+
+        ConfigHelper.ask(
+          ident: :repo_path,
+          prompt: REPO_PATH_DESC,
+          required: true,
+          default: Dir.pwd
+        )
+
+        # set response on the options hash
+        options[:repo_path] = CodeownerValidator.repo_path
+      end
+    end
+  end
+end

data/lib/codeowner_validator/code_owners.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative 'helpers/utility_helper'
+require 'codeowner_validator/lists/whitelist'
+require 'codeowners/checker/group'
+require_relative '../codeowners/checker/group/line'
+
+# rubocop:disable Style/ImplicitRuntimeError
+module CodeownerValidator
+  # Public: Manages the interactions with the GitHub CODEOWNERS file.  Information such as
+  # assignments, missing assignments, etc are retrieved though the usage of this class.
+  class CodeOwners
+    include UtilityHelper
+
+    # Public: The absolute path the the repository for evaluation
+    attr_reader :repo_path
+
+    class << self
+      # Public: Returns a instance of the [CodeOwners] object
+      #
+      # @param [Hash] args A hash of arguments allowed for creation of a [CodeOwners] object
+      # @option args [String] :repo_path The absolute path to the repository to be evaluated
+      def persist!(repo_path:, **args)
+        new(repo_path: repo_path, **args)
+      end
+    end
+
+    # Public: Returns a instance of the [CodeOwners] object
+    #
+    # @param [Hash] _args A hash of arguments allowed for creation of a [CodeOwners] object
+    # @option args [String] :repo_path The absolute path to the repository to be evaluated
+    def initialize(repo_path:, **_args)
+      @repo_path = repo_path
+
+      # initialize params to suppress warnings about instance variables not initialized
+      @list = nil
+      @codeowner_file = nil
+      @codeowner_file_paths = nil
+      @included_files = nil
+    end
+
+    # Public: Returns a [Hash] of key/value pairs of relative file name to git status ('A', 'M', 'D')
+    # between two commits.
+    #
+    # @param [String] from The staring point for analyzing. Defaults to 'HEAD'
+    # @param [String] to The end point for analyzing. Defaults to 'HEAD^'
+    # @return [Hash] of key/value pairs of relative file name to git status ('A', 'M', 'D')
+    #
+    # @example
+    #   {
+    #     "config/tenants/cert-int/eds04.yml" => "M",
+    #     "config/tenants/dev-int/edd03.yml" => "M"
+    #   }
+    def changes_to_analyze(from: 'HEAD', to: 'HEAD^')
+      git.diff(from, to).name_status.select(&whitelist)
+    end
+
+    # Public: Returns an [Array] of patterns that have no files associated to them
+    #
+    # @return [Array] [Array] of patterns that have no files associated to them
+    def useless_pattern
+      @useless_pattern ||=
+        list.select do |line|
+          line.pattern? && !pattern_has_files(line.pattern)
+        end
+    end
+
+    # Public: Returns a [Hash] of key/value pairs of relative file name to git details for a supplied pattern
+    #
+    # @param [String] pattern The pattern to search for files within the repository
+    # @return [Hash] of key/value pairs of relative file name to git details for a supplied pattern
+    #
+    # @example
+    #   pattern_has_files('config/tenants/dev')
+    #   {
+    #     {
+    #       "config/tenants/dev/64dev.yml" => {
+    #         path: "config/tenants/dev/64dev.yml",
+    #         mode_index: "100644",
+    #         sha_index: "598b2193b22bc006ff000e3a51f6805b336ebed8",
+    #         stage: "0"
+    #       },
+    #       "config/tenants/dev/deveng.yml" => {
+    #         path: "config/tenants/dev/deveng.yml",
+    #         mode_index: "100644",
+    #         sha_index: "ee63d8c6e9ae7f432aafa7bd3436fae222cb3f5c",
+    #         stage: "0"
+    #       }
+    #     }
+    #   }
+    def pattern_has_files(pattern)
+      git.ls_files(pattern.gsub(/^\//, '')).reject(&whitelist).any?
+    end
+
+    # Public: Return a list of files from the repository that do not have an owner assigned
+    #
+    # @return [Array] of files from the repository that are missing an assignment
+    def missing_assignments
+      @missing_assignments ||= included_files.reject(&method(:defined_owner?))
+    end
+
+    # Public: Return a list of files from the codowners file that are missing the owner assignment
+    #
+    # @return [Array] of unrecognized lines from the codeowners file missing owner assignment
+    def unrecognized_assignments
+      list.select do |line|
+        line.is_a?(Codeowners::Checker::Group::UnrecognizedLine)
+      end
+    end
+
+    # Public: Return a list of files from the codeowners file that are noted but do not exist
+    #
+    # @return [Array] of <Codeowners::Checker::Group::UnrecognizedLine>s or <Codeowners::Checker::Group::Pattern>s
+    def invalid_reference_lines
+      list.select do |line|
+        next unless line.pattern? || line.is_a?(Codeowners::Checker::Group::UnrecognizedLine)
+
+        filename = line.pattern? ? line.pattern : line.to_file
+        File.exist?(File.join(repo_path, filename)) == false
+      end
+    end
+
+    # Public: Returns a [Hash] of keyed item to array of patterns that are duplicated within the code owners file
+    #
+    # @return [Hash] of keyed [String] patterns to an [Array] of [Pattern]s
+    #
+    # Example:
+    # {
+    #   "config/domains/cert-int/CaseCartCoordinator_CERTIFICATION.yml": [
+    #     {Codeowners::Checker::Group::Pattern},
+    #     {Codeowners::Checker::Group::Pattern}
+    #   ]
+    # }
+    def duplicated_patterns
+      list.select { |l| l.pattern? }.group_by { |e| e.pattern }.select { |_k, v| v.size > 1 }
+    end
+
+    # Public: Return all relative paths to files for evaluation if to be owned by a set of code owners
+    #
+    # @return [Array] of relative paths to files that are to be included within the code owner evaluation
+    def included_files
+      return @included_files if @included_files
+
+      @included_files = []
+      in_folder repo_path do
+        Dir.glob(File.join(Dir.pwd, '**/*')) do |f|
+          p = Pathname.new(f)
+          # only return files for evaluation
+          next unless p.file?
+
+          # in order to properly match, must evaluate relative to the repo location that is
+          # being evaluated.  absolute paths of the files do not match with relative matches
+          relative_path_to_file = p.relative_path_from(Dir.pwd)
+          @included_files << relative_path_to_file.to_s if whitelist.whitelisted?(relative_path_to_file)
+        end
+      end
+
+      @included_files
+    end
+
+    # Public: Returns the patterns utilized with an array association to those patterns
+    #
+    # @return [Hash] The patterns keyed by the team with an array of associations
+    #
+    # Example Response:
+    # {
+    #   "@orion-delivery/delivery-team": [
+    #     "*"
+    #   ],
+    #   "@orion-delivery/orion-delivery-ets": [
+    #     "config/domains/production/**/*",
+    #     "config/domains/sandbox/**/*"
+    #   ],
+    #   "@orion-delivery/orion-shells": [
+    #     "config/feature_definitions/authn-android-enable_biometric_unlock.yml",
+    #     "config/domains/cert-int/IONServer_CERTIFICATION.yml"
+    #   ]
+    # }
+    def patterns_by_owner
+      @patterns_by_owner ||=
+        main_group.each_with_object(hash_of_arrays) do |line, patterns_by_owner|
+          next unless line.pattern?
+
+          line.owners.each { |owner| patterns_by_owner[owner] << line.pattern.gsub(/^\//, '') }
+        end
+    end
+
+    # Public: Returns the lines associated to a specific owner
+    #
+    # @param [String] owner The owner to search for patterns
+    # @return [Array] of <Codeowners::Checker::Group::Pattern> objects
+    def find_by_owner(owner)
+      main_group.find.select do |line|
+        next unless line.pattern?
+
+        line.owner == owner
+      end
+    end
+
+    # Public: Returns <true> if there is a defined owner for a given file
+    #
+    # @param [String] file The file to search if there is an owner assigned
+    # @return <true> if found; otherwise, <false>
+    def defined_owner?(file)
+      main_group.find do |line|
+        next unless line.pattern?
+
+        return true if line.match_file?(file)
+      end
+
+      false
+    end
+
+    # Public: Returns an [Array] of [Codeowners::Checker::Group] objects indicating
+    # the grouping of code owners
+    #
+    # @return [Array] of [Codeowners::Checker::Group] objects indicating the grouping
+    # of code owners
+    def main_group
+      @main_group ||= ::Codeowners::Checker::Group.parse(list)
+    end
+
+    # Public: Returns a [String] for the code owner file if it exists; otherwise, raise exception
+    #
+    # @return [String] the path to the codeowners file; otherwise, raise exception if not exists
+    def codeowner_file
+      return @codeowner_file if @codeowner_file
+
+      codeowner_file_paths.each do |path|
+        current_file_path = File.join(repo_path, path)
+        return current_file_path if File.exist?(current_file_path)
+      end
+
+      raise "Unable to locate a code owners file located [#{codeowner_file_paths.join(',')}]"
+    end
+
+    # Public: Returns <true> if the provided file is deemed whitelisted per the configuration;
+    # otherwise, <false>
+    #
+    # @return [true|false] if the provided file is deemed whitelisted per the configuration
+    def whitelisted?(file)
+      whitelist.whitelisted?(file)
+    end
+
+    private
+
+    # returns the git object representation of the repo provided
+    def git
+      @git ||= Git.open(@repo_path, log: Logger.new(IO::NULL))
+    end
+
+    # returns the configured whitelist of patterns to include
+    def whitelist
+      @whitelist ||= ::CodeownerValidator::Lists::Whitelist.new(repo_path: repo_path)
+    end
+
+    # locations to search for the codeowners file
+    def codeowner_file_paths
+      return @codeowner_file_paths if @codeowner_file_paths
+
+      @codeowner_file_paths = %w[CODEOWNERS docs/CODEOWNERS .github/CODEOWNERS]
+
+      # allow customization of the locations to search for the file
+      if ENV['CODEOWNER_FILE_PATHS']
+        ENV['CODEOWNER_FILE_PATHS']&.split(',')&.each(&:strip!)&.each do |str|
+          @codeowner_file_paths << str
+        end
+      end
+
+      @codeowner_file_paths
+    end
+
+    # constructs a new hash-to-array mapping
+    def hash_of_arrays
+      Hash.new { |h, k| h[k] = [] }
+    end
+
+    # returns an array of built lines
+    def list
+      return @list if @list
+
+      @list =
+        content.each_with_index.map do |line, index|
+          l = build_line(line)
+          l.line_number = index + 1
+          l
+        end
+
+      @list.compact!
+
+      @list
+    end
+
+    # builds a group line identifier
+    def build_line(line)
+      ::Codeowners::Checker::Group::Line.build(line)
+    end
+
+    # @return <Array> of lines chomped
+    def content
+      @content ||= ::File.readlines(codeowner_file).map(&:chomp)
+    rescue Errno::ENOENT
+      @content = []
+    end
+  end
+end
+# rubocop:enable Style/ImplicitRuntimeError

data/lib/codeowner_validator/common/command.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/common/logging'
+require 'open3'
+
+module CodeownerValidator
+  # Public: Module utilized for housing the interactions with the terminal
+  module Command
+    include ::CodeownerValidator::Logging
+
+    # Executes system commands
+    def run(*args, log: true)
+      output = []
+      status = nil
+      log_command(*args) if log
+
+      Open3.popen2e(*args) do |_stdin, stdout_and_stderr, wait_thr|
+        until (line = stdout_and_stderr.gets).nil?
+          output.push line
+          log_info line.chop
+        end
+
+        status = wait_thr.value
+      end
+
+      return if status.success?
+
+      message =
+        [].tap do |ar|
+          ar << "Status: #{status.exitstatus}"
+          # because some commands contain sensitive information (ie passwords),
+          # may not want to display the actual command
+          ar << "Command: #{args.join(' ')}" if log
+        end
+
+      log_error message.join(', ')
+      raise message.join(', ')
+    end
+  end
+end

data/lib/codeowner_validator/common/logging.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require 'logger'
+
+module CodeownerValidator
+  # Public: Mixin for adding methods needed for logging directly to the stdout
+  module Logging
+    # Internal: Reader for the logger attribute.
+    #
+    # Returns a Logger instance.
+    def logger
+      return @logger if @logger
+
+      # depending of the context, utilize existing rails logger if exists
+      @logger = rails_logger || default_logger
+    end
+
+    # Public: Designation if to show verbose output
+    def log_verbose(*messages)
+      return unless verbose?
+
+      messages.flatten.each do |message|
+        logger.info Rainbow(message || yield).magenta.bright
+      end
+    end
+
+    # Public: Displays the command message to the console
+    def log_command(*messages)
+      messages.flatten.each do |message|
+        logger.info Rainbow(message).bright
+      end
+    end
+
+    # Public: Displays an informational message to the console
+    def log_info(*messages)
+      messages.flatten.each do |message|
+        logger.info Rainbow(message).blue.bright
+      end
+    end
+
+    # Public: Displays a warning message to the console
+    def log_warn(*messages)
+      messages.flatten.each do |message|
+        logger.warn Rainbow(message).yellow
+      end
+    end
+
+    # Public: Displays an error message to the console
+    def log_error(*messages)
+      messages.flatten.each do |message|
+        logger.error Rainbow(message).red.bold
+      end
+    end
+
+    # Public: Displays the stderr output to the console
+    def log_stderr(*args)
+      args.each do |message|
+        logger.error message
+      end
+    end
+
+    # Public: Displays the current program running name
+    def program_name
+      @program_name ||= File.basename($PROGRAM_NAME)
+    end
+
+    private
+
+    # Get the Rails logger if it's defined.
+    #
+    # @example Get Rails' logger.
+    #   Loggable.rails_logger
+    #
+    # @return [ Logger ] The Rails logger.
+    def rails_logger
+      defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+    end
+
+    def default_logger
+      logger = ::Logger.new(STDOUT)
+      logger.level = ::Logger::INFO
+      logger
+    end
+  end
+end

data/lib/codeowner_validator/common/tasks/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/common/logging'
+require 'codeowner_validator/common/command'
+require 'codeowner_validator/helpers/utility_helper'
+
+module CodeownerValidator
+  module Tasks
+    # Public: The tasks base class is used for defining the basis for task executions from the
+    # importer or merger executors.
+    class Base
+      include ::CodeownerValidator::Logging
+      include ::CodeownerValidator::Command
+      include ::CodeownerValidator::UtilityHelper
+
+      # Public: Initializing the task with provided arguments
+      # @param [Hash] _args The hash of arguments to utilize for the initialization
+      # @options _args [Boolean] :verbose Indicate if verbose output should be included
+      # @options _args [String] :repo_path The absolute path to the repo for evaluation
+      def initialize(verbose: false, repo_path:, **_args)
+        @verbose = verbose
+        @repo_path = repo_path
+      end
+
+      # Public: Returns the summary of what the task is to accomplish.  Expectation that each
+      # task will define its intent which overrides just the class name output.
+      def summary
+        self.class.name
+      end
+
+      # Public: Executes task's commands
+      def execute
+        comments&.each { |c| log_error c.comment }
+      end
+
+      # Public: Executes all tasks and responds with an array of comments
+      #
+      # @return [Array] Returns an array of comments from the execution of the tasks to be utilized by the consumer
+      def comments; end
+
+      # Public: Returns the codeowner object associated to the repository selected
+      #
+      # @return [CodeownerValidator::CodeOwners] object associate to the repository selected
+      def codeowners
+        @codeowners ||= CodeOwners.new(repo_path: @repo_path)
+      end
+
+      private
+
+      def in_repo_folder(&block)
+        in_folder(@repo_path, &block)
+      end
+
+      def verbose?
+        return CodeownerValidator.verbose if CodeownerValidator.respond_to?(:verbose)
+
+        env_verbose = %w[true yes].include? ENV['VERBOSE']&.downcase
+        @verbose || env_verbose
+      end
+    end
+  end
+end