Add checkboxes to required reviews comments (#28)

Author: BakerNet

README.md

@@ -4,7 +4,7 @@ Code Ownership & Review Assignment Tool - GitHub CODEOWNERS but better
 
 [![Go Report Card](https://goreportcard.com/badge/github.com/multimediallc/codeowners-plus)](https://goreportcard.com/report/github.com/multimediallc/codeowners-plus?kill_cache=1)
 [![Tests](https://github.com/multimediallc/codeowners-plus/actions/workflows/go.yml/badge.svg)](https://github.com/multimediallc/codeowners-plus/actions/workflows/go.yml)
-![Coverage](https://img.shields.io/badge/Coverage-83.6%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Coverage-84.2%25-brightgreen)
 [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 

internal/app/app.go

@@ -0,0 +1,386 @@
+package app
+
+import (
+	"fmt"
+	"io"
+	"slices"
+	"strings"
+	"time"
+
+	owners "github.com/multimediallc/codeowners-plus/internal/config"
+	"github.com/multimediallc/codeowners-plus/internal/git"
+	gh "github.com/multimediallc/codeowners-plus/internal/github"
+	"github.com/multimediallc/codeowners-plus/pkg/codeowners"
+	f "github.com/multimediallc/codeowners-plus/pkg/functional"
+)
+
+// Config holds the application configuration
+type Config struct {
+	Token         string
+	RepoDir       string
+	PR            int
+	Repo          string
+	Verbose       bool
+	Quiet         bool
+	InfoBuffer    io.Writer
+	WarningBuffer io.Writer
+}
+
+// App represents the application with its dependencies
+type App struct {
+	Conf       *owners.Config
+	config     *Config
+	client     gh.Client
+	codeowners codeowners.CodeOwners
+	gitDiff    git.Diff
+}
+
+// New creates a new App instance with the given configuration
+func New(cfg Config) (*App, error) {
+	repoSplit := strings.Split(cfg.Repo, "/")
+	if len(repoSplit) != 2 {
+		return nil, fmt.Errorf("invalid repo name: %s", cfg.Repo)
+	}
+	owner := repoSplit[0]
+	repo := repoSplit[1]
+
+	client := gh.NewClient(owner, repo, cfg.Token)
+	app := &App{
+		config: &cfg,
+		client: client,
+	}
+
+	return app, nil
+}
+
+func (a *App) printDebug(format string, args ...interface{}) {
+	if a.config.Verbose {
+		_, _ = fmt.Fprintf(a.config.InfoBuffer, format, args...)
+	}
+}
+
+func (a *App) printWarn(format string, args ...interface{}) {
+	_, _ = fmt.Fprintf(a.config.WarningBuffer, format, args...)
+}
+
+// Run executes the application logic
+func (a *App) Run() (bool, string, error) {
+	// Initialize PR
+	if err := a.client.InitPR(a.config.PR); err != nil {
+		return false, "", fmt.Errorf("InitPR Error: %v", err)
+	}
+	a.printDebug("PR: %d\n", a.client.PR().GetNumber())
+
+	// Read config
+	conf, err := owners.ReadConfig(a.config.RepoDir)
+	if err != nil {
+		a.printWarn("Error reading codeowners.toml - using default config\n")
+	}
+	a.Conf = conf
+
+	// Setup diff context
+	diffContext := git.DiffContext{
+		Base:       a.client.PR().Base.GetSHA(),
+		Head:       a.client.PR().Head.GetSHA(),
+		Dir:        a.config.RepoDir,
+		IgnoreDirs: conf.Ignore,
+	}
+
+	// Get the diff of the PR
+	a.printDebug("Getting diff for %s...%s\n", diffContext.Base, diffContext.Head)
+	gitDiff, err := git.NewDiff(diffContext)
+	if err != nil {
+		return false, "", fmt.Errorf("NewGitDiff Error: %v", err)
+	}
+	a.gitDiff = gitDiff
+
+	// Initialize codeowners
+	codeOwners, err := codeowners.New(a.config.RepoDir, gitDiff.AllChanges(), a.config.WarningBuffer)
+	if err != nil {
+		return false, "", fmt.Errorf("NewCodeOwners Error: %v", err)
+	}
+	a.codeowners = codeOwners
+
+	// Set author
+	author := fmt.Sprintf("@%s", a.client.PR().User.GetLogin())
+	codeOwners.SetAuthor(author)
+
+	// Warn about unowned files
+	for _, uFile := range codeOwners.UnownedFiles() {
+		a.printWarn("WARNING: Unowned File: %s\n", uFile)
+	}
+
+	// Print file owners if verbose
+	if a.config.Verbose {
+		a.printFileOwners(codeOwners)
+	}
+
+	// Process approvals and reviewers
+	return a.processApprovalsAndReviewers()
+}
+
+func (a *App) processApprovalsAndReviewers() (bool, string, error) {
+	message := ""
+	// Get all required owners before filtering
+	allRequiredOwners := a.codeowners.AllRequired()
+	allRequiredOwnerNames := allRequiredOwners.Flatten()
+	a.printDebug("All Required Owners: %s\n", allRequiredOwnerNames)
+
+	// Get optional reviewers
+	allOptionalReviewerNames := a.codeowners.AllOptional().Flatten()
+	allOptionalReviewerNames = f.Filtered(allOptionalReviewerNames, func(name string) bool {
+		return !slices.Contains(allRequiredOwnerNames, name)
+	})
+	a.printDebug("All Optional Reviewers: %s\n", allOptionalReviewerNames)
+
+	// Initialize user reviewer map
+	if err := a.client.InitUserReviewerMap(allRequiredOwnerNames); err != nil {
+		return false, message, fmt.Errorf("InitUserReviewerMap Error: %v", err)
+	}
+
+	// Get current approvals
+	ghApprovals, err := a.client.GetCurrentReviewerApprovals()
+	if err != nil {
+		return false, message, fmt.Errorf("GetCurrentApprovals Error: %v", err)
+	}
+	a.printDebug("Current Approvals: %+v\n", ghApprovals)
+
+	// Process token owner approval if enabled
+	var tokenOwnerApproval *gh.CurrentApproval
+	if a.Conf.Enforcement.Approval {
+		tokenOwnerApproval, err = a.processTokenOwnerApproval()
+		if err != nil {
+			return false, message, err
+		}
+	}
+
+	// Process approvals and dismiss stale ones
+	validApprovalCount, err := a.processApprovals(ghApprovals)
+	if err != nil {
+		return false, message, err
+	}
+
+	// Request reviews from required owners
+	err = a.requestReviews()
+	if err != nil {
+		return false, message, err
+	}
+
+	unapprovedOwners := a.codeowners.AllRequired()
+	maxReviewsMet := false
+	if a.Conf.MaxReviews != nil && *a.Conf.MaxReviews > 0 {
+		if validApprovalCount >= *a.Conf.MaxReviews && len(f.Intersection(unapprovedOwners.Flatten(), a.Conf.UnskippableReviewers)) == 0 {
+			maxReviewsMet = true
+		}
+	}
+
+	// Add comments to the PR if necessary
+	err = a.addReviewStatusComment(allRequiredOwners, maxReviewsMet)
+	if err != nil {
+		return false, message, fmt.Errorf("failed to add review status comment: %w", err)
+	}
+	err = a.addOptionalCcComment(allOptionalReviewerNames)
+	if err != nil {
+		return false, message, fmt.Errorf("failed to add optional CC comment: %w", err)
+	}
+
+	// Exit if there are any unapproved codeowner teams
+	if len(unapprovedOwners) > 0 && !maxReviewsMet {
+		// Return failed status if any codeowner team has not approved the PR
+		unapprovedCommentString := unapprovedOwners.ToCommentString(false)
+		if a.Conf.Enforcement.Approval && tokenOwnerApproval != nil {
+			_ = a.client.DismissStaleReviews([]*gh.CurrentApproval{tokenOwnerApproval})
+		}
+		message = fmt.Sprintf(
+			"FAIL: Codeowners reviews not satisfied\nStill required:\n%s",
+			unapprovedCommentString,
+		)
+		return false, message, nil
+	}
+
+	// Exit if there are not enough reviews
+	if a.Conf.MinReviews != nil && *a.Conf.MinReviews > 0 {
+		if validApprovalCount < *a.Conf.MinReviews {
+			message = fmt.Sprintf("FAIL: Min Reviews not satisfied. Need %d, found %d", *a.Conf.MinReviews, validApprovalCount)
+			return false, message, nil
+		}
+	}
+
+	message = "Codeowners reviews satisfied"
+	if a.Conf.Enforcement.Approval && tokenOwnerApproval == nil {
+		// Approve the PR since all codeowner teams have approved
+		err = a.client.ApprovePR()
+		if err != nil {
+			return true, message, fmt.Errorf("ApprovePR Error: %v", err)
+		}
+	}
+	return true, message, nil
+}
+
+func (a *App) addReviewStatusComment(allRequiredOwners codeowners.ReviewerGroups, maxReviewsMet bool) error {
+	// Comment on the PR with the codeowner teams required for review
+
+	if a.config.Quiet || len(allRequiredOwners) == 0 {
+		a.printDebug("Skipping review status comment (disabled or no unapproved owners).\n")
+		return nil
+	}
+
+	var commentPrefix = "Codeowners approval required for this PR:\n"
+
+	hasHighPriority, err := a.client.IsInLabels(a.Conf.HighPriorityLabels)
+	if err != nil {
+		a.printWarn("WARNING: Error checking high priority labels: %v\n", err)
+	} else if hasHighPriority {
+		commentPrefix = "❗High Prio❗\n\n" + commentPrefix
+	}
+
+	comment := commentPrefix + allRequiredOwners.ToCommentString(true)
+
+	if maxReviewsMet {
+		comment += "\n\nThe PR has received the max number of required reviews. No further action is required."
+	}
+
+	fiveDaysAgo := time.Now().AddDate(0, 0, -5)
+	existingComment, existingFound, err := a.client.FindExistingComment(commentPrefix, &fiveDaysAgo)
+	if err != nil {
+		return fmt.Errorf("FindExistingComment Error: %v", err)
+	}
+
+	if existingFound {
+		if found, _ := a.client.IsInComments(comment, &fiveDaysAgo); found {
+			// we don't need to update the comment
+			return nil
+		}
+		a.printDebug("Updating existing review status comment\n")
+		err = a.client.UpdateComment(existingComment, comment)
+		if err != nil {
+			return fmt.Errorf("UpdateComment Error: %v", err)
+		}
+	} else {
+		a.printDebug("Adding new review status comment: %q\n", comment)
+		err = a.client.AddComment(comment)
+		if err != nil {
+			return fmt.Errorf("AddComment Error: %v", err)
+		}
+	}
+
+	return nil
+}
+
+func (a *App) addOptionalCcComment(allOptionalReviewerNames []string) error {
+	// Add CC comment to the PR with the optional reviewers that have not already been mentioned in the PR comments
+
+	if a.config.Quiet || len(allOptionalReviewerNames) == 0 {
+		return nil
+	}
+
+	var isInCommentsError error
+	viewersToPing := f.Filtered(allOptionalReviewerNames, func(name string) bool {
+		if isInCommentsError != nil {
+			return false
+		}
+		found, err := a.client.IsSubstringInComments(name, nil)
+		if err != nil {
+			a.printWarn("WARNING: Error checking comments for substring '%s': %v\n", name, err)
+			isInCommentsError = err
+			return false
+		}
+		return !found
+	})
+
+	if isInCommentsError != nil {
+		return fmt.Errorf("IsInComments Error: %v", isInCommentsError)
+	}
+
+	// Add the CC comment if there are any viewers to ping
+	if len(viewersToPing) > 0 {
+		comment := fmt.Sprintf("cc %s", strings.Join(viewersToPing, " "))
+		a.printDebug("Adding CC comment: %q\n", comment)
+		err := a.client.AddComment(comment)
+		if err != nil {
+			return fmt.Errorf("AddComment Error: %v", err)
+		}
+	} else {
+		a.printDebug("No new optional reviewers to CC.\n")
+	}
+
+	return nil
+}
+
+func (a *App) processTokenOwnerApproval() (*gh.CurrentApproval, error) {
+	tokenOwner, err := a.client.GetTokenUser()
+	if err != nil {
+		a.printWarn("WARNING: You might be trying to use a bot as an Enforcement.Approval user," +
+			" but this will not work due to GitHub CODEOWNERS not allowing bots as code owners." +
+			" To use the Enforcement.Approval feature, the token must belong to a GitHub user account")
+
+		a.Conf.Enforcement.Approval = false
+		return nil, nil
+	}
+
+	tokenOwnerApproval, _ := a.client.FindUserApproval(tokenOwner)
+	return tokenOwnerApproval, nil
+}
+
+func (a *App) processApprovals(ghApprovals []*gh.CurrentApproval) (int, error) {
+	fileReviewers := f.MapMap(a.codeowners.FileRequired(), func(reviewers codeowners.ReviewerGroups) []string { return reviewers.Flatten() })
+	approvers, approvalsToDismiss := a.client.CheckApprovals(fileReviewers, ghApprovals, a.gitDiff)
+	a.codeowners.ApplyApprovals(approvers)
+
+	if len(approvalsToDismiss) > 0 {
+		a.printDebug("Dismissing Stale Approvals: %+v\n", approvalsToDismiss)
+		if err := a.client.DismissStaleReviews(approvalsToDismiss); err != nil {
+			return 0, fmt.Errorf("DismissStaleReviews Error: %v", err)
+		}
+	}
+
+	return len(ghApprovals) - len(approvalsToDismiss), nil
+}
+
+func (a *App) requestReviews() error {
+	if a.config.Quiet {
+		return nil
+	}
+
+	unapprovedOwners := a.codeowners.AllRequired()
+	unapprovedOwnerNames := unapprovedOwners.Flatten()
+	a.printDebug("Remaining Required Owners: %s\n", unapprovedOwnerNames)
+
+	currentlyRequestedOwners, err := a.client.GetCurrentlyRequested()
+	if err != nil {
+		return fmt.Errorf("GetCurrentlyRequested Error: %v", err)
+	}
+	a.printDebug("Currently Requested Owners: %s\n", currentlyRequestedOwners)
+
+	previousReviewers, err := a.client.GetAlreadyReviewed()
+	if err != nil {
+		return fmt.Errorf("GetAlreadyReviewed Error: %v", err)
+	}
+	a.printDebug("Already Reviewed Owners: %s\n", previousReviewers)
+
+	filteredOwners := unapprovedOwners.FilterOut(currentlyRequestedOwners...)
+	filteredOwners = filteredOwners.FilterOut(previousReviewers...)
+	filteredOwnerNames := filteredOwners.Flatten()
+
+	if len(filteredOwners) > 0 {
+		a.printDebug("Requesting Reviews from: %s\n", filteredOwnerNames)
+		if err := a.client.RequestReviewers(filteredOwnerNames); err != nil {
+			return fmt.Errorf("RequestReviewers Error: %v", err)
+		}
+	}
+
+	return nil
+}
+
+func (a *App) printFileOwners(codeOwners codeowners.CodeOwners) {
+	fileRequired := codeOwners.FileRequired()
+	a.printDebug("File Reviewers:\n")
+	for file, reviewers := range fileRequired {
+		a.printDebug("- %s: %+v\n", file, reviewers.Flatten())
+	}
+	fileOptional := codeOwners.FileOptional()
+	a.printDebug("File Optional:\n")
+	for file, reviewers := range fileOptional {
+		a.printDebug("- %s: %+v\n", file, reviewers.Flatten())
+	}
+}