Renaming to smth that makes more sense

Author: italolelis

cmd/create.go cmd/create_repo.gocmd/create.go renamed to cmd/create_repo.go

@@ -6,8 +6,7 @@ import (
 
 	"github.com/deiwin/interact"
 	"github.com/hellofresh/github-cli/pkg/pullapprove"
-
-	"github.com/hellofresh/github-cli/pkg/github"
+	"github.com/hellofresh/github-cli/pkg/repo"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
@@ -36,7 +35,8 @@ var (
 	}
 )
 
-func RunCreate(cmd *cobra.Command, args []string) {
+// 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)
@@ -50,43 +50,38 @@ func RunCreate(cmd *cobra.Command, args []string) {
 		log.Fatal(err)
 	}
 
-	opts := &github.HelloFreshRepoOpt{
-		Token:   globalConfig.Github.Token,
+	opts := &repo.HelloFreshRepoOpt{
+		Name:    repoName,
+		Org:     org,
 		Private: createRepoFlags.Private,
-		PullApprove: &github.PullApproveRule{
+		PullApprove: &repo.PullApproveRule{
 			Enabled:             createRepoFlags.HasPullApprove,
 			Filename:            globalConfig.PullApprove.Filename,
 			ProtectedBranchName: globalConfig.PullApprove.ProtectedBranchName,
 			Client:              pullapprove.New(globalConfig.PullApprove.Token),
 		},
-		Labels: &github.LabelsRule{
+		Labels: &repo.LabelsRule{
 			Enabled:             createRepoFlags.HasLabels,
 			RemoveDefaultLabels: globalConfig.Github.RemoveDefaultLabels,
 			Labels:              globalConfig.Github.Labels,
 		},
-		Teams: &github.TeamsRule{
+		Teams: &repo.TeamsRule{
 			Enabled: createRepoFlags.HasTeams,
 			Teams:   globalConfig.Github.Teams,
 		},
-		Webhooks: &github.WebhooksRule{
+		Webhooks: &repo.WebhooksRule{
 			Enabled:  createRepoFlags.HasWebhooks,
 			Webhooks: globalConfig.Github.Webhooks,
 		},
-		BranchProtections: &github.BranchProtectionsRule{
+		BranchProtections: &repo.BranchProtectionsRule{
 			Enabled:     createRepoFlags.HasBranchProtections,
 			Protections: globalConfig.Github.Protections,
 		},
 	}
 
-	creator, err := github.NewHelloFreshRepoCreator(repoName, org, opts)
-	if err != nil {
-		log.WithError(err).Error("Could not create github client")
-		os.Exit(1)
-	}
-
-	err = creator.Create()
+	creator := repo.NewGithub(githubClient)
+	err = creator.Create(opts)
 	if err != nil {
-		log.WithError(err).Error("Could not create github repo")
-		os.Exit(1)
+		log.WithError(err).Fatal("Could not create github repo")
 	}
 }

pkg/github/client.go pkg/repo/github.gopkg/github/client.go renamed to pkg/repo/github.go

@@ -1,4 +1,4 @@
-package github
+package repo
 
 import (
 	"context"
@@ -8,30 +8,27 @@ import (
 	"github.com/hellofresh/github-cli/pkg/pullapprove"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
-	"golang.org/x/oauth2"
 )
 
 type (
 	// RepoCreateor is used as an aggregator of rules to setup your repository
 	RepoCreateor interface {
-		Create() error
+		Create(opts *HelloFreshRepoOpt) error
 	}
 
-	// HelloFreshRepoCreator contains all the hellofresh repository creation rules
-	HelloFreshRepoCreator struct {
+	// GithubRepo contains all the hellofresh repository creation rules for github
+	GithubRepo struct {
 		GithubClient *github.Client
-		Name         string
-		Org          string
-		Private      bool
-		opts         *HelloFreshRepoOpt
 	}
 
 	// HelloFreshRepoOpt represents the repo creation options
 	HelloFreshRepoOpt struct {
-		Token             string
+		Name              string
+		Org               string
 		Private           bool
 		PullApprove       *PullApproveRule
 		Teams             *TeamsRule
+		Collaborators     *CollaboratorsRule
 		Labels            *LabelsRule
 		Webhooks          *WebhooksRule
 		BranchProtections *BranchProtectionsRule
@@ -49,6 +46,11 @@ type (
 		Teams   []*config.Team
 	}
 
+	CollaboratorsRule struct {
+		Enabled       bool
+		Collaborators []*config.Collaborator
+	}
+
 	LabelsRule struct {
 		Enabled             bool
 		RemoveDefaultLabels bool
@@ -68,69 +70,64 @@ type (
 
 var ctx = context.Background()
 
-// NewHelloFreshRepoCreator creates a new instance of Client
-func NewHelloFreshRepoCreator(name string, org string, opts *HelloFreshRepoOpt) (*HelloFreshRepoCreator, error) {
-	if opts.Token == "" {
-		return nil, errors.New("You must provide a github token")
+// NewGithub creates a new instance of Client
+func NewGithub(githubClient *github.Client) *GithubRepo {
+	return &GithubRepo{
+		GithubClient: githubClient,
 	}
-
-	ts := oauth2.StaticTokenSource(
-		&oauth2.Token{AccessToken: opts.Token},
-	)
-	tc := oauth2.NewClient(ctx, ts)
-
-	return &HelloFreshRepoCreator{
-		Name:         name,
-		Org:          org,
-		Private:      opts.Private,
-		GithubClient: github.NewClient(tc),
-		opts:         opts,
-	}, nil
 }
 
 // Create aggregates all rules to create a repository with all necessary requirements
-func (c *HelloFreshRepoCreator) Create() error {
+func (c *GithubRepo) Create(opts *HelloFreshRepoOpt) error {
 	log.Info("Creating repository...")
-	err := c.createRepo()
+	err := c.createRepo(opts.Name, opts.Org, opts.Private)
 	if err != nil {
 		return errors.Wrap(err, "could not create repository")
 	}
 
-	if c.opts.PullApprove.Enabled {
+	if opts.PullApprove != nil && opts.PullApprove.Enabled {
 		log.Info("Adding pull approve...")
-		err = c.addPullApprove()
+		err = c.addPullApprove(opts.Name, opts.Org, opts.PullApprove)
 		if err != nil {
 			return errors.Wrap(err, "could not add pull approve")
 		}
 	}
 
-	if c.opts.Teams.Enabled {
+	if opts.Teams != nil && opts.Teams.Enabled {
 		log.Info("Adding teams to repository...")
-		err = c.addTeamsToRepo()
+		err = c.addTeamsToRepo(opts.Name, opts.Org, opts.Teams)
 		if err != nil {
 			return errors.Wrap(err, "could add teams to repository")
 		}
 	}
 
-	if c.opts.Labels.Enabled {
+	if opts.Collaborators != nil && opts.Collaborators.Enabled {
+		log.Info("Adding collaborators to repository...")
+		err = c.addCollaborators(opts.Name, opts.Org, opts.Collaborators)
+		if err != nil {
+			return errors.Wrap(err, "could not add collaborators to repository")
+		}
+	}
+
+	if opts.Labels != nil && opts.Labels.Enabled {
 		log.Info("Adding labels to repository...")
-		err = c.addLabelsToRepo()
+		err = c.addLabelsToRepo(opts.Name, opts.Org, opts.Labels)
 		if err != nil {
 			return errors.Wrap(err, "could add labels to repository")
 		}
 	}
 
-	if c.opts.Webhooks.Enabled {
+	if opts.Webhooks != nil && opts.Webhooks.Enabled {
 		log.Info("Adding webhooks to repository...")
-		err = c.addWebhooksToRepo()
+		err = c.addWebhooksToRepo(opts.Name, opts.Org, opts.Webhooks)
 		if err != nil {
 			return errors.Wrap(err, "could add webhooks to repository")
 		}
 	}
 
-	if c.opts.BranchProtections.Enabled {
+	if opts.BranchProtections != nil && opts.BranchProtections.Enabled {
 		log.Info("Adding branch protections to repository...")
-		err = c.addBranchProtections()
+		err = c.addBranchProtections(opts.Name, opts.Org, opts.BranchProtections)
 		if err != nil {
 			return errors.Wrap(err, "could add branch protections to repository")
 		}
@@ -140,100 +137,114 @@ func (c *HelloFreshRepoCreator) Create() error {
 	return nil
 }
 
-func (c *HelloFreshRepoCreator) createRepo() error {
+func (c *GithubRepo) createRepo(name string, org string, private bool) error {
 	repo := &github.Repository{
-		Name:      github.String(c.Name),
-		Private:   github.Bool(c.Private),
+		Name:      github.String(name),
+		Private:   github.Bool(private),
 		HasIssues: github.Bool(true),
 	}
 
-	_, _, err := c.GithubClient.Repositories.Create(ctx, c.Org, repo)
+	_, _, err := c.GithubClient.Repositories.Create(ctx, org, repo)
 	return err
 }
 
-func (c *HelloFreshRepoCreator) addPullApprove() error {
-	if c.opts.PullApprove.Client == nil {
+func (c *GithubRepo) addPullApprove(repo string, org string, opts *PullApproveRule) error {
+	if opts.Client == nil {
 		return errors.New("Cannot add pull approve, since the client is nil")
 	}
 
 	fileOpt := &github.RepositoryContentFileOptions{
 		Message: github.String("Initialize repository :tada:"),
 		Content: []byte("extends: hellofresh"),
-		Branch:  github.String(c.opts.PullApprove.ProtectedBranchName),
+		Branch:  github.String(opts.ProtectedBranchName),
 	}
-	_, _, err := c.GithubClient.Repositories.CreateFile(ctx, c.Org, c.Name, c.opts.PullApprove.Filename, fileOpt)
+	_, _, err := c.GithubClient.Repositories.CreateFile(ctx, org, repo, opts.Filename, fileOpt)
 	if err != nil {
 		return err
 	}
 
-	err = c.opts.PullApprove.Client.Create(c.Name, c.Org)
+	err = opts.Client.Create(repo, org)
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (c *HelloFreshRepoCreator) addTeamsToRepo() error {
+func (c *GithubRepo) addTeamsToRepo(repo string, org string, opts *TeamsRule) error {
 	var err error
 
-	for _, team := range c.opts.Teams.Teams {
+	for _, team := range opts.Teams {
 		opt := &github.OrganizationAddTeamRepoOptions{
 			Permission: team.Permission,
 		}
 
-		_, err = c.GithubClient.Organizations.AddTeamRepo(ctx, team.ID, c.Org, c.Name, opt)
+		_, err = c.GithubClient.Organizations.AddTeamRepo(ctx, team.ID, org, repo, opt)
 	}
 
 	return err
 }
 
-func (c *HelloFreshRepoCreator) addLabelsToRepo() error {
+func (c *GithubRepo) addLabelsToRepo(repo string, org string, opts *LabelsRule) error {
 	var err error
 	defaultLabels := []string{"bug", "duplicate", "enhancement", "help wanted", "invalid", "question", "wontfix", "good first issue"}
 
-	for _, label := range c.opts.Labels.Labels {
+	for _, label := range opts.Labels {
 		githubLabel := &github.Label{
 			Name:  github.String(label.Name),
 			Color: github.String(label.Color),
 		}
 
-		_, _, err = c.GithubClient.Issues.CreateLabel(ctx, c.Org, c.Name, githubLabel)
+		_, _, err = c.GithubClient.Issues.CreateLabel(ctx, org, repo, githubLabel)
 	}
 
-	if c.opts.Labels.RemoveDefaultLabels {
+	if opts.RemoveDefaultLabels {
 		for _, label := range defaultLabels {
-			_, err = c.GithubClient.Issues.DeleteLabel(ctx, c.Org, c.Name, label)
+			_, err = c.GithubClient.Issues.DeleteLabel(ctx, org, repo, label)
 		}
 	}
 
 	return err
 }
 
-func (c *HelloFreshRepoCreator) addWebhooksToRepo() error {
+func (c *GithubRepo) addWebhooksToRepo(repo string, org string, opts *WebhooksRule) error {
 	var err error
 
-	for _, webhook := range c.opts.Webhooks.Webhooks {
+	for _, webhook := range opts.Webhooks {
 		hook := &github.Hook{
 			Name:   github.String(webhook.Type),
 			Config: webhook.Config,
 		}
-		_, _, err = c.GithubClient.Repositories.CreateHook(ctx, c.Org, c.Name, hook)
+		_, _, err = c.GithubClient.Repositories.CreateHook(ctx, org, repo, hook)
 	}
 
 	return err
 }
 
-func (c *HelloFreshRepoCreator) addBranchProtections() error {
+func (c *GithubRepo) addBranchProtections(repo string, org string, opts *BranchProtectionsRule) error {
 	var err error
 
-	for branch, contexts := range c.opts.BranchProtections.Protections {
+	for branch, contexts := range opts.Protections {
 		pr := &github.ProtectionRequest{
 			RequiredStatusChecks: &github.RequiredStatusChecks{
 				Contexts: contexts,
 			},
 		}
-		_, _, err = c.GithubClient.Repositories.UpdateBranchProtection(ctx, c.Org, c.Name, branch, pr)
+		_, _, err = c.GithubClient.Repositories.UpdateBranchProtection(ctx, org, repo, branch, pr)
+	}
+
+	return err
+}
+
+func (c *GithubRepo) addCollaborators(repo string, org string, opts *CollaboratorsRule) error {
+	var err error
+
+	for _, collaborator := range opts.Collaborators {
+		opt := &github.RepositoryAddCollaboratorOptions{
+			Permission: collaborator.Permission,
+		}
+
+		_, err = c.GithubClient.Repositories.AddCollaborator(ctx, org, repo, collaborator.Username, opt)
 	}
 
 	return err