Merge pull request #6 from hellofresh/improved-repo-creation

Improved repo creation

Author: italolelis

.travis.yml

@@ -11,6 +11,7 @@ script:
 - make test
 
 before_deploy:
+- export VERSION = ${TRAVIS_BRANCH}
 - make
 
 deploy:

README.md

@@ -34,6 +34,7 @@ github-cli [command] [--flags]
 | `github-cli repo create [--flags]` | Creates a new github repository      |
 | `github-cli test create [--flags]` | Creates a new hellofresh hiring test |
 | `github-cli unseat [--flags]`      | Removes external collaborators from repositories |
+| `github-cli version`               | Prints the version information |
 
 ## Contributing
 

cmd/create_repo.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"github.com/fatih/color"
+	"github.com/google/go-github/github"
 	"github.com/hellofresh/github-cli/pkg/pullapprove"
 	"github.com/hellofresh/github-cli/pkg/repo"
 	"github.com/pkg/errors"
@@ -22,6 +23,9 @@ type (
 		HasDefaultLabels     bool
 		HasWebhooks          bool
 		HasBranchProtections bool
+		HasIssues            bool
+		HasWiki              bool
+		HasPages             bool
 	}
 )
 
@@ -34,28 +38,32 @@ func init() {
 	createRepoCmd.Flags().StringVarP(&createRepoFlags.Description, "description", "d", "", "The repository's description")
 	createRepoCmd.Flags().StringVarP(&createRepoFlags.Org, "organization", "o", "", "Github's organization")
 	createRepoCmd.Flags().BoolVar(&createRepoFlags.Private, "private", true, "Is the repository private?")
-	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasPullApprove, "add-pullapprove", true, "Enables pull approve")
-	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasTeams, "add-teams", true, "Enable teams")
-	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasLabels, "add-labels", true, "Enable labels")
-	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasDefaultLabels, "add-default-labels", true, "Removes the default github labels")
-	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasWebhooks, "add-webhooks", true, "Enables webhooks configurations")
-	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasBranchProtections, "add-branch-protections", true, "Enables branch protections")
+
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasIssues, "has-issues", true, "Enables issue pages")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasWiki, "has-wiki", false, "Enables wiki pages?")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasPages, "has-pages", false, "Enables github pages?")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasPullApprove, "has-pullapprove", true, "Enables pull approve")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasTeams, "has-teams", true, "Enable teams")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasLabels, "has-labels", true, "Enable labels")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasDefaultLabels, "rm-default-labels", true, "Removes the default github labels")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasWebhooks, "has-webhooks", false, "Enables webhooks configurations")
+	createRepoCmd.Flags().BoolVar(&createRepoFlags.HasBranchProtections, "has-branch-protections", true, "Enables branch protections")
 }
 
 // RunCreateRepo runs the command to create a new repository
 func RunCreateRepo(cmd *cobra.Command, args []string) {
 	var err error
+	var org string
 
 	name := createRepoFlags.Name
 	checkEmpty(name, "Please provide a repository name")
 
 	description := createRepoFlags.Description
 
-	org := createRepoFlags.Org
+	org = createRepoFlags.Org
 	if org == "" {
 		org = globalConfig.Github.Organization
 	}
-	checkEmpty(org, "Please provide an organization")
 
 	opts := &repo.GithubRepoOpts{
 		PullApprove: &repo.PullApproveOpts{
@@ -75,7 +83,15 @@ func RunCreateRepo(cmd *cobra.Command, args []string) {
 	creator := repo.NewGithub(githubClient)
 
 	color.White("Creating repository...")
-	err = creator.CreateRepo(name, description, org, createRepoFlags.Private)
+	ghRepo, err := creator.CreateRepo(org, &github.Repository{
+		Name:        github.String(name),
+		Description: github.String(description),
+		Private:     github.Bool(createRepoFlags.Private),
+		HasIssues:   github.Bool(createRepoFlags.HasIssues),
+		HasWiki:     github.Bool(createRepoFlags.HasWiki),
+		HasPages:    github.Bool(createRepoFlags.HasPages),
+		AutoInit:    github.Bool(true),
+	})
 	if errors.Cause(err) == repo.ErrRepositoryAlreadyExists {
 		color.Cyan("Repository already exists. Trying to normalize it...")
 	} else {
@@ -120,16 +136,19 @@ func RunCreateRepo(cmd *cobra.Command, args []string) {
 		if errors.Cause(err) == repo.ErrWebhookAlreadyExist {
 			color.Cyan("Webhook already exists, moving on...")
 		} else {
-			checkEmpty(errors.Wrap(err, "could add webhooks to repository"), "")
+			checkEmpty(errors.Wrap(err, "could not add webhooks to repository"), "")
 		}
 	}
 
 	if createRepoFlags.HasBranchProtections {
 		color.White("Adding branch protections to repository...")
 		err = creator.AddBranchProtections(name, org, opts.BranchProtections)
-		checkEmpty(errors.Wrap(err, "could add branch protections to repository"), "")
+		checkEmpty(errors.Wrap(err, "could not add branch protections to repository"), "")
 	}
 
-	color.Green("Repository created!")
-	checkEmpty(err, "Could not create github repo")
+	if ghRepo != nil {
+		color.Green("Repository created! \n Here is how to access it %s", *ghRepo.URL)
+	} else {
+		color.Green("Repository normalized!")
+	}
 }

cmd/create_test_repo.go

@@ -7,6 +7,7 @@ import (
 	"os/user"
 
 	"github.com/fatih/color"
+	"github.com/google/go-github/github"
 	"github.com/hellofresh/github-cli/pkg/config"
 	"github.com/hellofresh/github-cli/pkg/repo"
 	"github.com/pkg/errors"
@@ -56,7 +57,13 @@ func RunCreateTestRepo(cmd *cobra.Command, args []string) {
 	creator := repo.NewGithub(githubClient)
 
 	color.White("Creating repository...")
-	err = creator.CreateRepo(target, "", org, true)
+	_, err = creator.CreateRepo(org, &github.Repository{
+		Name:      github.String(target),
+		Private:   github.Bool(true),
+		HasIssues: github.Bool(false),
+		HasPages:  github.Bool(false),
+		HasWiki:   github.Bool(false),
+	})
 	checkEmpty(err, "Could not create github repo for candidate")
 
 	color.White("Adding collaborators to repository...")

cmd/delete_repo.go

@@ -0,0 +1,49 @@
+package cmd
+
+import (
+	"context"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+type (
+	// DeleteRepoFlags are the flags for the delete repo command
+	DeleteRepoFlags struct {
+		Org  string
+		Name string
+	}
+)
+
+var (
+	deleteRepoFlags DeleteRepoFlags
+
+	// Delete repo command
+	deleteRepoCmd = &cobra.Command{
+		Use:     "delete",
+		Aliases: []string{"del"},
+		Short:   "Deletes a github repository",
+		Run:     RunDeleteRepo,
+	}
+)
+
+func init() {
+	repoCmd.AddCommand(deleteRepoCmd)
+
+	deleteRepoCmd.Flags().StringVarP(&deleteRepoFlags.Name, "name", "n", "", "The name of the repository")
+	deleteRepoCmd.Flags().StringVarP(&deleteRepoFlags.Org, "organization", "o", "", "Github's organization")
+}
+
+// RunDeleteRepo runs the command to delete a repository
+func RunDeleteRepo(cmd *cobra.Command, args []string) {
+	org := deleteRepoFlags.Org
+	if org == "" {
+		org = globalConfig.Github.Organization
+	}
+	checkEmpty(org, "Please provide an organization")
+
+	_, err := githubClient.Repositories.Delete(context.Background(), org, deleteRepoFlags.Name)
+	checkEmpty(err, "Could not delete repository")
+
+	color.Green("Repository %s deleted!", deleteRepoFlags.Name)
+}

cmd/root.go

@@ -16,7 +16,6 @@ var (
 	cfgFile      string
 	globalConfig *config.Spec
 	githubClient *github.Client
-	version      string
 	token        string
 
 	// RootCmd is our main command
@@ -54,15 +53,6 @@ var (
 		Long:    `Creates a new hellofresh hiring test based on the rules defined on your .github.toml`,
 		Run:     RunCreateTestRepo,
 	}
-
-	// Unseat commands
-	unseatCmd = &cobra.Command{
-		Use:     "unseat",
-		Aliases: []string{"un"},
-		Short:   "Removes external collaborators from repositories",
-		Long:    `Removes external (people not in the organization) collaborators from repositories`,
-		Run:     RunUnseat,
-	}
 )
 
 func init() {
@@ -100,6 +90,7 @@ func init() {
 	RootCmd.PersistentFlags().StringVarP(&token, "token", "t", "", "config file (default is /etc/github/.github.toml)")
 
 	// Aggregates Root commands
+	RootCmd.AddCommand(versionCmd)
 	RootCmd.AddCommand(repoCmd)
 	RootCmd.AddCommand(testsCmd)
 	RootCmd.AddCommand(unseatCmd)

cmd/unseat.go

@@ -17,7 +17,18 @@ type (
 	}
 )
 
-var unseatFlags UnseatFlags
+var (
+	unseatFlags UnseatFlags
+
+	// Unseat commands
+	unseatCmd = &cobra.Command{
+		Use:     "unseat",
+		Aliases: []string{"un"},
+		Short:   "Removes external collaborators from repositories",
+		Long:    `Removes external (people not in the organization) collaborators from repositories`,
+		Run:     RunUnseat,
+	}
+)
 
 func init() {
 	unseatCmd.Flags().StringVarP(&unseatFlags.Org, "organization", "o", "", "Github's organization")

cmd/version.go

@@ -0,0 +1,22 @@
+package cmd
+
+import (
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var (
+	version = "0.0.0-dev"
+
+	versionCmd = &cobra.Command{
+		Use:     "version",
+		Short:   "Print the version information",
+		Aliases: []string{"v"},
+		Run:     RunVersion,
+	}
+)
+
+// RunVersion runs the command to print the current version
+func RunVersion(cmd *cobra.Command, args []string) {
+	color.Green("github-cli %s", version)
+}

pkg/repo/github.go

@@ -3,6 +3,7 @@ package repo
 import (
 	"context"
 	"net/http"
+	"strings"
 
 	"github.com/google/go-github/github"
 	"github.com/hellofresh/github-cli/pkg/config"
@@ -11,7 +12,7 @@ import (
 )
 
 type (
-	// GithubRepo contains all the hellofresh repository creation Optss for github
+	// GithubRepo contains all the hellofresh repository creation Opts for github
 	GithubRepo struct {
 		GithubClient *github.Client
 	}
@@ -44,12 +45,16 @@ var (
 	ctx = context.Background()
 	// ErrRepositoryAlreadyExists is used when the repository already exists
 	ErrRepositoryAlreadyExists = errors.New("github repository already exists")
+	// ErrRepositoryLimitExceeded is used when the repository limit is exceeded
+	ErrRepositoryLimitExceeded = errors.New("limit for private repos on this account is exceeded")
 	// ErrPullApproveFileAlreadyExists is used when the pull approve file already exists
 	ErrPullApproveFileAlreadyExists = errors.New("github pull approve file already exists")
 	// ErrLabelNotFound is used when a label is not found
 	ErrLabelNotFound = errors.New("github label does not exist")
 	// ErrWebhookAlreadyExist is used when a webhook already exists
 	ErrWebhookAlreadyExist = errors.New("github webhook already exists")
+	// ErrOrganizationNotFound is used when a webhook already exists
+	ErrOrganizationNotFound = errors.New("you must specify an organization to use this functionality")
 )
 
 // NewGithub creates a new instance of Client
@@ -60,22 +65,17 @@ func NewGithub(githubClient *github.Client) *GithubRepo {
 }
 
 // CreateRepo creates a github repository
-func (c *GithubRepo) CreateRepo(name string, description string, org string, private bool) error {
-	repo := &github.Repository{
-		Name:        github.String(name),
-		Description: github.String(description),
-		Private:     github.Bool(private),
-		HasIssues:   github.Bool(true),
-	}
-
-	_, _, err := c.GithubClient.Repositories.Create(ctx, org, repo)
+func (c *GithubRepo) CreateRepo(org string, repoOpts *github.Repository) (*github.Repository, error) {
+	ghRepo, _, err := c.GithubClient.Repositories.Create(ctx, org, repoOpts)
 	if githubError, ok := err.(*github.ErrorResponse); ok {
-		if githubError.Response.StatusCode == http.StatusUnprocessableEntity {
-			err = errors.Wrap(ErrRepositoryAlreadyExists, "repository already exists")
+		if strings.Contains(githubError.Message, "Visibility can't be private") {
+			err = ErrRepositoryLimitExceeded
+		} else if githubError.Response.StatusCode == http.StatusUnprocessableEntity {
+			err = ErrRepositoryAlreadyExists
 		}
 	}
 
-	return err
+	return ghRepo, err
 }
 
 // AddPullApprove adds a file to the github repository and calls pull approve API to register the new repo
@@ -93,7 +93,7 @@ func (c *GithubRepo) AddPullApprove(repo string, org string, opts *PullApproveOp
 	_, _, err = c.GithubClient.Repositories.CreateFile(ctx, org, repo, opts.Filename, fileOpt)
 	if githubError, ok := err.(*github.ErrorResponse); ok {
 		if githubError.Response.StatusCode == http.StatusUnprocessableEntity {
-			return errors.Wrap(ErrPullApproveFileAlreadyExists, "pull approve file already exists")
+			return ErrPullApproveFileAlreadyExists
 		}
 	} else {
 		return err
@@ -111,6 +111,10 @@ func (c *GithubRepo) AddPullApprove(repo string, org string, opts *PullApproveOp
 func (c *GithubRepo) AddTeamsToRepo(repo string, org string, teams []*config.Team) error {
 	var err error
 
+	if org == "" {
+		return ErrOrganizationNotFound
+	}
+
 	for _, team := range teams {
 		opt := &github.OrganizationAddTeamRepoOptions{
 			Permission: team.Permission,