refactor(repo): use repo struct whenever possible

Author: nobe4

internal/cmd/combine_prs.go

@@ -12,41 +12,41 @@ import (
 	"github.com/github/gh-combine/internal/github"
 )
 
-func CombinePRs(ctx context.Context, graphQlClient *api.GraphQLClient, restClient *api.RESTClient, owner, repo string, pulls github.Pulls) error {
+func CombinePRs(ctx context.Context, graphQlClient *api.GraphQLClient, restClient *api.RESTClient, repo github.Repo, pulls github.Pulls) error {
 	// Define the combined branch name
 	workingBranchName := combineBranchName + workingBranchSuffix
 
 	// Get the default branch of the repository
-	repoDefaultBranch, err := getDefaultBranch(ctx, restClient, owner, repo)
+	repoDefaultBranch, err := getDefaultBranch(ctx, restClient, repo.Owner, repo.Repo)
 	if err != nil {
 		return fmt.Errorf("failed to get default branch: %w", err)
 	}
 
-	baseBranchSHA, err := getBranchSHA(ctx, restClient, owner, repo, repoDefaultBranch)
+	baseBranchSHA, err := getBranchSHA(ctx, restClient, repo.Owner, repo.Repo, repoDefaultBranch)
 	if err != nil {
 		return fmt.Errorf("failed to get SHA of main branch: %w", err)
 	}
 
 	// Delete any pre-existing working branch
-	err = deleteBranch(ctx, restClient, owner, repo, workingBranchName)
+	err = deleteBranch(ctx, restClient, repo.Owner, repo.Repo, workingBranchName)
 	if err != nil {
 		Logger.Debug("Working branch not found, continuing", "branch", workingBranchName)
 	}
 
 	// Delete any pre-existing combined branch
-	err = deleteBranch(ctx, restClient, owner, repo, combineBranchName)
+	err = deleteBranch(ctx, restClient, repo.Owner, repo.Repo, combineBranchName)
 	if err != nil {
 		Logger.Debug("Combined branch not found, continuing", "branch", combineBranchName)
 	}
 
 	// Create the combined branch
-	err = createBranch(ctx, restClient, owner, repo, combineBranchName, baseBranchSHA)
+	err = createBranch(ctx, restClient, repo.Owner, repo.Repo, combineBranchName, baseBranchSHA)
 	if err != nil {
 		return fmt.Errorf("failed to create combined branch: %w", err)
 	}
 
 	// Create the working branch
-	err = createBranch(ctx, restClient, owner, repo, workingBranchName, baseBranchSHA)
+	err = createBranch(ctx, restClient, repo.Owner, repo.Repo, workingBranchName, baseBranchSHA)
 	if err != nil {
 		return fmt.Errorf("failed to create working branch: %w", err)
 	}
@@ -55,7 +55,7 @@ func CombinePRs(ctx context.Context, graphQlClient *api.GraphQLClient, restClien
 	var combinedPRs []string
 	var mergeFailedPRs []string
 	for _, pr := range pulls {
-		err := mergeBranch(ctx, restClient, owner, repo, workingBranchName, pr.Head.Ref)
+		err := mergeBranch(ctx, restClient, repo.Owner, repo.Repo, workingBranchName, pr.Head.Ref)
 		if err != nil {
 			// Check if the error is a 409 merge conflict
 			if isMergeConflictError(err) {
@@ -73,21 +73,21 @@ func CombinePRs(ctx context.Context, graphQlClient *api.GraphQLClient, restClien
 	}
 
 	// Update the combined branch to the latest commit of the working branch
-	err = updateRef(ctx, restClient, owner, repo, combineBranchName, workingBranchName)
+	err = updateRef(ctx, restClient, repo.Owner, repo.Repo, combineBranchName, workingBranchName)
 	if err != nil {
 		return fmt.Errorf("failed to update combined branch: %w", err)
 	}
 
 	// Delete the temporary working branch
-	err = deleteBranch(ctx, restClient, owner, repo, workingBranchName)
+	err = deleteBranch(ctx, restClient, repo.Owner, repo.Repo, workingBranchName)
 	if err != nil {
 		Logger.Warn("Failed to delete working branch", "branch", workingBranchName, "error", err)
 	}
 
 	// Create the combined PR
 	prBody := generatePRBody(combinedPRs, mergeFailedPRs)
 	prTitle := "Combined PRs"
-	err = createPullRequest(ctx, restClient, owner, repo, prTitle, combineBranchName, repoDefaultBranch, prBody)
+	err = createPullRequest(ctx, restClient, repo.Owner, repo.Repo, prTitle, combineBranchName, repoDefaultBranch, prBody)
 	if err != nil {
 		return fmt.Errorf("failed to create combined PR: %w", err)
 	}

internal/cmd/root.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"strings"
 
 	"github.com/cli/go-gh/v2/pkg/api"
 	"github.com/spf13/cobra"
@@ -187,7 +186,7 @@ func executeCombineCommand(ctx context.Context, spinner *Spinner, repos []string
 		return fmt.Errorf("failed to create REST client: %w", err)
 	}
 
-	for _, repo := range repos {
+	for _, repoString := range repos {
 		// Check if context was cancelled (CTRL+C pressed)
 		select {
 		case <-ctx.Done():
@@ -196,7 +195,14 @@ func executeCombineCommand(ctx context.Context, spinner *Spinner, repos []string
 			// Continue processing
 		}
 
-		spinner.UpdateMessage("Processing " + repo)
+		spinner.UpdateMessage("Parsing " + repoString)
+
+		repo, err := github.ParseRepo(repoString)
+		if err != nil {
+			return fmt.Errorf("failed to parse repo: %w", err)
+		}
+
+		spinner.UpdateMessage("Processing " + repo.String())
 		Logger.Debug("Processing repository", "repo", repo)
 
 		// Process the repository
@@ -215,16 +221,7 @@ func executeCombineCommand(ctx context.Context, spinner *Spinner, repos []string
 }
 
 // processRepository handles a single repository's PRs
-func processRepository(ctx context.Context, client *api.RESTClient, graphQlClient *api.GraphQLClient, spinner *Spinner, repo string) error {
-	// Parse owner and repo name
-	parts := strings.Split(repo, "/")
-	if len(parts) != 2 {
-		return fmt.Errorf("invalid repository format: %s", repo)
-	}
-
-	owner := parts[0]
-	repoName := parts[1]
-
+func processRepository(ctx context.Context, client *api.RESTClient, graphQlClient *api.GraphQLClient, spinner *Spinner, repo github.Repo) error {
 	// Check for cancellation
 	select {
 	case <-ctx.Done():
@@ -236,8 +233,7 @@ func processRepository(ctx context.Context, client *api.RESTClient, graphQlClien
 	// Get open PRs for the repository
 	var pulls github.Pulls
 
-	endpoint := fmt.Sprintf("repos/%s/%s/pulls?state=open", owner, repoName)
-	if err := client.Get(endpoint, &pulls); err != nil {
+	if err := client.Get(repo.PullsEndpoint(), &pulls); err != nil {
 		return err
 	}
 
@@ -266,7 +262,7 @@ func processRepository(ctx context.Context, client *api.RESTClient, graphQlClien
 		}
 
 		// Check if PR meets additional requirements (CI, approval)
-		meetsRequirements, err := PrMeetsRequirements(ctx, graphQlClient, owner, repoName, pull.Number)
+		meetsRequirements, err := PrMeetsRequirements(ctx, graphQlClient, repo.Owner, repo.Repo, pull.Number)
 		if err != nil {
 			Logger.Warn("Failed to check PR requirements", "repo", repo, "pr", pull.Number, "error", err)
 			continue
@@ -288,10 +284,8 @@ func processRepository(ctx context.Context, client *api.RESTClient, graphQlClien
 
 	Logger.Debug("Matched PRs", "repo", repo, "count", len(matchedPRs))
 
-	// If we get here, we have enough PRs to combine
-
 	// Combine the PRs
-	err := CombinePRs(ctx, graphQlClient, client, owner, repoName, matchedPRs)
+	err := CombinePRs(ctx, graphQlClient, client, repo, matchedPRs)
 	if err != nil {
 		return fmt.Errorf("failed to combine PRs: %w", err)
 	}