codeowner_validator 0.1.1

data/lib/codeowner_validator/group/comment/error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/group/comment'
+
+module CodeownerValidator
+  module Group
+    module Comment
+      # Public: An error comment response
+      class Error
+        include Comment
+
+        class << self
+          # @see CodeownerValidator::Group::Comment.match?
+          def match?(type)
+            Comment::TYPE_ERROR == type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/codeowner_validator/group/comment/info.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/group/comment'
+
+module CodeownerValidator
+  module Group
+    module Comment
+      # Public: An info comment response
+      class Info
+        include Comment
+
+        class << self
+          # @see CodeownerValidator::Group::Comment.match?
+          def match?(type)
+            Comment::TYPE_INFO == type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/codeowner_validator/group/comment/verbose.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/group/comment'
+
+module CodeownerValidator
+  module Group
+    module Comment
+      # Public: An info comment response
+      class Verbose
+        include Comment
+
+        class << self
+          # @see CodeownerValidator::Group::Comment.match?
+          def match?(type)
+            Comment::TYPE_VERBOSE == type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/codeowner_validator/group/comment/warn.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/group/comment'
+
+module CodeownerValidator
+  module Group
+    module Comment
+      # Public: A warn comment response
+      class Warn
+        include Comment
+
+        class << self
+          # @see CodeownerValidator::Group::Comment.match?
+          def match?(type)
+            Comment::TYPE_WARN == type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/codeowner_validator/group/comment.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CodeownerValidator
+  module Group
+    # Public: Object for storing base comment information that can be rendered appropriately by the consumer
+    module Comment
+      TYPE_VERBOSE = 1
+      TYPE_INFO    = 2
+      TYPE_WARN    = 3
+      TYPE_ERROR   = 4
+
+      # to keep track of hierarchical structure of comments and allow grouping
+      attr_accessor :parent
+      attr_reader :comment
+
+      class << self
+        # Public: Creates an instance of the comment for usage.
+        #
+        # @param [Hash] _args The hash of arguments accepted
+        # @option _args [String] :comment The comment to create
+        # @option _args [Integer] :type The comment type (info, warn, error, verbose)
+        #
+        # @return [Info|]
+        def build(comment:, type: TYPE_INFO, **_args)
+          subclasses.each do |klass|
+            return klass.new(comment) if klass.match?(type)
+          end
+          raise "Type '#{type}' not supported" # rubocop:disable Style/ImplicitRuntimeError
+        end
+
+        # Public: Returns <true> if the type of object requested is supported by the object; otherwise, <false>
+        #
+        # @param [Integer] type The type of comment to match on a subclass
+        def match?(type); end
+
+        private
+
+        # returns the available subclasses to the base object
+        def subclasses
+          [Info, Warn, Error, Verbose]
+        end
+      end
+
+      # Public: Creates an instance of the comment
+      #
+      # @param [String] comment The string text of the comment
+      def initialize(comment)
+        @comment = comment
+      end
+    end
+  end
+end
+
+# require all subclasses
+Dir.glob(File.join(File.dirname(__FILE__), 'comment', '**/*.rb'), &method(:require))

data/lib/codeowner_validator/helpers/config_helper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'tty-spinner'
+
+module CodeownerValidator
+  # Public: A configuration helper designed to assist in simple abstraction of TTY:Prompt requests
+  # and assign those responses to the base module's configuration
+  class ConfigHelper
+    class << self
+      # Public: An abstraction onto the TTY:Prompt.ask to allow requesting information from the user's input
+      # and saving that input within the base module's configuration
+      #
+      # @param [Hash] args The arguments in which to accept
+      # @option args [String] :ident The identifier to the config to store
+      # @option args [String] :prompt The prompt to display to the user
+      # @option args [String] :default The default value to display
+      # @option args [Boolean] :required Indicates if the requested ask required input from the user
+      # @option args [Boolean] :force_ask Indicates to ignore previous ask and perform again
+      # @option args [Boolean] :mask Indicates that the response should be hidden
+      def ask(ident:, prompt:, required: false, force_ask: false, mask: false, **args)
+        opts =
+          {}.tap do |h|
+            h[:required] = required
+            h[:default] = args[:default] if args[:default]
+          end
+
+        # return if either not being forced to ask or the information has been previously captured
+        return if !force_ask && ::CodeownerValidator.respond_to?(ident)
+
+        tty_prompt = ::TTY::Prompt.new
+        response =
+          tty_prompt.collect do
+            if mask
+              key(ident.to_sym).mask(
+                prompt,
+                opts
+              )
+            else
+              key(ident.to_sym).ask(
+                prompt,
+                opts
+              )
+            end
+          end
+
+        ::CodeownerValidator.configure! response
+      end
+
+      # Public: An abstraction onto the TTY:Prompt.select to allow requesting information from the user's input
+      # and saving that input within the base module's configuration
+      #
+      # @param [Hash] args The arguments in which to accept
+      # @option args [String] :ident The identifier to the config to store
+      # @option args [String] :prompt The prompt to display to the user
+      # @option args [Boolean] :force_ask Indicates to ignore previous ask and perform again
+      # @option args [Boolean] :choices The array of choices available for selection by the user
+      def select(ident:, prompt:, force_ask: false, choices:, **args)
+        # return if either not being forced to ask or the information has been previously captured
+        return if !force_ask && ::CodeownerValidator.respond_to?(ident)
+
+        tty_prompt = ::TTY::Prompt.new
+        response = tty_prompt.select(
+          prompt,
+          choices,
+          args
+        )
+
+        ::CodeownerValidator.configure! ident => response
+      end
+    end
+  end
+end

