fix(librarian): support SSH remotes (#1898)

Fixes: #1791

Author: codyoss

internal/github/github.go

@@ -86,20 +86,41 @@ type PullRequestMetadata struct {
 	Number int
 }
 
-// ParseURL parses a GitHub URL (anything to do with a repository) to determine
+// ParseRemote parses a GitHub remote (anything to do with a repository) to determine
 // the GitHub repo details (owner and name).
-func ParseURL(remoteURL string) (*Repository, error) {
-	if !strings.HasPrefix(remoteURL, "https://github.com/") {
-		return nil, fmt.Errorf("remote '%s' is not a GitHub remote", remoteURL)
+func ParseRemote(remote string) (*Repository, error) {
+	if strings.HasPrefix(remote, "https://github.com/") {
+		return parseHTTPRemote(remote)
 	}
-	remotePath := remoteURL[len("https://github.com/"):]
+	if strings.HasPrefix(remote, "git@") {
+		return parseSSHRemote(remote)
+	}
+	return nil, fmt.Errorf("remote '%s' is not a GitHub remote", remote)
+}
+
+func parseHTTPRemote(remote string) (*Repository, error) {
+	remotePath := remote[len("https://github.com/"):]
 	pathParts := strings.Split(remotePath, "/")
 	organization := pathParts[0]
 	repoName := pathParts[1]
 	repoName = strings.TrimSuffix(repoName, ".git")
 	return &Repository{Owner: organization, Name: repoName}, nil
 }
 
+func parseSSHRemote(remote string) (*Repository, error) {
+	pathParts := strings.Split(remote, ":")
+	if len(pathParts) != 2 {
+		return nil, fmt.Errorf("remote %q is not a GitHub remote", remote)
+	}
+	orgRepo := strings.Split(pathParts[1], "/")
+	if len(orgRepo) != 2 {
+		return nil, fmt.Errorf("remote %q is not a GitHub remote", remote)
+	}
+	organization := orgRepo[0]
+	repoName := strings.TrimSuffix(orgRepo[1], ".git")
+	return &Repository{Owner: organization, Name: repoName}, nil
+}
+
 // GetRawContent fetches the raw content of a file within a repository repo,
 // identifying the file by path, at a specific commit/tag/branch of ref.
 func (c *Client) GetRawContent(ctx context.Context, path, ref string) ([]byte, error) {
@@ -181,11 +202,9 @@ func FetchGitHubRepoFromRemote(repo gitrepo.Repository) (*Repository, error) {
 	for _, remote := range remotes {
 		if remote.Config().Name == "origin" {
 			urls := remote.Config().URLs
-			if len(urls) > 0 && strings.HasPrefix(urls[0], "https://github.com/") {
-				return ParseURL(urls[0])
+			if len(urls) > 0 {
+				return ParseRemote(urls[0])
 			}
-			// If 'origin' exists but is not a GitHub remote, we stop.
-			break
 		}
 	}
 

internal/github/github_test.go

@@ -182,7 +182,7 @@ func TestFetchGitHubRepoFromRemote(t *testing.T) {
 				"origin": {"https://gitlab.com/owner/repo.git"},
 			},
 			wantErr:       true,
-			wantErrSubstr: "could not find an 'origin' remote",
+			wantErrSubstr: "is not a GitHub remote",
 		},
 		{
 			name: "upstream is GitHub, but no origin",
@@ -208,7 +208,7 @@ func TestFetchGitHubRepoFromRemote(t *testing.T) {
 				"upstream": {"https://github.com/gh-owner/gh-repo.git"},
 			},
 			wantErr:       true,
-			wantErrSubstr: "could not find an 'origin' remote",
+			wantErrSubstr: "is not a GitHub remote",
 		},
 		{
 			name: "origin has multiple URLs, first is GitHub",
@@ -278,7 +278,7 @@ func TestParseURL(t *testing.T) {
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
-			repo, err := ParseURL(test.remoteURL)
+			repo, err := ParseRemote(test.remoteURL)
 
 			if test.wantErr {
 				if err == nil {
@@ -298,6 +298,65 @@ func TestParseURL(t *testing.T) {
 	}
 }
 
+func TestParseSSHRemote(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		name          string
+		remote        string
+		wantRepo      *Repository
+		wantErr       bool
+		wantErrSubstr string
+	}{
+		{
+			name:     "Valid SSH URL with .git",
+			remote:   "[email protected]:owner/repo.git",
+			wantRepo: &Repository{Owner: "owner", Name: "repo"},
+		},
+		{
+			name:     "Valid SSH URL without .git",
+			remote:   "[email protected]:owner/repo",
+			wantRepo: &Repository{Owner: "owner", Name: "repo"},
+		},
+		{
+			name:          "Invalid remote, no git@ prefix",
+			remote:        "https://github.com/owner/repo.git",
+			wantErr:       true,
+			wantErrSubstr: "not a GitHub remote",
+		},
+		{
+			name:          "Invalid remote, no colon",
+			remote:        "[email protected]/repo.git",
+			wantErr:       true,
+			wantErrSubstr: "not a GitHub remote",
+		},
+		{
+			name:          "Invalid remote, no slash",
+			remote:        "[email protected]:owner-repo.git",
+			wantErr:       true,
+			wantErrSubstr: "not a GitHub remote",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			repo, err := parseSSHRemote(test.remote)
+			if test.wantErr {
+				if err == nil {
+					t.Errorf("ParseSSHRemote() err = nil, want error containing %q", test.wantErrSubstr)
+				} else if !strings.Contains(err.Error(), test.wantErrSubstr) {
+					t.Errorf("ParseSSHRemote() err = %v, want error containing %q", err, test.wantErrSubstr)
+				}
+			} else {
+				if err != nil {
+					t.Errorf("ParseSSHRemote() err = %v, want nil", err)
+				}
+				if diff := cmp.Diff(test.wantRepo, repo); diff != "" {
+					t.Errorf("ParseSSHRemote() repo mismatch (-want +got): %s", diff)
+				}
+			}
+		})
+	}
+}
+
 func TestCreatePullRequest(t *testing.T) {
 	t.Parallel()
 	for _, test := range []struct {

internal/librarian/command.go

@@ -100,7 +100,7 @@ func newCommandRunner(cfg *config.Config) (*commandRunner, error) {
 
 	var gitRepo *github.Repository
 	if isURL(cfg.Repo) {
-		gitRepo, err = github.ParseURL(cfg.Repo)
+		gitRepo, err = github.ParseRemote(cfg.Repo)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse repo url: %w", err)
 		}