Merge remote-tracking branch 'origin' into cobra1.0

.github/PULL_REQUEST_TEMPLATE/bug_fix.md

@@ -1,6 +1,6 @@
 <!--
 Please make sure you read our contributing guidelines at
-https://github.com/cli/cli/blob/master/.github/CONTRIBUTING.md
+https://github.com/cli/cli/blob/trunk/.github/CONTRIBUTING.md
 before opening opening a pull request. Thanks!
 -->
 

.github/workflows/lint.yml

@@ -5,6 +5,11 @@ on:
       - "**.go"
       - go.mod
       - go.sum
+  pull_request:
+    paths:
+      - "**.go"
+      - go.mod
+      - go.sum
 
 jobs:
   lint:

Makefile

@@ -22,8 +22,8 @@ test:
 	go test ./...
 .PHONY: test
 
-site: bin/gh
-	bin/gh repo clone github/cli.github.com "$@"
+site:
+	git clone https://github.com/github/cli.github.com.git "$@"
 
 site-docs: site
 	git -C site pull

README.md

@@ -136,4 +136,4 @@ Install a prebuilt binary from the [releases page][]
 [Chocolatey]: https://chocolatey.org
 [releases page]: https://github.com/cli/cli/releases/latest
 [hub]: https://github.com/github/hub
-[contributing page]: https://github.com/cli/cli/blob/master/.github/CONTRIBUTING.md
+[contributing page]: https://github.com/cli/cli/blob/trunk/.github/CONTRIBUTING.md

api/client.go