data/lib/codeowner_validator/helpers/utility_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ImplicitRuntimeError
+module CodeownerValidator
+  # Public: A utility helper to provide common methods for reuse across multiple
+  # classes
+  module UtilityHelper
+    # Provides a way to change the current working directory to a different folder location.
+    # This ability can ease the reference of file references when working with multiple
+    # repository locations.
+    #
+    # @raise [RuntimeError] if the folder location does not exist.
+    def in_folder(folder)
+      raise "The folder location '#{folder}' does not exists" unless File.directory?(folder)
+
+      if defined?(Bundler)
+        Bundler.with_clean_env do
+          Dir.chdir folder do
+            yield
+          end
+        end
+      else
+        Dir.chdir folder do
+          yield
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Style/ImplicitRuntimeError

data/lib/codeowner_validator/lists/whitelist.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module CodeownerValidator
+  module Lists
+    # Manage whitelist file reading
+    class Whitelist
+      attr_reader :repo_path
+
+      # Public: Initialized with a provided file
+      #
+      # @param [String] filename The filename to initialize the list with
+      # @param [String] repo_path The repository base path utilized for evaluation of a .gitignore
+      def initialize(filename: nil, repo_path: nil)
+        @filename = filename
+        @repo_path = repo_path
+
+        # to avoid instance variable not initialized warnings
+        @whitelist_file = nil
+        @whitelist_file_paths = nil
+        @git_ignore_file = nil
+      end
+
+      # Public: Checks for existence configuration for the whitelist
+      #
+      # @return <true> if found; otherwise, <false>
+      def exist?
+        !pathspec.empty?
+      end
+
+      # Public: Returns <true> if the file supplied has been whitelisted; otherwise, <false>
+      #
+      # @param [String] filename The file to evaluate if has been whitelisted
+      # @return <true> if the file supplied has been whitelisted; otherwise, <false>
+      def whitelisted?(filename)
+        # if no items in the whitelist, assume all items are whitelisted
+        return true if pathspec.empty?
+
+        listed?(filename)
+      end
+
+      # add a `to_proc` method that allows instances of this class to be passed as a block
+      # for easier chaining executions
+      def to_proc
+        proc { |item| whitelisted?(item) }
+      end
+
+      private
+
+      # search for the .gitignore file if provided a repo path
+      def git_ignore_file
+        # if no repo, there can be no discovery of a file
+        return unless repo_path
+
+        return @git_ignore_file if @git_ignore_file
+
+        file = File.join(repo_path, '.gitignore')
+        @git_ignore_file = file if File.exist?(file)
+      end
+
+      # search for an actual file within the repository named 'CODEOWNERS_WHITELIST'
+      def whitelist_file
+        # if no repo, there can be no discovery of a file
+        return unless repo_path
+
+        return @whitelist_file if @whitelist_file
+
+        whitelist_file_paths.each do |path|
+          current_file_path = File.join(repo_path, path)
+          return current_file_path if File.exist?(current_file_path)
+        end
+
+        nil
+      end
+
+      # locations to search for the repository driven codeowners whitelist file
+      def whitelist_file_paths
+        return @whitelist_file_paths if @whitelist_file_paths
+
+        @whitelist_file_paths = %w[CODEOWNERS_WHITELIST .github/CODEOWNERS_WHITELIST]
+
+        # allow customization of the locations to search for the file
+        if ENV['CODEOWNER_WHITELIST_FILE_PATHS']
+          ENV['CODEOWNER_WHITELIST_FILE_PATHS']&.split(',')&.each(&:strip!)&.each do |str|
+            @whitelist_file_paths << str
+          end
+        end
+
+        @whitelist_file_paths
+      end
+
+      # checks for the match of the filename
+      def listed?(filename)
+        pathspec.match(filename)
+      end
+
+      # the pathspec is a combination of files and variables:
+      # * CODEOWNERS_WHITELIST - if provided a repo_path, file that exists in either the root repo path
+      #   or alongside the CODEOWNERS file
+      # * CODEOWNERS_WHITELIST - env variable of comma separated
+      # * .gitignore - if provided a repo_path, this file is automatically added
+      def pathspec
+        # to avoid instance variable @pathspec not initialized must check if defined prior
+        return @pathspec if defined?(@pathspec) && @pathspec
+
+        @pathspec = PathSpec.new([])
+
+        # first, add repo driven codeowners whitelist file
+        @pathspec.add ::File.readlines(whitelist_file).map(&:chomp) if whitelist_file
+
+        # second, add provided file
+        @pathspec.add ::File.readlines(@filename).map(&:chomp) if @filename && File.exist?(@filename)
+
+        # third, add items from the CODEOWNERS_WHITELIST
+        if ENV['CODEOWNERS_WHITELIST']
+          new_items =
+            [].tap do |ar|
+              ENV['CODEOWNERS_WHITELIST']&.split(',')&.each(&:strip!)&.each do |str|
+                ar << str
+              end
+            end
+
+          @pathspec.add new_items
+        end
+
+        # last, add items from the .gitignore.  this must always be last because
+        # of the check for empty specs at this point in which will require inclusion of
+        # all files prior to adding items to exclude.
+
+        # if a gitignore exists, add each reference
+        if git_ignore_file
+          # first, check if existing pathspec evaluation is empty, if yes, need to add all files '**'
+          # because the pathspec evaluation will only make evaluations based on the inclusive=false so need
+          # to first include all files to provide an entry to inclusive=true
+          @pathspec.add ['**'] if @pathspec.empty?
+
+          @pathspec.add ::File.readlines(git_ignore_file).map do |line|
+            "!#{line.chomp}"
+          end
+        end
+
+        @pathspec
+      end
+    end
+  end
+end

