From c30b482bf0d4e275488b91bc00aca2551988caee Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 17 Mar 2020 17:03:10 -0500
Subject: [PATCH 01/48] switch defaults for pr view

---
 command/pr.go      | 14 +++++++-------
 command/pr_test.go | 34 +++++++++++++++++-----------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/command/pr.go b/command/pr.go
index e1c8e796b..104b90ffd 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -31,7 +31,7 @@ func init() {
 	prListCmd.Flags().StringSliceP("label", "l", nil, "Filter by label")
 	prListCmd.Flags().StringP("assignee", "a", "", "Filter by assignee")
 
-	prViewCmd.Flags().BoolP("preview", "p", false, "Display preview of pull request content")
+	prViewCmd.Flags().BoolP("web", "w", false, "Open pull request in browser")
 }
 
 var prCmd = &cobra.Command{
@@ -262,7 +262,7 @@ func prView(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	preview, err := cmd.Flags().GetBool("preview")
+	web, err := cmd.Flags().GetBool("web")
 	if err != nil {
 		return err
 	}
@@ -283,7 +283,7 @@ func prView(cmd *cobra.Command, args []string) error {
 
 		if prNumber > 0 {
 			openURL = fmt.Sprintf("https://github.com/%s/pull/%d", ghrepo.FullName(baseRepo), prNumber)
-			if preview {
+			if !web {
 				pr, err = api.PullRequestByNumber(apiClient, baseRepo, prNumber)
 				if err != nil {
 					return err
@@ -299,12 +299,12 @@ func prView(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	if preview {
-		out := colorableOut(cmd)
-		return printPrPreview(out, pr)
-	} else {
+	if web {
 		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", openURL)
 		return utils.OpenInBrowser(openURL)
+	} else {
+		out := colorableOut(cmd)
+		return printPrPreview(out, pr)
 	}
 }
 
diff --git a/command/pr_test.go b/command/pr_test.go
index 3fd4d9e9b..96dd14da0 100644
--- a/command/pr_test.go
+++ b/command/pr_test.go
@@ -391,7 +391,7 @@ func TestPRView_preview(t *testing.T) {
 	defer jsonFile.Close()
 	http.StubResponse(200, jsonFile)
 
-	output, err := RunCommand(prViewCmd, "pr view -p 12")
+	output, err := RunCommand(prViewCmd, "pr view 12")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -426,7 +426,7 @@ func TestPRView_previewCurrentBranch(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view -p")
+	output, err := RunCommand(prViewCmd, "pr view")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -461,7 +461,7 @@ func TestPRView_previewCurrentBranchWithEmptyBody(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view -p")
+	output, err := RunCommand(prViewCmd, "pr view")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -481,7 +481,7 @@ func TestPRView_previewCurrentBranchWithEmptyBody(t *testing.T) {
 	}
 }
 
-func TestPRView_currentBranch(t *testing.T) {
+func TestPRView_web_currentBranch(t *testing.T) {
 	initBlankContext("OWNER/REPO", "blueberries")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -502,7 +502,7 @@ func TestPRView_currentBranch(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view")
+	output, err := RunCommand(prViewCmd, "pr view -w")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -519,7 +519,7 @@ func TestPRView_currentBranch(t *testing.T) {
 	}
 }
 
-func TestPRView_noResultsForBranch(t *testing.T) {
+func TestPRView_web_noResultsForBranch(t *testing.T) {
 	initBlankContext("OWNER/REPO", "blueberries")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -540,7 +540,7 @@ func TestPRView_noResultsForBranch(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	_, err := RunCommand(prViewCmd, "pr view")
+	_, err := RunCommand(prViewCmd, "pr view -w")
 	if err == nil || err.Error() != `no open pull requests found for branch "blueberries"` {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -550,7 +550,7 @@ func TestPRView_noResultsForBranch(t *testing.T) {
 	}
 }
 
-func TestPRView_numberArg(t *testing.T) {
+func TestPRView_web_numberArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -568,7 +568,7 @@ func TestPRView_numberArg(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view 23")
+	output, err := RunCommand(prViewCmd, "pr view -w 23")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -582,7 +582,7 @@ func TestPRView_numberArg(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_numberArgWithHash(t *testing.T) {
+func TestPRView_web_numberArgWithHash(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -600,7 +600,7 @@ func TestPRView_numberArgWithHash(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view \"#23\"")
+	output, err := RunCommand(prViewCmd, "pr view -w \"#23\"")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -614,7 +614,7 @@ func TestPRView_numberArgWithHash(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_urlArg(t *testing.T) {
+func TestPRView_web_urlArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -632,7 +632,7 @@ func TestPRView_urlArg(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view https://github.com/OWNER/REPO/pull/23/files")
+	output, err := RunCommand(prViewCmd, "pr view -w https://github.com/OWNER/REPO/pull/23/files")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -646,7 +646,7 @@ func TestPRView_urlArg(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_branchArg(t *testing.T) {
+func TestPRView_web_branchArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -666,7 +666,7 @@ func TestPRView_branchArg(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view blueberries")
+	output, err := RunCommand(prViewCmd, "pr view -w blueberries")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -680,7 +680,7 @@ func TestPRView_branchArg(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_branchWithOwnerArg(t *testing.T) {
+func TestPRView_web_branchWithOwnerArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -701,7 +701,7 @@ func TestPRView_branchWithOwnerArg(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view hubot:blueberries")
+	output, err := RunCommand(prViewCmd, "pr view -w hubot:blueberries")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}

From 00de6b9c09a0cc52a30321fe07be7a294dc02477 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 17 Mar 2020 17:06:14 -0500
Subject: [PATCH 02/48] switch defaults for issue view

---
 command/issue.go      |  12 ++--
 command/issue_test.go | 150 +++++++++++++++++++++---------------------
 2 files changed, 81 insertions(+), 81 deletions(-)

diff --git a/command/issue.go b/command/issue.go
index 32858d145..92656d4f1 100644
--- a/command/issue.go
+++ b/command/issue.go
@@ -39,7 +39,7 @@ func init() {
 	issueListCmd.Flags().StringP("author", "A", "", "Filter by author")
 
 	issueCmd.AddCommand(issueViewCmd)
-	issueViewCmd.Flags().BoolP("preview", "p", false, "Display preview of issue content")
+	issueViewCmd.Flags().BoolP("web", "w", false, "Open issue in browser")
 }
 
 var issueCmd = &cobra.Command{
@@ -233,17 +233,17 @@ func issueView(cmd *cobra.Command, args []string) error {
 	}
 	openURL := issue.URL
 
-	preview, err := cmd.Flags().GetBool("preview")
+	web, err := cmd.Flags().GetBool("web")
 	if err != nil {
 		return err
 	}
 
-	if preview {
-		out := colorableOut(cmd)
-		return printIssuePreview(out, issue)
-	} else {
+	if web {
 		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", openURL)
 		return utils.OpenInBrowser(openURL)
+	} else {
+		out := colorableOut(cmd)
+		return printIssuePreview(out, issue)
 	}
 
 }
diff --git a/command/issue_test.go b/command/issue_test.go
index 3fb359693..10b4abdd9 100644
--- a/command/issue_test.go
+++ b/command/issue_test.go
@@ -212,79 +212,79 @@ func TestIssueList_disabledIssues(t *testing.T) {
 	}
 }
 
+func TestIssueView_web(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "hasIssuesEnabled": true, "issue": {
+		"number": 123,
+		"url": "https://github.com/OWNER/REPO/issues/123"
+	} } } }
+	`))
+
+	var seenCmd *exec.Cmd
+	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+		seenCmd = cmd
+		return &test.OutputStub{}
+	})
+	defer restoreCmd()
+
+	output, err := RunCommand(issueViewCmd, "issue view -w 123")
+	if err != nil {
+		t.Errorf("error running command `issue view`: %v", err)
+	}
+
+	eq(t, output.String(), "")
+	eq(t, output.Stderr(), "Opening https://github.com/OWNER/REPO/issues/123 in your browser.\n")
+
+	if seenCmd == nil {
+		t.Fatal("expected a command to run")
+	}
+	url := seenCmd.Args[len(seenCmd.Args)-1]
+	eq(t, url, "https://github.com/OWNER/REPO/issues/123")
+}
+
+func TestIssueView_web_numberArgWithHash(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "hasIssuesEnabled": true, "issue": {
+		"number": 123,
+		"url": "https://github.com/OWNER/REPO/issues/123"
+	} } } }
+	`))
+
+	var seenCmd *exec.Cmd
+	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+		seenCmd = cmd
+		return &test.OutputStub{}
+	})
+	defer restoreCmd()
+
+	output, err := RunCommand(issueViewCmd, "issue view -w \"#123\"")
+	if err != nil {
+		t.Errorf("error running command `issue view`: %v", err)
+	}
+
+	eq(t, output.String(), "")
+	eq(t, output.Stderr(), "Opening https://github.com/OWNER/REPO/issues/123 in your browser.\n")
+
+	if seenCmd == nil {
+		t.Fatal("expected a command to run")
+	}
+	url := seenCmd.Args[len(seenCmd.Args)-1]
+	eq(t, url, "https://github.com/OWNER/REPO/issues/123")
+}
+
 func TestIssueView(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
 
-	http.StubResponse(200, bytes.NewBufferString(`
-	{ "data": { "repository": { "hasIssuesEnabled": true, "issue": {
-		"number": 123,
-		"url": "https://github.com/OWNER/REPO/issues/123"
-	} } } }
-	`))
-
-	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
-		seenCmd = cmd
-		return &test.OutputStub{}
-	})
-	defer restoreCmd()
-
-	output, err := RunCommand(issueViewCmd, "issue view 123")
-	if err != nil {
-		t.Errorf("error running command `issue view`: %v", err)
-	}
-
-	eq(t, output.String(), "")
-	eq(t, output.Stderr(), "Opening https://github.com/OWNER/REPO/issues/123 in your browser.\n")
-
-	if seenCmd == nil {
-		t.Fatal("expected a command to run")
-	}
-	url := seenCmd.Args[len(seenCmd.Args)-1]
-	eq(t, url, "https://github.com/OWNER/REPO/issues/123")
-}
-
-func TestIssueView_numberArgWithHash(t *testing.T) {
-	initBlankContext("OWNER/REPO", "master")
-	http := initFakeHTTP()
-	http.StubRepoResponse("OWNER", "REPO")
-
-	http.StubResponse(200, bytes.NewBufferString(`
-	{ "data": { "repository": { "hasIssuesEnabled": true, "issue": {
-		"number": 123,
-		"url": "https://github.com/OWNER/REPO/issues/123"
-	} } } }
-	`))
-
-	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
-		seenCmd = cmd
-		return &test.OutputStub{}
-	})
-	defer restoreCmd()
-
-	output, err := RunCommand(issueViewCmd, "issue view \"#123\"")
-	if err != nil {
-		t.Errorf("error running command `issue view`: %v", err)
-	}
-
-	eq(t, output.String(), "")
-	eq(t, output.Stderr(), "Opening https://github.com/OWNER/REPO/issues/123 in your browser.\n")
-
-	if seenCmd == nil {
-		t.Fatal("expected a command to run")
-	}
-	url := seenCmd.Args[len(seenCmd.Args)-1]
-	eq(t, url, "https://github.com/OWNER/REPO/issues/123")
-}
-
-func TestIssueView_preview(t *testing.T) {
-	initBlankContext("OWNER/REPO", "master")
-	http := initFakeHTTP()
-	http.StubRepoResponse("OWNER", "REPO")
-
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "hasIssuesEnabled": true, "issue": {
 		"number": 123,
@@ -305,7 +305,7 @@ func TestIssueView_preview(t *testing.T) {
 	} } } }
 	`))
 
-	output, err := RunCommand(issueViewCmd, "issue view -p 123")
+	output, err := RunCommand(issueViewCmd, "issue view 123")
 	if err != nil {
 		t.Errorf("error running command `issue view`: %v", err)
 	}
@@ -326,7 +326,7 @@ func TestIssueView_preview(t *testing.T) {
 	}
 }
 
-func TestIssueView_previewWithEmptyBody(t *testing.T) {
+func TestIssueView_WithEmptyBody(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -351,7 +351,7 @@ func TestIssueView_previewWithEmptyBody(t *testing.T) {
 	} } } }
 	`))
 
-	output, err := RunCommand(issueViewCmd, "issue view -p 123")
+	output, err := RunCommand(issueViewCmd, "issue view 123")
 	if err != nil {
 		t.Errorf("error running command `issue view`: %v", err)
 	}
@@ -371,7 +371,7 @@ func TestIssueView_previewWithEmptyBody(t *testing.T) {
 	}
 }
 
-func TestIssueView_notFound(t *testing.T) {
+func TestIssueView_web_notFound(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 
@@ -388,7 +388,7 @@ func TestIssueView_notFound(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	_, err := RunCommand(issueViewCmd, "issue view 9999")
+	_, err := RunCommand(issueViewCmd, "issue view -w 9999")
 	if err == nil || err.Error() != "graphql error: 'Could not resolve to an Issue with the number of 9999.'" {
 		t.Errorf("error running command `issue view`: %v", err)
 	}
@@ -416,7 +416,7 @@ func TestIssueView_disabledIssues(t *testing.T) {
 	}
 }
 
-func TestIssueView_urlArg(t *testing.T) {
+func TestIssueView_web_urlArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -435,7 +435,7 @@ func TestIssueView_urlArg(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(issueViewCmd, "issue view https://github.com/OWNER/REPO/issues/123")
+	output, err := RunCommand(issueViewCmd, "issue view -w https://github.com/OWNER/REPO/issues/123")
 	if err != nil {
 		t.Errorf("error running command `issue view`: %v", err)
 	}

From e4b43b08b987cd291d662e7f9979e1c70cead962 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 17 Mar 2020 17:13:48 -0500
Subject: [PATCH 03/48] update usage text

---
 command/issue.go | 2 +-
 command/pr.go    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/command/issue.go b/command/issue.go
index 92656d4f1..4db194278 100644
--- a/command/issue.go
+++ b/command/issue.go
@@ -74,7 +74,7 @@ var issueViewCmd = &cobra.Command{
 		}
 		return nil
 	},
-	Short: "View an issue in the browser",
+	Short: "View an issue",
 	RunE:  issueView,
 }
 
diff --git a/command/pr.go b/command/pr.go
index 104b90ffd..e9f78c819 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -57,10 +57,10 @@ var prStatusCmd = &cobra.Command{
 var prViewCmd = &cobra.Command{
 	Use:   "view [{<number> | <url> | <branch>}]",
 	Short: "View a pull request in the browser",
-	Long: `View a pull request specified by the argument in the browser.
+	Long: `View a pull request specified by the argument.
 
 Without an argument, the pull request that belongs to the current
-branch is opened.`,
+branch is displayed.`,
 	RunE: prView,
 }
 

From d75faab85a7b5fae4353046207cc95572ea7b2f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Thu, 19 Mar 2020 16:04:23 +0100
Subject: [PATCH 04/48] Creating a PR now always prioritizes an existing fork
 as a push target

Before: the default push target for the current branch in `pr create`
was the first repository found among git remotes that has write access.

Now: the default push target is the fork the base repo, if said fork
exists and has write access, falling back to old behavior otherwise.

This change in the default is to facilitate contributions to projects
that have a hard requirement that all pull requests (even those opened
by people with write access to that project) come from forks.
---
 api/queries_repo.go       | 39 +++++++++++++++++++++++++++
 command/pr_create.go      | 36 +++++++++++++------------
 command/pr_create_test.go | 40 +++++++++++++++++++++++++---
 context/context.go        | 30 +++++++++++++++++++--
 context/remote_test.go    | 56 +++++++++++++++++++++++++++++++++++++++
 5 files changed, 178 insertions(+), 23 deletions(-)

diff --git a/api/queries_repo.go b/api/queries_repo.go
index 048b72b50..79068f0ea 100644
--- a/api/queries_repo.go
+++ b/api/queries_repo.go
@@ -3,6 +3,7 @@ package api
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"sort"
 	"strings"
@@ -220,6 +221,44 @@ func ForkRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 	}, nil
 }
 
+// RepoFindFork finds a fork of repo affiliated with the viewer
+func RepoFindFork(client *Client, repo ghrepo.Interface) (*Repository, error) {
+	result := struct {
+		Repository struct {
+			Forks struct {
+				Nodes []Repository
+			}
+		}
+	}{}
+
+	variables := map[string]interface{}{
+		"owner": repo.RepoOwner(),
+		"repo":  repo.RepoName(),
+	}
+
+	if err := client.GraphQL(`
+	query($owner: String!, $repo: String!) {
+		repository(owner: $owner, name: $repo) {
+			forks(first: 1, affiliations: [OWNER, COLLABORATOR]) {
+				nodes {
+					id
+					name
+					owner { login }
+					url
+				}
+			}
+		}
+	}
+	`, variables, &result); err != nil {
+		return nil, err
+	}
+
+	if len(result.Repository.Forks.Nodes) > 0 {
+		return &result.Repository.Forks.Nodes[0], nil
+	}
+	return nil, &NotFoundError{errors.New("no fork found")}
+}
+
 // RepoCreateInput represents input parameters for RepoCreate
 type RepoCreateInput struct {
 	Name        string `json:"name"`
diff --git a/command/pr_create.go b/command/pr_create.go
index ca7800a19..e4a4bd2de 100644
--- a/command/pr_create.go
+++ b/command/pr_create.go
@@ -193,7 +193,6 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	}
 
 	didForkRepo := false
-	var headRemote *context.Remote
 	if headRepoErr != nil {
 		if baseRepo.IsPrivate {
 			return fmt.Errorf("cannot fork private repository '%s'", ghrepo.FullName(baseRepo))
@@ -203,19 +202,6 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 			return fmt.Errorf("error forking repo: %w", err)
 		}
 		didForkRepo = true
-		// TODO: support non-HTTPS git remote URLs
-		baseRepoURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(baseRepo))
-		headRepoURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(headRepo))
-		// TODO: figure out what to name the new git remote
-		gitRemote, err := git.AddRemote("fork", baseRepoURL, headRepoURL)
-		if err != nil {
-			return fmt.Errorf("error adding remote: %w", err)
-		}
-		headRemote = &context.Remote{
-			Remote: gitRemote,
-			Owner:  headRepo.RepoOwner(),
-			Repo:   headRepo.RepoName(),
-		}
 	}
 
 	headBranchLabel := headBranch
@@ -223,10 +209,26 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 		headBranchLabel = fmt.Sprintf("%s:%s", headRepo.RepoOwner(), headBranch)
 	}
 
-	if headRemote == nil {
-		headRemote, err = repoContext.RemoteForRepo(headRepo)
+	headRemote, err := repoContext.RemoteForRepo(headRepo)
+	// There are two cases when an existing remote for the head repo will be
+	// missing:
+	// 1. the head repo was just created by auto-forking;
+	// 2. an existing fork was discovered by quering the API.
+	//
+	// In either case, we want to add the head repo as a new git remote so we
+	// can push to it.
+	if err != nil {
+		// TODO: support non-HTTPS git remote URLs
+		headRepoURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(headRepo))
+		// TODO: prevent clashes with another remote of a same name
+		gitRemote, err := git.AddRemote("fork", headRepoURL, "")
 		if err != nil {
-			return fmt.Errorf("git remote not found for head repository: %w", err)
+			return fmt.Errorf("error adding remote: %w", err)
+		}
+		headRemote = &context.Remote{
+			Remote: gitRemote,
+			Owner:  headRepo.RepoOwner(),
+			Repo:   headRepo.RepoName(),
 		}
 	}
 
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 688dfd9c8..ebffb686a 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -14,6 +14,10 @@ func TestPRCreate(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -34,7 +38,7 @@ func TestPRCreate(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create -t "my title" -b "my body"`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -61,6 +65,10 @@ func TestPRCreate_alreadyExists(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes": [
 			{ "url": "https://github.com/OWNER/REPO/pull/123",
@@ -87,6 +95,10 @@ func TestPRCreate_web(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
@@ -113,6 +125,10 @@ func TestPRCreate_ReportsUncommittedChanges(t *testing.T) {
 	http := initFakeHTTP()
 
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -232,6 +248,10 @@ func TestPRCreate_survey_defaults_multicommit(t *testing.T) {
 	initBlankContext("OWNER/REPO", "cool_bug-fixes")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -273,7 +293,7 @@ func TestPRCreate_survey_defaults_multicommit(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -302,6 +322,10 @@ func TestPRCreate_survey_defaults_monocommit(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -344,7 +368,7 @@ func TestPRCreate_survey_defaults_monocommit(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -373,6 +397,10 @@ func TestPRCreate_survey_autofill(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -396,7 +424,7 @@ func TestPRCreate_survey_autofill(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create -f`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -457,6 +485,10 @@ func TestPRCreate_defaults_error_interactive(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "createPullRequest": { "pullRequest": {
 			"URL": "https://github.com/OWNER/REPO/pull/12"
diff --git a/context/context.go b/context/context.go
index 6c3bd5aee..27744a08a 100644
--- a/context/context.go
+++ b/context/context.go
@@ -51,7 +51,10 @@ func ResolveRemotesToRepos(remotes Remotes, client *api.Client, base string) (Re
 		repos = append(repos, baseOverride)
 	}
 
-	result := ResolvedRemotes{Remotes: remotes}
+	result := ResolvedRemotes{
+		Remotes:   remotes,
+		apiClient: client,
+	}
 	if hasBaseOverride {
 		result.BaseOverride = baseOverride
 	}
@@ -67,6 +70,7 @@ type ResolvedRemotes struct {
 	BaseOverride ghrepo.Interface
 	Remotes      Remotes
 	Network      api.RepoNetworkResult
+	apiClient    *api.Client
 }
 
 // BaseRepo is the first found repository in the "upstream", "github", "origin"
@@ -95,8 +99,30 @@ func (r ResolvedRemotes) BaseRepo() (*api.Repository, error) {
 	return nil, errors.New("not found")
 }
 
-// HeadRepo is the first found repository that has push access
+// HeadRepo is a fork of base repo (if any), or the first found repository that
+// has push access
 func (r ResolvedRemotes) HeadRepo() (*api.Repository, error) {
+	baseRepo, err := r.BaseRepo()
+	if err != nil {
+		return nil, err
+	}
+
+	// try to find a pushable fork among existing remotes
+	for _, repo := range r.Network.Repositories {
+		if repo != nil && repo.Parent != nil && repo.ViewerCanPush() && ghrepo.IsSame(repo.Parent, baseRepo) {
+			return repo, nil
+		}
+	}
+
+	// a fork might still exist on GitHub, so let's query for it
+	var notFound *api.NotFoundError
+	if repo, err := api.RepoFindFork(r.apiClient, baseRepo); err == nil {
+		return repo, nil
+	} else if !errors.As(err, &notFound) {
+		return nil, err
+	}
+
+	// fall back to any listed repository that has push access
 	for _, repo := range r.Network.Repositories {
 		if repo != nil && repo.ViewerCanPush() {
 			return repo, nil
diff --git a/context/remote_test.go b/context/remote_test.go
index 04ccbc56c..dd6a5d59a 100644
--- a/context/remote_test.go
+++ b/context/remote_test.go
@@ -1,6 +1,7 @@
 package context
 
 import (
+	"bytes"
 	"errors"
 	"net/url"
 	"testing"
@@ -61,6 +62,14 @@ func Test_translateRemotes(t *testing.T) {
 }
 
 func Test_resolvedRemotes_triangularSetup(t *testing.T) {
+	http := &api.FakeHTTP{}
+	apiClient := api.NewClient(api.ReplaceTripper(http))
+
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
+
 	resolved := ResolvedRemotes{
 		BaseOverride: nil,
 		Remotes: Remotes{
@@ -89,6 +98,7 @@ func Test_resolvedRemotes_triangularSetup(t *testing.T) {
 				},
 			},
 		},
+		apiClient: apiClient,
 	}
 
 	baseRepo, err := resolved.BaseRepo()
@@ -118,6 +128,52 @@ func Test_resolvedRemotes_triangularSetup(t *testing.T) {
 	}
 }
 
+func Test_resolvedRemotes_forkLookup(t *testing.T) {
+	http := &api.FakeHTTP{}
+	apiClient := api.NewClient(api.ReplaceTripper(http))
+
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+		{ "id": "FORKID",
+		  "url": "https://github.com/FORKOWNER/REPO",
+		  "name": "REPO",
+		  "owner": { "login": "FORKOWNER" }
+		}
+	] } } } }
+	`))
+
+	resolved := ResolvedRemotes{
+		BaseOverride: nil,
+		Remotes: Remotes{
+			&Remote{
+				Remote: &git.Remote{Name: "origin"},
+				Owner:  "OWNER",
+				Repo:   "REPO",
+			},
+		},
+		Network: api.RepoNetworkResult{
+			Repositories: []*api.Repository{
+				&api.Repository{
+					Name:             "NEWNAME",
+					Owner:            api.RepositoryOwner{Login: "NEWOWNER"},
+					ViewerPermission: "READ",
+				},
+			},
+		},
+		apiClient: apiClient,
+	}
+
+	headRepo, err := resolved.HeadRepo()
+	if err != nil {
+		t.Fatalf("got %v", err)
+	}
+	eq(t, ghrepo.FullName(headRepo), "FORKOWNER/REPO")
+	_, err = resolved.RemoteForRepo(headRepo)
+	if err == nil {
+		t.Fatal("expected to not find a matching remote")
+	}
+}
+
 func Test_resolvedRemotes_clonedFork(t *testing.T) {
 	resolved := ResolvedRemotes{
 		BaseOverride: nil,

From ef17aa520d74e88619e038c0fffb5cfdb9b48d3a Mon Sep 17 00:00:00 2001
From: Amanda Pinsker <ampinsk@github.com>
Date: Thu, 19 Mar 2020 10:33:34 -0700
Subject: [PATCH 05/48] Add unicode to pr status

---
 command/pr.go | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/command/pr.go b/command/pr.go
index bd7743f46..85a3e2b86 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -412,28 +412,28 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 				var summary string
 				if checks.Failing > 0 {
 					if checks.Failing == checks.Total {
-						summary = utils.Red("All checks failing")
+						summary = utils.Red("× All checks failing")
 					} else {
 						summary = utils.Red(fmt.Sprintf("%d/%d checks failing", checks.Failing, checks.Total))
 					}
 				} else if checks.Pending > 0 {
 					summary = utils.Yellow("Checks pending")
 				} else if checks.Passing == checks.Total {
-					summary = utils.Green("Checks passing")
+					summary = utils.Green("✓ Checks passing")
 				}
-				fmt.Fprintf(w, " - %s", summary)
+				fmt.Fprintf(w, "%s", summary)
 			}
 
 			if reviews.ChangesRequested {
-				fmt.Fprintf(w, " - %s", utils.Red("Changes requested"))
+				fmt.Fprintf(w, "%s", utils.Red("+ Changes requested"))
 			} else if reviews.ReviewRequired {
-				fmt.Fprintf(w, " - %s", utils.Yellow("Review required"))
+				fmt.Fprintf(w, "%s", utils.Yellow("- Review required"))
 			} else if reviews.Approved {
-				fmt.Fprintf(w, " - %s", utils.Green("Approved"))
+				fmt.Fprintf(w, "%s", utils.Green("✓ Approved"))
 			}
 		} else {
 			s := strings.Title(strings.ToLower(pr.State))
-			fmt.Fprintf(w, " - %s", prStateColorFunc(s))
+			fmt.Fprintf(w, "%s", prStateColorFunc(s))
 		}
 
 		fmt.Fprint(w, "\n")

From be7ffe3099abb73d8e319e650d501a193ac81b25 Mon Sep 17 00:00:00 2001
From: Amanda Pinsker <ampinsk@github.com>
Date: Thu, 19 Mar 2020 13:16:00 -0700
Subject: [PATCH 06/48] Tweak unicode some more

---
 command/pr.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/command/pr.go b/command/pr.go
index 85a3e2b86..3755344b8 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -398,7 +398,7 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 			prStateColorFunc = utils.Red
 		}
 
-		fmt.Fprintf(w, "  %s  %s %s", prStateColorFunc(prNumber), text.Truncate(50, replaceExcessiveWhitespace(pr.Title)), utils.Cyan("["+pr.HeadLabel()+"]"))
+		fmt.Fprintf(w, "  %s  %s %s ", prStateColorFunc(prNumber), text.Truncate(50, replaceExcessiveWhitespace(pr.Title)), utils.Cyan("["+pr.HeadLabel()+"]"))
 
 		checks := pr.ChecksStatus()
 		reviews := pr.ReviewStatus()
@@ -412,24 +412,24 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 				var summary string
 				if checks.Failing > 0 {
 					if checks.Failing == checks.Total {
-						summary = utils.Red("× All checks failing")
+						summary = utils.Red("× All checks failing ")
 					} else {
-						summary = utils.Red(fmt.Sprintf("%d/%d checks failing", checks.Failing, checks.Total))
+						summary = utils.Red(fmt.Sprintf("× %d/%d checks failing ", checks.Failing, checks.Total))
 					}
 				} else if checks.Pending > 0 {
-					summary = utils.Yellow("Checks pending")
+					summary = utils.Yellow("- Checks pending ")
 				} else if checks.Passing == checks.Total {
-					summary = utils.Green("✓ Checks passing")
+					summary = utils.Green("✓ Checks passing ")
 				}
 				fmt.Fprintf(w, "%s", summary)
 			}
 
 			if reviews.ChangesRequested {
-				fmt.Fprintf(w, "%s", utils.Red("+ Changes requested"))
+				fmt.Fprintf(w, "%s", utils.Red("+ Changes requested "))
 			} else if reviews.ReviewRequired {
-				fmt.Fprintf(w, "%s", utils.Yellow("- Review required"))
+				fmt.Fprintf(w, "%s", utils.Yellow("- Review required "))
 			} else if reviews.Approved {
-				fmt.Fprintf(w, "%s", utils.Green("✓ Approved"))
+				fmt.Fprintf(w, "%s", utils.Green("✓ Approved "))
 			}
 		} else {
 			s := strings.Title(strings.ToLower(pr.State))

From fe7def13d3e7b5cca9287298927424097c207104 Mon Sep 17 00:00:00 2001
From: Amanda Pinsker <ampinsk@github.com>
Date: Thu, 19 Mar 2020 13:16:07 -0700
Subject: [PATCH 07/48] Update tests

---
 command/pr_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/command/pr_test.go b/command/pr_test.go
index 4b9d0c6de..9fda8980c 100644
--- a/command/pr_test.go
+++ b/command/pr_test.go
@@ -144,9 +144,9 @@ func TestPRStatus_reviewsAndChecks(t *testing.T) {
 	}
 
 	expected := []string{
-		"- Checks passing - Changes requested",
-		"- Checks pending - Approved",
-		"- 1/3 checks failing - Review required",
+		"✓ Checks passing + Changes requested",
+		"- Checks pending ✓ Approved",
+		"× 1/3 checks failing - Review required",
 	}
 
 	for _, line := range expected {

From 57942fcaf889f0dc47dee345a5b4cc47c60bcd5c Mon Sep 17 00:00:00 2001
From: Amanda Pinsker <ampinsk@github.com>
Date: Thu, 19 Mar 2020 13:30:35 -0700
Subject: [PATCH 08/48] Add unicode for merge states back in

---
 command/pr.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/command/pr.go b/command/pr.go
index 3755344b8..b7a26b8b7 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -433,7 +433,7 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 			}
 		} else {
 			s := strings.Title(strings.ToLower(pr.State))
-			fmt.Fprintf(w, "%s", prStateColorFunc(s))
+			fmt.Fprintf(w, "- %s", prStateColorFunc(s))
 		}
 
 		fmt.Fprint(w, "\n")

From e3653672a8f9929ed5faec74d81b5c21d695f046 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 20 Mar 2020 13:08:33 +0100
Subject: [PATCH 09/48] Simplify `git.AddRemote` implementation

The 2nd argument now unused since we've determined that, in practice, we
can safely fetch git objects from a freshly created fork on GitHub and
that we don't need the remote URL-swapping workaround.
---
 command/pr_create.go |  2 +-
 command/repo.go      |  2 +-
 git/remote.go        | 24 ++++++------------------
 3 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/command/pr_create.go b/command/pr_create.go
index e4a4bd2de..66efd8a30 100644
--- a/command/pr_create.go
+++ b/command/pr_create.go
@@ -221,7 +221,7 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 		// TODO: support non-HTTPS git remote URLs
 		headRepoURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(headRepo))
 		// TODO: prevent clashes with another remote of a same name
-		gitRemote, err := git.AddRemote("fork", headRepoURL, "")
+		gitRemote, err := git.AddRemote("fork", headRepoURL)
 		if err != nil {
 			return fmt.Errorf("error adding remote: %w", err)
 		}
diff --git a/command/repo.go b/command/repo.go
index 1dc9b13a5..ec860ed38 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -344,7 +344,7 @@ func repoFork(cmd *cobra.Command, args []string) error {
 			}
 		}
 		if remoteDesired {
-			_, err := git.AddRemote("fork", forkedRepo.CloneURL, "")
+			_, err := git.AddRemote("fork", forkedRepo.CloneURL)
 			if err != nil {
 				return fmt.Errorf("failed to add remote: %w", err)
 			}
diff --git a/git/remote.go b/git/remote.go
index f98606a2e..9a8b3fccb 100644
--- a/git/remote.go
+++ b/git/remote.go
@@ -71,34 +71,22 @@ func parseRemotes(gitRemotes []string) (remotes RemoteSet) {
 	return
 }
 
-// AddRemote adds a new git remote. The initURL is the remote URL with which the
-// automatic fetch is made and finalURL, if non-blank, is set as the remote URL
-// after the fetch.
-func AddRemote(name, initURL, finalURL string) (*Remote, error) {
-	addCmd := exec.Command("git", "remote", "add", "-f", name, initURL)
+// AddRemote adds a new git remote and auto-fetches objects from it
+func AddRemote(name, u string) (*Remote, error) {
+	addCmd := exec.Command("git", "remote", "add", "-f", name, u)
 	err := utils.PrepareCmd(addCmd).Run()
 	if err != nil {
 		return nil, err
 	}
 
-	if finalURL == "" {
-		finalURL = initURL
-	} else {
-		setCmd := exec.Command("git", "remote", "set-url", name, finalURL)
-		err := utils.PrepareCmd(setCmd).Run()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	finalURLParsed, err := url.Parse(finalURL)
+	urlParsed, err := url.Parse(u)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Remote{
 		Name:     name,
-		FetchURL: finalURLParsed,
-		PushURL:  finalURLParsed,
+		FetchURL: urlParsed,
+		PushURL:  urlParsed,
 	}, nil
 }

From ff96f48479b98596a7077f78fddb652adf5ba940 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Fri, 20 Mar 2020 16:10:32 -0500
Subject: [PATCH 10/48] add ExpectLines helper

---
 command/issue_test.go | 32 ++++++++------------------
 command/pr_test.go    | 49 ++++++++++++----------------------------
 command/repo_test.go  | 52 ++++++++++---------------------------------
 test/helpers.go       | 13 +++++++++++
 4 files changed, 48 insertions(+), 98 deletions(-)

diff --git a/command/issue_test.go b/command/issue_test.go
index 0d839d5a2..2f5875653 100644
--- a/command/issue_test.go
+++ b/command/issue_test.go
@@ -316,18 +316,11 @@ func TestIssueView_preview(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`ix of coins`),
-		regexp.MustCompile(`opened by marseilles. 9 comments. \(tarot\)`),
-		regexp.MustCompile(`bold story`),
-		regexp.MustCompile(`View this issue on GitHub: https://github.com/OWNER/REPO/issues/123`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"ix of coins",
+		`opened by marseilles. 9 comments. \(tarot\)`,
+		"bold story",
+		"View this issue on GitHub: https://github.com/OWNER/REPO/issues/123")
 }
 
 func TestIssueView_previewWithEmptyBody(t *testing.T) {
@@ -362,17 +355,10 @@ func TestIssueView_previewWithEmptyBody(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`ix of coins`),
-		regexp.MustCompile(`opened by marseilles. 9 comments. \(tarot\)`),
-		regexp.MustCompile(`View this issue on GitHub: https://github.com/OWNER/REPO/issues/123`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"ix of coins",
+		`opened by marseilles. 9 comments. \(tarot\)`,
+		"View this issue on GitHub: https://github.com/OWNER/REPO/issues/123")
 }
 
 func TestIssueView_notFound(t *testing.T) {
diff --git a/command/pr_test.go b/command/pr_test.go
index 4b9d0c6de..56dae177e 100644
--- a/command/pr_test.go
+++ b/command/pr_test.go
@@ -416,18 +416,11 @@ func TestPRView_preview(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Blueberries are from a fork`),
-		regexp.MustCompile(`nobody wants to merge 12 commits into master from blueberries`),
-		regexp.MustCompile(`blueberries taste good`),
-		regexp.MustCompile(`View this pull request on GitHub: https://github.com/OWNER/REPO/pull/12`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Blueberries are from a fork",
+		"nobody wants to merge 12 commits into master from blueberries",
+		"blueberries taste good",
+		"View this pull request on GitHub: https://github.com/OWNER/REPO/pull/12")
 }
 
 func TestPRView_previewCurrentBranch(t *testing.T) {
@@ -451,18 +444,11 @@ func TestPRView_previewCurrentBranch(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Blueberries are a good fruit`),
-		regexp.MustCompile(`nobody wants to merge 8 commits into master from blueberries`),
-		regexp.MustCompile(`blueberries taste good`),
-		regexp.MustCompile(`View this pull request on GitHub: https://github.com/OWNER/REPO/pull/10`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Blueberries are a good fruit",
+		"nobody wants to merge 8 commits into master from blueberries",
+		"blueberries taste good",
+		"View this pull request on GitHub: https://github.com/OWNER/REPO/pull/10")
 }
 
 func TestPRView_previewCurrentBranchWithEmptyBody(t *testing.T) {
@@ -486,17 +472,10 @@ func TestPRView_previewCurrentBranchWithEmptyBody(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Blueberries are a good fruit`),
-		regexp.MustCompile(`nobody wants to merge 8 commits into master from blueberries`),
-		regexp.MustCompile(`View this pull request on GitHub: https://github.com/OWNER/REPO/pull/10`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Blueberries are a good fruit",
+		"nobody wants to merge 8 commits into master from blueberries",
+		"View this pull request on GitHub: https://github.com/OWNER/REPO/pull/10")
 }
 
 func TestPRView_currentBranch(t *testing.T) {
diff --git a/command/repo_test.go b/command/repo_test.go
index 6001be817..3b4d65812 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -137,16 +137,9 @@ func TestRepoFork_in_parent_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Remote added at fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Remote added at fork")
 }
 
 func TestRepoFork_outside_yes(t *testing.T) {
@@ -169,16 +162,9 @@ func TestRepoFork_outside_yes(t *testing.T) {
 
 	eq(t, strings.Join(seenCmd.Args, " "), "git clone https://github.com/someone/repo.git")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Cloned fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Cloned fork")
 }
 
 func TestRepoFork_outside_survey_yes(t *testing.T) {
@@ -208,16 +194,9 @@ func TestRepoFork_outside_survey_yes(t *testing.T) {
 
 	eq(t, strings.Join(seenCmd.Args, " "), "git clone https://github.com/someone/repo.git")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Cloned fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Cloned fork")
 }
 
 func TestRepoFork_outside_survey_no(t *testing.T) {
@@ -290,16 +269,9 @@ func TestRepoFork_in_parent_survey_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Remote added at fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Remote added at fork")
 }
 
 func TestRepoFork_in_parent_survey_no(t *testing.T) {
diff --git a/test/helpers.go b/test/helpers.go
index 6bcfcadca..c4c4f976b 100644
--- a/test/helpers.go
+++ b/test/helpers.go
@@ -6,6 +6,8 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
+	"testing"
 )
 
 // OutputStub implements a simple utils.Runnable
@@ -74,3 +76,14 @@ func UseTempGitRepo() *TempGitRepo {
 
 	return &TempGitRepo{Remote: remotePath, TearDown: tearDown}
 }
+
+func ExpectLines(t *testing.T, output string, lines ...string) {
+	var r *regexp.Regexp
+	for _, l := range lines {
+		r = regexp.MustCompile(l)
+		if !r.MatchString(output) {
+			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
+			return
+		}
+	}
+}

From 3459dfab95aa2c86a152a71a55e1041cd4aef6b0 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 17 Mar 2020 17:31:29 -0500
Subject: [PATCH 11/48] add viewing repo in terminal

---
 api/queries_repo.go  | 14 ++++---
 command/repo.go      | 95 +++++++++++++++++++++++++++++++++++++++++---
 command/repo_test.go | 87 ++++++++++++++++++++++++++++++++++++----
 3 files changed, 177 insertions(+), 19 deletions(-)

diff --git a/api/queries_repo.go b/api/queries_repo.go
index 048b72b50..4b8a017ff 100644
--- a/api/queries_repo.go
+++ b/api/queries_repo.go
@@ -13,12 +13,13 @@ import (
 
 // Repository contains information about a GitHub repo
 type Repository struct {
-	ID        string
-	Name      string
-	URL       string
-	CloneURL  string
-	CreatedAt time.Time
-	Owner     RepositoryOwner
+	ID          string
+	Name        string
+	Description string
+	URL         string
+	CloneURL    string
+	CreatedAt   time.Time
+	Owner       RepositoryOwner
 
 	IsPrivate        bool
 	HasIssuesEnabled bool
@@ -69,6 +70,7 @@ func GitHubRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 		repository(owner: $owner, name: $name) {
 			id
 			hasIssuesEnabled
+			description
 		}
 	}`
 	variables := map[string]interface{}{
diff --git a/command/repo.go b/command/repo.go
index 1dc9b13a5..3bd412e77 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -1,11 +1,13 @@
 package command
 
 import (
+	"encoding/base64"
 	"fmt"
 	"net/url"
 	"os"
 	"path"
 	"strings"
+	"text/template"
 	"time"
 
 	"github.com/AlecAivazis/survey/v2"
@@ -35,6 +37,7 @@ func init() {
 	repoForkCmd.Flags().Lookup("remote").NoOptDefVal = "true"
 
 	repoCmd.AddCommand(repoViewCmd)
+	repoViewCmd.Flags().BoolP("web", "w", false, "Open repository in browser")
 }
 
 var repoCmd = &cobra.Command{
@@ -78,9 +81,9 @@ With no argument, creates a fork of the current repository. Otherwise, forks the
 var repoViewCmd = &cobra.Command{
 	Use:   "view [<repository>]",
 	Short: "View a repository in the browser",
-	Long: `View a GitHub repository in the browser.
+	Long: `View a GitHub repository.
 
-With no argument, the repository for the current directory is opened.`,
+With no argument, the repository for the current directory is displayed.`,
 	RunE: repoView,
 }
 
@@ -386,6 +389,7 @@ var Confirm = func(prompt string, result *bool) error {
 
 func repoView(cmd *cobra.Command, args []string) error {
 	ctx := contextForCommand(cmd)
+
 	var toView ghrepo.Interface
 	if len(args) == 0 {
 		var err error
@@ -414,12 +418,91 @@ func repoView(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	_, err = api.GitHubRepo(apiClient, toView)
+	repo, err := api.GitHubRepo(apiClient, toView)
 	if err != nil {
 		return err
 	}
 
-	openURL := fmt.Sprintf("https://github.com/%s", ghrepo.FullName(toView))
-	fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", displayURL(openURL))
-	return utils.OpenInBrowser(openURL)
+	web, err := cmd.Flags().GetBool("web")
+	if err != nil {
+		return err
+	}
+
+	fullName := ghrepo.FullName(toView)
+
+	openURL := fmt.Sprintf("https://github.com/%s", fullName)
+	if web {
+		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", displayURL(openURL))
+		return utils.OpenInBrowser(openURL)
+	}
+
+	repoTmpl := `
+{{.FullName}}
+{{.Description}}
+
+{{.Readme}}
+
+{{.View}}
+`
+
+	tmpl, err := template.New("repo").Parse(repoTmpl)
+	if err != nil {
+		return err
+	}
+
+	type readmeResponse struct {
+		Name    string
+		Content string
+	}
+
+	var readme readmeResponse
+
+	err = apiClient.REST("GET", fmt.Sprintf("repos/%s/readme", fullName), nil, &readme)
+	if err != nil && !strings.HasSuffix(err.Error(), "'Not Found'") {
+		return fmt.Errorf("could not get readme for repo: %w", err)
+	}
+
+	decoded, err := base64.StdEncoding.DecodeString(readme.Content)
+	if err != nil {
+		return fmt.Errorf("failed to decode readme: %w", err)
+	}
+
+	readmeContent := string(decoded)
+
+	if strings.HasSuffix(readme.Name, ".md") {
+		readmeContent, err = utils.RenderMarkdown(readmeContent)
+		if err != nil {
+			return fmt.Errorf("failed to render readme as markdown: %w", err)
+		}
+	}
+
+	if readmeContent == "" {
+		readmeContent = utils.Gray("No README provided")
+	}
+
+	description := repo.Description
+	if description == "" {
+		description = utils.Gray("No description provided")
+	}
+
+	repoData := struct {
+		FullName    string
+		Description string
+		Readme      string
+		View        string
+	}{
+		FullName:    utils.Bold(fullName),
+		Description: description,
+		Readme:      readmeContent,
+		View:        utils.Gray(fmt.Sprintf("View this repository on GitHub: %s", openURL)),
+	}
+
+	out := colorableOut(cmd)
+
+	err = tmpl.Execute(out, repoData)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
diff --git a/command/repo_test.go b/command/repo_test.go
index 3b4d65812..979f45cd0 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -552,8 +552,7 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
 	}
 }
 
-
-func TestRepoView(t *testing.T) {
+func TestRepoView_web(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -568,7 +567,7 @@ func TestRepoView(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(repoViewCmd, "repo view")
+	output, err := RunCommand(repoViewCmd, "repo view -w")
 	if err != nil {
 		t.Errorf("error running command `repo view`: %v", err)
 	}
@@ -583,7 +582,7 @@ func TestRepoView(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO")
 }
 
-func TestRepoView_ownerRepo(t *testing.T) {
+func TestRepoView_web_ownerRepo(t *testing.T) {
 	ctx := context.NewBlank()
 	ctx.SetBranch("master")
 	initContext = func() context.Context {
@@ -601,7 +600,7 @@ func TestRepoView_ownerRepo(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(repoViewCmd, "repo view cli/cli")
+	output, err := RunCommand(repoViewCmd, "repo view -w cli/cli")
 	if err != nil {
 		t.Errorf("error running command `repo view`: %v", err)
 	}
@@ -616,7 +615,7 @@ func TestRepoView_ownerRepo(t *testing.T) {
 	eq(t, url, "https://github.com/cli/cli")
 }
 
-func TestRepoView_fullURL(t *testing.T) {
+func TestRepoView_web_fullURL(t *testing.T) {
 	ctx := context.NewBlank()
 	ctx.SetBranch("master")
 	initContext = func() context.Context {
@@ -633,7 +632,7 @@ func TestRepoView_fullURL(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(repoViewCmd, "repo view https://github.com/cli/cli")
+	output, err := RunCommand(repoViewCmd, "repo view -w https://github.com/cli/cli")
 	if err != nil {
 		t.Errorf("error running command `repo view`: %v", err)
 	}
@@ -647,3 +646,77 @@ func TestRepoView_fullURL(t *testing.T) {
 	url := seenCmd.Args[len(seenCmd.Args)-1]
 	eq(t, url, "https://github.com/cli/cli")
 }
+
+func TestRepoView(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": {
+				"repository": {
+		      "description": "social distancing"
+		}}}
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "name": "readme.md",
+		  "content": "IyB0cnVseSBjb29sIHJlYWRtZSBjaGVjayBpdCBvdXQ="}
+	`))
+
+	output, err := RunCommand(repoViewCmd, "repo view")
+	if err != nil {
+		t.Errorf("error running command `repo view`: %v", err)
+	}
+
+	test.ExpectLines(t, output.String(),
+		"OWNER/REPO",
+		"social distancing",
+		"truly cool readme",
+		"View this repository on GitHub: https://github.com/OWNER/REPO")
+
+}
+
+func TestRepoView_nonmarkdown_readme(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": {
+				"repository": {
+		      "description": "social distancing"
+		}}}
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "name": "readme.org",
+		  "content": "IyB0cnVseSBjb29sIHJlYWRtZSBjaGVjayBpdCBvdXQ="}
+	`))
+
+	output, err := RunCommand(repoViewCmd, "repo view")
+	if err != nil {
+		t.Errorf("error running command `repo view`: %v", err)
+	}
+
+	test.ExpectLines(t, output.String(),
+		"OWNER/REPO",
+		"social distancing",
+		"# truly cool readme",
+		"View this repository on GitHub: https://github.com/OWNER/REPO")
+}
+
+func TestRepoView_blanks(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString("{}"))
+	http.StubResponse(200, bytes.NewBufferString("{}"))
+
+	output, err := RunCommand(repoViewCmd, "repo view")
+	if err != nil {
+		t.Errorf("error running command `repo view`: %v", err)
+	}
+
+	test.ExpectLines(t, output.String(),
+		"OWNER/REPO",
+		"No description provided",
+		"No README provided",
+		"View this repository on GitHub: https://github.com/OWNER/REPO")
+}

From 121173c3308b264d0565251976f07917de8f75fa Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Mon, 23 Mar 2020 15:21:58 -0500
Subject: [PATCH 12/48] better error reporting + catch for empty repo

---
 command/pr.go      | 2 +-
 context/context.go | 2 +-
 git/git.go         | 9 +++++++++
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/command/pr.go b/command/pr.go
index bd7743f46..924059882 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -84,7 +84,7 @@ func prStatus(cmd *cobra.Command, args []string) error {
 	repoOverride, _ := cmd.Flags().GetString("repo")
 	currentPRNumber, currentPRHeadRef, err := prSelectorForCurrentBranch(ctx, baseRepo)
 	if err != nil && repoOverride == "" && err.Error() != "git: not on any branch" {
-		return err
+		return fmt.Errorf("could not query for pull request for current branch: %w", err)
 	}
 
 	prPayload, err := api.PullRequests(apiClient, baseRepo, currentPRNumber, currentPRHeadRef, currentUser)
diff --git a/context/context.go b/context/context.go
index 6c3bd5aee..23ce74d85 100644
--- a/context/context.go
+++ b/context/context.go
@@ -184,7 +184,7 @@ func (c *fsContext) Branch() (string, error) {
 
 	currentBranch, err := git.CurrentBranch()
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("could not determine current branch: %w", err)
 	}
 
 	c.branch = currentBranch
diff --git a/git/git.go b/git/git.go
index 37253462a..cdf1e869f 100644
--- a/git/git.go
+++ b/git/git.go
@@ -21,6 +21,15 @@ func VerifyRef(ref string) bool {
 
 // CurrentBranch reads the checked-out branch for the git repository
 func CurrentBranch() (string, error) {
+	err := utils.PrepareCmd(GitCommand("log")).Run()
+	if err != nil {
+		// this is a hack.
+		errRe := regexp.MustCompile("your current branch '([^']+)' does not have any commits yet")
+		matches := errRe.FindAllStringSubmatch(err.Error(), -1)
+		if len(matches) > 0 && matches[0][1] != "" {
+			return matches[0][1], nil
+		}
+	}
 	// we avoid using `git branch --show-current` for compatibility with git < 2.22
 	branchCmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
 	output, err := utils.PrepareCmd(branchCmd).Output()

From 633ccddb7ad41fb51d381164ad36b45abb820ad2 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Mon, 23 Mar 2020 15:58:18 -0500
Subject: [PATCH 13/48] remove unused test helper

---
 test/helpers.go | 62 -------------------------------------------------
 1 file changed, 62 deletions(-)

diff --git a/test/helpers.go b/test/helpers.go
index 6bcfcadca..add7b90c3 100644
--- a/test/helpers.go
+++ b/test/helpers.go
@@ -1,13 +1,5 @@
 package test
 
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-)
-
 // OutputStub implements a simple utils.Runnable
 type OutputStub struct {
 	Out []byte
@@ -20,57 +12,3 @@ func (s OutputStub) Output() ([]byte, error) {
 func (s OutputStub) Run() error {
 	return nil
 }
-
-type TempGitRepo struct {
-	Remote   string
-	TearDown func()
-}
-
-func UseTempGitRepo() *TempGitRepo {
-	pwd, _ := os.Getwd()
-	oldEnv := make(map[string]string)
-	overrideEnv := func(name, value string) {
-		oldEnv[name] = os.Getenv(name)
-		os.Setenv(name, value)
-	}
-
-	remotePath := filepath.Join(pwd, "..", "test", "fixtures", "test.git")
-	home, err := ioutil.TempDir("", "test-repo")
-	if err != nil {
-		panic(err)
-	}
-
-	overrideEnv("HOME", home)
-	overrideEnv("XDG_CONFIG_HOME", "")
-	overrideEnv("XDG_CONFIG_DIRS", "")
-
-	targetPath := filepath.Join(home, "test.git")
-	cmd := exec.Command("git", "clone", remotePath, targetPath)
-	if output, err := cmd.Output(); err != nil {
-		panic(fmt.Errorf("error running %s\n%s\n%s", cmd, err, output))
-	}
-
-	if err = os.Chdir(targetPath); err != nil {
-		panic(err)
-	}
-
-	// Our libs expect the origin to be a github url
-	cmd = exec.Command("git", "remote", "set-url", "origin", "https://github.com/github/FAKE-GITHUB-REPO-NAME")
-	if output, err := cmd.Output(); err != nil {
-		panic(fmt.Errorf("error running %s\n%s\n%s", cmd, err, output))
-	}
-
-	tearDown := func() {
-		if err := os.Chdir(pwd); err != nil {
-			panic(err)
-		}
-		for name, value := range oldEnv {
-			os.Setenv(name, value)
-		}
-		if err = os.RemoveAll(home); err != nil {
-			panic(err)
-		}
-	}
-
-	return &TempGitRepo{Remote: remotePath, TearDown: tearDown}
-}

From 5187ad4431f953b5690701536c832dd85f9b85e3 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Mon, 23 Mar 2020 16:32:29 -0500
Subject: [PATCH 14/48] move preparecmd and Runnable to its own package

---
 command/issue_test.go                       | 14 +++++-----
 command/pr_checkout.go                      |  4 +--
 command/pr_checkout_test.go                 | 20 +++++++-------
 command/pr_test.go                          | 22 ++++++++--------
 command/repo.go                             | 11 ++++----
 command/repo_test.go                        | 29 ++++++++++-----------
 command/testing.go                          |  8 +++---
 git/git.go                                  | 24 ++++++++---------
 git/git_test.go                             |  6 ++---
 git/remote.go                               |  6 ++---
 utils/prepare_cmd.go => internal/run/run.go |  2 +-
 utils/utils.go                              |  3 ++-
 12 files changed, 75 insertions(+), 74 deletions(-)
 rename utils/prepare_cmd.go => internal/run/run.go (99%)

diff --git a/command/issue_test.go b/command/issue_test.go
index 0d839d5a2..17a698a22 100644
--- a/command/issue_test.go
+++ b/command/issue_test.go
@@ -10,8 +10,8 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 func TestIssueStatus(t *testing.T) {
@@ -229,7 +229,7 @@ func TestIssueView(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -263,7 +263,7 @@ func TestIssueView_numberArgWithHash(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -386,7 +386,7 @@ func TestIssueView_notFound(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -433,7 +433,7 @@ func TestIssueView_urlArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -518,7 +518,7 @@ func TestIssueCreate_web(t *testing.T) {
 	http.StubRepoResponse("OWNER", "REPO")
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -544,7 +544,7 @@ func TestIssueCreate_webTitleBody(t *testing.T) {
 	http.StubRepoResponse("OWNER", "REPO")
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
diff --git a/command/pr_checkout.go b/command/pr_checkout.go
index 08a37033d..bf7cedbb7 100644
--- a/command/pr_checkout.go
+++ b/command/pr_checkout.go
@@ -7,7 +7,7 @@ import (
 	"os/exec"
 
 	"github.com/cli/cli/git"
-	"github.com/cli/cli/utils"
+	"github.com/cli/cli/internal/run"
 	"github.com/spf13/cobra"
 )
 
@@ -91,7 +91,7 @@ func prCheckout(cmd *cobra.Command, args []string) error {
 		cmd := exec.Command(args[0], args[1:]...)
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
-		if err := utils.PrepareCmd(cmd).Run(); err != nil {
+		if err := run.PrepareCmd(cmd).Run(); err != nil {
 			return err
 		}
 	}
diff --git a/command/pr_checkout_test.go b/command/pr_checkout_test.go
index ce0266c5e..cc7eddd2b 100644
--- a/command/pr_checkout_test.go
+++ b/command/pr_checkout_test.go
@@ -7,8 +7,8 @@ import (
 	"testing"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 func TestPRCheckout_sameRepo(t *testing.T) {
@@ -41,7 +41,7 @@ func TestPRCheckout_sameRepo(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git show-ref --verify --quiet refs/heads/feature":
 			return &errorStub{"exit status: 1"}
@@ -93,7 +93,7 @@ func TestPRCheckout_urlArg(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git show-ref --verify --quiet refs/heads/feature":
 			return &errorStub{"exit status: 1"}
@@ -142,7 +142,7 @@ func TestPRCheckout_branchArg(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git show-ref --verify --quiet refs/heads/feature":
 			return &errorStub{"exit status: 1"}
@@ -191,7 +191,7 @@ func TestPRCheckout_existingBranch(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git show-ref --verify --quiet refs/heads/feature":
 			return &test.OutputStub{}
@@ -243,7 +243,7 @@ func TestPRCheckout_differentRepo_remoteExists(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git show-ref --verify --quiet refs/heads/feature":
 			return &errorStub{"exit status: 1"}
@@ -295,7 +295,7 @@ func TestPRCheckout_differentRepo(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
 			return &errorStub{"exit status 1"}
@@ -347,7 +347,7 @@ func TestPRCheckout_differentRepo_existingBranch(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
 			return &test.OutputStub{[]byte("refs/heads/feature\n")}
@@ -397,7 +397,7 @@ func TestPRCheckout_differentRepo_currentBranch(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
 			return &test.OutputStub{[]byte("refs/heads/feature\n")}
@@ -447,7 +447,7 @@ func TestPRCheckout_maintainerCanModify(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
 			return &errorStub{"exit status 1"}
diff --git a/command/pr_test.go b/command/pr_test.go
index 4b9d0c6de..c47e28963 100644
--- a/command/pr_test.go
+++ b/command/pr_test.go
@@ -11,8 +11,8 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 	"github.com/google/shlex"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -108,7 +108,7 @@ func TestPRStatus_fork(t *testing.T) {
 	defer jsonFile.Close()
 	http.StubResponse(200, jsonFile)
 
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
 			return &test.OutputStub{[]byte(`branch.blueberries.remote origin
@@ -439,7 +439,7 @@ func TestPRView_previewCurrentBranch(t *testing.T) {
 	defer jsonFile.Close()
 	http.StubResponse(200, jsonFile)
 
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
@@ -474,7 +474,7 @@ func TestPRView_previewCurrentBranchWithEmptyBody(t *testing.T) {
 	defer jsonFile.Close()
 	http.StubResponse(200, jsonFile)
 
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
@@ -509,7 +509,7 @@ func TestPRView_currentBranch(t *testing.T) {
 	http.StubResponse(200, jsonFile)
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
 			return &test.OutputStub{}
@@ -547,7 +547,7 @@ func TestPRView_noResultsForBranch(t *testing.T) {
 	http.StubResponse(200, jsonFile)
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
 			return &test.OutputStub{}
@@ -580,7 +580,7 @@ func TestPRView_numberArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -612,7 +612,7 @@ func TestPRView_numberArgWithHash(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -644,7 +644,7 @@ func TestPRView_urlArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -678,7 +678,7 @@ func TestPRView_branchArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -713,7 +713,7 @@ func TestPRView_branchWithOwnerArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
diff --git a/command/repo.go b/command/repo.go
index 1dc9b13a5..5ea27a2ce 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -12,6 +12,7 @@ import (
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/git"
 	"github.com/cli/cli/internal/ghrepo"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/utils"
 	"github.com/spf13/cobra"
 )
@@ -98,7 +99,7 @@ func repoClone(cmd *cobra.Command, args []string) error {
 	cloneCmd.Stdin = os.Stdin
 	cloneCmd.Stdout = os.Stdout
 	cloneCmd.Stderr = os.Stderr
-	return utils.PrepareCmd(cloneCmd).Run()
+	return run.PrepareCmd(cloneCmd).Run()
 }
 
 func repoCreate(cmd *cobra.Command, args []string) error {
@@ -198,7 +199,7 @@ func repoCreate(cmd *cobra.Command, args []string) error {
 		remoteAdd := git.GitCommand("remote", "add", "origin", remoteURL)
 		remoteAdd.Stdout = os.Stdout
 		remoteAdd.Stderr = os.Stderr
-		err = utils.PrepareCmd(remoteAdd).Run()
+		err = run.PrepareCmd(remoteAdd).Run()
 		if err != nil {
 			return err
 		}
@@ -218,14 +219,14 @@ func repoCreate(cmd *cobra.Command, args []string) error {
 			gitInit := git.GitCommand("init", path)
 			gitInit.Stdout = os.Stdout
 			gitInit.Stderr = os.Stderr
-			err = utils.PrepareCmd(gitInit).Run()
+			err = run.PrepareCmd(gitInit).Run()
 			if err != nil {
 				return err
 			}
 			gitRemoteAdd := git.GitCommand("-C", path, "remote", "add", "origin", remoteURL)
 			gitRemoteAdd.Stdout = os.Stdout
 			gitRemoteAdd.Stderr = os.Stderr
-			err = utils.PrepareCmd(gitRemoteAdd).Run()
+			err = run.PrepareCmd(gitRemoteAdd).Run()
 			if err != nil {
 				return err
 			}
@@ -364,7 +365,7 @@ func repoFork(cmd *cobra.Command, args []string) error {
 			cloneCmd.Stdin = os.Stdin
 			cloneCmd.Stdout = os.Stdout
 			cloneCmd.Stderr = os.Stderr
-			err = utils.PrepareCmd(cloneCmd).Run()
+			err = run.PrepareCmd(cloneCmd).Run()
 			if err != nil {
 				return fmt.Errorf("failed to clone fork: %w", err)
 			}
diff --git a/command/repo_test.go b/command/repo_test.go
index 6001be817..d3b035d18 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -11,8 +11,8 @@ import (
 	"time"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 func TestRepoFork_already_forked(t *testing.T) {
@@ -116,7 +116,7 @@ func TestRepoFork_in_parent_yes(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	var seenCmds []*exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmds = append(seenCmds, cmd)
 		return &test.OutputStub{}
 	})()
@@ -155,7 +155,7 @@ func TestRepoFork_outside_yes(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	var seenCmd *exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})()
@@ -187,7 +187,7 @@ func TestRepoFork_outside_survey_yes(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	var seenCmd *exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})()
@@ -226,7 +226,7 @@ func TestRepoFork_outside_survey_no(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	cmdRun := false
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		cmdRun = true
 		return &test.OutputStub{}
 	})()
@@ -262,7 +262,7 @@ func TestRepoFork_in_parent_survey_yes(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	var seenCmds []*exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmds = append(seenCmds, cmd)
 		return &test.OutputStub{}
 	})()
@@ -310,7 +310,7 @@ func TestRepoFork_in_parent_survey_no(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	cmdRun := false
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		cmdRun = true
 		return &test.OutputStub{}
 	})()
@@ -368,7 +368,7 @@ func TestRepoClone(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var seenCmd *exec.Cmd
-			restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+			restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 				seenCmd = cmd
 				return &test.OutputStub{}
 			})
@@ -408,7 +408,7 @@ func TestRepoCreate(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -473,7 +473,7 @@ func TestRepoCreate_org(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -538,7 +538,7 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -580,7 +580,6 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
 	}
 }
 
-
 func TestRepoView(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
@@ -590,7 +589,7 @@ func TestRepoView(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -623,7 +622,7 @@ func TestRepoView_ownerRepo(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -655,7 +654,7 @@ func TestRepoView_fullURL(t *testing.T) {
 	{ }
 	`))
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
diff --git a/command/testing.go b/command/testing.go
index 0221ce8cf..6d1a2594e 100644
--- a/command/testing.go
+++ b/command/testing.go
@@ -11,8 +11,8 @@ import (
 
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 // TODO this is split between here and test/helpers.go. I did that because otherwise our test
@@ -27,7 +27,7 @@ type CmdStubber struct {
 
 func initCmdStubber() (*CmdStubber, func()) {
 	cs := CmdStubber{}
-	teardown := utils.SetPrepareCmd(createStubbedPrepareCmd(&cs))
+	teardown := run.SetPrepareCmd(createStubbedPrepareCmd(&cs))
 	return &cs, teardown
 }
 
@@ -36,8 +36,8 @@ func (cs *CmdStubber) Stub(desiredOutput string) {
 	cs.Stubs = append(cs.Stubs, &test.OutputStub{[]byte(desiredOutput)})
 }
 
-func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) utils.Runnable {
-	return func(cmd *exec.Cmd) utils.Runnable {
+func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {
+	return func(cmd *exec.Cmd) run.Runnable {
 		cs.Calls = append(cs.Calls, cmd)
 		call := cs.Count
 		cs.Count += 1
diff --git a/git/git.go b/git/git.go
index cdf1e869f..b604c398a 100644
--- a/git/git.go
+++ b/git/git.go
@@ -10,18 +10,18 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/cli/cli/utils"
+	"github.com/cli/cli/internal/run"
 )
 
 func VerifyRef(ref string) bool {
 	showRef := exec.Command("git", "show-ref", "--verify", "--quiet", ref)
-	err := utils.PrepareCmd(showRef).Run()
+	err := run.PrepareCmd(showRef).Run()
 	return err == nil
 }
 
 // CurrentBranch reads the checked-out branch for the git repository
 func CurrentBranch() (string, error) {
-	err := utils.PrepareCmd(GitCommand("log")).Run()
+	err := run.PrepareCmd(GitCommand("log")).Run()
 	if err != nil {
 		// this is a hack.
 		errRe := regexp.MustCompile("your current branch '([^']+)' does not have any commits yet")
@@ -32,7 +32,7 @@ func CurrentBranch() (string, error) {
 	}
 	// we avoid using `git branch --show-current` for compatibility with git < 2.22
 	branchCmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
-	output, err := utils.PrepareCmd(branchCmd).Output()
+	output, err := run.PrepareCmd(branchCmd).Output()
 	branchName := firstLine(output)
 	if err == nil && branchName == "HEAD" {
 		return "", errors.New("git: not on any branch")
@@ -42,13 +42,13 @@ func CurrentBranch() (string, error) {
 
 func listRemotes() ([]string, error) {
 	remoteCmd := exec.Command("git", "remote", "-v")
-	output, err := utils.PrepareCmd(remoteCmd).Output()
+	output, err := run.PrepareCmd(remoteCmd).Output()
 	return outputLines(output), err
 }
 
 func Config(name string) (string, error) {
 	configCmd := exec.Command("git", "config", name)
-	output, err := utils.PrepareCmd(configCmd).Output()
+	output, err := run.PrepareCmd(configCmd).Output()
 	if err != nil {
 		return "", fmt.Errorf("unknown config key: %s", name)
 	}
@@ -63,7 +63,7 @@ var GitCommand = func(args ...string) *exec.Cmd {
 
 func UncommittedChangeCount() (int, error) {
 	statusCmd := GitCommand("status", "--porcelain")
-	output, err := utils.PrepareCmd(statusCmd).Output()
+	output, err := run.PrepareCmd(statusCmd).Output()
 	if err != nil {
 		return 0, err
 	}
@@ -90,7 +90,7 @@ func Commits(baseRef, headRef string) ([]*Commit, error) {
 		"-c", "log.ShowSignature=false",
 		"log", "--pretty=format:%H,%s",
 		"--cherry", fmt.Sprintf("%s...%s", baseRef, headRef))
-	output, err := utils.PrepareCmd(logCmd).Output()
+	output, err := run.PrepareCmd(logCmd).Output()
 	if err != nil {
 		return []*Commit{}, err
 	}
@@ -118,7 +118,7 @@ func Commits(baseRef, headRef string) ([]*Commit, error) {
 
 func CommitBody(sha string) (string, error) {
 	showCmd := GitCommand("-c", "log.ShowSignature=false", "show", "-s", "--pretty=format:%b", sha)
-	output, err := utils.PrepareCmd(showCmd).Output()
+	output, err := run.PrepareCmd(showCmd).Output()
 	if err != nil {
 		return "", err
 	}
@@ -130,7 +130,7 @@ func Push(remote string, ref string) error {
 	pushCmd := GitCommand("push", "--set-upstream", remote, ref)
 	pushCmd.Stdout = os.Stdout
 	pushCmd.Stderr = os.Stderr
-	return utils.PrepareCmd(pushCmd).Run()
+	return run.PrepareCmd(pushCmd).Run()
 }
 
 type BranchConfig struct {
@@ -143,7 +143,7 @@ type BranchConfig struct {
 func ReadBranchConfig(branch string) (cfg BranchConfig) {
 	prefix := regexp.QuoteMeta(fmt.Sprintf("branch.%s.", branch))
 	configCmd := GitCommand("config", "--get-regexp", fmt.Sprintf("^%s(remote|merge)$", prefix))
-	output, err := utils.PrepareCmd(configCmd).Output()
+	output, err := run.PrepareCmd(configCmd).Output()
 	if err != nil {
 		return
 	}
@@ -174,7 +174,7 @@ func ReadBranchConfig(branch string) (cfg BranchConfig) {
 // ToplevelDir returns the top-level directory path of the current repository
 func ToplevelDir() (string, error) {
 	showCmd := exec.Command("git", "rev-parse", "--show-toplevel")
-	output, err := utils.PrepareCmd(showCmd).Output()
+	output, err := run.PrepareCmd(showCmd).Output()
 	return firstLine(output), err
 
 }
diff --git a/git/git_test.go b/git/git_test.go
index 9e3f9a333..d52902dbe 100644
--- a/git/git_test.go
+++ b/git/git_test.go
@@ -4,8 +4,8 @@ import (
 	"os/exec"
 	"testing"
 
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 func Test_UncommittedChangeCount(t *testing.T) {
@@ -20,13 +20,13 @@ func Test_UncommittedChangeCount(t *testing.T) {
 		c{Label: "untracked file", Expected: 2, Output: " M poem.txt\n?? new.txt"},
 	}
 
-	teardown := utils.SetPrepareCmd(func(*exec.Cmd) utils.Runnable {
+	teardown := run.SetPrepareCmd(func(*exec.Cmd) run.Runnable {
 		return &test.OutputStub{}
 	})
 	defer teardown()
 
 	for _, v := range cases {
-		_ = utils.SetPrepareCmd(func(*exec.Cmd) utils.Runnable {
+		_ = run.SetPrepareCmd(func(*exec.Cmd) run.Runnable {
 			return &test.OutputStub{[]byte(v.Output)}
 		})
 		ucc, _ := UncommittedChangeCount()
diff --git a/git/remote.go b/git/remote.go
index f98606a2e..bfecfd3b0 100644
--- a/git/remote.go
+++ b/git/remote.go
@@ -6,7 +6,7 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/cli/cli/utils"
+	"github.com/cli/cli/internal/run"
 )
 
 var remoteRE = regexp.MustCompile(`(.+)\s+(.+)\s+\((push|fetch)\)`)
@@ -76,7 +76,7 @@ func parseRemotes(gitRemotes []string) (remotes RemoteSet) {
 // after the fetch.
 func AddRemote(name, initURL, finalURL string) (*Remote, error) {
 	addCmd := exec.Command("git", "remote", "add", "-f", name, initURL)
-	err := utils.PrepareCmd(addCmd).Run()
+	err := run.PrepareCmd(addCmd).Run()
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +85,7 @@ func AddRemote(name, initURL, finalURL string) (*Remote, error) {
 		finalURL = initURL
 	} else {
 		setCmd := exec.Command("git", "remote", "set-url", name, finalURL)
-		err := utils.PrepareCmd(setCmd).Run()
+		err := run.PrepareCmd(setCmd).Run()
 		if err != nil {
 			return nil, err
 		}
diff --git a/utils/prepare_cmd.go b/internal/run/run.go
similarity index 99%
rename from utils/prepare_cmd.go
rename to internal/run/run.go
index 6b354cb80..67de76fa2 100644
--- a/utils/prepare_cmd.go
+++ b/internal/run/run.go
@@ -1,4 +1,4 @@
-package utils
+package run
 
 import (
 	"bytes"
diff --git a/utils/utils.go b/utils/utils.go
index 6217871b7..1f7fd7106 100644
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/briandowns/spinner"
 	"github.com/charmbracelet/glamour"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/pkg/browser"
 )
 
@@ -16,7 +17,7 @@ func OpenInBrowser(url string) error {
 	if err != nil {
 		return err
 	}
-	return PrepareCmd(browseCmd).Run()
+	return run.PrepareCmd(browseCmd).Run()
 }
 
 func RenderMarkdown(text string) (string, error) {

From 88cf6ce16e2f237c3e98f43c729398dab8647edb Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Mon, 23 Mar 2020 16:36:24 -0500
Subject: [PATCH 15/48] consolidate CmdStubber into test package

---
 command/pr_create_test.go | 23 ++++++++++++-----------
 command/testing.go        | 36 ------------------------------------
 test/helpers.go           | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 48 insertions(+), 47 deletions(-)

diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 688dfd9c8..3b8769ad2 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/test"
 )
 
 func TestPRCreate(t *testing.T) {
@@ -24,7 +25,7 @@ func TestPRCreate(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                         // git status
@@ -68,7 +69,7 @@ func TestPRCreate_alreadyExists(t *testing.T) {
 		] } } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                         // git status
@@ -88,7 +89,7 @@ func TestPRCreate_web(t *testing.T) {
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                         // git status
@@ -123,7 +124,7 @@ func TestPRCreate_ReportsUncommittedChanges(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub(" M git/git.go")                            // git status
@@ -193,7 +194,7 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                         // git status
@@ -242,7 +243,7 @@ func TestPRCreate_survey_defaults_multicommit(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                         // git status
@@ -312,7 +313,7 @@ func TestPRCreate_survey_defaults_monocommit(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                                        // git status
@@ -383,7 +384,7 @@ func TestPRCreate_survey_autofill(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                                        // git status
@@ -426,7 +427,7 @@ func TestPRCreate_defaults_error_autofill(t *testing.T) {
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("") // git status
@@ -442,7 +443,7 @@ func TestPRCreate_defaults_error_web(t *testing.T) {
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("") // git status
@@ -463,7 +464,7 @@ func TestPRCreate_defaults_error_interactive(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("") // git status
diff --git a/command/testing.go b/command/testing.go
index 6d1a2594e..8ab97fc81 100644
--- a/command/testing.go
+++ b/command/testing.go
@@ -3,7 +3,6 @@ package command
 import (
 	"errors"
 	"fmt"
-	"os/exec"
 	"reflect"
 
 	"github.com/AlecAivazis/survey/v2"
@@ -11,43 +10,8 @@ import (
 
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/context"
-	"github.com/cli/cli/internal/run"
-	"github.com/cli/cli/test"
 )
 
-// TODO this is split between here and test/helpers.go. I did that because otherwise our test
-// package would have to import utils (for utils.Runnable) which felt wrong. while utils_test
-// currently doesn't import test helpers, i don't see why that ought to be precluded.
-// I'm wondering if this is a case for having a global package just for storing Interfaces.
-type CmdStubber struct {
-	Stubs []*test.OutputStub
-	Count int
-	Calls []*exec.Cmd
-}
-
-func initCmdStubber() (*CmdStubber, func()) {
-	cs := CmdStubber{}
-	teardown := run.SetPrepareCmd(createStubbedPrepareCmd(&cs))
-	return &cs, teardown
-}
-
-func (cs *CmdStubber) Stub(desiredOutput string) {
-	// TODO maybe have some kind of command mapping but going simple for now
-	cs.Stubs = append(cs.Stubs, &test.OutputStub{[]byte(desiredOutput)})
-}
-
-func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {
-	return func(cmd *exec.Cmd) run.Runnable {
-		cs.Calls = append(cs.Calls, cmd)
-		call := cs.Count
-		cs.Count += 1
-		if call >= len(cs.Stubs) {
-			panic(fmt.Sprintf("more execs than stubs. most recent call: %v", cmd))
-		}
-		return cs.Stubs[call]
-	}
-}
-
 type askStubber struct {
 	Asks  [][]*survey.Question
 	Count int
diff --git a/test/helpers.go b/test/helpers.go
index add7b90c3..d9c3c8f68 100644
--- a/test/helpers.go
+++ b/test/helpers.go
@@ -1,5 +1,12 @@
 package test
 
+import (
+	"fmt"
+	"os/exec"
+
+	"github.com/cli/cli/internal/run"
+)
+
 // OutputStub implements a simple utils.Runnable
 type OutputStub struct {
 	Out []byte
@@ -12,3 +19,32 @@ func (s OutputStub) Output() ([]byte, error) {
 func (s OutputStub) Run() error {
 	return nil
 }
+
+type CmdStubber struct {
+	Stubs []*OutputStub
+	Count int
+	Calls []*exec.Cmd
+}
+
+func InitCmdStubber() (*CmdStubber, func()) {
+	cs := CmdStubber{}
+	teardown := run.SetPrepareCmd(createStubbedPrepareCmd(&cs))
+	return &cs, teardown
+}
+
+func (cs *CmdStubber) Stub(desiredOutput string) {
+	// TODO maybe have some kind of command mapping but going simple for now
+	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte(desiredOutput)})
+}
+
+func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {
+	return func(cmd *exec.Cmd) run.Runnable {
+		cs.Calls = append(cs.Calls, cmd)
+		call := cs.Count
+		cs.Count += 1
+		if call >= len(cs.Stubs) {
+			panic(fmt.Sprintf("more execs than stubs. most recent call: %v", cmd))
+		}
+		return cs.Stubs[call]
+	}
+}

From dd1e2a2dfc0a275f749dbc78b5e1632de11c74db Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 24 Mar 2020 14:18:49 -0500
Subject: [PATCH 16/48] add StubError to CmdStubber

---
 command/pr_checkout_test.go |  4 ++--
 command/pr_test.go          |  2 +-
 git/git_test.go             |  2 +-
 test/helpers.go             | 17 +++++++++++++++--
 4 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/command/pr_checkout_test.go b/command/pr_checkout_test.go
index cc7eddd2b..3ab8afeee 100644
--- a/command/pr_checkout_test.go
+++ b/command/pr_checkout_test.go
@@ -350,7 +350,7 @@ func TestPRCheckout_differentRepo_existingBranch(t *testing.T) {
 	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
-			return &test.OutputStub{[]byte("refs/heads/feature\n")}
+			return &test.OutputStub{[]byte("refs/heads/feature\n"), nil}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
 			return &test.OutputStub{}
@@ -400,7 +400,7 @@ func TestPRCheckout_differentRepo_currentBranch(t *testing.T) {
 	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
-			return &test.OutputStub{[]byte("refs/heads/feature\n")}
+			return &test.OutputStub{[]byte("refs/heads/feature\n"), nil}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
 			return &test.OutputStub{}
diff --git a/command/pr_test.go b/command/pr_test.go
index c47e28963..8647b32d7 100644
--- a/command/pr_test.go
+++ b/command/pr_test.go
@@ -112,7 +112,7 @@ func TestPRStatus_fork(t *testing.T) {
 		switch strings.Join(cmd.Args, " ") {
 		case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
 			return &test.OutputStub{[]byte(`branch.blueberries.remote origin
-branch.blueberries.merge refs/heads/blueberries`)}
+branch.blueberries.merge refs/heads/blueberries`), nil}
 		default:
 			panic("not implemented")
 		}
diff --git a/git/git_test.go b/git/git_test.go
index d52902dbe..d8698751f 100644
--- a/git/git_test.go
+++ b/git/git_test.go
@@ -27,7 +27,7 @@ func Test_UncommittedChangeCount(t *testing.T) {
 
 	for _, v := range cases {
 		_ = run.SetPrepareCmd(func(*exec.Cmd) run.Runnable {
-			return &test.OutputStub{[]byte(v.Output)}
+			return &test.OutputStub{[]byte(v.Output), nil}
 		})
 		ucc, _ := UncommittedChangeCount()
 
diff --git a/test/helpers.go b/test/helpers.go
index d9c3c8f68..9ffb18c41 100644
--- a/test/helpers.go
+++ b/test/helpers.go
@@ -1,6 +1,7 @@
 package test
 
 import (
+	"errors"
 	"fmt"
 	"os/exec"
 
@@ -9,14 +10,21 @@ import (
 
 // OutputStub implements a simple utils.Runnable
 type OutputStub struct {
-	Out []byte
+	Out   []byte
+	Error error
 }
 
 func (s OutputStub) Output() ([]byte, error) {
+	if s.Error != nil {
+		return s.Out, s.Error
+	}
 	return s.Out, nil
 }
 
 func (s OutputStub) Run() error {
+	if s.Error != nil {
+		return s.Error
+	}
 	return nil
 }
 
@@ -34,7 +42,12 @@ func InitCmdStubber() (*CmdStubber, func()) {
 
 func (cs *CmdStubber) Stub(desiredOutput string) {
 	// TODO maybe have some kind of command mapping but going simple for now
-	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte(desiredOutput)})
+	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte(desiredOutput), nil})
+}
+
+func (cs *CmdStubber) StubError(msg string) {
+	// TODO consider handling CmdErr instead of a raw error
+	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte{}, errors.New(msg)})
 }
 
 func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {

From 4632ab1a1ec9b22c7ff96c639ca96c673762d09f Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 24 Mar 2020 14:19:02 -0500
Subject: [PATCH 17/48] test for CurrentBranch on an empty repo

---
 git/git.go      |  2 +-
 git/git_test.go | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/git/git.go b/git/git.go
index b604c398a..8f2025f54 100644
--- a/git/git.go
+++ b/git/git.go
@@ -28,7 +28,7 @@ func CurrentBranch() (string, error) {
 		matches := errRe.FindAllStringSubmatch(err.Error(), -1)
 		if len(matches) > 0 && matches[0][1] != "" {
 			return matches[0][1], nil
-		}
+		} // else we continue on. it's weird that git log failed but we'll let other errors surface.
 	}
 	// we avoid using `git branch --show-current` for compatibility with git < 2.22
 	branchCmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
diff --git a/git/git_test.go b/git/git_test.go
index d8698751f..d5791e451 100644
--- a/git/git_test.go
+++ b/git/git_test.go
@@ -1,6 +1,7 @@
 package git
 
 import (
+	"fmt"
 	"os/exec"
 	"testing"
 
@@ -36,3 +37,21 @@ func Test_UncommittedChangeCount(t *testing.T) {
 		}
 	}
 }
+
+func Test_CurrentBranch_no_commits(t *testing.T) {
+	cs, teardown := test.InitCmdStubber()
+	defer teardown()
+
+	expected := "cool_branch-name"
+
+	cs.StubError(fmt.Sprintf("fatal: your current branch '%s' does not have any commits yet", expected))
+
+	result, err := CurrentBranch()
+	if err != nil {
+		t.Errorf("got unexpected error: %w", err)
+	}
+	if result != expected {
+		t.Errorf("unexpected branch name: %s instead of %s", result, expected)
+	}
+
+}

From 379ecdab542842c07047fa70ba432dcc02e03bdb Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 24 Mar 2020 15:21:18 -0500
Subject: [PATCH 18/48] move readme fetching to api package

---
 api/queries_repo.go | 42 ++++++++++++++++++++++++++++++++++++++++++
 command/repo.go     | 27 +--------------------------
 2 files changed, 43 insertions(+), 26 deletions(-)

diff --git a/api/queries_repo.go b/api/queries_repo.go
index 4b8a017ff..c4e8e3649 100644
--- a/api/queries_repo.go
+++ b/api/queries_repo.go
@@ -2,6 +2,7 @@ package api
 
 import (
 	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"sort"
@@ -9,6 +10,7 @@ import (
 	"time"
 
 	"github.com/cli/cli/internal/ghrepo"
+	"github.com/cli/cli/utils"
 )
 
 // Repository contains information about a GitHub repo
@@ -281,3 +283,43 @@ func RepoCreate(client *Client, input RepoCreateInput) (*Repository, error) {
 
 	return &response.CreateRepository.Repository, nil
 }
+
+func RepositoryReadme(client *Client, fullName string) (string, error) {
+	type readmeResponse struct {
+		Name    string
+		Content string
+	}
+
+	var readme readmeResponse
+
+	err := client.REST("GET", fmt.Sprintf("repos/%s/readme", fullName), nil, &readme)
+	if err != nil && !strings.HasSuffix(err.Error(), "'Not Found'") {
+		return "", fmt.Errorf("could not get readme for repo: %w", err)
+	}
+
+	decoded, err := base64.StdEncoding.DecodeString(readme.Content)
+	if err != nil {
+		return "", fmt.Errorf("failed to decode readme: %w", err)
+	}
+
+	readmeContent := string(decoded)
+
+	if isMarkdownFile(readme.Name) {
+		readmeContent, err = utils.RenderMarkdown(readmeContent)
+		if err != nil {
+			return "", fmt.Errorf("failed to render readme as markdown: %w", err)
+		}
+	}
+
+	return readmeContent, nil
+
+}
+
+func isMarkdownFile(filename string) bool {
+	// kind of gross, but i'm assuming that 90% of the time the suffix will just be .md. it didn't
+	// seem worth executing a regex for this given that assumption.
+	return strings.HasSuffix(filename, ".md") ||
+		strings.HasSuffix(filename, ".markdown") ||
+		strings.HasSuffix(filename, ".mdown") ||
+		strings.HasSuffix(filename, ".mkdown")
+}
diff --git a/command/repo.go b/command/repo.go
index 3bd412e77..c4c9db384 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -1,7 +1,6 @@
 package command
 
 import (
-	"encoding/base64"
 	"fmt"
 	"net/url"
 	"os"
@@ -450,31 +449,7 @@ func repoView(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	type readmeResponse struct {
-		Name    string
-		Content string
-	}
-
-	var readme readmeResponse
-
-	err = apiClient.REST("GET", fmt.Sprintf("repos/%s/readme", fullName), nil, &readme)
-	if err != nil && !strings.HasSuffix(err.Error(), "'Not Found'") {
-		return fmt.Errorf("could not get readme for repo: %w", err)
-	}
-
-	decoded, err := base64.StdEncoding.DecodeString(readme.Content)
-	if err != nil {
-		return fmt.Errorf("failed to decode readme: %w", err)
-	}
-
-	readmeContent := string(decoded)
-
-	if strings.HasSuffix(readme.Name, ".md") {
-		readmeContent, err = utils.RenderMarkdown(readmeContent)
-		if err != nil {
-			return fmt.Errorf("failed to render readme as markdown: %w", err)
-		}
-	}
+	readmeContent, err := api.RepositoryReadme(apiClient, fullName)
 
 	if readmeContent == "" {
 		readmeContent = utils.Gray("No README provided")

From 7c73cf88ae5b9ea8c45b20c946b72f7bda226bcf Mon Sep 17 00:00:00 2001
From: Amanda Pinsker <ampinsk@github.com>
Date: Tue, 24 Mar 2020 15:01:21 -0700
Subject: [PATCH 19/48] Remove formatting from Fprint
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Mislav Marohnić <mislav@github.com>
---
 command/pr.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/command/pr.go b/command/pr.go
index b7a26b8b7..22cd5dcaf 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -421,7 +421,7 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 				} else if checks.Passing == checks.Total {
 					summary = utils.Green("✓ Checks passing ")
 				}
-				fmt.Fprintf(w, "%s", summary)
+				fmt.Fprint(w, summary)
 			}
 
 			if reviews.ChangesRequested {

From 5726376ab18f8fbd88f34a677f8223cff663a086 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Wed, 25 Mar 2020 08:26:06 +0100
Subject: [PATCH 20/48] Guard against faulty `affiliations` GraphQL filter

This API was just fixed in github.com, but it will take a while for the
change to propagate to GitHub Enterprise installs, so guard ourselves
from false positives when querying forks.
---
 api/queries_repo.go       | 9 +++++++--
 command/pr_create_test.go | 4 ++++
 context/remote_test.go    | 3 ++-
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/api/queries_repo.go b/api/queries_repo.go
index 8ba8ee148..4bfa35f58 100644
--- a/api/queries_repo.go
+++ b/api/queries_repo.go
@@ -245,6 +245,7 @@ func RepoFindFork(client *Client, repo ghrepo.Interface) (*Repository, error) {
 					name
 					owner { login }
 					url
+					viewerPermission
 				}
 			}
 		}
@@ -253,8 +254,12 @@ func RepoFindFork(client *Client, repo ghrepo.Interface) (*Repository, error) {
 		return nil, err
 	}
 
-	if len(result.Repository.Forks.Nodes) > 0 {
-		return &result.Repository.Forks.Nodes[0], nil
+	forks := result.Repository.Forks.Nodes
+	// we check ViewerCanPush, even though we expect it to always be true per
+	// `affiliations` condition, to guard against versions of GitHub with a
+	// faulty `affiliations` implementation
+	if len(forks) > 0 && forks[0].ViewerCanPush() {
+		return &forks[0], nil
 	}
 	return nil, &NotFoundError{errors.New("no fork found")}
 }
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 50ff70f9b..a92ad76ff 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -96,6 +96,10 @@ func TestPRCreate_alreadyExistsDifferentBase(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes": [
 			{ "url": "https://github.com/OWNER/REPO/pull/123",
diff --git a/context/remote_test.go b/context/remote_test.go
index dd6a5d59a..5c3c46bc7 100644
--- a/context/remote_test.go
+++ b/context/remote_test.go
@@ -137,7 +137,8 @@ func Test_resolvedRemotes_forkLookup(t *testing.T) {
 		{ "id": "FORKID",
 		  "url": "https://github.com/FORKOWNER/REPO",
 		  "name": "REPO",
-		  "owner": { "login": "FORKOWNER" }
+		  "owner": { "login": "FORKOWNER" },
+		  "viewerPermission": "WRITE"
 		}
 	] } } } }
 	`))

From 11327030e708ec612e241d7a46bb4eedec7de1b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Wed, 25 Mar 2020 09:05:51 +0100
Subject: [PATCH 21/48] Tweak whitespace printing in `pr status`

---
 command/pr.go | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/command/pr.go b/command/pr.go
index 22cd5dcaf..aa22464f4 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -398,13 +398,15 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 			prStateColorFunc = utils.Red
 		}
 
-		fmt.Fprintf(w, "  %s  %s %s ", prStateColorFunc(prNumber), text.Truncate(50, replaceExcessiveWhitespace(pr.Title)), utils.Cyan("["+pr.HeadLabel()+"]"))
+		fmt.Fprintf(w, "  %s  %s %s", prStateColorFunc(prNumber), text.Truncate(50, replaceExcessiveWhitespace(pr.Title)), utils.Cyan("["+pr.HeadLabel()+"]"))
 
 		checks := pr.ChecksStatus()
 		reviews := pr.ReviewStatus()
 
 		if pr.State == "OPEN" {
-			if checks.Total > 0 || reviews.ChangesRequested || reviews.Approved {
+			reviewStatus := reviews.ChangesRequested || reviews.Approved || reviews.ReviewRequired
+			if checks.Total > 0 || reviewStatus {
+				// show checks & reviews on their own line
 				fmt.Fprintf(w, "\n  ")
 			}
 
@@ -412,28 +414,33 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 				var summary string
 				if checks.Failing > 0 {
 					if checks.Failing == checks.Total {
-						summary = utils.Red("× All checks failing ")
+						summary = utils.Red("× All checks failing")
 					} else {
-						summary = utils.Red(fmt.Sprintf("× %d/%d checks failing ", checks.Failing, checks.Total))
+						summary = utils.Red(fmt.Sprintf("× %d/%d checks failing", checks.Failing, checks.Total))
 					}
 				} else if checks.Pending > 0 {
-					summary = utils.Yellow("- Checks pending ")
+					summary = utils.Yellow("- Checks pending")
 				} else if checks.Passing == checks.Total {
-					summary = utils.Green("✓ Checks passing ")
+					summary = utils.Green("✓ Checks passing")
 				}
 				fmt.Fprint(w, summary)
 			}
 
+			if checks.Total > 0 && reviewStatus {
+				// add padding between checks & reviews
+				fmt.Fprint(w, " ")
+			}
+
 			if reviews.ChangesRequested {
-				fmt.Fprintf(w, "%s", utils.Red("+ Changes requested "))
+				fmt.Fprint(w, utils.Red("+ Changes requested"))
 			} else if reviews.ReviewRequired {
-				fmt.Fprintf(w, "%s", utils.Yellow("- Review required "))
+				fmt.Fprint(w, utils.Yellow("- Review required"))
 			} else if reviews.Approved {
-				fmt.Fprintf(w, "%s", utils.Green("✓ Approved "))
+				fmt.Fprint(w, utils.Green("✓ Approved"))
 			}
 		} else {
 			s := strings.Title(strings.ToLower(pr.State))
-			fmt.Fprintf(w, "- %s", prStateColorFunc(s))
+			fmt.Fprintf(w, " - %s", prStateColorFunc(s))
 		}
 
 		fmt.Fprint(w, "\n")

From a8a57595dcf39d1cda20e1592f197b28cd421127 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 25 Mar 2020 11:26:58 -0500
Subject: [PATCH 22/48] explicitly ignore readme fetching error

---
 command/repo.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/command/repo.go b/command/repo.go
index c4c9db384..cfb762767 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -449,7 +449,7 @@ func repoView(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	readmeContent, err := api.RepositoryReadme(apiClient, fullName)
+	readmeContent, _ := api.RepositoryReadme(apiClient, fullName)
 
 	if readmeContent == "" {
 		readmeContent = utils.Gray("No README provided")

From 897d5c3dcae96587a4337df739831320a246622c Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 25 Mar 2020 11:57:53 -0500
Subject: [PATCH 23/48] fall back to symbolic-ref in CurrentBranch

---
 git/git.go      | 32 ++++++++++++++++++--------------
 git/git_test.go | 49 +++++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 63 insertions(+), 18 deletions(-)

diff --git a/git/git.go b/git/git.go
index 8f2025f54..09c731885 100644
--- a/git/git.go
+++ b/git/git.go
@@ -21,23 +21,27 @@ func VerifyRef(ref string) bool {
 
 // CurrentBranch reads the checked-out branch for the git repository
 func CurrentBranch() (string, error) {
-	err := run.PrepareCmd(GitCommand("log")).Run()
-	if err != nil {
-		// this is a hack.
-		errRe := regexp.MustCompile("your current branch '([^']+)' does not have any commits yet")
-		matches := errRe.FindAllStringSubmatch(err.Error(), -1)
-		if len(matches) > 0 && matches[0][1] != "" {
-			return matches[0][1], nil
-		} // else we continue on. it's weird that git log failed but we'll let other errors surface.
-	}
+	noBranchError := errors.New("git: not on any branch")
+
 	// we avoid using `git branch --show-current` for compatibility with git < 2.22
-	branchCmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
-	output, err := run.PrepareCmd(branchCmd).Output()
+	output, err := run.PrepareCmd(GitCommand("rev-parse", "--abbrev-ref", "HEAD")).Output()
 	branchName := firstLine(output)
-	if err == nil && branchName == "HEAD" {
-		return "", errors.New("git: not on any branch")
+	if err == nil {
+		if branchName == "HEAD" {
+			return "", noBranchError
+		} else {
+			return branchName, nil
+		}
 	}
-	return branchName, err
+
+	// Fall back to symbolic-ref in case we're in a repository with no commits
+	output, err = run.PrepareCmd(GitCommand("symbolic-ref", "--short", "HEAD")).Output()
+	if err != nil {
+		return "", noBranchError
+	}
+	branchName = firstLine(output)
+
+	return branchName, nil
 }
 
 func listRemotes() ([]string, error) {
diff --git a/git/git_test.go b/git/git_test.go
index d5791e451..50ce4c71c 100644
--- a/git/git_test.go
+++ b/git/git_test.go
@@ -1,7 +1,6 @@
 package git
 
 import (
-	"fmt"
 	"os/exec"
 	"testing"
 
@@ -42,16 +41,58 @@ func Test_CurrentBranch_no_commits(t *testing.T) {
 	cs, teardown := test.InitCmdStubber()
 	defer teardown()
 
-	expected := "cool_branch-name"
+	expected := "branch-name"
 
-	cs.StubError(fmt.Sprintf("fatal: your current branch '%s' does not have any commits yet", expected))
+	cs.StubError("")
+	cs.Stub(expected)
 
 	result, err := CurrentBranch()
 	if err != nil {
 		t.Errorf("got unexpected error: %w", err)
 	}
+	if len(cs.Calls) != 2 {
+		t.Errorf("expected 2 git calls, saw %d", len(cs.Calls))
+	}
 	if result != expected {
 		t.Errorf("unexpected branch name: %s instead of %s", result, expected)
 	}
-
+}
+
+func Test_CurrentBranch(t *testing.T) {
+	cs, teardown := test.InitCmdStubber()
+	defer teardown()
+
+	expected := "branch-name"
+
+	cs.Stub(expected)
+
+	result, err := CurrentBranch()
+	if err != nil {
+		t.Errorf("got unexpected error: %w", err)
+	}
+	if len(cs.Calls) != 1 {
+		t.Errorf("expected 1 git call, saw %d", len(cs.Calls))
+	}
+	if result != expected {
+		t.Errorf("unexpected branch name: %s instead of %s", result, expected)
+	}
+}
+
+func Test_CurrentBranch_detached_head(t *testing.T) {
+	cs, teardown := test.InitCmdStubber()
+	defer teardown()
+
+	cs.Stub("HEAD")
+
+	_, err := CurrentBranch()
+	if err == nil {
+		t.Errorf("expected an error")
+	}
+	expectedError := "git: not on any branch"
+	if err.Error() != expectedError {
+		t.Errorf("got unexpected error: %s instead of %s", err.Error(), expectedError)
+	}
+	if len(cs.Calls) != 1 {
+		t.Errorf("expected 1 git call, saw %d", len(cs.Calls))
+	}
 }

From dd877b6a34923fc721ed44d3bb3400af8144b5e0 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Wed, 25 Mar 2020 12:01:44 -0500
Subject: [PATCH 24/48] merge fallout

---
 command/pr_checkout_test.go | 2 +-
 command/pr_create_test.go   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/command/pr_checkout_test.go b/command/pr_checkout_test.go
index 4f48babe4..9aca71901 100644
--- a/command/pr_checkout_test.go
+++ b/command/pr_checkout_test.go
@@ -145,7 +145,7 @@ func TestPRCheckout_urlArg_differentBase(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git show-ref --verify --quiet refs/heads/feature":
 			return &errorStub{"exit status: 1"}
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 4ec940f77..76a7c8803 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -98,7 +98,7 @@ func TestPRCreate_alreadyExistsDifferentBase(t *testing.T) {
 	`))
 	http.StubResponse(200, bytes.NewBufferString("{}"))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("")                                         // git status

From c36b84e550dc6ddc71dc3b1e89f4c2ac852a5368 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Thu, 26 Mar 2020 19:21:40 +0100
Subject: [PATCH 25/48] Convert `git.VerifyRef` into a more versatile
 `ShowRefs`

This is so we can pass a list of full qualified refs and have them
resolved for both existence and their commit hashes.
---
 command/pr_checkout.go      |  2 +-
 command/pr_checkout_test.go | 12 ++++++------
 git/git.go                  | 29 +++++++++++++++++++++++++----
 3 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/command/pr_checkout.go b/command/pr_checkout.go
index 336a5a8d1..fc2a743ec 100644
--- a/command/pr_checkout.go
+++ b/command/pr_checkout.go
@@ -66,7 +66,7 @@ func prCheckout(cmd *cobra.Command, args []string) error {
 		cmdQueue = append(cmdQueue, []string{"git", "fetch", headRemote.Name, refSpec})
 
 		// local branch already exists
-		if git.VerifyRef("refs/heads/" + newBranchName) {
+		if _, err := git.ShowRefs("refs/heads/" + newBranchName); err == nil {
 			cmdQueue = append(cmdQueue, []string{"git", "checkout", newBranchName})
 			cmdQueue = append(cmdQueue, []string{"git", "merge", "--ff-only", fmt.Sprintf("refs/remotes/%s", remoteBranch)})
 		} else {
diff --git a/command/pr_checkout_test.go b/command/pr_checkout_test.go
index 1a36756a7..e155e2a82 100644
--- a/command/pr_checkout_test.go
+++ b/command/pr_checkout_test.go
@@ -46,7 +46,7 @@ func TestPRCheckout_sameRepo(t *testing.T) {
 	ranCommands := [][]string{}
 	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -98,7 +98,7 @@ func TestPRCheckout_urlArg(t *testing.T) {
 	ranCommands := [][]string{}
 	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -147,7 +147,7 @@ func TestPRCheckout_urlArg_differentBase(t *testing.T) {
 	ranCommands := [][]string{}
 	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -210,7 +210,7 @@ func TestPRCheckout_branchArg(t *testing.T) {
 	ranCommands := [][]string{}
 	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -260,7 +260,7 @@ func TestPRCheckout_existingBranch(t *testing.T) {
 	ranCommands := [][]string{}
 	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &test.OutputStub{}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -313,7 +313,7 @@ func TestPRCheckout_differentRepo_remoteExists(t *testing.T) {
 	ranCommands := [][]string{}
 	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
diff --git a/git/git.go b/git/git.go
index 37253462a..275aec819 100644
--- a/git/git.go
+++ b/git/git.go
@@ -13,10 +13,31 @@ import (
 	"github.com/cli/cli/utils"
 )
 
-func VerifyRef(ref string) bool {
-	showRef := exec.Command("git", "show-ref", "--verify", "--quiet", ref)
-	err := utils.PrepareCmd(showRef).Run()
-	return err == nil
+// Ref represents a git commit reference
+type Ref struct {
+	Hash string
+	Name string
+}
+
+// ShowRefs resolves fully-qualified refs to commit hashes
+func ShowRefs(ref ...string) ([]Ref, error) {
+	args := append([]string{"show-ref", "--verify", "--"}, ref...)
+	showRef := exec.Command("git", args...)
+	output, err := utils.PrepareCmd(showRef).Output()
+
+	var refs []Ref
+	for _, line := range outputLines(output) {
+		parts := strings.SplitN(line, " ", 2)
+		if len(parts) < 2 {
+			continue
+		}
+		refs = append(refs, Ref{
+			Hash: parts[0],
+			Name: parts[1],
+		})
+	}
+
+	return refs, err
 }
 
 // CurrentBranch reads the checked-out branch for the git repository

From 3907914225c9f4154d3c89297c418c35bfaa6f6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Thu, 26 Mar 2020 19:23:17 +0100
Subject: [PATCH 26/48] Guard against filesystem paths in
 `git.ReadBranchConfig`

A valid remote specificication read from `branch.<name>.remote` git
config can be a URL, a `.`, a filesystem path, and a remote name. When
detecting the remote name, be sure not to take filesystem paths instead.
---
 git/git.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/git/git.go b/git/git.go
index 275aec819..40b1d877e 100644
--- a/git/git.go
+++ b/git/git.go
@@ -173,7 +173,7 @@ func ReadBranchConfig(branch string) (cfg BranchConfig) {
 					continue
 				}
 				cfg.RemoteURL = u
-			} else {
+			} else if !isFilesystemPath(parts[1]) {
 				cfg.RemoteName = parts[1]
 			}
 		case "merge":
@@ -183,6 +183,10 @@ func ReadBranchConfig(branch string) (cfg BranchConfig) {
 	return
 }
 
+func isFilesystemPath(p string) bool {
+	return p == "." || strings.HasPrefix(p, "./") || strings.HasPrefix(p, "/")
+}
+
 // ToplevelDir returns the top-level directory path of the current repository
 func ToplevelDir() (string, error) {
 	showCmd := exec.Command("git", "rev-parse", "--show-toplevel")

From cba8331d55940fca70528418b9b5c31844b9b8f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Thu, 26 Mar 2020 19:26:36 +0100
Subject: [PATCH 27/48] Avoid auto-forking/pushing an already pushed branch in
 `pr create`

A branch is considered already pushed if its HEAD commit hash matches
the commit hash of one of the remote tracking branches:
`refs/remotes/<remote>/<branch>`

This mechanism allows the user to:

- Choose a remote as push target for their branch different than the one
  that would automatically get chosen for them by `pr create`;

- Avoid a `git push` operation (and its associated git hooks) if a push
  was not necessary in the first place.
---
 command/pr_create.go      | 113 +++++++++++++++++++++++++-------
 command/pr_create_test.go | 131 +++++++++++++++++++++++++++++++++++++-
 git/git.go                |  10 +++
 3 files changed, 227 insertions(+), 27 deletions(-)

diff --git a/command/pr_create.go b/command/pr_create.go
index 2be922987..408145348 100644
--- a/command/pr_create.go
+++ b/command/pr_create.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"strings"
 	"time"
 
 	"github.com/cli/cli/api"
@@ -75,7 +76,27 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return fmt.Errorf("could not determine the current branch: %w", err)
 	}
-	headRepo, headRepoErr := repoContext.HeadRepo()
+
+	var headRepo ghrepo.Interface
+	var headRemote *context.Remote
+
+	// determine whether the head branch is already pushed to a remote
+	headBranchPushedTo := determineTrackingBranch(remotes, headBranch)
+	if headBranchPushedTo != nil {
+		for _, r := range remotes {
+			if r.Name != headBranchPushedTo.RemoteName {
+				continue
+			}
+			headRepo = r
+			headRemote = r
+			break
+		}
+	}
+
+	// otherwise, determine the head repository with info obtained from the API
+	if headRepo == nil {
+		headRepo, _ = repoContext.HeadRepo()
+	}
 
 	baseBranch, err := cmd.Flags().GetString("base")
 	if err != nil {
@@ -193,8 +214,9 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	}
 
 	didForkRepo := false
-	var headRemote *context.Remote
-	if headRepoErr != nil {
+	// if a head repository could not be determined so far, automatically create
+	// one by forking the base repository
+	if headRepo == nil {
 		if baseRepo.IsPrivate {
 			return fmt.Errorf("cannot fork private repository '%s'", ghrepo.FullName(baseRepo))
 		}
@@ -223,29 +245,31 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 		headBranchLabel = fmt.Sprintf("%s:%s", headRepo.RepoOwner(), headBranch)
 	}
 
-	if headRemote == nil {
-		headRemote, err = repoContext.RemoteForRepo(headRepo)
-		if err != nil {
-			return fmt.Errorf("git remote not found for head repository: %w", err)
-		}
-	}
-
-	pushTries := 0
-	maxPushTries := 3
-	for {
-		// TODO: respect existing upstream configuration of the current branch
-		if err := git.Push(headRemote.Name, fmt.Sprintf("HEAD:%s", headBranch)); err != nil {
-			if didForkRepo && pushTries < maxPushTries {
-				pushTries++
-				// first wait 2 seconds after forking, then 4s, then 6s
-				waitSeconds := 2 * pushTries
-				fmt.Fprintf(cmd.ErrOrStderr(), "waiting %s before retrying...\n", utils.Pluralize(waitSeconds, "second"))
-				time.Sleep(time.Duration(waitSeconds) * time.Second)
-				continue
+	// automatically push the branch if it hasn't been pushed anywhere yet
+	if headBranchPushedTo == nil {
+		if headRemote == nil {
+			headRemote, err = repoContext.RemoteForRepo(headRepo)
+			if err != nil {
+				return fmt.Errorf("git remote not found for head repository: %w", err)
 			}
-			return err
 		}
-		break
+
+		pushTries := 0
+		maxPushTries := 3
+		for {
+			if err := git.Push(headRemote.Name, fmt.Sprintf("HEAD:%s", headBranch)); err != nil {
+				if didForkRepo && pushTries < maxPushTries {
+					pushTries++
+					// first wait 2 seconds after forking, then 4s, then 6s
+					waitSeconds := 2 * pushTries
+					fmt.Fprintf(cmd.ErrOrStderr(), "waiting %s before retrying...\n", utils.Pluralize(waitSeconds, "second"))
+					time.Sleep(time.Duration(waitSeconds) * time.Second)
+					continue
+				}
+				return err
+			}
+			break
+		}
 	}
 
 	if action == SubmitAction {
@@ -275,6 +299,47 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	return nil
 }
 
+func determineTrackingBranch(remotes context.Remotes, headBranch string) *git.TrackingRef {
+	refsForLookup := []string{"HEAD"}
+	var trackingRefs []git.TrackingRef
+
+	headBranchConfig := git.ReadBranchConfig(headBranch)
+	if headBranchConfig.RemoteName != "" {
+		tr := git.TrackingRef{
+			RemoteName: headBranchConfig.RemoteName,
+			BranchName: strings.TrimPrefix(headBranchConfig.MergeRef, "refs/heads/"),
+		}
+		trackingRefs = append(trackingRefs, tr)
+		refsForLookup = append(refsForLookup, tr.String())
+	}
+
+	for _, remote := range remotes {
+		tr := git.TrackingRef{
+			RemoteName: remote.Name,
+			BranchName: headBranch,
+		}
+		trackingRefs = append(trackingRefs, tr)
+		refsForLookup = append(refsForLookup, tr.String())
+	}
+
+	resolvedRefs, _ := git.ShowRefs(refsForLookup...)
+	if len(resolvedRefs) > 1 {
+		for _, r := range resolvedRefs[1:] {
+			if r.Hash != resolvedRefs[0].Hash {
+				continue
+			}
+			for _, tr := range trackingRefs {
+				if tr.String() != r.Name {
+					continue
+				}
+				return &tr
+			}
+		}
+	}
+
+	return nil
+}
+
 func generateCompareURL(r ghrepo.Interface, base, head, title, body string) string {
 	u := fmt.Sprintf(
 		"https://github.com/%s/compare/%s...%s?expand=1",
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 874b02a86..a91dd0744 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/git"
 )
 
 func TestPRCreate(t *testing.T) {
@@ -27,6 +28,8 @@ func TestPRCreate(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -72,6 +75,8 @@ func TestPRCreate_alreadyExists(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 
@@ -100,6 +105,8 @@ func TestPRCreate_alreadyExistsDifferentBase(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git rev-parse
@@ -118,6 +125,8 @@ func TestPRCreate_web(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -129,9 +138,9 @@ func TestPRCreate_web(t *testing.T) {
 	eq(t, output.String(), "")
 	eq(t, output.Stderr(), "Opening github.com/OWNER/REPO/compare/master...feature in your browser.\n")
 
-	eq(t, len(cs.Calls), 4)
-	eq(t, strings.Join(cs.Calls[2].Args, " "), "git push --set-upstream origin HEAD:feature")
-	browserCall := cs.Calls[3].Args
+	eq(t, len(cs.Calls), 6)
+	eq(t, strings.Join(cs.Calls[4].Args, " "), "git push --set-upstream origin HEAD:feature")
+	browserCall := cs.Calls[5].Args
 	eq(t, browserCall[len(browserCall)-1], "https://github.com/OWNER/REPO/compare/master...feature?expand=1")
 }
 
@@ -153,6 +162,8 @@ func TestPRCreate_ReportsUncommittedChanges(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub(" M git/git.go")                            // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -223,6 +234,8 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -272,6 +285,8 @@ func TestPRCreate_survey_defaults_multicommit(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git rev-parse
@@ -342,6 +357,8 @@ func TestPRCreate_survey_defaults_monocommit(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                                        // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                                        // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                                        // git status
 	cs.Stub("1234567890,the sky above the port")                       // git log
 	cs.Stub("was the color of a television, turned to a dead channel") // git show
@@ -413,6 +430,8 @@ func TestPRCreate_survey_autofill(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                                        // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                                        // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                                        // git status
 	cs.Stub("1234567890,the sky above the port")                       // git log
 	cs.Stub("was the color of a television, turned to a dead channel") // git show
@@ -456,6 +475,8 @@ func TestPRCreate_defaults_error_autofill(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("") // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("") // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("") // git status
 	cs.Stub("") // git log
 
@@ -472,6 +493,8 @@ func TestPRCreate_defaults_error_web(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("") // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("") // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("") // git status
 	cs.Stub("") // git log
 
@@ -493,6 +516,8 @@ func TestPRCreate_defaults_error_interactive(t *testing.T) {
 	cs, cmdTeardown := initCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("") // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("") // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("") // git status
 	cs.Stub("") // git log
 	cs.Stub("") // git rev-parse
@@ -525,3 +550,103 @@ func TestPRCreate_defaults_error_interactive(t *testing.T) {
 	stderr := string(output.Stderr())
 	eq(t, strings.Contains(stderr, "warning: could not compute title or body defaults: could not find any commits"), true)
 }
+
+func Test_determineTrackingBranch_empty(t *testing.T) {
+	cs, cmdTeardown := initCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{}
+
+	cs.Stub("")              // git config --get-regexp (ReadBranchConfig)
+	cs.Stub("deadbeef HEAD") // git show-ref --verify   (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref != nil {
+		t.Errorf("expected nil result, got %v", ref)
+	}
+}
+
+func Test_determineTrackingBranch_noMatch(t *testing.T) {
+	cs, cmdTeardown := initCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{
+		&context.Remote{
+			Remote: &git.Remote{Name: "origin"},
+			Owner:  "hubot",
+			Repo:   "Spoon-Knife",
+		},
+		&context.Remote{
+			Remote: &git.Remote{Name: "upstream"},
+			Owner:  "octocat",
+			Repo:   "Spoon-Knife",
+		},
+	}
+
+	cs.Stub("") // git config --get-regexp (ReadBranchConfig)
+	cs.Stub(`deadbeef HEAD
+deadb00f refs/remotes/origin/feature`) // git show-ref --verify (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref != nil {
+		t.Errorf("expected nil result, got %v", ref)
+	}
+}
+
+func Test_determineTrackingBranch_hasMatch(t *testing.T) {
+	cs, cmdTeardown := initCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{
+		&context.Remote{
+			Remote: &git.Remote{Name: "origin"},
+			Owner:  "hubot",
+			Repo:   "Spoon-Knife",
+		},
+		&context.Remote{
+			Remote: &git.Remote{Name: "upstream"},
+			Owner:  "octocat",
+			Repo:   "Spoon-Knife",
+		},
+	}
+
+	cs.Stub("") // git config --get-regexp (ReadBranchConfig)
+	cs.Stub(`deadbeef HEAD
+deadb00f refs/remotes/origin/feature
+deadbeef refs/remotes/upstream/feature`) // git show-ref --verify (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref == nil {
+		t.Fatal("expected result, got nil")
+	}
+
+	eq(t, cs.Calls[1].Args, []string{"git", "show-ref", "--verify", "--", "HEAD", "refs/remotes/origin/feature", "refs/remotes/upstream/feature"})
+
+	eq(t, ref.RemoteName, "upstream")
+	eq(t, ref.BranchName, "feature")
+}
+
+func Test_determineTrackingBranch_respectTrackingConfig(t *testing.T) {
+	cs, cmdTeardown := initCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{
+		&context.Remote{
+			Remote: &git.Remote{Name: "origin"},
+			Owner:  "hubot",
+			Repo:   "Spoon-Knife",
+		},
+	}
+
+	cs.Stub(`branch.feature.remote origin
+branch.feature.merge refs/heads/great-feat`) // git config --get-regexp (ReadBranchConfig)
+	cs.Stub(`deadbeef HEAD
+deadb00f refs/remotes/origin/feature`) // git show-ref --verify (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref != nil {
+		t.Errorf("expected nil result, got %v", ref)
+	}
+
+	eq(t, cs.Calls[1].Args, []string{"git", "show-ref", "--verify", "--", "HEAD", "refs/remotes/origin/great-feat", "refs/remotes/origin/feature"})
+}
diff --git a/git/git.go b/git/git.go
index 40b1d877e..ce32742a4 100644
--- a/git/git.go
+++ b/git/git.go
@@ -19,6 +19,16 @@ type Ref struct {
 	Name string
 }
 
+// TrackingRef represents a ref for a remote tracking branch
+type TrackingRef struct {
+	RemoteName string
+	BranchName string
+}
+
+func (r TrackingRef) String() string {
+	return "refs/remotes/" + r.RemoteName + "/" + r.BranchName
+}
+
 // ShowRefs resolves fully-qualified refs to commit hashes
 func ShowRefs(ref ...string) ([]Ref, error) {
 	args := append([]string{"show-ref", "--verify", "--"}, ref...)

From 0af232444cbde4cacdf00a05e81f57770fb0bf67 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Thu, 26 Mar 2020 15:00:58 -0500
Subject: [PATCH 28/48] consolidate into one symbolic-ref call

---
 git/git.go | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/git/git.go b/git/git.go
index 09c731885..bbdc6e301 100644
--- a/git/git.go
+++ b/git/git.go
@@ -21,27 +21,23 @@ func VerifyRef(ref string) bool {
 
 // CurrentBranch reads the checked-out branch for the git repository
 func CurrentBranch() (string, error) {
-	noBranchError := errors.New("git: not on any branch")
 
-	// we avoid using `git branch --show-current` for compatibility with git < 2.22
-	output, err := run.PrepareCmd(GitCommand("rev-parse", "--abbrev-ref", "HEAD")).Output()
-	branchName := firstLine(output)
+	refCmd := GitCommand("symbolic-ref", "--quiet", "--short", "HEAD")
+
+	output, err := run.PrepareCmd(refCmd).Output()
 	if err == nil {
-		if branchName == "HEAD" {
-			return "", noBranchError
-		} else {
-			return branchName, nil
-		}
+		// Found the branch name
+		return firstLine(output), nil
 	}
 
-	// Fall back to symbolic-ref in case we're in a repository with no commits
-	output, err = run.PrepareCmd(GitCommand("symbolic-ref", "--short", "HEAD")).Output()
-	if err != nil {
-		return "", noBranchError
+	ce := err.(*run.CmdError)
+	if ce.Stderr.Len() == 0 {
+		// Detached head
+		return "", errors.New("git: not on any branch")
 	}
-	branchName = firstLine(output)
 
-	return branchName, nil
+	// Unknown error
+	return "", err
 }
 
 func listRemotes() ([]string, error) {

From ca99096ca8e97dcbb4abeb54b297cf91304e2898 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Thu, 26 Mar 2020 15:32:31 -0500
Subject: [PATCH 29/48] use CmdError in StubError and fix git_test

---
 git/git.go      |  1 -
 git/git_test.go | 43 +++++++++++++++++++++----------------------
 test/helpers.go | 11 +++++++----
 3 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/git/git.go b/git/git.go
index bbdc6e301..16570a0fa 100644
--- a/git/git.go
+++ b/git/git.go
@@ -21,7 +21,6 @@ func VerifyRef(ref string) bool {
 
 // CurrentBranch reads the checked-out branch for the git repository
 func CurrentBranch() (string, error) {
-
 	refCmd := GitCommand("symbolic-ref", "--quiet", "--short", "HEAD")
 
 	output, err := run.PrepareCmd(refCmd).Output()
diff --git a/git/git_test.go b/git/git_test.go
index 50ce4c71c..b73104c95 100644
--- a/git/git_test.go
+++ b/git/git_test.go
@@ -37,27 +37,6 @@ func Test_UncommittedChangeCount(t *testing.T) {
 	}
 }
 
-func Test_CurrentBranch_no_commits(t *testing.T) {
-	cs, teardown := test.InitCmdStubber()
-	defer teardown()
-
-	expected := "branch-name"
-
-	cs.StubError("")
-	cs.Stub(expected)
-
-	result, err := CurrentBranch()
-	if err != nil {
-		t.Errorf("got unexpected error: %w", err)
-	}
-	if len(cs.Calls) != 2 {
-		t.Errorf("expected 2 git calls, saw %d", len(cs.Calls))
-	}
-	if result != expected {
-		t.Errorf("unexpected branch name: %s instead of %s", result, expected)
-	}
-}
-
 func Test_CurrentBranch(t *testing.T) {
 	cs, teardown := test.InitCmdStubber()
 	defer teardown()
@@ -82,7 +61,7 @@ func Test_CurrentBranch_detached_head(t *testing.T) {
 	cs, teardown := test.InitCmdStubber()
 	defer teardown()
 
-	cs.Stub("HEAD")
+	cs.StubError("")
 
 	_, err := CurrentBranch()
 	if err == nil {
@@ -96,3 +75,23 @@ func Test_CurrentBranch_detached_head(t *testing.T) {
 		t.Errorf("expected 1 git call, saw %d", len(cs.Calls))
 	}
 }
+
+func Test_CurrentBranch_unexpected_error(t *testing.T) {
+	cs, teardown := test.InitCmdStubber()
+	defer teardown()
+
+	cs.StubError("lol")
+
+	expectedError := "lol\nstub: lol"
+
+	_, err := CurrentBranch()
+	if err == nil {
+		t.Errorf("expected an error")
+	}
+	if err.Error() != expectedError {
+		t.Errorf("got unexpected error: %s instead of %s", err.Error(), expectedError)
+	}
+	if len(cs.Calls) != 1 {
+		t.Errorf("expected 1 git call, saw %d", len(cs.Calls))
+	}
+}
diff --git a/test/helpers.go b/test/helpers.go
index cffdc5272..390d779c4 100644
--- a/test/helpers.go
+++ b/test/helpers.go
@@ -1,6 +1,7 @@
 package test
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"os/exec"
@@ -13,7 +14,7 @@ import (
 // OutputStub implements a simple utils.Runnable
 type OutputStub struct {
 	Out   []byte
-	Error error
+	Error *run.CmdError
 }
 
 func (s OutputStub) Output() ([]byte, error) {
@@ -47,9 +48,11 @@ func (cs *CmdStubber) Stub(desiredOutput string) {
 	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte(desiredOutput), nil})
 }
 
-func (cs *CmdStubber) StubError(msg string) {
-	// TODO consider handling CmdErr instead of a raw error
-	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte{}, errors.New(msg)})
+func (cs *CmdStubber) StubError(errText string) {
+	stderrBuff := bytes.NewBufferString(errText)
+	args := []string{"stub"} // TODO make more real?
+	err := errors.New(errText)
+	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte{}, &run.CmdError{stderrBuff, args, err}})
 }
 
 func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {

From c0bc938ea4368ba5e7b889e25364a040d208f3f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 27 Mar 2020 09:54:11 +0100
Subject: [PATCH 30/48] Prevent crash when encountering "STALE" check
 conclusion

The "STALE" conclusion has shipped this January and is basically a
conclusion that can only be reported by GitHub and not explicitly set by
any integrations.
---
 api/pull_request_test.go | 8 +++++---
 api/queries_pr.go        | 2 +-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/api/pull_request_test.go b/api/pull_request_test.go
index 82386108d..609a27e7c 100644
--- a/api/pull_request_test.go
+++ b/api/pull_request_test.go
@@ -22,7 +22,9 @@ func TestPullRequest_ChecksStatus(t *testing.T) {
 					{ "status": "COMPLETED",
 					  "conclusion": "FAILURE" },
 					{ "status": "COMPLETED",
-					  "conclusion": "ACTION_REQUIRED" }
+					  "conclusion": "ACTION_REQUIRED" },
+					{ "status": "COMPLETED",
+					  "conclusion": "STALE" }
 				]
 			}
 		}
@@ -32,8 +34,8 @@ func TestPullRequest_ChecksStatus(t *testing.T) {
 	eq(t, err, nil)
 
 	checks := pr.ChecksStatus()
-	eq(t, checks.Total, 7)
-	eq(t, checks.Pending, 2)
+	eq(t, checks.Total, 8)
+	eq(t, checks.Pending, 3)
 	eq(t, checks.Failing, 3)
 	eq(t, checks.Passing, 2)
 }
diff --git a/api/queries_pr.go b/api/queries_pr.go
index b2e5f2f77..0f11f4392 100644
--- a/api/queries_pr.go
+++ b/api/queries_pr.go
@@ -120,7 +120,7 @@ func (pr *PullRequest) ChecksStatus() (summary PullRequestChecksStatus) {
 			summary.Passing++
 		case "ERROR", "FAILURE", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED":
 			summary.Failing++
-		case "EXPECTED", "REQUESTED", "QUEUED", "PENDING", "IN_PROGRESS":
+		case "EXPECTED", "REQUESTED", "QUEUED", "PENDING", "IN_PROGRESS", "STALE":
 			summary.Pending++
 		default:
 			panic(fmt.Errorf("unsupported status: %q", state))

From a6335396cf42abff4fbd68f0737879b6d0849cc9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 27 Mar 2020 13:11:17 +0100
Subject: [PATCH 31/48] repo fork: simplify printing the name of an existing
 forked repo

---
 command/repo.go      | 10 +---------
 command/repo_test.go |  3 +--
 2 files changed, 2 insertions(+), 11 deletions(-)

diff --git a/command/repo.go b/command/repo.go
index be930c0c8..39de4bb86 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -301,14 +301,6 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	s.FinalMSG = utils.Gray(fmt.Sprintf("- %s\n", loading))
 	s.Start()
 
-	authLogin, err := ctx.AuthLogin()
-	if err != nil {
-		s.Stop()
-		return fmt.Errorf("could not determine current username: %w", err)
-	}
-
-	possibleFork := ghrepo.New(authLogin, toFork.RepoName())
-
 	forkedRepo, err := api.ForkRepo(apiClient, toFork)
 	if err != nil {
 		s.Stop()
@@ -325,7 +317,7 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	if created_ago > time.Minute {
 		fmt.Fprintf(out, "%s %s %s\n",
 			utils.Yellow("!"),
-			utils.Bold(ghrepo.FullName(possibleFork)),
+			utils.Bold(ghrepo.FullName(forkedRepo)),
 			"already exists")
 	} else {
 		fmt.Fprintf(out, "%s Created fork %s\n", greenCheck, utils.Bold(ghrepo.FullName(forkedRepo)))
diff --git a/command/repo_test.go b/command/repo_test.go
index 6001be817..cc5cefe84 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -18,9 +18,8 @@ import (
 func TestRepoFork_already_forked(t *testing.T) {
 	initContext = func() context.Context {
 		ctx := context.NewBlank()
-		ctx.SetBaseRepo("REPO")
+		ctx.SetBaseRepo("OWNER/REPO")
 		ctx.SetBranch("master")
-		ctx.SetAuthLogin("someone")
 		ctx.SetRemotes(map[string]string{
 			"origin": "OWNER/REPO",
 		})

From 0f98d56649c0373ae2a3dd48bf0cb9173156f015 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 27 Mar 2020 13:11:36 +0100
Subject: [PATCH 32/48] Rename underscored variable to camelcase

---
 command/repo.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/command/repo.go b/command/repo.go
index 39de4bb86..6c77300da 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -313,8 +313,8 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	// returns the fork repo data even if it already exists -- with no change in status code or
 	// anything. We thus check the created time to see if the repo is brand new or not; if it's not,
 	// we assume the fork already existed and report an error.
-	created_ago := Since(forkedRepo.CreatedAt)
-	if created_ago > time.Minute {
+	createdAgo := Since(forkedRepo.CreatedAt)
+	if createdAgo > time.Minute {
 		fmt.Fprintf(out, "%s %s %s\n",
 			utils.Yellow("!"),
 			utils.Bold(ghrepo.FullName(forkedRepo)),

From 965f2704f34acf03482d25eb08adcf5408d5e441 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 27 Mar 2020 13:27:22 +0100
Subject: [PATCH 33/48] repo fork: reuse existing git remote

Avoid adding a new git remote for a fork if an existing remote is found
that points to the exact forked repo.
---
 command/repo.go      |  9 +++++++++
 command/repo_test.go | 26 +++++++++++++++++++++++++-
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/command/repo.go b/command/repo.go
index 6c77300da..7f31b816c 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -328,6 +328,15 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	}
 
 	if inParent {
+		remotes, err := ctx.Remotes()
+		if err != nil {
+			return err
+		}
+		if remote, err := remotes.FindByRepo(forkedRepo.RepoOwner(), forkedRepo.RepoName()); err == nil {
+			fmt.Fprintf(out, "%s Using existing remote %s\n", greenCheck, utils.Bold(remote.Name))
+			return nil
+		}
+
 		remoteDesired := remotePref == "true"
 		if remotePref == "prompt" {
 			err = Confirm("Would you like to add a remote for the fork?", &remoteDesired)
diff --git a/command/repo_test.go b/command/repo_test.go
index cc5cefe84..6f4591b60 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -40,6 +40,31 @@ func TestRepoFork_already_forked(t *testing.T) {
 	}
 }
 
+func TestRepoFork_reuseRemote(t *testing.T) {
+	initContext = func() context.Context {
+		ctx := context.NewBlank()
+		ctx.SetBaseRepo("OWNER/REPO")
+		ctx.SetBranch("master")
+		ctx.SetRemotes(map[string]string{
+			"upstream": "OWNER/REPO",
+			"origin":   "someone/REPO",
+		})
+		return ctx
+	}
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	defer http.StubWithFixture(200, "forkResult.json")()
+
+	output, err := RunCommand(repoForkCmd, "repo fork")
+	if err != nil {
+		t.Errorf("got unexpected error: %v", err)
+	}
+	if !strings.Contains(output.String(), "Using existing remote origin") {
+		t.Errorf("output did not match: %q", output)
+		return
+	}
+}
+
 func stubSince(d time.Duration) func() {
 	originalSince := Since
 	Since = func(t time.Time) time.Duration {
@@ -579,7 +604,6 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
 	}
 }
 
-
 func TestRepoView(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()

From c17251d106a8c368c75c2e4dd6944a2c98033afb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 27 Mar 2020 13:52:31 +0100
Subject: [PATCH 34/48] Add table-driven test for `repoFromURL`

---
 internal/ghrepo/repo_test.go | 76 +++++++++++++++++++++++-------------
 1 file changed, 48 insertions(+), 28 deletions(-)

diff --git a/internal/ghrepo/repo_test.go b/internal/ghrepo/repo_test.go
index 6ff775c84..cc0f231b8 100644
--- a/internal/ghrepo/repo_test.go
+++ b/internal/ghrepo/repo_test.go
@@ -1,40 +1,60 @@
 package ghrepo
 
 import (
+	"errors"
+	"fmt"
 	"net/url"
 	"testing"
 )
 
 func Test_repoFromURL(t *testing.T) {
-	u, _ := url.Parse("http://github.com/monalisa/octo-cat.git")
-	repo, err := FromURL(u)
-	if err != nil {
-		t.Fatalf("got error %q", err)
+	tests := []struct {
+		name   string
+		input  string
+		result string
+		err    error
+	}{
+		{
+			name:   "github.com URL",
+			input:  "https://github.com/monalisa/octo-cat.git",
+			result: "monalisa/octo-cat",
+			err:    nil,
+		},
+		{
+			name:   "unsupported hostname",
+			input:  "https://example.com/one/two",
+			result: "",
+			err:    errors.New("unsupported hostname: example.com"),
+		},
+		{
+			name:   "filesystem path",
+			input:  "/path/to/file",
+			result: "",
+			err:    errors.New("unsupported hostname: "),
+		},
 	}
-	if repo.RepoOwner() != "monalisa" {
-		t.Errorf("got owner %q", repo.RepoOwner())
-	}
-	if repo.RepoName() != "octo-cat" {
-		t.Errorf("got name %q", repo.RepoName())
-	}
-}
 
-func Test_repoFromURL_invalid(t *testing.T) {
-	cases := [][]string{
-		[]string{
-			"https://example.com/one/two",
-			"unsupported hostname: example.com",
-		},
-		[]string{
-			"/path/to/disk",
-			"unsupported hostname: ",
-		},
-	}
-	for _, c := range cases {
-		u, _ := url.Parse(c[0])
-		_, err := FromURL(u)
-		if err == nil || err.Error() != c[1] {
-			t.Errorf("got %q", err)
-		}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			u, err := url.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("got error %q", err)
+			}
+
+			repo, err := FromURL(u)
+			if err != nil {
+				if tt.err == nil {
+					t.Fatalf("got error %q", err)
+				} else if tt.err.Error() == err.Error() {
+					return
+				}
+				t.Fatalf("got error %q", err)
+			}
+
+			got := fmt.Sprintf("%s/%s", repo.RepoOwner(), repo.RepoName())
+			if tt.result != got {
+				t.Errorf("expected %q, got %q", tt.result, got)
+			}
+		})
 	}
 }

From 303f60815f72f9fc1b7d449eb3dbf503c89d9ffb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 27 Mar 2020 13:55:16 +0100
Subject: [PATCH 35/48] Support `www.github.com` git remote URLs

---
 internal/ghrepo/repo.go      | 2 +-
 internal/ghrepo/repo_test.go | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/internal/ghrepo/repo.go b/internal/ghrepo/repo.go
index f683d9249..fe3a0eba7 100644
--- a/internal/ghrepo/repo.go
+++ b/internal/ghrepo/repo.go
@@ -33,7 +33,7 @@ func FromFullName(nwo string) Interface {
 }
 
 func FromURL(u *url.URL) (Interface, error) {
-	if !strings.EqualFold(u.Hostname(), defaultHostname) {
+	if !strings.EqualFold(u.Hostname(), defaultHostname) && !strings.EqualFold(u.Hostname(), "www."+defaultHostname) {
 		return nil, fmt.Errorf("unsupported hostname: %s", u.Hostname())
 	}
 	parts := strings.SplitN(strings.TrimPrefix(u.Path, "/"), "/", 3)
diff --git a/internal/ghrepo/repo_test.go b/internal/ghrepo/repo_test.go
index cc0f231b8..fef04fb8c 100644
--- a/internal/ghrepo/repo_test.go
+++ b/internal/ghrepo/repo_test.go
@@ -20,6 +20,12 @@ func Test_repoFromURL(t *testing.T) {
 			result: "monalisa/octo-cat",
 			err:    nil,
 		},
+		{
+			name:   "www.github.com URL",
+			input:  "http://www.GITHUB.com/monalisa/octo-cat.git",
+			result: "monalisa/octo-cat",
+			err:    nil,
+		},
 		{
 			name:   "unsupported hostname",
 			input:  "https://example.com/one/two",

From 894899c71d666d48c90a1bad53d1568ccab92ae6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Fri, 27 Mar 2020 13:58:50 +0100
Subject: [PATCH 36/48] Add code docs for `ghrepo` package

---
 internal/ghrepo/repo.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/internal/ghrepo/repo.go b/internal/ghrepo/repo.go
index fe3a0eba7..a4bfa82d6 100644
--- a/internal/ghrepo/repo.go
+++ b/internal/ghrepo/repo.go
@@ -8,21 +8,26 @@ import (
 
 const defaultHostname = "github.com"
 
+// Interface describes an object that represents a GitHub repository
 type Interface interface {
 	RepoName() string
 	RepoOwner() string
 }
 
+// New instantiates a GitHub repository from owner and name arguments
 func New(owner, repo string) Interface {
 	return &ghRepo{
 		owner: owner,
 		name:  repo,
 	}
 }
+
+// FullName serializes a GitHub repository into an "OWNER/REPO" string
 func FullName(r Interface) string {
 	return fmt.Sprintf("%s/%s", r.RepoOwner(), r.RepoName())
 }
 
+// FromFullName extracts the GitHub repository inforation from an "OWNER/REPO" string
 func FromFullName(nwo string) Interface {
 	var r ghRepo
 	parts := strings.SplitN(nwo, "/", 2)
@@ -32,6 +37,7 @@ func FromFullName(nwo string) Interface {
 	return &r
 }
 
+// FromURL extracts the GitHub repository information from a URL
 func FromURL(u *url.URL) (Interface, error) {
 	if !strings.EqualFold(u.Hostname(), defaultHostname) && !strings.EqualFold(u.Hostname(), "www."+defaultHostname) {
 		return nil, fmt.Errorf("unsupported hostname: %s", u.Hostname())
@@ -43,6 +49,7 @@ func FromURL(u *url.URL) (Interface, error) {
 	return New(parts[0], strings.TrimSuffix(parts[1], ".git")), nil
 }
 
+// IsSame compares two GitHub repositories
 func IsSame(a, b Interface) bool {
 	return strings.EqualFold(a.RepoOwner(), b.RepoOwner()) &&
 		strings.EqualFold(a.RepoName(), b.RepoName())

From eb403a3b1e992400beef25ddb8d2181cb7d26b05 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Fri, 27 Mar 2020 11:35:39 -0500
Subject: [PATCH 37/48] more nuanced error typing

---
 git/git.go      | 10 ++++++----
 test/helpers.go |  3 ++-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/git/git.go b/git/git.go
index 16570a0fa..a4fae4408 100644
--- a/git/git.go
+++ b/git/git.go
@@ -29,10 +29,12 @@ func CurrentBranch() (string, error) {
 		return firstLine(output), nil
 	}
 
-	ce := err.(*run.CmdError)
-	if ce.Stderr.Len() == 0 {
-		// Detached head
-		return "", errors.New("git: not on any branch")
+	var cmdErr *run.CmdError
+	if errors.As(err, &cmdErr) {
+		if cmdErr.Stderr.Len() == 0 {
+			// Detached head
+			return "", errors.New("git: not on any branch")
+		}
 	}
 
 	// Unknown error
diff --git a/test/helpers.go b/test/helpers.go
index 390d779c4..556b27157 100644
--- a/test/helpers.go
+++ b/test/helpers.go
@@ -14,7 +14,7 @@ import (
 // OutputStub implements a simple utils.Runnable
 type OutputStub struct {
 	Out   []byte
-	Error *run.CmdError
+	Error error
 }
 
 func (s OutputStub) Output() ([]byte, error) {
@@ -49,6 +49,7 @@ func (cs *CmdStubber) Stub(desiredOutput string) {
 }
 
 func (cs *CmdStubber) StubError(errText string) {
+	// TODO support error types beyond CmdError
 	stderrBuff := bytes.NewBufferString(errText)
 	args := []string{"stub"} // TODO make more real?
 	err := errors.New(errText)

From c966f0dca5a472fba79485cefc71780295c59309 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Mon, 30 Mar 2020 12:04:45 -0500
Subject: [PATCH 38/48] test fallout

---
 command/pr_create_test.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 2791a083d..72a439677 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -589,7 +589,7 @@ func TestPRCreate_defaults_error_interactive(t *testing.T) {
 }
 
 func Test_determineTrackingBranch_empty(t *testing.T) {
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	remotes := context.Remotes{}
@@ -604,7 +604,7 @@ func Test_determineTrackingBranch_empty(t *testing.T) {
 }
 
 func Test_determineTrackingBranch_noMatch(t *testing.T) {
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	remotes := context.Remotes{
@@ -631,7 +631,7 @@ deadb00f refs/remotes/origin/feature`) // git show-ref --verify (ShowRefs)
 }
 
 func Test_determineTrackingBranch_hasMatch(t *testing.T) {
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	remotes := context.Remotes{
@@ -664,7 +664,7 @@ deadbeef refs/remotes/upstream/feature`) // git show-ref --verify (ShowRefs)
 }
 
 func Test_determineTrackingBranch_respectTrackingConfig(t *testing.T) {
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	remotes := context.Remotes{

From 24a332bb1b73a2660963d4d8d7f228b378207a20 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Tue, 31 Mar 2020 13:32:44 +0200
Subject: [PATCH 39/48] Use remote tracking branch for base when detecting
 commits for `pr create`

This is to avoid errors when a local base branch is missing or out of
date.
---
 command/pr_create.go      | 6 +++++-
 command/pr_create_test.go | 4 ++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/command/pr_create.go b/command/pr_create.go
index 238057bf8..96448175c 100644
--- a/command/pr_create.go
+++ b/command/pr_create.go
@@ -122,7 +122,11 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("could not parse body: %w", err)
 	}
 
-	defs, defaultsErr := computeDefaults(baseBranch, headBranch)
+	baseTrackingBranch := baseBranch
+	if baseRemote, err := remotes.FindByRepo(baseRepo.RepoOwner(), baseRepo.RepoName()); err == nil {
+		baseTrackingBranch = fmt.Sprintf("%s/%s", baseRemote.Name, baseBranch)
+	}
+	defs, defaultsErr := computeDefaults(baseTrackingBranch, headBranch)
 
 	isWeb, err := cmd.Flags().GetBool("web")
 	if err != nil {
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 01b5516d3..5189ca5c8 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -514,7 +514,7 @@ func TestPRCreate_defaults_error_autofill(t *testing.T) {
 
 	_, err := RunCommand(prCreateCmd, "pr create -f")
 
-	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between master and feature")
+	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between origin/master and feature")
 }
 
 func TestPRCreate_defaults_error_web(t *testing.T) {
@@ -532,7 +532,7 @@ func TestPRCreate_defaults_error_web(t *testing.T) {
 
 	_, err := RunCommand(prCreateCmd, "pr create -w")
 
-	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between master and feature")
+	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between origin/master and feature")
 }
 
 func TestPRCreate_defaults_error_interactive(t *testing.T) {

From 219e3ecc5bbb92cf70e3632b823736f2d16c6d28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Tue, 31 Mar 2020 13:34:16 +0200
Subject: [PATCH 40/48] Stop querying base branch commit hash from API

This code was put in place in preparation for a feature that never
shipped. Namely, we wanted to use the commit hash for the base branch so
we can get an accurate `git log` involving the changes in a pull
request. However, getting the commit hash from API is not the way to go
because the latest commit might not be available in the person's local
repository, and using a local tracking branch for base such as
`origin/master` works quite well in most cases without dereferencing it.
---
 api/fake_http.go          | 9 +++------
 api/queries_repo.go       | 6 +-----
 command/pr_create_test.go | 9 +++------
 3 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/api/fake_http.go b/api/fake_http.go
index 92b904bd5..ab726fb34 100644
--- a/api/fake_http.go
+++ b/api/fake_http.go
@@ -54,8 +54,7 @@ func (f *FakeHTTP) StubRepoResponse(owner, repo string) {
 			"name": "%s",
 			"owner": {"login": "%s"},
 			"defaultBranchRef": {
-				"name": "master",
-				"target": {"oid": "deadbeef"}
+				"name": "master"
 			},
 			"viewerPermission": "WRITE"
 		} } }
@@ -76,8 +75,7 @@ func (f *FakeHTTP) StubForkedRepoResponse(forkFullName, parentFullName string) {
 			"name": "%s",
 			"owner": {"login": "%s"},
 			"defaultBranchRef": {
-				"name": "master",
-				"target": {"oid": "deadbeef"}
+				"name": "master"
 			},
 			"viewerPermission": "ADMIN",
 			"parent": {
@@ -85,8 +83,7 @@ func (f *FakeHTTP) StubForkedRepoResponse(forkFullName, parentFullName string) {
 				"name": "%s",
 				"owner": {"login": "%s"},
 				"defaultBranchRef": {
-					"name": "master",
-					"target": {"oid": "deadbeef"}
+					"name": "master"
 				},
 				"viewerPermission": "READ"
 			}
diff --git a/api/queries_repo.go b/api/queries_repo.go
index 5a5061eda..5a2e8e1da 100644
--- a/api/queries_repo.go
+++ b/api/queries_repo.go
@@ -28,10 +28,7 @@ type Repository struct {
 	HasIssuesEnabled bool
 	ViewerPermission string
 	DefaultBranchRef struct {
-		Name   string
-		Target struct {
-			OID string
-		}
+		Name string
 	}
 
 	Parent *Repository
@@ -127,7 +124,6 @@ func RepoNetwork(client *Client, repos []ghrepo.Interface) (RepoNetworkResult, e
 		viewerPermission
 		defaultBranchRef {
 			name
-			target { oid }
 		}
 		isPrivate
 	}
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 5189ca5c8..fa0fbd0ce 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -215,8 +215,7 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 									"name": "REPO",
 									"owner": {"login": "OWNER"},
 									"defaultBranchRef": {
-										"name": "default",
-										"target": {"oid": "deadbeef"}
+										"name": "default"
 									},
 									"viewerPermission": "READ"
 								},
@@ -226,8 +225,7 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 										"name": "REPO",
 										"owner": {"login": "OWNER"},
 										"defaultBranchRef": {
-											"name": "default",
-											"target": {"oid": "deadbeef"}
+											"name": "default"
 										},
 										"viewerPermission": "READ"
 									},
@@ -235,8 +233,7 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 									"name": "REPO",
 									"owner": {"login": "MYSELF"},
 									"defaultBranchRef": {
-										"name": "default",
-										"target": {"oid": "deadbeef"}
+										"name": "default"
 									},
 									"viewerPermission": "WRITE"
 		} } }

From 846060918144576ea58d428de74e237986e47c00 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Tue, 31 Mar 2020 15:21:57 +0200
Subject: [PATCH 41/48] repo clone: automatically set up "upstream" remote for
 forks

---
 api/queries_repo.go  | 33 +++++++++++++++++++++++++++++
 command/repo.go      | 43 ++++++++++++++++++++++++++++++++++++-
 command/repo_test.go | 50 ++++++++++++++++++++++++++++++++++----------
 go.mod               |  2 ++
 go.sum               |  4 ++++
 5 files changed, 120 insertions(+), 12 deletions(-)

diff --git a/api/queries_repo.go b/api/queries_repo.go
index 5a5061eda..f52d9ddd8 100644
--- a/api/queries_repo.go
+++ b/api/queries_repo.go
@@ -2,6 +2,7 @@ package api
 
 import (
 	"bytes"
+	"context"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
@@ -12,6 +13,7 @@ import (
 
 	"github.com/cli/cli/internal/ghrepo"
 	"github.com/cli/cli/utils"
+	"github.com/shurcooL/githubv4"
 )
 
 // Repository contains information about a GitHub repo
@@ -93,6 +95,37 @@ func GitHubRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 	return &result.Repository, nil
 }
 
+// RepoParent finds out the parent repository of a fork
+func RepoParent(client *Client, repo ghrepo.Interface) (ghrepo.Interface, error) {
+	var query struct {
+		Repository struct {
+			Parent *struct {
+				Name  string
+				Owner struct {
+					Login string
+				}
+			}
+		} `graphql:"repository(owner: $owner, name: $name)"`
+	}
+
+	variables := map[string]interface{}{
+		"owner": githubv4.String(repo.RepoOwner()),
+		"name":  githubv4.String(repo.RepoName()),
+	}
+
+	v4 := githubv4.NewClient(client.http)
+	err := v4.Query(context.Background(), &query, variables)
+	if err != nil {
+		return nil, err
+	}
+	if query.Repository.Parent == nil {
+		return nil, nil
+	}
+
+	parent := ghrepo.New(query.Repository.Parent.Owner.Login, query.Repository.Parent.Name)
+	return parent, nil
+}
+
 // RepoNetworkResult describes the relationship between related repositories
 type RepoNetworkResult struct {
 	ViewerLogin  string
diff --git a/command/repo.go b/command/repo.go
index 959cfbaec..4b94812d5 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -93,6 +93,28 @@ func repoClone(cmd *cobra.Command, args []string) error {
 		cloneURL = fmt.Sprintf("https://github.com/%s.git", cloneURL)
 	}
 
+	var repo ghrepo.Interface
+	var parentRepo ghrepo.Interface
+
+	// TODO: consider caching and reusing `git.ParseSSHConfig().Translator()`
+	// here to handle hostname aliases in SSH remotes
+	if u, err := git.ParseURL(cloneURL); err == nil {
+		repo, _ = ghrepo.FromURL(u)
+	}
+
+	if repo != nil {
+		ctx := contextForCommand(cmd)
+		apiClient, err := apiClientForContext(ctx)
+		if err != nil {
+			return err
+		}
+
+		parentRepo, err = api.RepoParent(apiClient, repo)
+		if err != nil {
+			return err
+		}
+	}
+
 	cloneArgs := []string{"clone"}
 	cloneArgs = append(cloneArgs, args[1:]...)
 	cloneArgs = append(cloneArgs, cloneURL)
@@ -101,7 +123,26 @@ func repoClone(cmd *cobra.Command, args []string) error {
 	cloneCmd.Stdin = os.Stdin
 	cloneCmd.Stdout = os.Stdout
 	cloneCmd.Stderr = os.Stderr
-	return run.PrepareCmd(cloneCmd).Run()
+	err := run.PrepareCmd(cloneCmd).Run()
+	if err != nil {
+		return err
+	}
+
+	if parentRepo != nil {
+		// TODO: support SSH remote URLs
+		upstreamURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(parentRepo))
+		cloneDir := path.Base(strings.TrimSuffix(cloneURL, ".git"))
+
+		cloneCmd := git.GitCommand("-C", cloneDir, "remote", "add", "upstream", upstreamURL)
+		cloneCmd.Stdout = os.Stdout
+		cloneCmd.Stderr = os.Stderr
+		err := run.PrepareCmd(cloneCmd).Run()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
 
 func repoCreate(cmd *cobra.Command, args []string) error {
diff --git a/command/repo_test.go b/command/repo_test.go
index 1b9aa2642..10820cd45 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -363,12 +363,17 @@ func TestRepoClone(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			var seenCmd *exec.Cmd
-			restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
-				seenCmd = cmd
-				return &test.OutputStub{}
-			})
-			defer restoreCmd()
+			http := initFakeHTTP()
+			http.StubResponse(200, bytes.NewBufferString(`
+			{ "data": { "repository": {
+				"parent": null
+			} } }
+			`))
+
+			cs, restore := test.InitCmdStubber()
+			defer restore()
+
+			cs.Stub("") // git clone
 
 			output, err := RunCommand(repoCloneCmd, tt.args)
 			if err != nil {
@@ -377,15 +382,38 @@ func TestRepoClone(t *testing.T) {
 
 			eq(t, output.String(), "")
 			eq(t, output.Stderr(), "")
-
-			if seenCmd == nil {
-				t.Fatal("expected a command to run")
-			}
-			eq(t, strings.Join(seenCmd.Args, " "), tt.want)
+			eq(t, cs.Count, 1)
+			eq(t, strings.Join(cs.Calls[0].Args, " "), tt.want)
 		})
 	}
 }
 
+func TestRepoClone_hasParent(t *testing.T) {
+	http := initFakeHTTP()
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": {
+		"parent": {
+			"owner": {"login": "hubot"},
+			"name": "ORIG"
+		}
+	} } }
+	`))
+
+	cs, restore := test.InitCmdStubber()
+	defer restore()
+
+	cs.Stub("") // git clone
+	cs.Stub("") // git remote add
+
+	_, err := RunCommand(repoCloneCmd, "repo clone OWNER/REPO")
+	if err != nil {
+		t.Fatalf("error running command `repo clone`: %v", err)
+	}
+
+	eq(t, cs.Count, 2)
+	eq(t, strings.Join(cs.Calls[1].Args, " "), "git -C REPO remote add upstream https://github.com/hubot/ORIG.git")
+}
+
 func TestRepoCreate(t *testing.T) {
 	ctx := context.NewBlank()
 	ctx.SetBranch("master")
diff --git a/go.mod b/go.mod
index ee45df4ed..aab4c58d4 100644
--- a/go.mod
+++ b/go.mod
@@ -16,6 +16,8 @@ require (
 	github.com/mattn/go-runewidth v0.0.8 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b
 	github.com/mitchellh/go-homedir v1.1.0
+	github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0
+	github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f // indirect
 	github.com/spf13/cobra v0.0.6
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.4.0 // indirect
diff --git a/go.sum b/go.sum
index b94236621..a41c1d54b 100644
--- a/go.sum
+++ b/go.sum
@@ -145,6 +145,10 @@ github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0 h1:T9uus1QvcPgeLShS30YOnnzk3r9Vvygp45muhlrufgY=
+github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0/go.mod h1:hAF0iLZy4td2EX+/8Tw+4nodhlMrwN3HupfaXj3zkGo=
+github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f h1:tygelZueB1EtXkPI6mQ4o9DQ0+FKW41hTbunoXZCTqk=
+github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f/go.mod h1:AuYgA5Kyo4c7HfUmvRGs/6rGlMMV/6B1bVnB9JxJEEg=
 github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=

From fa3d65b2b60da648d12d1070e14c26fdc272abe0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Tue, 31 Mar 2020 18:36:41 +0200
Subject: [PATCH 42/48] Add "upstream" remote after `repo fork`

---
 command/repo.go      | 45 ++++++++++++++++++++++++++++++++++----------
 command/repo_test.go | 39 ++++++++++++++++++++------------------
 2 files changed, 56 insertions(+), 28 deletions(-)

diff --git a/command/repo.go b/command/repo.go
index 4b94812d5..afc6ddec7 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -129,14 +129,7 @@ func repoClone(cmd *cobra.Command, args []string) error {
 	}
 
 	if parentRepo != nil {
-		// TODO: support SSH remote URLs
-		upstreamURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(parentRepo))
-		cloneDir := path.Base(strings.TrimSuffix(cloneURL, ".git"))
-
-		cloneCmd := git.GitCommand("-C", cloneDir, "remote", "add", "upstream", upstreamURL)
-		cloneCmd.Stdout = os.Stdout
-		cloneCmd.Stderr = os.Stderr
-		err := run.PrepareCmd(cloneCmd).Run()
+		err := addUpstreamRemote(parentRepo, cloneURL)
 		if err != nil {
 			return err
 		}
@@ -145,6 +138,17 @@ func repoClone(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+func addUpstreamRemote(parentRepo ghrepo.Interface, cloneURL string) error {
+	// TODO: support SSH remote URLs
+	upstreamURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(parentRepo))
+	cloneDir := path.Base(strings.TrimSuffix(cloneURL, ".git"))
+
+	cloneCmd := git.GitCommand("-C", cloneDir, "remote", "add", "upstream", upstreamURL)
+	cloneCmd.Stdout = os.Stdout
+	cloneCmd.Stderr = os.Stderr
+	return run.PrepareCmd(cloneCmd).Run()
+}
+
 func repoCreate(cmd *cobra.Command, args []string) error {
 	projectDir, projectDirErr := git.ToplevelDir()
 
@@ -389,12 +393,28 @@ func repoFork(cmd *cobra.Command, args []string) error {
 			}
 		}
 		if remoteDesired {
-			_, err := git.AddRemote("fork", forkedRepo.CloneURL)
+			remoteName := "origin"
+
+			remotes, err := ctx.Remotes()
+			if err != nil {
+				return err
+			}
+			if _, err := remotes.FindByName(remoteName); err == nil {
+				renameTarget := "upstream"
+				renameCmd := git.GitCommand("remote", "rename", remoteName, renameTarget)
+				err = run.PrepareCmd(renameCmd).Run()
+				if err != nil {
+					return err
+				}
+				fmt.Fprintf(out, "%s Renamed %s remote to %s\n", greenCheck, utils.Bold(remoteName), utils.Bold(renameTarget))
+			}
+
+			_, err = git.AddRemote(remoteName, forkedRepo.CloneURL)
 			if err != nil {
 				return fmt.Errorf("failed to add remote: %w", err)
 			}
 
-			fmt.Fprintf(out, "%s Remote added at %s\n", greenCheck, utils.Bold("fork"))
+			fmt.Fprintf(out, "%s Added remote %s\n", greenCheck, utils.Bold(remoteName))
 		}
 	} else {
 		cloneDesired := clonePref == "true"
@@ -414,6 +434,11 @@ func repoFork(cmd *cobra.Command, args []string) error {
 				return fmt.Errorf("failed to clone fork: %w", err)
 			}
 
+			err = addUpstreamRemote(toFork, forkedRepo.CloneURL)
+			if err != nil {
+				return err
+			}
+
 			fmt.Fprintf(out, "%s Cloned fork\n", greenCheck)
 		}
 	}
diff --git a/command/repo_test.go b/command/repo_test.go
index 10820cd45..f0d271cf8 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -151,8 +151,8 @@ func TestRepoFork_in_parent_yes(t *testing.T) {
 	}
 
 	expectedCmds := []string{
-		"git remote add -f fork https://github.com/someone/repo.git",
-		"git fetch fork",
+		"git remote rename origin upstream",
+		"git remote add -f origin https://github.com/someone/repo.git",
 	}
 
 	for x, cmd := range seenCmds {
@@ -163,7 +163,7 @@ func TestRepoFork_in_parent_yes(t *testing.T) {
 
 	test.ExpectLines(t, output.String(),
 		"Created fork someone/REPO",
-		"Remote added at fork")
+		"Added remote origin")
 }
 
 func TestRepoFork_outside_yes(t *testing.T) {
@@ -171,11 +171,11 @@ func TestRepoFork_outside_yes(t *testing.T) {
 	http := initFakeHTTP()
 	defer http.StubWithFixture(200, "forkResult.json")()
 
-	var seenCmd *exec.Cmd
-	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
-		seenCmd = cmd
-		return &test.OutputStub{}
-	})()
+	cs, restore := test.InitCmdStubber()
+	defer restore()
+
+	cs.Stub("") // git clone
+	cs.Stub("") // git remote add
 
 	output, err := RunCommand(repoForkCmd, "repo fork --clone OWNER/REPO")
 	if err != nil {
@@ -184,7 +184,8 @@ func TestRepoFork_outside_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	eq(t, strings.Join(seenCmd.Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[0].Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[1].Args, " "), "git -C repo remote add upstream https://github.com/OWNER/REPO.git")
 
 	test.ExpectLines(t, output.String(),
 		"Created fork someone/REPO",
@@ -196,11 +197,11 @@ func TestRepoFork_outside_survey_yes(t *testing.T) {
 	http := initFakeHTTP()
 	defer http.StubWithFixture(200, "forkResult.json")()
 
-	var seenCmd *exec.Cmd
-	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
-		seenCmd = cmd
-		return &test.OutputStub{}
-	})()
+	cs, restore := test.InitCmdStubber()
+	defer restore()
+
+	cs.Stub("") // git clone
+	cs.Stub("") // git remote add
 
 	oldConfirm := Confirm
 	Confirm = func(_ string, result *bool) error {
@@ -216,7 +217,8 @@ func TestRepoFork_outside_survey_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	eq(t, strings.Join(seenCmd.Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[0].Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[1].Args, " "), "git -C repo remote add upstream https://github.com/OWNER/REPO.git")
 
 	test.ExpectLines(t, output.String(),
 		"Created fork someone/REPO",
@@ -283,8 +285,8 @@ func TestRepoFork_in_parent_survey_yes(t *testing.T) {
 	}
 
 	expectedCmds := []string{
-		"git remote add -f fork https://github.com/someone/repo.git",
-		"git fetch fork",
+		"git remote rename origin upstream",
+		"git remote add -f origin https://github.com/someone/repo.git",
 	}
 
 	for x, cmd := range seenCmds {
@@ -295,7 +297,8 @@ func TestRepoFork_in_parent_survey_yes(t *testing.T) {
 
 	test.ExpectLines(t, output.String(),
 		"Created fork someone/REPO",
-		"Remote added at fork")
+		"Renamed origin remote to upstream",
+		"Added remote origin")
 }
 
 func TestRepoFork_in_parent_survey_no(t *testing.T) {

From 0680bb5c6c230ea6adccbc63c1374fe56d11d971 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 31 Mar 2020 14:47:27 -0500
Subject: [PATCH 43/48] go mod tidy

---
 go.sum | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/go.sum b/go.sum
index a41c1d54b..a5f4af4b9 100644
--- a/go.sum
+++ b/go.sum
@@ -58,6 +58,7 @@ github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfU
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -199,6 +200,7 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20200219183655-46282727080f h1:dB42wwhNuwPvh8f+5zZWNcU+F2Xs/B9wXXwvUCOH7r8=
 golang.org/x/net v0.0.0-20200219183655-46282727080f/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be h1:vEDujvNQGv4jgYKudGeI/+DAX4Jffq6hpD55MmoEvKs=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -224,6 +226,7 @@ golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+google.golang.org/appengine v1.1.0 h1:igQkv0AAhEIvTEpD5LIpAfav2eeVO9HBTjvKHVJPRSs=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=

From a8894a074586b3b5a1b922452f37c13e50941d0b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Wed, 1 Apr 2020 14:20:58 +0200
Subject: [PATCH 44/48] Assert that running `go fmt` or `go mod tidy` produces
 no changes in CI

This will help avoid introducing code changes that are not properly
formatted, or `go mod` dependency changes that are untidy.

Ref. 0680bb5c6c230ea6adccbc63c1374fe56d11d971
---
 .github/workflows/go.yml | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 2789ade34..500bced8f 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -20,8 +20,24 @@ jobs:
       - name: Verify dependencies
         run: go mod verify
 
-      - name: Build
+      - name: Run tests
         shell: bash
         run: |
-          go test -race ./...
-          go build -v ./cmd/gh
+          assert-nothing-changed() {
+            local diff
+            git checkout -- .
+            "$@" >/dev/null || true
+            if ! diff="$(git diff --exit-code)"; then
+              printf '\n\e[31mError: running `\e[31;1m%s\e[31;22m` results in modifications that you must check into version control:\e[0m\n%s\n' "$*" "$diff" >&2
+              return 1
+            fi
+          }
+
+          STATUS=0
+          go test -race ./... || STATUS=$?
+          assert-nothing-changed go fmt ./... || STATUS=$?
+          assert-nothing-changed go mod tidy || STATUS=$?
+          exit $STATUS
+
+      - name: Build
+        run: go build -v ./cmd/gh

From 7dbc5e99e4b3433a6bf34492a83233ed3cec1279 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Wed, 1 Apr 2020 14:42:32 +0200
Subject: [PATCH 45/48] go: download dependencies before running tests in CI

---
 .github/workflows/go.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 500bced8f..02b04922e 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -18,7 +18,10 @@ jobs:
         uses: actions/checkout@v2
 
       - name: Verify dependencies
-        run: go mod verify
+        shell: bash
+        run: |
+          go mod verify
+          go mod download
 
       - name: Run tests
         shell: bash

From 228312a30d7c861eff39c87526b0edadfba468c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Wed, 1 Apr 2020 14:47:42 +0200
Subject: [PATCH 46/48] Have git diff produce colored output in CI

---
 .github/workflows/go.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 02b04922e..d4b95cafc 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -30,7 +30,7 @@ jobs:
             local diff
             git checkout -- .
             "$@" >/dev/null || true
-            if ! diff="$(git diff --exit-code)"; then
+            if ! diff="$(git diff -U1 --color --exit-code)"; then
               printf '\n\e[31mError: running `\e[31;1m%s\e[31;22m` results in modifications that you must check into version control:\e[0m\n%s\n' "$*" "$diff" >&2
               return 1
             fi

From ad190519c64b0f24e3ba74bbd6d6694f0e72bdb4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Wed, 1 Apr 2020 15:09:24 +0200
Subject: [PATCH 47/48] Simplify ANSI coloring

---
 .github/workflows/go.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index d4b95cafc..e8098bcd8 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -31,7 +31,7 @@ jobs:
             git checkout -- .
             "$@" >/dev/null || true
             if ! diff="$(git diff -U1 --color --exit-code)"; then
-              printf '\n\e[31mError: running `\e[31;1m%s\e[31;22m` results in modifications that you must check into version control:\e[0m\n%s\n' "$*" "$diff" >&2
+              printf '\n\e[31mError: running `\e[1m%s\e[22m` results in modifications that you must check into version control:\e[0m\n%s\n' "$*" "$diff" >&2
               return 1
             fi
           }

From f0e6c98bf058a17d23a177c05c1d62c317683158 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mislav=20Marohni=C4=87?= <mislav.marohnic@gmail.com>
Date: Wed, 1 Apr 2020 19:37:56 +0200
Subject: [PATCH 48/48] Fix auto-forking scenario in `pr create`

When an existing `headRepo` couldn't be detected, it's time to auto-fork
one. Unfortunately, an obscure Go behavior made it seem like `headRepo`
was a non-nil value, where in fact it did contain a nil pointer which
would crash the process.

This avoids ever assigning nil pointers to `var headRepo ghrepo.Interface`.
---
 api/fake_http.go          |  8 ++++++--
 command/pr_create.go      | 17 ++++++++--------
 command/pr_create_test.go | 43 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 57 insertions(+), 11 deletions(-)

diff --git a/api/fake_http.go b/api/fake_http.go
index ab726fb34..a88c9df17 100644
--- a/api/fake_http.go
+++ b/api/fake_http.go
@@ -48,6 +48,10 @@ func (f *FakeHTTP) StubWithFixture(status int, fixtureFileName string) func() {
 }
 
 func (f *FakeHTTP) StubRepoResponse(owner, repo string) {
+	f.StubRepoResponseWithPermission(owner, repo, "WRITE")
+}
+
+func (f *FakeHTTP) StubRepoResponseWithPermission(owner, repo, permission string) {
 	body := bytes.NewBufferString(fmt.Sprintf(`
 		{ "data": { "repo_000": {
 			"id": "REPOID",
@@ -56,9 +60,9 @@ func (f *FakeHTTP) StubRepoResponse(owner, repo string) {
 			"defaultBranchRef": {
 				"name": "master"
 			},
-			"viewerPermission": "WRITE"
+			"viewerPermission": "%s"
 		} } }
-	`, repo, owner))
+	`, repo, owner, permission))
 	resp := &http.Response{
 		StatusCode: 200,
 		Body:       ioutil.NopCloser(body),
diff --git a/command/pr_create.go b/command/pr_create.go
index 96448175c..96b3e27df 100644
--- a/command/pr_create.go
+++ b/command/pr_create.go
@@ -95,7 +95,9 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 
 	// otherwise, determine the head repository with info obtained from the API
 	if headRepo == nil {
-		headRepo, _ = repoContext.HeadRepo()
+		if r, err := repoContext.HeadRepo(); err == nil {
+			headRepo = r
+		}
 	}
 
 	baseBranch, err := cmd.Flags().GetString("base")
@@ -236,6 +238,10 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 		headBranchLabel = fmt.Sprintf("%s:%s", headRepo.RepoOwner(), headBranch)
 	}
 
+	if headRemote == nil {
+		headRemote, _ = repoContext.RemoteForRepo(headRepo)
+	}
+
 	// There are two cases when an existing remote for the head repo will be
 	// missing:
 	// 1. the head repo was just created by auto-forking;
@@ -243,7 +249,7 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	//
 	// In either case, we want to add the head repo as a new git remote so we
 	// can push to it.
-	if err != nil {
+	if headRemote == nil {
 		// TODO: support non-HTTPS git remote URLs
 		headRepoURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(headRepo))
 		// TODO: prevent clashes with another remote of a same name
@@ -260,13 +266,6 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 
 	// automatically push the branch if it hasn't been pushed anywhere yet
 	if headBranchPushedTo == nil {
-		if headRemote == nil {
-			headRemote, err = repoContext.RemoteForRepo(headRepo)
-			if err != nil {
-				return fmt.Errorf("git remote not found for head repository: %w", err)
-			}
-		}
-
 		pushTries := 0
 		maxPushTries := 3
 		for {
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index b04f28b3a..5a89ad911 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -65,6 +65,49 @@ func TestPRCreate(t *testing.T) {
 	eq(t, output.String(), "https://github.com/OWNER/REPO/pull/12\n")
 }
 
+func TestPRCreate_withForking(t *testing.T) {
+	initBlankContext("OWNER/REPO", "feature")
+	http := initFakeHTTP()
+	http.StubRepoResponseWithPermission("OWNER", "REPO", "READ")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": { "forks": { "nodes": [
+		] } } } }
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes" : [
+		] } } } }
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "node_id": "NODEID",
+		"name": "REPO",
+		"owner": {"login": "myself"},
+		"clone_url": "http://example.com",
+		"created_at": "2008-02-25T20:21:40Z"
+		}
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "createPullRequest": { "pullRequest": {
+			"URL": "https://github.com/OWNER/REPO/pull/12"
+		} } } }
+	`))
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
+	cs.Stub("")                                         // git status
+	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
+	cs.Stub("")                                         // git remote add
+	cs.Stub("")                                         // git push
+
+	output, err := RunCommand(prCreateCmd, `pr create -t title -b body`)
+	eq(t, err, nil)
+
+	eq(t, http.Requests[3].URL.Path, "/repos/OWNER/REPO/forks")
+	eq(t, output.String(), "https://github.com/OWNER/REPO/pull/12\n")
+}
+
 func TestPRCreate_alreadyExists(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()