Merge branch 'trunk' into feature/ssh-signing-key

pkg/cmd/codespace/jupyter.go

@@ -45,17 +45,23 @@ func (a *App) Jupyter(ctx context.Context, selector *CodespaceSelector) (err err
 	}
 	defer safeClose(session, &err)
 
-	serverPort, serverUrl := 0, ""
+	var (
+		invoker    rpc.Invoker
+		serverPort int
+		serverUrl  string
+	)
 	err = a.RunWithProgress("Starting JupyterLab on codespace", func() (err error) {
-		invoker, err := rpc.CreateInvoker(ctx, session)
+		invoker, err = rpc.CreateInvoker(ctx, session)
 		if err != nil {
 			return
 		}
-		defer safeClose(invoker, &err)
 
 		serverPort, serverUrl, err = invoker.StartJupyterServer(ctx)
 		return
 	})
+	if invoker != nil {
+		defer safeClose(invoker, &err)
+	}
 	if err != nil {
 		return err
 	}

pkg/cmd/codespace/ssh.go

@@ -171,17 +171,23 @@ func (a *App) SSH(ctx context.Context, sshArgs []string, opts sshOptions) (err e
 	}
 	defer safeClose(session, &err)
 
-	remoteSSHServerPort, sshUser := 0, ""
+	var (
+		invoker             rpc.Invoker
+		remoteSSHServerPort int
+		sshUser             string
+	)
 	err = a.RunWithProgress("Fetching SSH Details", func() (err error) {
-		invoker, err := rpc.CreateInvoker(ctx, session)
+		invoker, err = rpc.CreateInvoker(ctx, session)
 		if err != nil {
 			return
 		}
-		defer safeClose(invoker, &err)
 
 		remoteSSHServerPort, sshUser, err = invoker.StartSSHServerWithOptions(ctx, startSSHOptions)
 		return
 	})
+	if invoker != nil {
+		defer safeClose(invoker, &err)
+	}
 	if err != nil {
 		return fmt.Errorf("error getting ssh server details: %w", err)
 	}

pkg/cmd/org/list/http.go