data/lib/codeowner_validator/tasks/duplicate_checker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/common/tasks/base'
+require 'codeowner_validator/group/comment'
+
+module CodeownerValidator
+  module Tasks
+    # Public: The duplicate checker executes an evaluation on the code owners file looking for duplicate
+    # pattern references
+    class DuplicateChecker < Base
+      include ::CodeownerValidator::Group
+
+      # @see ::CodeownerValidator::Tasks::Base.summary
+      def summary
+        'Executing Duplicated Pattern Checker'
+      end
+
+      # @see ::CodeownerValidator::Tasks::Base.comments
+      def comments
+        comments = []
+
+        codeowners.duplicated_patterns.each do |key, value|
+          msg = "Pattern '#{key}' is defined #{value.size} times on lines " \
+                "#{value.map(&:line_number).join(', ')}"
+          comments << Comment.build(comment: msg, type: Comment::TYPE_ERROR)
+        end
+
+        comments
+      end
+    end
+  end
+end

data/lib/codeowner_validator/tasks/file_exists_checker.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/common/tasks/base'
+require 'codeowner_validator/group/comment'
+
+module CodeownerValidator
+  module Tasks
+    # Public: The file existence checker executes an evaluation on the code owners file looking for references
+    # to non-existent files within the repository
+    class FileExistsChecker < Base
+      include ::CodeownerValidator::Group
+
+      # @see ::CodeownerValidator::Tasks::Base.summary
+      def summary
+        'Executing File Exists Checker'
+      end
+
+      # @see ::CodeownerValidator::Tasks::Base.comments
+      def comments
+        comments = []
+
+        codeowners.invalid_reference_lines.each do |line|
+          file_name = line.pattern? ? line.pattern : line
+          msg = "line #{line.line_number}: '#{file_name}' does not match any files in the repository"
+          comments << Comment.build(
+            comment: msg,
+            type: Comment::TYPE_ERROR
+          )
+        end
+
+        comments
+      end
+    end
+  end
+end

data/lib/codeowner_validator/tasks/missing_assignment_checker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/common/tasks/base'
+
+module CodeownerValidator
+  module Tasks
+    # Public: The missing assignment checker executes an evaluation on the code owners file looking for files
+    # within the repository that are not noted as been assigned by the codeowners file
+    class MissingAssignmentChecker < Base
+      include ::CodeownerValidator::Group
+
+      # @see ::CodeownerValidator::Tasks::Base.summary
+      def summary
+        'Executing Missing Assignment Checker'
+      end
+
+      # @see ::CodeownerValidator::Tasks::Base.comments
+      def comments
+        comments = []
+
+        codeowners.missing_assignments.each do |file|
+          comments << Comment.build(
+            comment: "File '#{file}' is missing from the code owners file",
+            type: Comment::TYPE_ERROR
+          )
+        end
+
+        comments
+      end
+    end
+  end
+end