@@ -16,14 +16,18 @@ import (
 // ClientOption represents an argument to NewClient
 type ClientOption = func(http.RoundTripper) http.RoundTripper
 
-// NewClient initializes a Client
-func NewClient(opts ...ClientOption) *Client {
+// NewHTTPClient initializes an http.Client
+func NewHTTPClient(opts ...ClientOption) *http.Client {
 	tr := http.DefaultTransport
 	for _, opt := range opts {
 		tr = opt(tr)
 	}
-	http := &http.Client{Transport: tr}
-	client := &Client{http: http}
+	return &http.Client{Transport: tr}
+}
+
+// NewClient initializes a Client
+func NewClient(opts ...ClientOption) *Client {
+	client := &Client{http: NewHTTPClient(opts...)}
 	return client
 }
 
@@ -145,6 +149,41 @@ func (gr GraphQLErrorResponse) Error() string {
 	return fmt.Sprintf("graphql error: '%s'", strings.Join(errorMessages, ", "))
 }
 
+// Returns whether or not scopes are present, appID, and error
+func (c Client) HasScopes(wantedScopes ...string) (bool, string, error) {
+	url := "https://api.github.com/user"
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return false, "", err
+	}
+
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+
+	res, err := c.http.Do(req)
+	if err != nil {
+		return false, "", err
+	}
+	defer res.Body.Close()
+
+	appID := res.Header.Get("X-Oauth-Client-Id")
+	hasScopes := strings.Split(res.Header.Get("X-Oauth-Scopes"), ",")
+
+	found := 0
+	for _, s := range hasScopes {
+		for _, w := range wantedScopes {
+			if w == strings.TrimSpace(s) {
+				found++
+			}
+		}
+	}
+
+	if found == len(wantedScopes) {
+		return true, appID, nil
+	}
+
+	return false, appID, nil
+}
+
 // GraphQL performs a GraphQL request and parses the response
 func (c Client) GraphQL(query string, variables map[string]interface{}, data interface{}) error {
 	url := "https://api.github.com/graphql"

api/queries_gist.go

@@ -0,0 +1,52 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+)
+
+// Gist represents a GitHub's gist.
+type Gist struct {
+	Description string                    `json:"description,omitempty"`
+	Public      bool                      `json:"public,omitempty"`
+	Files       map[GistFilename]GistFile `json:"files,omitempty"`
+	HTMLURL     string                    `json:"html_url,omitempty"`
+}
+
+type GistFilename string
+
+type GistFile struct {
+	Content string `json:"content,omitempty"`
+}
+
+// Create a gist for authenticated user.
+//
+// GitHub API docs: https://developer.github.com/v3/gists/#create-a-gist
+func GistCreate(client *Client, description string, public bool, files map[string]string) (*Gist, error) {
+	gistFiles := map[GistFilename]GistFile{}
+
+	for filename, content := range files {
+		gistFiles[GistFilename(filename)] = GistFile{content}
+	}
+
+	path := "gists"
+	body := &Gist{
+		Description: description,
+		Public:      public,
+		Files:       gistFiles,
+	}
+	result := Gist{}
+
+	requestByte, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	requestBody := bytes.NewReader(requestByte)
+
+	err = client.REST("POST", path, requestBody, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}

api/queries_pr.go

@@ -48,6 +48,7 @@ type PullRequest struct {
 	BaseRefName string
 	HeadRefName string
 	Body        string
+	Mergeable   string
 
 	Author struct {
 		Login string
@@ -418,6 +419,7 @@ func PullRequestByNumber(client *Client, repo ghrepo.Interface, number int) (*Pu
 				state
 				closed
 				body
+				mergeable
 				author {
 				  login
 				}
@@ -526,6 +528,7 @@ func PullRequestForBranch(client *Client, repo ghrepo.Interface, baseBranch, hea
 					title
 					state
 					body
+					mergeable
 					author {
 						login
 					}
@@ -1010,6 +1013,14 @@ func PullRequestReady(client *Client, repo ghrepo.Interface, pr *PullRequest) er
 	return err
 }
 
+func BranchDeleteRemote(client *Client, repo ghrepo.Interface, branch string) error {
+	var response struct {
+		NodeID string `json:"node_id"`
+	}
+	path := fmt.Sprintf("repos/%s/%s/git/refs/heads/%s", repo.RepoOwner(), repo.RepoName(), branch)
+	return client.REST("DELETE", path, nil, &response)
+}
+
 func min(a, b int) int {
 	if a < b {
 		return a

api/queries_repo.go

@@ -84,6 +84,9 @@ func GitHubRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 			hasIssuesEnabled
 			description
 			viewerPermission
+			defaultBranchRef {
+				name
+			}
 		}
 	}`
 	variables := map[string]interface{}{

api/queries_user.go

@@ -0,0 +1,18 @@
+package api
+
+import (
+	"context"
+
+	"github.com/shurcooL/githubv4"
+)
+
+func CurrentLoginName(client *Client) (string, error) {
+	var query struct {
+		Viewer struct {
+			Login string
+		}
+	}
+	v4 := githubv4.NewClient(client.http)
+	err := v4.Query(context.Background(), &query, nil)
+	return query.Viewer.Login, err
+}

cmd/gh/main.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/cli/cli/command"
 	"github.com/cli/cli/internal/config"
+	"github.com/cli/cli/pkg/cmdutil"
 	"github.com/cli/cli/update"
 	"github.com/cli/cli/utils"
 	"github.com/mgutz/ansi"
@@ -48,6 +49,10 @@ func main() {
 }
 
 func printError(out io.Writer, err error, cmd *cobra.Command, debug bool) {
+	if err == cmdutil.SilentError {
+		return
+	}
+
 	var dnsError *net.DNSError
 	if errors.As(err, &dnsError) {
 		fmt.Fprintf(out, "error connecting to %s\n", dnsError.Name)
@@ -60,7 +65,7 @@ func printError(out io.Writer, err error, cmd *cobra.Command, debug bool) {
 
 	fmt.Fprintln(out, err)
 
-	var flagError *command.FlagError
+	var flagError *cmdutil.FlagError
 	if errors.As(err, &flagError) || strings.HasPrefix(err.Error(), "unknown command ") {
 		if !strings.HasSuffix(err.Error(), "\n") {
 			fmt.Fprintln(out)

cmd/gh/main_test.go

@@ -7,7 +7,7 @@ import (
 	"net"
 	"testing"
 
-	"github.com/cli/cli/command"
+	"github.com/cli/cli/pkg/cmdutil"
 	"github.com/spf13/cobra"
 )
 
@@ -49,7 +49,7 @@ check your internet connection or githubstatus.com
 		{
 			name: "Cobra flag error",
 			args: args{
-				err:   &command.FlagError{Err: errors.New("unknown flag --foo")},
+				err:   &cmdutil.FlagError{Err: errors.New("unknown flag --foo")},
 				cmd:   cmd,
 				debug: false,
 			},

command/gist.go

@@ -0,0 +1,150 @@
+package command
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+
+	"github.com/cli/cli/api"
+	"github.com/cli/cli/utils"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	RootCmd.AddCommand(gistCmd)
+	gistCmd.AddCommand(gistCreateCmd)
+	gistCreateCmd.Flags().StringP("desc", "d", "", "A description for this gist")
+	gistCreateCmd.Flags().BoolP("public", "p", false, "When true, the gist will be public and available for anyone to see (default: private)")
+}
+
+var gistCmd = &cobra.Command{
+	Use:   "gist",
+	Short: "Create gists",
+	Long:  `Work with GitHub gists.`,
+}
+
+var gistCreateCmd = &cobra.Command{
+	Use:   `create {<filename>|-}...`,
+	Short: "Create a new gist",
+	Long: `gh gist create: create gists
+
+Gists can be created from one or many files. This command can also read from STDIN. By default, gists are private; use --public to change this.
+
+Examples
+
+    gh gist create hello.py                   # turn file hello.py into a gist
+    gh gist create --public hello.py          # turn file hello.py into a public gist
+    gh gist create -d"a file!" hello.py       # turn file hello.py into a gist, with description
+    gh gist create hello.py world.py cool.txt # make a gist out of several files
+    gh gist create -                          # read from STDIN to create a gist
+    cat cool.txt | gh gist create             # read the output of another command and make a gist out of it
+`,
+	RunE: gistCreate,
+}
+
+type Opts struct {
+	Description string
+	Public      bool
+}
+
+func gistCreate(cmd *cobra.Command, args []string) error {
+	ctx := contextForCommand(cmd)
+	client, err := apiClientForContext(ctx)
+	if err != nil {
+		return err
+	}
+
+	// This performs a dummy query, checks what scopes we have, and then asks for a user to reauth
+	// with expanded scopes. it introduces latency whenever this command is run: a trade-off to avoid
+	// having every single user reauth as a result of this feature even if they never once use gists.
+	//
+	// In the future we'd rather have the ability to detect a "reauth needed" scenario and replay
+	// failed requests but some short spikes indicated that that would be a fair bit of work.
+	client, err = ensureScopes(ctx, client, "gist")
+	if err != nil {
+		return err
+	}
+
+	opts, err := processOpts(cmd)
+	if err != nil {
+		return fmt.Errorf("did not understand arguments: %w", err)
+	}
+
+	info, err := os.Stdin.Stat()
+	if err != nil {
+		return fmt.Errorf("failed to check STDIN: %w", err)
+	}
+	if (info.Mode() & os.ModeCharDevice) != os.ModeCharDevice {
+		args = append(args, "-")
+	}
+
+	files, err := processFiles(os.Stdin, args)
+	if err != nil {
+		return fmt.Errorf("failed to collect files for posting: %w", err)
+	}
+
+	errOut := colorableErr(cmd)
+	fmt.Fprintf(errOut, "%s Creating gist...\n", utils.Gray("-"))
+
+	gist, err := api.GistCreate(client, opts.Description, opts.Public, files)
+	if err != nil {
+		return fmt.Errorf("%s Failed to create gist: %w", utils.Red("X"), err)
+	}
+
+	fmt.Fprintf(errOut, "%s Created gist\n", utils.Green("✓"))
+
+	fmt.Fprintln(cmd.OutOrStdout(), gist.HTMLURL)
+
+	return nil
+}
+
+func processOpts(cmd *cobra.Command) (*Opts, error) {
+	description, err := cmd.Flags().GetString("desc")
+	if err != nil {
+		return nil, err
+	}
+
+	public, err := cmd.Flags().GetBool("public")
+	if err != nil {
+		return nil, err
+	}
+
+	return &Opts{
+		Description: description,
+		Public:      public,
+	}, err
+}
+
+func processFiles(stdin io.Reader, filenames []string) (map[string]string, error) {
+	fs := map[string]string{}
+
+	if len(filenames) == 0 {
+		return fs, errors.New("no filenames passed and nothing on STDIN")
+	}
+
+	for i, f := range filenames {
+		var filename string
+		var content []byte
+		var err error
+		if f == "-" {
+			filename = fmt.Sprintf("gistfile%d.txt", i)
+			content, err = ioutil.ReadAll(stdin)
+			if err != nil {
+				return fs, fmt.Errorf("failed to read from stdin: %w", err)
+			}
+		} else {
+			content, err = ioutil.ReadFile(f)
+			if err != nil {
+				return fs, fmt.Errorf("failed to read file %s: %w", f, err)
+			}
+			filename = path.Base(f)
+		}
+
+		fs[filename] = string(content)
+	}
+
+	return fs, nil
+}

command/gist_test.go

@@ -0,0 +1,52 @@
+package command
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"strings"
+	"testing"
+)
+
+func TestGistCreate(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+
+	http := initFakeHTTP()
+	http.StubResponse(200, bytes.NewBufferString(`
+	{
+		"html_url": "https://gist.github.com/aa5a315d61ae9438b18d"
+	}
+	`))
+
+	output, err := RunCommand(`gist create "../test/fixtures/gistCreate.json" -d "Gist description" --public`)
+	eq(t, err, nil)
+
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[0].Body)
+	reqBody := struct {
+		Description string
+		Public      bool
+		Files       map[string]struct {
+			Content string
+		}
+	}{}
+
+	err = json.Unmarshal(bodyBytes, &reqBody)
+	if err != nil {
+		t.Fatalf("unexpected json error: %s", err)
+	}
+
+	eq(t, reqBody.Description, "Gist description")
+	eq(t, reqBody.Public, true)
+	eq(t, reqBody.Files["gistCreate.json"].Content, "{}")
+	eq(t, output.String(), "https://gist.github.com/aa5a315d61ae9438b18d\n")
+}
+
+func TestGistCreate_stdin(t *testing.T) {
+	fakeStdin := strings.NewReader("hey cool how is it going")
+	files, err := processFiles(fakeStdin, []string{"-"})
+	if err != nil {
+		t.Fatalf("unexpected error processing files: %s", err)
+	}
+
+	eq(t, files["gistfile0.txt"], "hey cool how is it going")
+}

command/issue.go

@@ -73,14 +73,9 @@ var issueStatusCmd = &cobra.Command{
 	RunE:  issueStatus,
 }
 var issueViewCmd = &cobra.Command{
-	Use: "view {<number> | <url>}",
-	Args: func(cmd *cobra.Command, args []string) error {
-		if len(args) < 1 {
-			return FlagError{errors.New("issue number or URL required as argument")}
-		}
-		return nil
-	},
+	Use:   "view {<number> | <url>}",
 	Short: "View an issue",
+	Args:  cobra.ExactArgs(1),
 	Long: `Display the title, body, and other information about an issue.
 
 With '--web', open the issue in a web browser instead.`,
@@ -172,7 +167,7 @@ func issueStatus(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	currentUser, err := ctx.AuthLogin()
+	currentUser, err := api.CurrentLoginName(apiClient)
 	if err != nil {
 		return err
 	}

command/issue_test.go

@@ -20,6 +20,9 @@ func TestIssueStatus(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.Register(
+		httpmock.GraphQL(`\bviewer\b`),
+		httpmock.StringResponse(`{"data":{"viewer":{"login":"octocat"}}}`))
 
 	jsonFile, _ := os.Open("../test/fixtures/issueStatus.json")
 	defer jsonFile.Close()
@@ -49,6 +52,9 @@ func TestIssueStatus_blankSlate(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.Register(
+		httpmock.GraphQL(`\bviewer\b`),
+		httpmock.StringResponse(`{"data":{"viewer":{"login":"octocat"}}}`))
 
 	http.StubResponse(200, bytes.NewBufferString(`
 	{ "data": { "repository": {
@@ -86,6 +92,9 @@ func TestIssueStatus_disabledIssues(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.Register(
+		httpmock.GraphQL(`\bviewer\b`),
+		httpmock.StringResponse(`{"data":{"viewer":{"login":"octocat"}}}`))
 
 	http.StubResponse(200, bytes.NewBufferString(`
 	{ "data": { "repository": {

command/pr.go

@@ -1,6 +1,7 @@
 package command
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"regexp"
@@ -8,6 +9,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/context"
 	"github.com/cli/cli/git"
@@ -26,7 +28,8 @@ func init() {
 	prCmd.AddCommand(prCloseCmd)
 	prCmd.AddCommand(prReopenCmd)
 	prCmd.AddCommand(prMergeCmd)
-	prMergeCmd.Flags().BoolP("merge", "m", true, "Merge the commits with the base branch")
+	prMergeCmd.Flags().BoolP("delete-branch", "d", true, "Delete the local and remote branch after merge")
+	prMergeCmd.Flags().BoolP("merge", "m", false, "Merge the commits with the base branch")
 	prMergeCmd.Flags().BoolP("rebase", "r", false, "Rebase the commits onto the base branch")
 	prMergeCmd.Flags().BoolP("squash", "s", false, "Squash the commits into one commit and merge it into the base branch")
 	prCmd.AddCommand(prReadyCmd)
@@ -93,7 +96,7 @@ var prMergeCmd = &cobra.Command{
 }
 var prReadyCmd = &cobra.Command{
 	Use:   "ready [<number> | <url> | <branch>]",
-	Short: "Make a pull request as ready for review",
+	Short: "Mark a pull request as ready for review",
 	Args:  cobra.MaximumNArgs(1),
 	RunE:  prReady,
 }
@@ -105,11 +108,6 @@ func prStatus(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	currentUser, err := ctx.AuthLogin()
-	if err != nil {
-		return err
-	}
-
 	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
@@ -122,6 +120,8 @@ func prStatus(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("could not query for pull request for current branch: %w", err)
 	}
 
+	// the `@me` macro is available because the API lookup is ElasticSearch-based
+	currentUser := "@me"
 	prPayload, err := api.PullRequests(apiClient, baseRepo, currentPRNumber, currentPRHeadRef, currentUser)
 	if err != nil {
 		return err
@@ -451,7 +451,15 @@ func prMerge(cmd *cobra.Command, args []string) error {
 
 	var pr *api.PullRequest
 	if len(args) > 0 {
-		pr, err = prFromArg(apiClient, baseRepo, args[0])
+		var prNumber string
+		n, _ := prFromURL(args[0])
+		if n != "" {
+			prNumber = n
+		} else {
+			prNumber = args[0]
+		}
+
+		pr, err = prFromArg(apiClient, baseRepo, prNumber)
 		if err != nil {
 			return err
 		}
@@ -471,41 +479,181 @@ func prMerge(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	if pr.State == "MERGED" {
+	if pr.Mergeable == "CONFLICTING" {
+		err := fmt.Errorf("%s Pull request #%d has conflicts and isn't mergeable ", utils.Red("!"), pr.Number)
+		return err
+	} else if pr.Mergeable == "UNKNOWN" {
+		err := fmt.Errorf("%s Pull request #%d can't be merged right now; try again in a few seconds", utils.Red("!"), pr.Number)
+		return err
+	} else if pr.State == "MERGED" {
 		err := fmt.Errorf("%s Pull request #%d was already merged", utils.Red("!"), pr.Number)
 		return err
 	}
 
-	rebase, err := cmd.Flags().GetBool("rebase")
-	if err != nil {
-		return err
-	}
-	squash, err := cmd.Flags().GetBool("squash")
+	var mergeMethod api.PullRequestMergeMethod
+	deleteBranch, err := cmd.Flags().GetBool("delete-branch")
 	if err != nil {
 		return err
 	}
 
-	var output string
-	if rebase {
-		output = fmt.Sprintf("%s Rebased and merged pull request #%d\n", utils.Green("✔"), pr.Number)
+	deleteLocalBranch := !cmd.Flags().Changed("repo")
+	crossRepoPR := pr.HeadRepositoryOwner.Login != baseRepo.RepoOwner()
+
+	// Ensure only one merge method is specified
+	enabledFlagCount := 0
+	isInteractive := false
+	if b, _ := cmd.Flags().GetBool("merge"); b {
+		enabledFlagCount++
+		mergeMethod = api.PullRequestMergeMethodMerge
+	}
+	if b, _ := cmd.Flags().GetBool("rebase"); b {
+		enabledFlagCount++
+		mergeMethod = api.PullRequestMergeMethodRebase
+	}
+	if b, _ := cmd.Flags().GetBool("squash"); b {
+		enabledFlagCount++
+		mergeMethod = api.PullRequestMergeMethodSquash
+	}
+
+	if enabledFlagCount == 0 {
+		isInteractive = true
+	} else if enabledFlagCount > 1 {
+		return errors.New("expected exactly one of --merge, --rebase, or --squash to be true")
+	}
+
+	if isInteractive {
+		mergeMethod, deleteBranch, err = prInteractiveMerge(deleteLocalBranch, crossRepoPR)
+		if err != nil {
+			return nil
+		}
+	}
+
+	var action string
+	if mergeMethod == api.PullRequestMergeMethodRebase {
+		action = "Rebased and merged"
 		err = api.PullRequestMerge(apiClient, baseRepo, pr, api.PullRequestMergeMethodRebase)
-	} else if squash {
-		output = fmt.Sprintf("%s Squashed and merged pull request #%d\n", utils.Green("✔"), pr.Number)
+	} else if mergeMethod == api.PullRequestMergeMethodSquash {
+		action = "Squashed and merged"
 		err = api.PullRequestMerge(apiClient, baseRepo, pr, api.PullRequestMergeMethodSquash)
-	} else {
-		output = fmt.Sprintf("%s Merged pull request #%d\n", utils.Green("✔"), pr.Number)
+	} else if mergeMethod == api.PullRequestMergeMethodMerge {
+		action = "Merged"
 		err = api.PullRequestMerge(apiClient, baseRepo, pr, api.PullRequestMergeMethodMerge)
+	} else {
+		err = fmt.Errorf("unknown merge method (%d) used", mergeMethod)
+		return err
 	}
 
 	if err != nil {
 		return fmt.Errorf("API call failed: %w", err)
 	}
 
-	fmt.Fprint(colorableOut(cmd), output)
+	fmt.Fprintf(colorableOut(cmd), "%s %s pull request #%d\n", utils.Magenta("✔"), action, pr.Number)
+
+	if deleteBranch {
+		repo, err := api.GitHubRepo(apiClient, baseRepo)
+		if err != nil {
+			return err
+		}
+
+		currentBranch, err := ctx.Branch()
+		if err != nil {
+			return err
+		}
+
+		branchSwitchString := ""
+
+		if deleteLocalBranch && !crossRepoPR {
+			var branchToSwitchTo string
+			if currentBranch == pr.HeadRefName {
+				branchToSwitchTo = repo.DefaultBranchRef.Name
+				err = git.CheckoutBranch(repo.DefaultBranchRef.Name)
+				if err != nil {
+					return err
+				}
+			}
+
+			localBranchExists := git.HasLocalBranch(pr.HeadRefName)
+			if localBranchExists {
+				err = git.DeleteLocalBranch(pr.HeadRefName)
+				if err != nil {
+					err = fmt.Errorf("failed to delete local branch %s: %w", utils.Cyan(pr.HeadRefName), err)
+					return err
+				}
+			}
+
+			if branchToSwitchTo != "" {
+				branchSwitchString = fmt.Sprintf(" and switched to branch %s", utils.Cyan(branchToSwitchTo))
+			}
+		}
+
+		if !crossRepoPR {
+			err = api.BranchDeleteRemote(apiClient, baseRepo, pr.HeadRefName)
+			if err != nil {
+				err = fmt.Errorf("failed to delete remote branch %s: %w", utils.Cyan(pr.HeadRefName), err)
+				return err
+			}
+		}
+
+		fmt.Fprintf(colorableOut(cmd), "%s Deleted branch %s%s\n", utils.Red("✔"), utils.Cyan(pr.HeadRefName), branchSwitchString)
+	}
 
 	return nil
 }
 
+func prInteractiveMerge(deleteLocalBranch bool, crossRepoPR bool) (api.PullRequestMergeMethod, bool, error) {
+	mergeMethodQuestion := &survey.Question{
+		Name: "mergeMethod",
+		Prompt: &survey.Select{
+			Message: "What merge method would you like to use?",
+			Options: []string{"Create a merge commit", "Rebase and merge", "Squash and merge"},
+			Default: "Create a merge commit",
+		},
+	}
+
+	qs := []*survey.Question{mergeMethodQuestion}
+
+	if !crossRepoPR {
+		var message string
+		if deleteLocalBranch {
+			message = "Delete the branch locally and on GitHub?"
+		} else {
+			message = "Delete the branch on GitHub?"
+		}
+
+		deleteBranchQuestion := &survey.Question{
+			Name: "deleteBranch",
+			Prompt: &survey.Confirm{
+				Message: message,
+				Default: true,
+			},
+		}
+		qs = append(qs, deleteBranchQuestion)
+	}
+
+	answers := struct {
+		MergeMethod  int
+		DeleteBranch bool
+	}{}
+
+	err := SurveyAsk(qs, &answers)
+	if err != nil {
+		return 0, false, fmt.Errorf("could not prompt: %w", err)
+	}
+
+	var mergeMethod api.PullRequestMergeMethod
+	switch answers.MergeMethod {
+	case 0:
+		mergeMethod = api.PullRequestMergeMethodMerge
+	case 1:
+		mergeMethod = api.PullRequestMergeMethodRebase
+	case 2:
+		mergeMethod = api.PullRequestMergeMethodSquash
+	}
+
+	deleteBranch := answers.DeleteBranch
+	return mergeMethod, deleteBranch, nil
+}
+
 func printPrPreview(out io.Writer, pr *api.PullRequest) error {
 	// Header (Title and State)
 	fmt.Fprintln(out, utils.Bold(pr.Title))

command/pr_test.go

@@ -982,10 +982,10 @@ func initWithStubs(branch string, stubs ...stubResponse) {
 	initBlankContext("", "OWNER/REPO", branch)
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
-
 	for _, s := range stubs {
 		http.StubResponse(s.ResponseCode, s.ResponseBody)
 	}
+	http.StubRepoResponse("OWNER", "REPO")
 }
 
 func TestPrMerge(t *testing.T) {
@@ -994,9 +994,19 @@ func TestPrMerge(t *testing.T) {
 			"pullRequest": { "number": 1, "closed": false, "state": "OPEN"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
-	output, err := RunCommand("pr merge 1")
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("branch.blueberries.remote origin\nbranch.blueberries.merge refs/heads/blueberries") // git config --get-regexp ^branch\.master\.(remote|merge)
+	cs.Stub("")                                                                                  // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("")                                                                                  // git symbolic-ref --quiet --short HEAD
+	cs.Stub("")                                                                                  // git checkout master
+	cs.Stub("")
+
+	output, err := RunCommand("pr merge 1 --merge")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
 	}
@@ -1008,11 +1018,96 @@ func TestPrMerge(t *testing.T) {
 	}
 }
 
+func TestPrMerge_withRepoFlag(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubResponse(200, bytes.NewBufferString(`{ "data": { "repository": {
+		"pullRequest": { "number": 1, "closed": false, "state": "OPEN"}
+		} } }`))
+	http.StubResponse(200, bytes.NewBufferString(`{ "data": {} }`))
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`{"node_id": "THE-ID"}`))
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	eq(t, len(cs.Calls), 0)
+
+	output, err := RunCommand("pr merge 1 --merge -R stinky/boi")
+	if err != nil {
+		t.Fatalf("error running command `pr merge`: %v", err)
+	}
+
+	r := regexp.MustCompile(`Merged pull request #1`)
+
+	if !r.MatchString(output.String()) {
+		t.Fatalf("output did not match regexp /%s/\n> output\n%q\n", r, output.Stderr())
+	}
+}
+
+func TestPrMerge_deleteBranch(t *testing.T) {
+	initWithStubs("blueberries",
+		stubResponse{200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes": [
+			{ "headRefName": "blueberries", "id": "THE-ID", "number": 3}
+		] } } } }`)},
+		stubResponse{200, bytes.NewBufferString(`{ "data": {} }`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
+	)
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git rev-parse --verify blueberries`
+	cs.Stub("") // git branch -d
+	cs.Stub("") // git push origin --delete blueberries
+
+	output, err := RunCommand(`pr merge --merge --delete-branch`)
+	if err != nil {
+		t.Fatalf("Got unexpected error running `pr merge` %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Merged pull request #3", "Deleted branch blueberries")
+}
+
+func TestPrMerge_deleteNonCurrentBranch(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "another-branch")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "pullRequests": { "nodes": [
+		{ "headRefName": "blueberries", "id": "THE-ID", "number": 3}
+	] } } } }`))
+	http.StubResponse(200, bytes.NewBufferString(`{ "data": {} }`))
+	http.StubResponse(200, bytes.NewBufferString(`{"node_id": "THE-ID"}`))
+	http.StubRepoResponse("OWNER", "REPO")
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+	// We don't expect the default branch to be checked out, just that blueberries is deleted
+	cs.Stub("") // git rev-parse --verify blueberries
+	cs.Stub("") // git branch -d blueberries
+	cs.Stub("") // git push origin --delete blueberries
+
+	output, err := RunCommand(`pr merge --merge --delete-branch blueberries`)
+	if err != nil {
+		t.Fatalf("Got unexpected error running `pr merge` %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Merged pull request #3", "Deleted branch blueberries")
+}
+
 func TestPrMerge_noPrNumberGiven(t *testing.T) {
 	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("branch.blueberries.remote origin\nbranch.blueberries.merge refs/heads/blueberries") // git config --get-regexp ^branch\.master\.(remote|merge)
+	cs.Stub("")                                                                                  // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("")                                                                                  // git symbolic-ref --quiet --short HEAD
+	cs.Stub("")                                                                                  // git checkout master
+	cs.Stub("")                                                                                  // git branch -d
 
 	jsonFile, _ := os.Open("../test/fixtures/prViewPreviewWithMetadataByBranch.json")
 	defer jsonFile.Close()
@@ -1020,9 +1115,10 @@ func TestPrMerge_noPrNumberGiven(t *testing.T) {
 	initWithStubs("blueberries",
 		stubResponse{200, jsonFile},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
-	output, err := RunCommand("pr merge")
+	output, err := RunCommand("pr merge --merge")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
 	}
@@ -1040,8 +1136,17 @@ func TestPrMerge_rebase(t *testing.T) {
 			"pullRequest": { "number": 2, "closed": false, "state": "OPEN"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git branch -d
+
 	output, err := RunCommand("pr merge 2 --rebase")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
@@ -1060,8 +1165,17 @@ func TestPrMerge_squash(t *testing.T) {
 			"pullRequest": { "number": 3, "closed": false, "state": "OPEN"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git branch -d
+
 	output, err := RunCommand("pr merge 3 --squash")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
@@ -1080,8 +1194,17 @@ func TestPrMerge_alreadyMerged(t *testing.T) {
 			"pullRequest": { "number": 4, "closed": true, "state": "MERGED"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git branch -d
+
 	output, err := RunCommand("pr merge 4")
 	if err == nil {
 		t.Fatalf("expected an error running command `pr merge`: %v", err)
@@ -1094,6 +1217,60 @@ func TestPrMerge_alreadyMerged(t *testing.T) {
 	}
 }
 
+func TestPRMerge_interactive(t *testing.T) {
+	initWithStubs("blueberries",
+		stubResponse{200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes": [
+			{ "headRefName": "blueberries", "headRepositoryOwner": {"login": "OWNER"}, "id": "THE-ID", "number": 3}
+		] } } } }`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{ "data": {} }`)})
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git push origin --delete blueberries
+	cs.Stub("") // git branch -d
+
+	as, surveyTeardown := initAskStubber()
+	defer surveyTeardown()
+
+	as.Stub([]*QuestionStub{
+		{
+			Name:  "mergeMethod",
+			Value: 0,
+		},
+		{
+			Name:  "deleteBranch",
+			Value: true,
+		},
+	})
+
+	output, err := RunCommand(`pr merge`)
+	if err != nil {
+		t.Fatalf("Got unexpected error running `pr merge` %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Merged pull request #3", "Deleted branch blueberries")
+}
+
+func TestPrMerge_multipleMergeMethods(t *testing.T) {
+	initWithStubs("master",
+		stubResponse{200, bytes.NewBufferString(`{ "data": { "repository": {
+			"pullRequest": { "number": 1, "closed": false, "state": "OPEN"}
+		} } }`)},
+		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+	)
+
+	_, err := RunCommand("pr merge 1 --merge --squash")
+	if err == nil {
+		t.Fatal("expected error running `pr merge` with multiple merge methods")
+	}
+}
+
 func TestPRReady(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()

command/root.go

@@ -1,8 +1,10 @@
 package command
 
 import (
+	"errors"
 	"fmt"
 	"io"
+	"net/http"
 	"os"
 	"regexp"
 	"runtime/debug"
@@ -12,6 +14,9 @@ import (
 	"github.com/cli/cli/context"
 	"github.com/cli/cli/internal/config"
 	"github.com/cli/cli/internal/ghrepo"
+	apiCmd "github.com/cli/cli/pkg/cmd/api"
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
 	"github.com/cli/cli/utils"
 
 	"github.com/spf13/cobra"
@@ -59,21 +64,26 @@ func init() {
 		if err == pflag.ErrHelp {
 			return err
 		}
-		return &FlagError{Err: err}
+		return &cmdutil.FlagError{Err: err}
 	})
-}
 
-// FlagError is the kind of error raised in flag processing
-type FlagError struct {
-	Err error
-}
-
-func (fe FlagError) Error() string {
-	return fe.Err.Error()
-}
-
-func (fe FlagError) Unwrap() error {
-	return fe.Err
+	// TODO: iron out how a factory incorporates context
+	cmdFactory := &cmdutil.Factory{
+		IOStreams: iostreams.System(),
+		HttpClient: func() (*http.Client, error) {
+			token := os.Getenv("GITHUB_TOKEN")
+			if len(token) == 0 {
+				ctx := context.New()
+				var err error
+				token, err = ctx.AuthToken()
+				if err != nil {
+					return nil, err
+				}
+			}
+			return httpClient(token), nil
+		},
+	}
+	RootCmd.AddCommand(apiCmd.NewCmdApi(cmdFactory, nil))
 }
 
 // RootCmd is the entry point of command-line execution
@@ -100,6 +110,9 @@ var initContext = func() context.Context {
 	if repo := os.Getenv("GH_REPO"); repo != "" {
 		ctx.SetBaseRepo(repo)
 	}
+	if token := os.Getenv("GITHUB_TOKEN"); token != "" {
+		ctx.SetAuthToken(token)
+	}
 	return ctx
 }
 
@@ -112,11 +125,15 @@ func BasicClient() (*api.Client, error) {
 	}
 	opts = append(opts, api.AddHeader("User-Agent", fmt.Sprintf("GitHub CLI %s", Version)))
 
-	if c, err := config.ParseDefaultConfig(); err == nil {
-		if token, _ := c.Get(defaultHostname, "oauth_token"); token != "" {
-			opts = append(opts, api.AddHeader("Authorization", fmt.Sprintf("token %s", token)))
+	token := os.Getenv("GITHUB_TOKEN")
+	if token == "" {
+		if c, err := config.ParseDefaultConfig(); err == nil {
+			token, _ = c.Get(defaultHostname, "oauth_token")
 		}
 	}
+	if token != "" {
+		opts = append(opts, api.AddHeader("Authorization", fmt.Sprintf("token %s", token)))
+	}
 	return api.NewClient(opts...), nil
 }
 
@@ -128,6 +145,19 @@ func contextForCommand(cmd *cobra.Command) context.Context {
 	return ctx
 }
 
+// for cmdutil-powered commands
+func httpClient(token string) *http.Client {
+	var opts []api.ClientOption
+	if verbose := os.Getenv("DEBUG"); verbose != "" {
+		opts = append(opts, apiVerboseLog())
+	}
+	opts = append(opts,
+		api.AddHeader("Authorization", fmt.Sprintf("token %s", token)),
+		api.AddHeader("User-Agent", fmt.Sprintf("GitHub CLI %s", Version)),
+	)
+	return api.NewHTTPClient(opts...)
+}
+
 // overridden in tests
 var apiClientForContext = func(ctx context.Context) (*api.Client, error) {
 	token, err := ctx.AuthToken()
@@ -144,8 +174,12 @@ var apiClientForContext = func(ctx context.Context) (*api.Client, error) {
 		return fmt.Sprintf("token %s", token)
 	}
 
+	tokenFromEnv := func() bool {
+		return os.Getenv("GITHUB_TOKEN") == token
+	}
+
 	checkScopesFunc := func(appID string) error {
-		if config.IsGitHubApp(appID) && utils.IsTerminal(os.Stdin) && utils.IsTerminal(os.Stderr) {
+		if config.IsGitHubApp(appID) && !tokenFromEnv() && utils.IsTerminal(os.Stdin) && utils.IsTerminal(os.Stderr) {
 			newToken, loginHandle, err := config.AuthFlow("Notice: additional authorization required")
 			if err != nil {
 				return err
@@ -167,7 +201,11 @@ var apiClientForContext = func(ctx context.Context) (*api.Client, error) {
 		} else {
 			fmt.Fprintln(os.Stderr, "Warning: gh now requires the `read:org` OAuth scope.")
 			fmt.Fprintln(os.Stderr, "Visit https://github.com/settings/tokens and edit your token to enable `read:org`")
-			fmt.Fprintln(os.Stderr, "or generate a new token and paste it via `gh config set -h github.com oauth_token MYTOKEN`")
+			if tokenFromEnv() {
+				fmt.Fprintln(os.Stderr, "or generate a new token for the GITHUB_TOKEN environment variable")
+			} else {
+				fmt.Fprintln(os.Stderr, "or generate a new token and paste it via `gh config set -h github.com oauth_token MYTOKEN`")
+			}
 		}
 		return nil
 	}
@@ -183,6 +221,55 @@ var apiClientForContext = func(ctx context.Context) (*api.Client, error) {
 	return api.NewClient(opts...), nil
 }
 
+var ensureScopes = func(ctx context.Context, client *api.Client, wantedScopes ...string) (*api.Client, error) {
+	hasScopes, appID, err := client.HasScopes(wantedScopes...)
+	if err != nil {
+		return client, err
+	}
+
+	if hasScopes {
+		return client, nil
+	}
+
+	tokenFromEnv := len(os.Getenv("GITHUB_TOKEN")) > 0
+
+	if config.IsGitHubApp(appID) && !tokenFromEnv && utils.IsTerminal(os.Stdin) && utils.IsTerminal(os.Stderr) {
+		newToken, loginHandle, err := config.AuthFlow("Notice: additional authorization required")
+		if err != nil {
+			return client, err
+		}
+		cfg, err := ctx.Config()
+		if err != nil {
+			return client, err
+		}
+		_ = cfg.Set(defaultHostname, "oauth_token", newToken)
+		_ = cfg.Set(defaultHostname, "user", loginHandle)
+		// update config file on disk
+		err = cfg.Write()
+		if err != nil {
+			return client, err
+		}
+		// update configuration in memory
+		config.AuthFlowComplete()
+		reloadedClient, err := apiClientForContext(ctx)
+		if err != nil {
+			return client, err
+		}
+
+		return reloadedClient, nil
+	} else {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("Warning: gh now requires %s OAuth scopes.", wantedScopes))
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("Visit https://github.com/settings/tokens and edit your token to enable %s", wantedScopes))
+		if tokenFromEnv {
+			fmt.Fprintln(os.Stderr, "or generate a new token for the GITHUB_TOKEN environment variable")
+		} else {
+			fmt.Fprintln(os.Stderr, "or generate a new token and paste it via `gh config set -h github.com oauth_token MYTOKEN`")
+		}
+		return client, errors.New("Unable to reauthenticate")
+	}
+
+}
+
 func apiVerboseLog() api.ClientOption {
 	logTraffic := strings.Contains(os.Getenv("DEBUG"), "api")
 	colorize := utils.IsTerminal(os.Stderr)

command/testing.go

@@ -96,6 +96,9 @@ func initBlankContext(cfg, repo, branch string) {
 
 func initFakeHTTP() *httpmock.Registry {
 	http := &httpmock.Registry{}
+	ensureScopes = func(ctx context.Context, client *api.Client, wantedScopes ...string) (*api.Client, error) {
+		return client, nil
+	}
 	apiClientForContext = func(context.Context) (*api.Client, error) {
 		return api.NewClient(api.ReplaceTripper(http)), nil
 	}

context/blank_context.go

@@ -17,7 +17,6 @@ func NewBlank() *blankContext {
 // A Context implementation that queries the filesystem
 type blankContext struct {
 	authToken string
-	authLogin string
 	branch    string
 	baseRepo  ghrepo.Interface
 	remotes   Remotes
@@ -39,14 +38,6 @@ func (c *blankContext) SetAuthToken(t string) {
 	c.authToken = t
 }
 
-func (c *blankContext) SetAuthLogin(login string) {
-	c.authLogin = login
-}
-
-func (c *blankContext) AuthLogin() (string, error) {
-	return c.authLogin, nil
-}
-
 func (c *blankContext) Branch() (string, error) {
 	if c.branch == "" {
 		return "", fmt.Errorf("branch was not initialized")

context/context.go

@@ -18,7 +18,6 @@ const defaultHostname = "github.com"
 type Context interface {
 	AuthToken() (string, error)
 	SetAuthToken(string)
-	AuthLogin() (string, error)
 	Branch() (string, error)
 	SetBranch(string)
 	Remotes() (Remotes, error)
@@ -195,20 +194,6 @@ func (c *fsContext) SetAuthToken(t string) {
 	c.authToken = t
 }
 
-func (c *fsContext) AuthLogin() (string, error) {
-	config, err := c.Config()
-	if err != nil {
-		return "", err
-	}
-
-	login, err := config.Get(defaultHostname, "user")
-	if login == "" || err != nil {
-		return "", err
-	}
-
-	return login, nil
-}
-
 func (c *fsContext) Branch() (string, error) {
 	if c.branch != "" {
 		return c.branch, nil

docs/releasing.md

@@ -1,13 +1,20 @@
 # Releasing
 
-## Release to production
+_First create a prerelease to verify the relase infrastructure_
 
-This can all be done from your local terminal.
+1. `git tag v1.2.3-pre`
+2. `git push origin v1.2.3-pre`
+3. Wait several minutes for the build to run <https://github.com/cli/cli/actions>
+4. Verify the prerelease succeeded and has the correct artifacts at <https://github.com/cli/cli/releases>
 
-1. `git tag v1.2.3`
-2. `git push origin v1.2.3`
-3. Wait a few minutes for the build to run <https://github.com/cli/cli/actions>
-4. Check <https://github.com/cli/cli/releases>
+_Next create a the production release_
+
+5. `git tag v1.2.3`
+6. `git push origin v1.2.3`
+7. Wait several minutes for the build to run <https://github.com/cli/cli/actions>
+8. Check <https://github.com/cli/cli/releases>
+9. Verify the marketing site was updated https://cli.github.com/
+10. Delete the prerelease on GitHub <https://github.com/cli/cli/releases>
 
 ## Release locally for debugging
 

git/git.go

@@ -203,6 +203,24 @@ func ReadBranchConfig(branch string) (cfg BranchConfig) {
 	return
 }
 
+func DeleteLocalBranch(branch string) error {
+	branchCmd := GitCommand("branch", "-D", branch)
+	err := run.PrepareCmd(branchCmd).Run()
+	return err
+}
+
+func HasLocalBranch(branch string) bool {
+	configCmd := GitCommand("rev-parse", "--verify", "refs/heads/"+branch)
+	_, err := run.PrepareCmd(configCmd).Output()
+	return err == nil
+}
+
+func CheckoutBranch(branch string) error {
+	configCmd := GitCommand("checkout", branch)
+	err := run.PrepareCmd(configCmd).Run()
+	return err
+}
+
 func isFilesystemPath(p string) bool {
 	return p == "." || strings.HasPrefix(p, "./") || strings.HasPrefix(p, "/")
 }

go.mod

@@ -21,7 +21,7 @@ require (
 	github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f // indirect
 	github.com/spf13/cobra v1.0.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.4.0 // indirect
+	github.com/stretchr/testify v1.5.1
 	golang.org/x/crypto v0.0.0-20200219234226-1ad67e1f0ef4
 	golang.org/x/net v0.0.0-20200219183655-46282727080f // indirect
 	golang.org/x/text v0.3.2

go.sum

@@ -167,13 +167,14 @@ github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=

internal/config/config_setup.go

@@ -41,7 +41,7 @@ func AuthFlow(notice string) (string, string, error) {
 		Hostname:     oauthHost,
 		ClientID:     oauthClientID,
 		ClientSecret: oauthClientSecret,
-		Scopes:       []string{"repo", "read:org"},
+		Scopes:       []string{"repo", "read:org", "gist"},
 		WriteSuccessHTML: func(w io.Writer) {
 			fmt.Fprintln(w, oauthSuccessPage)
 		},
@@ -116,14 +116,7 @@ func setupConfigFile(filename string) (Config, error) {
 
 func getViewer(token string) (string, error) {
 	http := api.NewClient(api.AddHeader("Authorization", fmt.Sprintf("token %s", token)))
-
-	response := struct {
-		Viewer struct {
-			Login string
-		}
-	}{}
-	err := http.GraphQL("{ viewer { login } }", nil, &response)
-	return response.Viewer.Login, err
+	return api.CurrentLoginName(http)
 }
 
 func waitForEnter(r io.Reader) error {

pkg/cmd/api/api.go

@@ -0,0 +1,190 @@
+package api
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
+	"github.com/spf13/cobra"
+)
+
+type ApiOptions struct {
+	IO *iostreams.IOStreams
+
+	RequestMethod       string
+	RequestMethodPassed bool
+	RequestPath         string
+	MagicFields         []string
+	RawFields           []string
+	RequestHeaders      []string
+	ShowResponseHeaders bool
+
+	HttpClient func() (*http.Client, error)
+}
+
+func NewCmdApi(f *cmdutil.Factory, runF func(*ApiOptions) error) *cobra.Command {
+	opts := ApiOptions{
+		IO:         f.IOStreams,
+		HttpClient: f.HttpClient,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "api <endpoint>",
+		Short: "Make an authenticated GitHub API request",
+		Long: `Makes an authenticated HTTP request to the GitHub API and prints the response.
+
+The <endpoint> argument should either be a path of a GitHub API v3 endpoint, or
+"graphql" to access the GitHub API v4.
+
+The default HTTP request method is "GET" normally and "POST" if any parameters
+were added. Override the method with '--method'.
+
+Pass one or more '--raw-field' values in "<key>=<value>" format to add
+JSON-encoded string parameters to the POST body.
+
+The '--field' flag behaves like '--raw-field' with magic type conversion based
+on the format of the value:
+
+- literal values "true", "false", "null", and integer numbers get converted to
+  appropriate JSON types;
+- if the value starts with "@", the rest of the value is interpreted as a
+  filename to read the value from. Pass "-" to read from standard input.
+`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(c *cobra.Command, args []string) error {
+			opts.RequestPath = args[0]
+			opts.RequestMethodPassed = c.Flags().Changed("method")
+
+			if runF != nil {
+				return runF(&opts)
+			}
+			return apiRun(&opts)
+		},
+	}
+
+	cmd.Flags().StringVarP(&opts.RequestMethod, "method", "X", "GET", "The HTTP method for the request")
+	cmd.Flags().StringArrayVarP(&opts.MagicFields, "field", "F", nil, "Add a parameter of inferred type")
+	cmd.Flags().StringArrayVarP(&opts.RawFields, "raw-field", "f", nil, "Add a string parameter")
+	cmd.Flags().StringArrayVarP(&opts.RequestHeaders, "header", "H", nil, "Add an additional HTTP request header")
+	cmd.Flags().BoolVarP(&opts.ShowResponseHeaders, "include", "i", false, "Include HTTP response headers in the output")
+	return cmd
+}
+
+func apiRun(opts *ApiOptions) error {
+	params, err := parseFields(opts)
+	if err != nil {
+		return err
+	}
+
+	method := opts.RequestMethod
+	if len(params) > 0 && !opts.RequestMethodPassed {
+		method = "POST"
+	}
+
+	httpClient, err := opts.HttpClient()
+	if err != nil {
+		return err
+	}
+
+	resp, err := httpRequest(httpClient, method, opts.RequestPath, params, opts.RequestHeaders)
+	if err != nil {
+		return err
+	}
+
+	if opts.ShowResponseHeaders {
+		for name, vals := range resp.Header {
+			fmt.Fprintf(opts.IO.Out, "%s: %s\r\n", name, strings.Join(vals, ", "))
+		}
+		fmt.Fprint(opts.IO.Out, "\r\n")
+	}
+
+	if resp.StatusCode == 204 {
+		return nil
+	}
+	defer resp.Body.Close()
+
+	_, err = io.Copy(opts.IO.Out, resp.Body)
+	if err != nil {
+		return err
+	}
+
+	// TODO: detect GraphQL errors
+	if resp.StatusCode > 299 {
+		return cmdutil.SilentError
+	}
+
+	return nil
+}
+
+func parseFields(opts *ApiOptions) (map[string]interface{}, error) {
+	params := make(map[string]interface{})
+	for _, f := range opts.RawFields {
+		key, value, err := parseField(f)
+		if err != nil {
+			return params, err
+		}
+		params[key] = value
+	}
+	for _, f := range opts.MagicFields {
+		key, strValue, err := parseField(f)
+		if err != nil {
+			return params, err
+		}
+		value, err := magicFieldValue(strValue, opts.IO.In)
+		if err != nil {
+			return params, fmt.Errorf("error parsing %q value: %w", key, err)
+		}
+		params[key] = value
+	}
+	return params, nil
+}
+
+func parseField(f string) (string, string, error) {
+	idx := strings.IndexRune(f, '=')
+	if idx == -1 {
+		return f, "", fmt.Errorf("field %q requires a value separated by an '=' sign", f)
+	}
+	return f[0:idx], f[idx+1:], nil
+}
+
+func magicFieldValue(v string, stdin io.ReadCloser) (interface{}, error) {
+	if strings.HasPrefix(v, "@") {
+		return readUserFile(v[1:], stdin)
+	}
+
+	if n, err := strconv.Atoi(v); err == nil {
+		return n, nil
+	}
+
+	switch v {
+	case "true":
+		return true, nil
+	case "false":
+		return false, nil
+	case "null":
+		return nil, nil
+	default:
+		return v, nil
+	}
+}
+
+func readUserFile(fn string, stdin io.ReadCloser) ([]byte, error) {
+	var r io.ReadCloser
+	if fn == "-" {
+		r = stdin
+	} else {
+		var err error
+		r, err = os.Open(fn)
+		if err != nil {
+			return nil, err
+		}
+	}
+	defer r.Close()
+	return ioutil.ReadAll(r)
+}

pkg/cmd/api/api_test.go

@@ -0,0 +1,307 @@
+package api
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"testing"
+
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
+	"github.com/google/shlex"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_NewCmdApi(t *testing.T) {
+	f := &cmdutil.Factory{}
+
+	tests := []struct {
+		name     string
+		cli      string
+		wants    ApiOptions
+		wantsErr bool
+	}{
+		{
+			name: "no flags",
+			cli:  "graphql",
+			wants: ApiOptions{
+				RequestMethod:       "GET",
+				RequestMethodPassed: false,
+				RequestPath:         "graphql",
+				RawFields:           []string(nil),
+				MagicFields:         []string(nil),
+				RequestHeaders:      []string(nil),
+				ShowResponseHeaders: false,
+			},
+			wantsErr: false,
+		},
+		{
+			name: "override method",
+			cli:  "repos/octocat/Spoon-Knife -XDELETE",
+			wants: ApiOptions{
+				RequestMethod:       "DELETE",
+				RequestMethodPassed: true,
+				RequestPath:         "repos/octocat/Spoon-Knife",
+				RawFields:           []string(nil),
+				MagicFields:         []string(nil),
+				RequestHeaders:      []string(nil),
+				ShowResponseHeaders: false,
+			},
+			wantsErr: false,
+		},
+		{
+			name: "with fields",
+			cli:  "graphql -f query=QUERY -F body=@file.txt",
+			wants: ApiOptions{
+				RequestMethod:       "GET",
+				RequestMethodPassed: false,
+				RequestPath:         "graphql",
+				RawFields:           []string{"query=QUERY"},
+				MagicFields:         []string{"body=@file.txt"},
+				RequestHeaders:      []string(nil),
+				ShowResponseHeaders: false,
+			},
+			wantsErr: false,
+		},
+		{
+			name: "with headers",
+			cli:  "user -H 'accept: text/plain' -i",
+			wants: ApiOptions{
+				RequestMethod:       "GET",
+				RequestMethodPassed: false,
+				RequestPath:         "user",
+				RawFields:           []string(nil),
+				MagicFields:         []string(nil),
+				RequestHeaders:      []string{"accept: text/plain"},
+				ShowResponseHeaders: true,
+			},
+			wantsErr: false,
+		},
+		{
+			name:     "no arguments",
+			cli:      "",
+			wantsErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd := NewCmdApi(f, func(o *ApiOptions) error {
+				assert.Equal(t, tt.wants.RequestMethod, o.RequestMethod)
+				assert.Equal(t, tt.wants.RequestMethodPassed, o.RequestMethodPassed)
+				assert.Equal(t, tt.wants.RequestPath, o.RequestPath)
+				assert.Equal(t, tt.wants.RawFields, o.RawFields)
+				assert.Equal(t, tt.wants.MagicFields, o.MagicFields)
+				assert.Equal(t, tt.wants.RequestHeaders, o.RequestHeaders)
+				assert.Equal(t, tt.wants.ShowResponseHeaders, o.ShowResponseHeaders)
+				return nil
+			})
+
+			argv, err := shlex.Split(tt.cli)
+			assert.NoError(t, err)
+			cmd.SetArgs(argv)
+			cmd.SetIn(&bytes.Buffer{})
+			cmd.SetOut(&bytes.Buffer{})
+			cmd.SetErr(&bytes.Buffer{})
+			_, err = cmd.ExecuteC()
+			if tt.wantsErr {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+		})
+	}
+}
+
+func Test_apiRun(t *testing.T) {
+	tests := []struct {
+		name         string
+		options      ApiOptions
+		httpResponse *http.Response
+		err          error
+		stdout       string
+		stderr       string
+	}{
+		{
+			name: "success",
+			httpResponse: &http.Response{
+				StatusCode: 200,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`bam!`)),
+			},
+			err:    nil,
+			stdout: `bam!`,
+			stderr: ``,
+		},
+		{
+			name: "show response headers",
+			options: ApiOptions{
+				ShowResponseHeaders: true,
+			},
+			httpResponse: &http.Response{
+				StatusCode: 200,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`body`)),
+				Header:     http.Header{"Content-Type": []string{"text/plain"}},
+			},
+			err:    nil,
+			stdout: "Content-Type: text/plain\r\n\r\nbody",
+			stderr: ``,
+		},
+		{
+			name: "success 204",
+			httpResponse: &http.Response{
+				StatusCode: 204,
+				Body:       nil,
+			},
+			err:    nil,
+			stdout: ``,
+			stderr: ``,
+		},
+		{
+			name: "failure",
+			httpResponse: &http.Response{
+				StatusCode: 502,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`gateway timeout`)),
+			},
+			err:    cmdutil.SilentError,
+			stdout: `gateway timeout`,
+			stderr: ``,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			io, _, stdout, stderr := iostreams.Test()
+
+			tt.options.IO = io
+			tt.options.HttpClient = func() (*http.Client, error) {
+				var tr roundTripper = func(req *http.Request) (*http.Response, error) {
+					resp := tt.httpResponse
+					resp.Request = req
+					return resp, nil
+				}
+				return &http.Client{Transport: tr}, nil
+			}
+
+			err := apiRun(&tt.options)
+			if err != tt.err {
+				t.Errorf("expected error %v, got %v", tt.err, err)
+			}
+
+			if stdout.String() != tt.stdout {
+				t.Errorf("expected output %q, got %q", tt.stdout, stdout.String())
+			}
+			if stderr.String() != tt.stderr {
+				t.Errorf("expected error output %q, got %q", tt.stderr, stderr.String())
+			}
+		})
+	}
+}
+
+func Test_parseFields(t *testing.T) {
+	io, stdin, _, _ := iostreams.Test()
+	fmt.Fprint(stdin, "pasted contents")
+
+	opts := ApiOptions{
+		IO: io,
+		RawFields: []string{
+			"robot=Hubot",
+			"destroyer=false",
+			"helper=true",
+			"location=@work",
+		},
+		MagicFields: []string{
+			"input=@-",
+			"enabled=true",
+			"victories=123",
+		},
+	}
+
+	params, err := parseFields(&opts)
+	if err != nil {
+		t.Fatalf("parseFields error: %v", err)
+	}
+
+	expect := map[string]interface{}{
+		"robot":     "Hubot",
+		"destroyer": "false",
+		"helper":    "true",
+		"location":  "@work",
+		"input":     []byte("pasted contents"),
+		"enabled":   true,
+		"victories": 123,
+	}
+	assert.Equal(t, expect, params)
+}
+
+func Test_magicFieldValue(t *testing.T) {
+	f, err := ioutil.TempFile("", "gh-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fmt.Fprint(f, "file contents")
+	f.Close()
+	t.Cleanup(func() { os.Remove(f.Name()) })
+
+	type args struct {
+		v     string
+		stdin io.ReadCloser
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    interface{}
+		wantErr bool
+	}{
+		{
+			name:    "string",
+			args:    args{v: "hello"},
+			want:    "hello",
+			wantErr: false,
+		},
+		{
+			name:    "bool true",
+			args:    args{v: "true"},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name:    "bool false",
+			args:    args{v: "false"},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name:    "null",
+			args:    args{v: "null"},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:    "file",
+			args:    args{v: "@" + f.Name()},
+			want:    []byte("file contents"),
+			wantErr: false,
+		},
+		{
+			name:    "file error",
+			args:    args{v: "@"},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := magicFieldValue(tt.args.v, tt.args.stdin)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("magicFieldValue() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if tt.wantErr {
+				return
+			}
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

pkg/cmd/api/http.go

@@ -0,0 +1,109 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+func httpRequest(client *http.Client, method string, p string, params interface{}, headers []string) (*http.Response, error) {
+	// TODO: GHE support
+	url := "https://api.github.com/" + p
+	var body io.Reader
+	var bodyIsJSON bool
+	isGraphQL := p == "graphql"
+
+	switch pp := params.(type) {
+	case map[string]interface{}:
+		if strings.EqualFold(method, "GET") {
+			url = addQuery(url, pp)
+		} else {
+			if isGraphQL {
+				pp = groupGraphQLVariables(pp)
+			}
+			b, err := json.Marshal(pp)
+			if err != nil {
+				return nil, fmt.Errorf("error serializing parameters: %w", err)
+			}
+			body = bytes.NewBuffer(b)
+			bodyIsJSON = true
+		}
+	case io.Reader:
+		body = pp
+	case nil:
+		body = nil
+	default:
+		return nil, fmt.Errorf("unrecognized parameters type: %v", params)
+	}
+
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, h := range headers {
+		idx := strings.IndexRune(h, ':')
+		if idx == -1 {
+			return nil, fmt.Errorf("header %q requires a value separated by ':'", h)
+		}
+		req.Header.Add(h[0:idx], strings.TrimSpace(h[idx+1:]))
+	}
+	if bodyIsJSON && req.Header.Get("Content-Type") == "" {
+		req.Header.Set("Content-Type", "application/json; charset=utf-8")
+	}
+
+	return client.Do(req)
+}
+
+func groupGraphQLVariables(params map[string]interface{}) map[string]interface{} {
+	topLevel := make(map[string]interface{})
+	variables := make(map[string]interface{})
+
+	for key, val := range params {
+		switch key {
+		case "query":
+			topLevel[key] = val
+		default:
+			variables[key] = val
+		}
+	}
+
+	if len(variables) > 0 {
+		topLevel["variables"] = variables
+	}
+	return topLevel
+}
+
+func addQuery(path string, params map[string]interface{}) string {
+	if len(params) == 0 {
+		return path
+	}
+
+	query := url.Values{}
+	for key, value := range params {
+		switch v := value.(type) {
+		case string:
+			query.Add(key, v)
+		case []byte:
+			query.Add(key, string(v))
+		case nil:
+			query.Add(key, "")
+		case int:
+			query.Add(key, fmt.Sprintf("%d", v))
+		case bool:
+			query.Add(key, fmt.Sprintf("%v", v))
+		default:
+			panic(fmt.Sprintf("unknown type %v", v))
+		}
+	}
+
+	sep := "?"
+	if strings.ContainsRune(path, '?') {
+		sep = "&"
+	}
+	return path + sep + query.Encode()
+}

pkg/cmd/api/http_test.go

@@ -0,0 +1,306 @@
+package api
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_groupGraphQLVariables(t *testing.T) {
+	tests := []struct {
+		name string
+		args map[string]interface{}
+		want map[string]interface{}
+	}{
+		{
+			name: "empty",
+			args: map[string]interface{}{},
+			want: map[string]interface{}{},
+		},
+		{
+			name: "query only",
+			args: map[string]interface{}{
+				"query": "QUERY",
+			},
+			want: map[string]interface{}{
+				"query": "QUERY",
+			},
+		},
+		{
+			name: "variables only",
+			args: map[string]interface{}{
+				"name": "hubot",
+			},
+			want: map[string]interface{}{
+				"variables": map[string]interface{}{
+					"name": "hubot",
+				},
+			},
+		},
+		{
+			name: "query + variables",
+			args: map[string]interface{}{
+				"query": "QUERY",
+				"name":  "hubot",
+				"power": 9001,
+			},
+			want: map[string]interface{}{
+				"query": "QUERY",
+				"variables": map[string]interface{}{
+					"name":  "hubot",
+					"power": 9001,
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := groupGraphQLVariables(tt.args)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+type roundTripper func(*http.Request) (*http.Response, error)
+
+func (f roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req)
+}
+
+func Test_httpRequest(t *testing.T) {
+	var tr roundTripper = func(req *http.Request) (*http.Response, error) {
+		return &http.Response{Request: req}, nil
+	}
+	httpClient := http.Client{Transport: tr}
+
+	type args struct {
+		client  *http.Client
+		method  string
+		p       string
+		params  interface{}
+		headers []string
+	}
+	type expects struct {
+		method  string
+		u       string
+		body    string
+		headers string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    expects
+		wantErr bool
+	}{
+		{
+			name: "simple GET",
+			args: args{
+				client:  &httpClient,
+				method:  "GET",
+				p:       "repos/octocat/spoon-knife",
+				params:  nil,
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "GET",
+				u:       "https://api.github.com/repos/octocat/spoon-knife",
+				body:    "",
+				headers: "",
+			},
+		},
+		{
+			name: "GET with params",
+			args: args{
+				client: &httpClient,
+				method: "GET",
+				p:      "repos/octocat/spoon-knife",
+				params: map[string]interface{}{
+					"a": "b",
+				},
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "GET",
+				u:       "https://api.github.com/repos/octocat/spoon-knife?a=b",
+				body:    "",
+				headers: "",
+			},
+		},
+		{
+			name: "POST with params",
+			args: args{
+				client: &httpClient,
+				method: "POST",
+				p:      "repos",
+				params: map[string]interface{}{
+					"a": "b",
+				},
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "POST",
+				u:       "https://api.github.com/repos",
+				body:    `{"a":"b"}`,
+				headers: "Content-Type: application/json; charset=utf-8\r\n",
+			},
+		},
+		{
+			name: "POST GraphQL",
+			args: args{
+				client: &httpClient,
+				method: "POST",
+				p:      "graphql",
+				params: map[string]interface{}{
+					"a": "b",
+				},
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "POST",
+				u:       "https://api.github.com/graphql",
+				body:    `{"variables":{"a":"b"}}`,
+				headers: "Content-Type: application/json; charset=utf-8\r\n",
+			},
+		},
+		{
+			name: "POST with body and type",
+			args: args{
+				client: &httpClient,
+				method: "POST",
+				p:      "repos",
+				params: bytes.NewBufferString("CUSTOM"),
+				headers: []string{
+					"content-type: text/plain",
+					"accept: application/json",
+				},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "POST",
+				u:       "https://api.github.com/repos",
+				body:    `CUSTOM`,
+				headers: "Accept: application/json\r\nContent-Type: text/plain\r\n",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := httpRequest(tt.args.client, tt.args.method, tt.args.p, tt.args.params, tt.args.headers)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("httpRequest() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			req := got.Request
+			if req.Method != tt.want.method {
+				t.Errorf("Request.Method = %q, want %q", req.Method, tt.want.method)
+			}
+			if req.URL.String() != tt.want.u {
+				t.Errorf("Request.URL = %q, want %q", req.URL.String(), tt.want.u)
+			}
+
+			if tt.want.body != "" {
+				bb, err := ioutil.ReadAll(req.Body)
+				if err != nil {
+					t.Errorf("Request.Body ReadAll error = %v", err)
+					return
+				}
+				if string(bb) != tt.want.body {
+					t.Errorf("Request.Body = %q, want %q", string(bb), tt.want.body)
+				}
+			}
+
+			h := bytes.Buffer{}
+			err = req.Header.WriteSubset(&h, map[string]bool{})
+			if err != nil {
+				t.Errorf("Request.Header WriteSubset error = %v", err)
+				return
+			}
+			if h.String() != tt.want.headers {
+				t.Errorf("Request.Header = %q, want %q", h.String(), tt.want.headers)
+			}
+		})
+	}
+}
+
+func Test_addQuery(t *testing.T) {
+	type args struct {
+		path   string
+		params map[string]interface{}
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "string",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": "hello"},
+			},
+			want: "?a=hello",
+		},
+		{
+			name: "append",
+			args: args{
+				path:   "path",
+				params: map[string]interface{}{"a": "b"},
+			},
+			want: "path?a=b",
+		},
+		{
+			name: "append query",
+			args: args{
+				path:   "path?foo=bar",
+				params: map[string]interface{}{"a": "b"},
+			},
+			want: "path?foo=bar&a=b",
+		},
+		{
+			name: "[]byte",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": []byte("hello")},
+			},
+			want: "?a=hello",
+		},
+		{
+			name: "int",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": 123},
+			},
+			want: "?a=123",
+		},
+		{
+			name: "nil",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": nil},
+			},
+			want: "?a=",
+		},
+		{
+			name: "bool",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": true, "b": false},
+			},
+			want: "?a=true&b=false",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := addQuery(tt.args.path, tt.args.params); got != tt.want {
+				t.Errorf("addQuery() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/cmdutil/errors.go

@@ -0,0 +1,19 @@
+package cmdutil
+
+import "errors"
+
+// FlagError is the kind of error raised in flag processing
+type FlagError struct {
+	Err error
+}
+
+func (fe FlagError) Error() string {
+	return fe.Err.Error()
+}
+
+func (fe FlagError) Unwrap() error {
+	return fe.Err
+}
+
+// SilentError is an error that triggers exit code 1 without any error messaging
+var SilentError = errors.New("SilentError")

pkg/cmdutil/factory.go

@@ -0,0 +1,12 @@
+package cmdutil
+
+import (
+	"net/http"
+
+	"github.com/cli/cli/pkg/iostreams"
+)
+
+type Factory struct {
+	IOStreams  *iostreams.IOStreams
+	HttpClient func() (*http.Client, error)
+}

pkg/iostreams/iostreams.go

@@ -0,0 +1,33 @@
+package iostreams
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"os"
+)
+
+type IOStreams struct {
+	In     io.ReadCloser
+	Out    io.Writer
+	ErrOut io.Writer
+}
+
+func System() *IOStreams {
+	return &IOStreams{
+		In:     os.Stdin,
+		Out:    os.Stdout,
+		ErrOut: os.Stderr,
+	}
+}
+
+func Test() (*IOStreams, *bytes.Buffer, *bytes.Buffer, *bytes.Buffer) {
+	in := &bytes.Buffer{}
+	out := &bytes.Buffer{}
+	errOut := &bytes.Buffer{}
+	return &IOStreams{
+		In:     ioutil.NopCloser(in),
+		Out:    out,
+		ErrOut: errOut,
+	}, in, out, errOut
+}

test/fixtures/gistCreate.json

@@ -0,0 +1 @@
+{}

test/helpers.go

@@ -68,6 +68,7 @@ func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {
 		if call >= len(cs.Stubs) {
 			panic(fmt.Sprintf("more execs than stubs. most recent call: %v", cmd))
 		}
+		// fmt.Printf("Called stub for `%v`\n", cmd) // Helpful for debugging
 		return cs.Stubs[call]
 	}
 }

wix.json

@@ -27,6 +27,6 @@
     "description": "Use GitHub from the CLI",
     "project-url": "https://github.com/cli/cli",
     "tags": "github cli git",
-    "license-url": "https://github.com/cli/cli/blob/master/LICENSE"
+    "license-url": "https://github.com/cli/cli/blob/trunk/LICENSE"
   }
 }