Support flags for the rit update repo command.

pkg/cmd/update_repo.go

@@ -17,8 +17,10 @@
 package cmd
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
+	"reflect"
 
 	"github.com/spf13/cobra"
 
@@ -30,8 +32,25 @@ import (
 const (
 	questionSelectARepo = "Select a repository to update: "
 	updateOptionAll     = "ALL"
+	repoName            = "name"
+	repoVersion         = "version"
 )
 
+var updateRepoFlags = flags{
+	{
+		name:        repoName,
+		kind:        reflect.String,
+		defValue:    "",
+		description: "repository name",
+	},
+	{
+		name:        repoVersion,
+		kind:        reflect.String,
+		defValue:    "latest",
+		description: "repository version",
+	},
+}
+
 type updateRepoCmd struct {
 	client        *http.Client
 	repo          formula.RepositoryListUpdater
@@ -71,99 +90,189 @@ func NewUpdateRepoCmd(
 		Use:       "repo",
 		Short:     "Update a repository.",
 		Example:   "rit update repo",
-		RunE:      RunFuncE(updateRepo.runStdin(), updateRepo.runPrompt()),
+		RunE:      RunFuncE(updateRepo.runStdin(), updateRepo.runCmd()),
 		ValidArgs: []string{""},
 		Args:      cobra.OnlyValidArgs,
 	}
 	cmd.LocalFlags()
+	addReservedFlags(cmd.Flags(), updateRepoFlags)
 
 	return cmd
 }
 
-func (up updateRepoCmd) runPrompt() CommandRunnerFunc {
+func (up updateRepoCmd) runCmd() CommandRunnerFunc {
 	return func(cmd *cobra.Command, args []string) error {
-		repos, err := up.repo.List()
+		reposToUpdate, err := up.resolveInput(cmd)
 		if err != nil {
 			return err
 		}
 
-		var reposName []string
-		var externalRepos formula.Repos
-		reposName = append(reposName, updateOptionAll)
-		for i := range repos {
-			if !repos[i].IsLocal {
-				externalRepos = append(externalRepos, repos[i])
-				reposName = append(reposName, repos[i].Name.String())
+		for _, value := range reposToUpdate {
+			err := up.repo.Update(value.Name, value.Version)
+			if err != nil {
+				return err
 			}
+			successMsg := fmt.Sprintf("The %q repository was updated with success to version %q\n", value.Name, value.Version)
+			prompt.Success(successMsg)
 		}
+		return nil
+	}
+}
 
-		helper := "Select a repository to update your version. P.S. Local repositories cannot be updated."
-		name, err := up.List(questionSelectARepo, reposName, helper)
-		if err != nil {
+func (up updateRepoCmd) runStdin() CommandRunnerFunc {
+	return func(cmd *cobra.Command, args []string) error {
+		r := formula.Repo{}
+
+		if err := stdin.ReadJson(cmd.InOrStdin(), &r); err != nil {
 			return err
 		}
 
-		flagAll := name == updateOptionAll
+		if err := up.repo.Update(r.Name, r.Version); err != nil {
+			return err
+		}
 
-		var repoToUpdate []formula.Repo
+		successMsg := fmt.Sprintf("The %q repository was updated with success to version %q", r.Name, r.Version)
+		prompt.Success(successMsg)
 
-		if flagAll {
-			repoToUpdate = externalRepos
-		} else {
-			for i := range externalRepos {
-				if externalRepos[i].Name == formula.RepoName(name) {
-					repoToUpdate = append(repoToUpdate, externalRepos[i])
-					break
-				}
-			}
-		}
+		return nil
+	}
+}
 
-		for _, currRepo := range repoToUpdate {
+func (up updateRepoCmd) resolveInput(cmd *cobra.Command) (formula.Repos, error) {
+	if IsFlagInput(cmd) {
+		return up.resolveFlags(cmd)
+	}
+	return up.resolvePrompt()
+}
 
-			git := up.repoProviders.Resolve(currRepo.Provider)
+func (up updateRepoCmd) resolvePrompt() (formula.Repos, error) {
+	repos, err := up.repo.List()
+	if err != nil {
+		return formula.Repos{}, err
+	}
 
-			repoInfo := git.NewRepoInfo(currRepo.Url, currRepo.Token)
-			tags, err := git.Repos.Tags(repoInfo)
-			if err != nil {
-				return err
-			}
+	var reposName []string
+	var externalRepos formula.Repos
+	reposName = append(reposName, updateOptionAll)
+	for i := range repos {
+		if !repos[i].IsLocal {
+			externalRepos = append(externalRepos, repos[i])
+			reposName = append(reposName, repos[i].Name.String())
+		}
+	}
 
-			currRepoVersion := fmt.Sprintf("Select your new version for %q:", currRepo.Name.String())
+	helper := "Select a repository to update your version. P.S. Local repositories cannot be updated."
+	name, err := up.List(questionSelectARepo, reposName, helper)
+	if err != nil {
+		return formula.Repos{}, err
+	}
 
-			version, err := up.List(currRepoVersion, tags.Names())
-			if err != nil {
-				return err
-			}
+	flagAll := name == updateOptionAll
 
-			currRepoName := string(currRepo.Name)
+	var repoToUpdate []formula.Repo
 
-			if err := up.repo.Update(formula.RepoName(currRepoName), formula.RepoVersion(version)); err != nil {
-				return err
+	if flagAll {
+		repoToUpdate = externalRepos
+	} else {
+		for i := range externalRepos {
+			if externalRepos[i].Name == formula.RepoName(name) {
+				repoToUpdate = append(repoToUpdate, externalRepos[i])
+				break
 			}
+		}
+	}
 
-			successMsg := fmt.Sprintf("The %q repository was updated with success to version %q\n", currRepo.Name, version)
-			prompt.Success(successMsg)
+	for i, currRepo := range repoToUpdate {
+		repoInfo, err := up.getRepoInfo(currRepo)
+		if err != nil {
+			return formula.Repos{}, err
 		}
 
-		return nil
+		currRepoVersion := fmt.Sprintf("Select your new version for %q:", currRepo.Name.String())
+
+		version, err := up.List(currRepoVersion, repoInfo)
+		if err != nil {
+			return formula.Repos{}, err
+		}
+		repoToUpdate[i].Version = formula.RepoVersion(version)
 	}
+	return repoToUpdate, nil
 }
 
-func (up updateRepoCmd) runStdin() CommandRunnerFunc {
-	return func(cmd *cobra.Command, args []string) error {
-		r := formula.Repo{}
+func (up *updateRepoCmd) resolveFlags(cmd *cobra.Command) (formula.Repos, error) {
+	name, err := cmd.Flags().GetString(repoName)
+	if err != nil {
+		return nil, err
+	}
 
-		if err := stdin.ReadJson(cmd.InOrStdin(), &r); err != nil {
-			return err
+	if name == "" {
+		return nil, errors.New(missingFlagText(repoName))
+	}
+
+	version, err := cmd.Flags().GetString(repoVersion)
+	if err != nil {
+		return nil, err
+	}
+	if version == "" {
+		return formula.Repos{}, errors.New(missingFlagText(repoVersion))
+	}
+
+	repoTarget := formula.Repo{Name: formula.RepoName(name), Version: formula.RepoVersion(version)}
+	var repoToUpdate []formula.Repo
+
+	repos, err := up.repo.List()
+	if err != nil {
+		return nil, err
+	}
+
+	var externalRepos formula.Repos
+	for i := range repos {
+		if !repos[i].IsLocal {
+			externalRepos = append(externalRepos, repos[i])
 		}
+	}
 
-		if err := up.repo.Update(r.Name, r.Version); err != nil {
-			return err
+	for _, currRepo := range externalRepos {
+		if repoTarget.Name == currRepo.Name {
+			info, _ := up.getRepoInfo(currRepo)
+			if version == "latest" {
+				repoTarget.Version = currRepo.LatestVersion
+				repoToUpdate = append(repoToUpdate, repoTarget)
+				return repoToUpdate, nil
+			} else if findVersion(info, repoTarget.Version) {
+				repoToUpdate = append(repoToUpdate, repoTarget)
+				return repoToUpdate, nil
+			} else {
+				errorMsg := fmt.Sprintf("The version %q of repository %q was not found.\n", repoTarget.Version, repoTarget.Name)
+				return repoToUpdate, errors.New(errorMsg)
+			}
 		}
+	}
 
-		successMsg := fmt.Sprintf("The %q repository was updated with success to version %q", r.Name, r.Version)
-		prompt.Success(successMsg)
+	if len(repoToUpdate) == 0 {
+		errorMsg := fmt.Sprintf("The repository %q was not found.\n", repoTarget.Name)
+		return formula.Repos{}, errors.New(errorMsg)
+	}
 
-		return nil
+	return repoToUpdate, nil
+}
+
+func (up *updateRepoCmd) getRepoInfo(repoToUpdate formula.Repo) ([]string, error) {
+	gitResp := up.repoProviders.Resolve(repoToUpdate.Provider)
+	repoInfo := gitResp.NewRepoInfo(repoToUpdate.Url, repoToUpdate.Token)
+	tags, err := gitResp.Repos.Tags(repoInfo)
+	if err != nil {
+		return nil, err
+	}
+	stringTags := tags.Names()
+	return stringTags, nil
+}
+
+func findVersion(source []string, value formula.RepoVersion) bool {
+	for _, item := range source {
+		if item == string(value) {
+			return true
+		}
 	}
+	return false
 }