data/lib/codeowner_validator/tasks/syntax_checker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/common/tasks/base'
+
+module CodeownerValidator
+  module Tasks
+    # Public: The syntax checker executes an evaluation on the code owners file looking for missing assignment
+    # within the file itself
+    class SyntaxChecker < Base
+      include ::CodeownerValidator::Group
+
+      # @see ::CodeownerValidator::Tasks::Base.summary
+      def summary
+        'Executing Valid Syntax Checker'
+      end
+
+      # @see ::CodeownerValidator::Tasks::Base.comments
+      def comments
+        comments = []
+
+        codeowners.unrecognized_assignments.each do |line|
+          comments << Comment.build(
+            comment: "line #{line.line_number}: Missing owner, at least one owner is required",
+            type: Comment::TYPE_ERROR
+          )
+        end
+
+        comments
+      end
+    end
+  end
+end

data/lib/codeowner_validator/validator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'codeowner_validator/common/tasks/base'
+Dir.glob(File.join(File.dirname(__FILE__), 'tasks', '**/*.rb'), &method(:require))
+require 'codeowner_validator/group/comment'
+
+module CodeownerValidator
+  # Public: The validator is utilized for execution of the tasks associated to the code owner validation tasks.
+  # It has the option to either execute a validation and automatically output the stdout or return an [Array]
+  # of comments for the consumer to do as they please.  The CLI execution will route all comments to stdout.
+  class Validator < ::CodeownerValidator::Tasks::Base
+    include ::CodeownerValidator::Group
+
+    # Public: Creates an instance of the executor with provided tasks
+    #
+    # @param [Hash] options The user provided options from the command line
+    # @options options [Array] :tasks Array of tasks that should be specifically executed by the merger
+    def initialize(tasks: [], **options)
+      super
+      @options = options
+
+      # allow defining what tasks the merger should execute
+      @tasks = tasks.map { |task_class| task_class.new(**@options) } unless tasks.empty?
+    end
+
+    # Public: Returns an array of summaries associated to all tasks that are to be executed
+    #
+    # @return [Array] An array of strings describing the tasks that are to be executed
+    def summary
+      tasks.map { |t| " * #{t.summary}" }
+    end
+
+    # Public: Performs the execution of all tasks
+    def validate
+      log_verbose(%w[Started:] + summary)
+
+      in_repo_folder do
+        tasks&.each(&:execute)
+      end
+
+      log_info 'VALIDATION complete! 🌟'
+    end
+
+    # Public: Performs the execution of all tasks and returns the comments to be interpreted
+    def comments
+      comments = []
+
+      in_repo_folder do
+        tasks&.each do |task|
+          parent = Comment.build(
+            comment: task.summary,
+            type: Comment::TYPE_VERBOSE
+          )
+          task.comments.each do |comment|
+            comment.parent = parent
+            comments << comment
+          end
+        end
+      end
+
+      comments.group_by(&:parent)
+    end
+
+    private
+
+    def tasks
+      @tasks ||=
+        [
+          Tasks::DuplicateChecker,
+          Tasks::SyntaxChecker,
+          Tasks::FileExistsChecker,
+          Tasks::MissingAssignmentChecker
+        ].compact.map { |task_class| task_class.new(@options) } # rubocop:disable Performance/ChainArrayAllocation
+    end
+  end
+end

data/lib/codeowner_validator/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CodeownerValidator
+  VERSION = '0.1.1'
+
+  # version module
+  module Version
+    MAJOR, MINOR, PATCH, *BUILD = VERSION.split '.'
+    NUMBERS = [MAJOR, MINOR, PATCH, *BUILD].freeze
+  end
+end

data/lib/codeowner_validator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'codeowners/checker'
+# pull in monkeypatch for codeowners-checker
+require_relative 'codeowners/checker/group/line'
+Dir.glob(File.join(File.dirname(__FILE__), 'codeowner_validator', '**/*.rb'), &method(:require))
+
+# Public: The code owner validator space is utilized for validations against
+# the code owner file for a given repository.
+module CodeownerValidator
+  class << self
+    # Public: Provides the ability to configure instance variables within the module.  If the
+    # method already exists, the value provide will be overwritten.
+    #
+    # @params [Hash] attrs The key/value paired items to be configured on the module.
+    def configure!(attrs = {})
+      attrs.each do |name, value|
+        name = name.to_s.to_sym
+        # protect against multiple executions
+        singleton_class.instance_eval { attr_accessor name } unless self.class.method_defined?(name)
+        send("#{name}=", value)
+      end
+    end
+  end
+
+  # Mail CLI
+  class CLI < Thor
+    desc 'validate', 'validates the codeowners file'
+    subcommand 'validate', ValidatorCLI
+  end
+end

data/lib/codeowners/checker/group/line.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# monkeypatch class to include line number
+module Codeowners
+  class Checker
+    class Group
+      class Line
+        attr_accessor :line_number
+      end
+    end
+  end
+end