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/23] 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/23] 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/23] 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 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 04/23] 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 05/23] 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 06/23] 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 07/23] 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 ff96f48479b98596a7077f78fddb652adf5ba940 Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Fri, 20 Mar 2020 16:10:32 -0500
Subject: [PATCH 08/23] 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 09/23] 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 379ecdab542842c07047fa70ba432dcc02e03bdb Mon Sep 17 00:00:00 2001
From: vilmibm <vilmibm@neongrid.space>
Date: Tue, 24 Mar 2020 15:21:18 -0500
Subject: [PATCH 10/23] 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 11/23] 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 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 12/23] 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 13/23] 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 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 14/23] 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 15/23] 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 16/23] 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 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 17/23] 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 18/23] 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 19/23] 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 20/23] 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 21/23] 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 22/23] 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 23/23] 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())