@@ -0,0 +1,98 @@
+package list
+
+import (
+	"net/http"
+
+	"github.com/cli/cli/v2/api"
+)
+
+type OrganizationList struct {
+	Organizations []Organization
+	TotalCount    int
+	User          string
+}
+
+type Organization struct {
+	Login string
+}
+
+func listOrgs(httpClient *http.Client, hostname string, limit int) (*OrganizationList, error) {
+	type response struct {
+		User struct {
+			Login         string
+			Organizations struct {
+				TotalCount int
+				Nodes      []Organization
+				PageInfo   struct {
+					HasNextPage bool
+					EndCursor   string
+				}
+			} `graphql:"organizations(first: $limit, after: $endCursor)"`
+		}
+	}
+
+	query := `query OrganizationList($user: String!, $limit: Int!, $endCursor: String) {
+		user(login: $user) {
+			login
+			organizations(first: $limit, after: $endCursor) {
+				totalCount
+				nodes {
+					login
+				}
+				pageInfo {
+					hasNextPage
+					endCursor
+				}
+			}
+		}
+	}`
+
+	client := api.NewClientFromHTTP(httpClient)
+
+	user, err := api.CurrentLoginName(client, hostname)
+	if err != nil {
+		return nil, err
+	}
+
+	listResult := OrganizationList{}
+	listResult.User = user
+	pageLimit := min(limit, 100)
+	variables := map[string]interface{}{
+		"user": user,
+	}
+
+loop:
+	for {
+		variables["limit"] = pageLimit
+		var data response
+		err := client.GraphQL(hostname, query, variables, &data)
+		if err != nil {
+			return nil, err
+		}
+
+		listResult.TotalCount = data.User.Organizations.TotalCount
+
+		for _, org := range data.User.Organizations.Nodes {
+			listResult.Organizations = append(listResult.Organizations, org)
+			if len(listResult.Organizations) == limit {
+				break loop
+			}
+		}
+
+		if data.User.Organizations.PageInfo.HasNextPage {
+			variables["endCursor"] = data.User.Organizations.PageInfo.EndCursor
+			pageLimit = min(pageLimit, limit-len(listResult.Organizations))
+		} else {
+			break
+		}
+	}
+
+	return &listResult, nil
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

pkg/cmd/org/list/http_test.go

@@ -0,0 +1,83 @@
+package list
+
+import (
+	"net/http"
+	"reflect"
+	"testing"
+
+	"github.com/cli/cli/v2/pkg/httpmock"
+)
+
+func Test_listOrgs(t *testing.T) {
+	type args struct {
+		limit int
+	}
+
+	tests := []struct {
+		name     string
+		args     args
+		httpStub func(*testing.T, *httpmock.Registry)
+		wantErr  bool
+	}{
+		{
+			name: "default",
+			args: args{
+				limit: 30,
+			},
+			httpStub: func(t *testing.T, reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.GraphQL(`query UserCurrent\b`),
+					httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
+				reg.Register(
+					httpmock.GraphQL(`query OrganizationList\b`),
+					httpmock.GraphQLQuery(`{"data":{}}`, func(query string, vars map[string]interface{}) {
+						want := map[string]interface{}{
+							"user":  "octocat",
+							"limit": float64(30),
+						}
+						if !reflect.DeepEqual(vars, want) {
+							t.Errorf("got GraphQL variables %#v, want %#v", vars, want)
+						}
+					}))
+			},
+		},
+		{
+			name: "with limit",
+			args: args{
+				limit: 1,
+			},
+			httpStub: func(t *testing.T, r *httpmock.Registry) {
+				r.Register(
+					httpmock.GraphQL(`query UserCurrent\b`),
+					httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
+				r.Register(
+					httpmock.GraphQL(`query OrganizationList\b`),
+					httpmock.GraphQLQuery(`{"data":{}}`, func(query string, vars map[string]interface{}) {
+						want := map[string]interface{}{
+							"user":  "octocat",
+							"limit": float64(1),
+						}
+						if !reflect.DeepEqual(vars, want) {
+							t.Errorf("got GraphQL variables %#v, want %#v", vars, want)
+						}
+					}))
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reg := &httpmock.Registry{}
+			if tt.httpStub != nil {
+				tt.httpStub(t, reg)
+			}
+			httpClient := &http.Client{Transport: reg}
+
+			_, err := listOrgs(httpClient, "octocat", tt.args.limit)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("listOrgs() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}

pkg/cmd/org/list/list.go

@@ -0,0 +1,108 @@
+package list
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/MakeNowJust/heredoc"
+	"github.com/cli/cli/v2/internal/config"
+	"github.com/cli/cli/v2/internal/tableprinter"
+	"github.com/cli/cli/v2/internal/text"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/spf13/cobra"
+)
+
+type ListOptions struct {
+	IO         *iostreams.IOStreams
+	Config     func() (config.Config, error)
+	HttpClient func() (*http.Client, error)
+
+	Limit int
+}
+
+func NewCmdList(f *cmdutil.Factory, runF func(*ListOptions) error) *cobra.Command {
+	opts := ListOptions{
+		IO:         f.IOStreams,
+		Config:     f.Config,
+		HttpClient: f.HttpClient,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "list",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "List organizations for the authenticated user.",
+		Example: heredoc.Doc(`
+			# List the first 30 organizations
+			$ gh org list
+
+			# List more organizations
+			$ gh org list --limit 100
+		`),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if opts.Limit < 1 {
+				return cmdutil.FlagErrorf("invalid limit: %v", opts.Limit)
+			}
+
+			if runF != nil {
+				return runF(&opts)
+			}
+			return listRun(&opts)
+		},
+	}
+
+	cmd.Flags().IntVarP(&opts.Limit, "limit", "L", 30, "Maximum number of organizations to list")
+
+	return cmd
+}
+
+func listRun(opts *ListOptions) error {
+	httpClient, err := opts.HttpClient()
+	if err != nil {
+		return err
+	}
+
+	cfg, err := opts.Config()
+	if err != nil {
+		return err
+	}
+
+	host, _ := cfg.Authentication().DefaultHost()
+
+	listResult, err := listOrgs(httpClient, host, opts.Limit)
+	if err != nil {
+		return err
+	}
+
+	if err := opts.IO.StartPager(); err != nil {
+		fmt.Fprintf(opts.IO.ErrOut, "error starting pager: %v\n", err)
+	}
+	defer opts.IO.StopPager()
+
+	if opts.IO.IsStdoutTTY() {
+		header := listHeader(listResult.User, len(listResult.Organizations), listResult.TotalCount)
+		fmt.Fprintf(opts.IO.Out, "\n%s\n\n", header)
+	}
+
+	table := tableprinter.New(opts.IO)
+
+	for _, org := range listResult.Organizations {
+		table.AddField(org.Login)
+		table.EndRow()
+	}
+
+	err = table.Render()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func listHeader(user string, resultCount, totalCount int) string {
+	if totalCount == 0 {
+		return "There are no organizations associated with @" + user
+	}
+
+	return fmt.Sprintf("Showing %d of %s", resultCount, text.Pluralize(totalCount, "organization"))
+}

pkg/cmd/org/list/list_test.go

@@ -0,0 +1,237 @@
+package list
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"github.com/MakeNowJust/heredoc"
+	"github.com/cli/cli/v2/internal/config"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/httpmock"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/google/shlex"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewCmdList(t *testing.T) {
+	tests := []struct {
+		name     string
+		cli      string
+		wants    ListOptions
+		wantsErr string
+	}{
+		{
+			name: "no arguments",
+			cli:  "",
+			wants: ListOptions{
+				Limit: 30,
+			},
+		},
+		{
+			name: "with limit",
+			cli:  "-L 101",
+			wants: ListOptions{
+				Limit: 101,
+			},
+		},
+		{
+			name:     "too many arguments",
+			cli:      "123 456",
+			wantsErr: "accepts at most 1 arg(s), received 2",
+		},
+		{
+			name:     "invalid limit",
+			cli:      "-L 0",
+			wantsErr: "invalid limit: 0",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := &cmdutil.Factory{}
+
+			argv, err := shlex.Split(tt.cli)
+			assert.NoError(t, err)
+
+			var gotOpts *ListOptions
+			cmd := NewCmdList(f, func(opts *ListOptions) error {
+				gotOpts = opts
+				return nil
+			})
+			cmd.SetArgs(argv)
+			cmd.SetIn(&bytes.Buffer{})
+			cmd.SetOut(&bytes.Buffer{})
+			cmd.SetErr(&bytes.Buffer{})
+
+			_, err = cmd.ExecuteC()
+			if tt.wantsErr != "" {
+				assert.EqualError(t, err, tt.wantsErr)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.wants.Limit, gotOpts.Limit)
+		})
+	}
+}
+
+func TestListRun(t *testing.T) {
+	tests := []struct {
+		name    string
+		opts    ListOptions
+		isTTY   bool
+		wantOut string
+	}{
+		{
+			name: "no organizations found",
+			opts: ListOptions{HttpClient: func() (*http.Client, error) {
+				r := &httpmock.Registry{}
+
+				r.Register(
+					httpmock.GraphQL(`query UserCurrent\b`),
+					httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
+
+				r.Register(
+					httpmock.GraphQL(`query OrganizationList\b`),
+					httpmock.StringResponse(`
+						{ "data": { "user": {	
+							"organizations": { "nodes": [], "totalCount": 0 }
+						} } }`,
+					),
+				)
+
+				return &http.Client{Transport: r}, nil
+			}},
+			isTTY: true,
+			wantOut: heredoc.Doc(`
+
+There are no organizations associated with @octocat
+
+`),
+		},
+		{
+			name: "default behavior",
+			opts: ListOptions{HttpClient: func() (*http.Client, error) {
+				r := &httpmock.Registry{}
+
+				r.Register(
+					httpmock.GraphQL(`query UserCurrent\b`),
+					httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
+
+				r.Register(
+					httpmock.GraphQL(`query OrganizationList\b`),
+					httpmock.StringResponse(`
+						{ "data": { "user": {	"organizations": {
+							"totalCount": 2,
+							"nodes": [
+							{
+								"login": "github"
+							},
+							{
+								"login": "cli"
+							}
+						]	}	} } }`,
+					),
+				)
+
+				return &http.Client{Transport: r}, nil
+			}},
+			isTTY: true,
+			wantOut: heredoc.Doc(`
+
+Showing 2 of 2 organizations
+
+github
+cli
+`),
+		},
+		{
+			name: "with limit",
+			opts: ListOptions{Limit: 1, HttpClient: func() (*http.Client, error) {
+				r := &httpmock.Registry{}
+
+				r.Register(
+					httpmock.GraphQL(`query UserCurrent\b`),
+					httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
+
+				r.Register(
+					httpmock.GraphQL(`query OrganizationList\b`),
+					httpmock.StringResponse(`
+						{ "data": { "user": {	"organizations": {
+							"totalCount": 2,
+							"nodes": [
+							{
+								"login": "github"
+							},
+							{
+								"login": "cli"
+							}
+						]	}	} } }`,
+					),
+				)
+
+				return &http.Client{Transport: r}, nil
+			}},
+			isTTY: true,
+			wantOut: heredoc.Doc(`
+
+Showing 1 of 2 organizations
+
+github
+`),
+		},
+		{
+			name: "nontty output",
+			opts: ListOptions{HttpClient: func() (*http.Client, error) {
+				r := &httpmock.Registry{}
+
+				r.Register(
+					httpmock.GraphQL(`query UserCurrent\b`),
+					httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
+
+				r.Register(
+					httpmock.GraphQL(`query OrganizationList\b`),
+					httpmock.StringResponse(`
+						{ "data": { "user": {	"organizations": {
+							"totalCount": 2,
+							"nodes": [
+							{
+								"login": "github"
+							},
+							{
+								"login": "cli"
+							}
+						]	}	} } }`,
+					),
+				)
+				return &http.Client{Transport: r}, nil
+			}},
+			isTTY: false,
+			wantOut: heredoc.Doc(`
+github
+cli
+`),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ios, _, stdout, _ := iostreams.Test()
+
+			ios.SetStdoutTTY(tt.isTTY)
+			ios.SetStdinTTY(tt.isTTY)
+			ios.SetStderrTTY(tt.isTTY)
+
+			tt.opts.IO = ios
+			tt.opts.Config = func() (config.Config, error) {
+				return config.NewBlankConfig(), nil
+			}
+
+			err := listRun(&tt.opts)
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.wantOut, stdout.String())
+		})
+	}
+}

pkg/cmd/org/org.go

@@ -0,0 +1,24 @@
+package org
+
+import (
+	"github.com/MakeNowJust/heredoc"
+	orgListCmd "github.com/cli/cli/v2/pkg/cmd/org/list"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/spf13/cobra"
+)
+
+func NewCmdOrg(f *cmdutil.Factory) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "org <command>",
+		Short: "Manage organizations",
+		Long:  "Work with Github organizations.",
+		Example: heredoc.Doc(`
+			$ gh org list
+		`),
+		GroupID: "core",
+	}
+
+	cmdutil.AddGroup(cmd, "General commands", orgListCmd.NewCmdList(f, nil))
+
+	return cmd
+}

pkg/cmd/root/root.go

@@ -22,6 +22,7 @@ import (
 	gpgKeyCmd "github.com/cli/cli/v2/pkg/cmd/gpg-key"
 	issueCmd "github.com/cli/cli/v2/pkg/cmd/issue"
 	labelCmd "github.com/cli/cli/v2/pkg/cmd/label"
+	orgCmd "github.com/cli/cli/v2/pkg/cmd/org"
 	prCmd "github.com/cli/cli/v2/pkg/cmd/pr"
 	releaseCmd "github.com/cli/cli/v2/pkg/cmd/release"
 	repoCmd "github.com/cli/cli/v2/pkg/cmd/repo"
@@ -115,6 +116,7 @@ func NewCmdRoot(f *cmdutil.Factory, version, buildDate string) *cobra.Command {
 
 	cmd.AddCommand(browseCmd.NewCmdBrowse(&repoResolvingCmdFactory, nil))
 	cmd.AddCommand(prCmd.NewCmdPR(&repoResolvingCmdFactory))
+	cmd.AddCommand(orgCmd.NewCmdOrg(&repoResolvingCmdFactory))
 	cmd.AddCommand(issueCmd.NewCmdIssue(&repoResolvingCmdFactory))
 	cmd.AddCommand(releaseCmd.NewCmdRelease(&repoResolvingCmdFactory))
 	cmd.AddCommand(repoCmd.NewCmdRepo(&repoResolvingCmdFactory))

pkg/cmd/search/commits/commits.go

@@ -112,7 +112,7 @@ func NewCmdCommits(f *cmdutil.Factory, runF func(*CommitsOptions) error) *cobra.
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Hash, "hash", "", "Filter by commit hash")
 	cmdutil.NilBoolFlag(cmd, &opts.Query.Qualifiers.Merge, "merge", "", "Filter on merge commits")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Parent, "parent", "", "Filter by parent hash")
-	cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.Repo, "repo", nil, "Filter on repository")
+	cmd.Flags().StringSliceVarP(&opts.Query.Qualifiers.Repo, "repo", "R", nil, "Filter on repository")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Tree, "tree", "", "Filter by tree hash")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.User, "owner", "", "Filter on repository owner")
 	cmdutil.StringSliceEnumFlag(cmd, &opts.Query.Qualifiers.Is, "visibility", "", nil, []string{"public", "private", "internal"}, "Filter based on repository visibility")

pkg/cmd/search/issues/issues.go

@@ -156,7 +156,7 @@ func NewCmdIssues(f *cmdutil.Factory, runF func(*shared.IssuesOptions) error) *c
 	cmd.Flags().BoolVar(&noProject, "no-project", false, "Filter on missing project")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Project, "project", "", "Filter on project board `number`")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Reactions, "reactions", "", "Filter on `number` of reactions")
