Better desing

Author: italolelis

cmd/create_repo.go

@@ -1,87 +1,125 @@
 package cmd
 
 import (
-	"errors"
-	"os"
-
-	"github.com/deiwin/interact"
+	"github.com/fatih/color"
 	"github.com/hellofresh/github-cli/pkg/pullapprove"
 	"github.com/hellofresh/github-cli/pkg/repo"
-	log "github.com/sirupsen/logrus"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
 
 type (
 	// CreateRepoFlags are the flags for the create repository command
 	CreateRepoFlags struct {
+		Name                 string
+		Description          string
+		Org                  string
 		Private              bool
 		HasPullApprove       bool
 		HasTeams             bool
+		HasCollaborators     bool
 		HasLabels            bool
 		HasDefaultLabels     bool
 		HasWebhooks          bool
 		HasBranchProtections bool
 	}
 )
 
-var (
-	createRepoFlags CreateRepoFlags
-	checkNotEmpty   = func(input string) error {
-		// note that the inputs provided to these checks are already trimmed
-		if input == "" {
-			return errors.New("input should not be empty")
-		}
-		return nil
-	}
-)
+var createRepoFlags CreateRepoFlags
+
+func init() {
+	repoCmd.AddCommand(createRepoCmd)
+
+	createRepoCmd.Flags().StringVarP(&createRepoFlags.Name, "name", "n", "", "The name of the repository")
+	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")
+}
 
 // RunCreateRepo runs the command to create a new repository
 func RunCreateRepo(cmd *cobra.Command, args []string) {
 	var err error
 
-	actor := interact.NewActor(os.Stdin, os.Stdout)
-	repoName, err := actor.Prompt("Please enter the repository name", checkNotEmpty)
-	if err != nil {
-		log.Fatal(err)
-	}
+	name := createRepoFlags.Name
+	checkEmpty(name, "Please provide a repository name")
+
+	description := createRepoFlags.Description
 
-	org, err := actor.PromptOptional("Please enter the org name", globalConfig.Github.Organization, checkNotEmpty)
-	if err != nil {
-		log.Fatal(err)
+	org := createRepoFlags.Org
+	if org == "" {
+		org = globalConfig.Github.Organization
 	}
+	checkEmpty(org, "Please provide an organization")
 
-	opts := &repo.HelloFreshRepoOpt{
-		Name:    repoName,
-		Org:     org,
-		Private: createRepoFlags.Private,
-		PullApprove: &repo.PullApproveRule{
-			Enabled:             createRepoFlags.HasPullApprove,
+	opts := &repo.GithubRepoOpts{
+		PullApprove: &repo.PullApproveOpts{
 			Filename:            globalConfig.PullApprove.Filename,
 			ProtectedBranchName: globalConfig.PullApprove.ProtectedBranchName,
 			Client:              pullapprove.New(globalConfig.PullApprove.Token),
 		},
-		Labels: &repo.LabelsRule{
-			Enabled:             createRepoFlags.HasLabels,
+		Labels: &repo.LabelsOpts{
 			RemoveDefaultLabels: globalConfig.Github.RemoveDefaultLabels,
 			Labels:              globalConfig.Github.Labels,
 		},
-		Teams: &repo.TeamsRule{
-			Enabled: createRepoFlags.HasTeams,
-			Teams:   globalConfig.Github.Teams,
+		Teams: &repo.TeamsOpts{
+			Teams: globalConfig.Github.Teams,
 		},
-		Webhooks: &repo.WebhooksRule{
-			Enabled:  createRepoFlags.HasWebhooks,
+		Webhooks: &repo.WebhooksOpts{
 			Webhooks: globalConfig.Github.Webhooks,
 		},
-		BranchProtections: &repo.BranchProtectionsRule{
-			Enabled:     createRepoFlags.HasBranchProtections,
+		BranchProtections: &repo.BranchProtectionsOpts{
 			Protections: globalConfig.Github.Protections,
 		},
 	}
 
 	creator := repo.NewGithub(githubClient)
-	err = creator.Create(opts)
-	if err != nil {
-		log.WithError(err).Fatal("Could not create github repo")
+
+	color.White("Creating repository...")
+	err = creator.CreateRepo(name, description, org, createRepoFlags.Private)
+	checkEmpty(errors.Wrap(err, "could not create repository"), "")
+
+	if createRepoFlags.HasPullApprove {
+		color.White("Adding pull approve...")
+		err = creator.AddPullApprove(name, org, opts.PullApprove)
+		checkEmpty(errors.Wrap(err, "could not add pull approve"), "")
 	}
+
+	if createRepoFlags.HasTeams {
+		color.White("Adding teams to repository...")
+		err = creator.AddTeamsToRepo(name, org, opts.Teams)
+		checkEmpty(errors.Wrap(err, "could add teams to repository"), "")
+	}
+
+	if createRepoFlags.HasCollaborators {
+		color.White("Adding collaborators to repository...")
+		err = creator.AddCollaborators(name, org, opts.Collaborators)
+		checkEmpty(errors.Wrap(err, "could not add collaborators to repository"), "")
+	}
+
+	if createRepoFlags.HasLabels {
+		color.White("Adding labels to repository...")
+		err = creator.AddLabelsToRepo(name, org, opts.Labels)
+		checkEmpty(errors.Wrap(err, "could add labels to repository"), "")
+	}
+
+	if createRepoFlags.HasWebhooks {
+		color.White("Adding webhooks to repository...")
+		err = creator.AddWebhooksToRepo(name, org, opts.Webhooks)
+		checkEmpty(errors.Wrap(err, "could 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"), "")
+	}
+
+	color.Green("Repository created!")
+	checkEmpty(err, "Could not create github repo")
 }

cmd/create_test_repo.go

@@ -6,96 +6,101 @@ import (
 	"os"
 	"os/user"
 
-	"github.com/deiwin/interact"
+	"github.com/fatih/color"
 	"github.com/hellofresh/github-cli/pkg/config"
 	"github.com/hellofresh/github-cli/pkg/repo"
-	log "github.com/sirupsen/logrus"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing/transport/ssh"
 	"gopkg.in/src-d/go-git.v4/storage/memory"
 )
 
+type (
+	// CreateTestRepoFlags are the flags for the create a hiring test repository command
+	CreateTestRepoFlags struct {
+		Org       string
+		Candidate string
+		TestRepo  string
+	}
+)
+
+var createTestRepoFlags CreateTestRepoFlags
+
+func init() {
+	testsCmd.AddCommand(createTestCmd)
+
+	createTestCmd.Flags().StringVarP(&createTestRepoFlags.TestRepo, "test-repo", "r", "", "The name of the test repository to clone from")
+	createTestCmd.Flags().StringVarP(&createTestRepoFlags.Candidate, "username", "u", "", "The github's name of the candidate")
+	createTestCmd.Flags().StringVarP(&createTestRepoFlags.Org, "organization", "o", "", "Github's organization")
+}
+
 // RunCreateTestRepo runs the command to create a new hiring test repository
 func RunCreateTestRepo(cmd *cobra.Command, args []string) {
 	var err error
-	actor := interact.NewActor(os.Stdin, os.Stdout)
-	org, err := actor.PromptOptional("Please enter the org name", globalConfig.Github.Organization, checkNotEmpty)
-	if err != nil {
-		log.Fatal(err)
-	}
 
-	candidate, err := actor.Prompt("GitHub username of the candidate", checkNotEmpty)
-	if err != nil {
-		log.Fatal(err)
+	org := createTestRepoFlags.Org
+	if org == "" {
+		org = globalConfig.Github.Organization
 	}
+	checkEmpty(org, "Please provide an organization")
 
-	testRepo, err := actor.Prompt("Name of the repo with the test", checkNotEmpty)
-	if err != nil {
-		log.Fatal(err)
-	}
+	candidate := createTestRepoFlags.Candidate
+	checkEmpty(org, "Please provide a candidate username")
+
+	testRepo := createTestRepoFlags.TestRepo
+	checkEmpty(org, "Please provide a test repository")
 
 	target := fmt.Sprintf("%s-%s", candidate, testRepo)
-	opts := &repo.HelloFreshRepoOpt{
-		Name:    target,
-		Org:     org,
-		Private: true,
-		Collaborators: &repo.CollaboratorsRule{
-			Enabled: true,
-			Collaborators: []*config.Collaborator{
-				&config.Collaborator{
-					Username:   candidate,
-					Permission: "push",
-				},
+
+	creator := repo.NewGithub(githubClient)
+
+	color.White("Creating repository...")
+	err = creator.CreateRepo(target, "", org, true)
+	checkEmpty(err, "Could not create github repo for candidate")
+
+	color.White("Adding collaborators to repository...")
+	opts := &repo.CollaboratorsOpts{
+		Collaborators: []*config.Collaborator{
+			&config.Collaborator{
+				Username:   candidate,
+				Permission: "push",
 			},
 		},
 	}
-	creator := repo.NewGithub(githubClient)
-	err = creator.Create(opts)
-	if err != nil {
-		log.WithError(err).Fatal("Could not create github repo for candidate")
-	}
+	err = creator.AddCollaborators(target, org, opts)
+	checkEmpty(errors.Wrap(err, "could not add collaborators to repository"), "")
 
 	if globalConfig.PublicKeyPath == "" {
 		user, _ := user.Current()
 		globalConfig.PublicKeyPath = fmt.Sprintf("%s/.ssh/id_rsa", user.HomeDir)
 	}
 
 	sshKey, err := ioutil.ReadFile(globalConfig.PublicKeyPath)
-	if err != nil {
-		log.WithError(err).Fatal("Error reading public key")
-	}
+	checkEmpty(err, "Error reading public key")
 
 	authMethod, err := ssh.NewPublicKeys("git", []byte(sshKey), "")
-	if err != nil {
-		log.WithError(err).Fatal("Error when creating public keys")
-	}
+	checkEmpty(err, "Error when creating public keys")
 
-	log.Info("Cloning repository...")
+	color.White("Cloning repository...")
 	r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 		Auth:     authMethod,
 		Progress: os.Stdout,
 		URL:      fmt.Sprintf("git@github.com:%s/%s", org, testRepo),
 	})
-	if err != nil {
-		log.WithError(err).Fatal("Error cloning to repository")
-	}
+	checkEmpty(err, "Error cloning to repository")
 
-	log.Info("Changing remote...")
+	color.White("Changing remote...")
 	remote, err := r.Remote(git.DefaultRemoteName)
-	if err != nil {
-		log.WithError(err).Fatal("Error changing remote for repository")
-	}
+	checkEmpty(err, "Error changing remote for repository")
 
-	log.Info("Pushing changes...")
+	color.White("Pushing changes...")
 	remote.Config().URLs = []string{fmt.Sprintf("git@github.com:%s/%s", org, target)}
 	err = remote.Push(&git.PushOptions{
 		RemoteName: git.DefaultRemoteName,
 		Progress:   os.Stdout,
 	})
-	if err != nil {
-		log.WithError(err).Fatal("Error pushing to repository")
-	}
+	checkEmpty(err, "Error pushing to repository")
 
-	log.Infof("Done! Test for %s is created", candidate)
+	color.Green("Done! Hiring test for %s is created", candidate)
 }