-	cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.Repo, "repo", nil, "Filter on repository")
+	cmd.Flags().StringSliceVarP(&opts.Query.Qualifiers.Repo, "repo", "R", nil, "Filter on repository")
 	cmdutil.StringEnumFlag(cmd, &opts.Query.Qualifiers.State, "state", "", "", []string{"open", "closed"}, "Filter based on state")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Team, "team-mentions", "", "Filter based on team mentions")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Updated, "updated", "", "Filter on last updated at `date`")

pkg/cmd/search/prs/prs.go

@@ -167,7 +167,7 @@ func NewCmdPrs(f *cmdutil.Factory, runF func(*shared.IssuesOptions) error) *cobr
 	cmd.Flags().BoolVar(&noProject, "no-project", false, "Filter on missing project")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Project, "project", "", "Filter on project board `number`")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Reactions, "reactions", "", "Filter on `number` of reactions")
-	cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.Repo, "repo", nil, "Filter on repository")
+	cmd.Flags().StringSliceVarP(&opts.Query.Qualifiers.Repo, "repo", "R", nil, "Filter on repository")
 	cmdutil.StringEnumFlag(cmd, &opts.Query.Qualifiers.State, "state", "", "", []string{"open", "closed"}, "Filter based on state")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Team, "team-mentions", "", "Filter based on team mentions")
 	cmd.Flags().StringVar(&opts.Query.Qualifiers.Updated, "updated", "", "Filter on last updated at `date`")