cmd

Documentation

Index

• Variables
• func Execute()

Variables

var FeatureCmd = &cobra.Command{
	Use:   "feature",
	Short: "Manage features",
	Long:  `Manage repository and Github features`,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Println(color.YellowString("GitHub Token: %s", gitHubToken))

		cmd.Usage()
		os.Exit(0)
	},
}

FeatureCmd represents the feature command

var FeatureStartCmd = &cobra.Command{
	Use:   "start [feature title]",
	Short: "Start a feature",
	Long:  `Start working on a feature`,
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		if len(args) == 0 {
			fmt.Println(color.RedString("ERROR: %s", "An feature title is required"))
			os.Exit(1)
		}
		featureTitle := args[0]

		repositoryPath := "."

		ghub.FeatureStart(repositoryPath, gitHubToken, featureTitle)
	},
}

FeatureStartCmd represents the feature start command

var GitHubToken string

GitHubToken ...

var InfoCmd = &cobra.Command{
	Use:   "info",
	Short: "Get information",
	Long:  `Get information about a repository and its Github project`,
	Args:  cobra.MinimumNArgs(0),
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		path := "."
		repository, err := ghub.OpenRepository(path, gitHubToken)
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}

		fmt.Printf("Git Repository Path: %s\n", path)
		fmt.Printf("GitHub Repository ID: %d\n", repository.GitHubRepository.ID)
		fmt.Printf("GitHub Repository Full Name: %s\n", *repository.GitHubRepository.FullName)
		fmt.Printf("GitHub Repository HTML URL: %s\n", *repository.GitHubRepository.HTMLURL)
	},
}

InfoCmd represents the info command

var IssueCmd = &cobra.Command{
	Use:   "issue",
	Short: "Manage issues",
	Long:  `Manage repository and Github issues`,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Println(color.YellowString("GitHub Token: %s", gitHubToken))

		cmd.Usage()
		os.Exit(0)
	},
}

IssueCmd represents the issue command

var IssueListCmd = &cobra.Command{
	Use:   "list",
	Short: "List issues",
	Long:  `List repository issues`,
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		path := "."
		repo, err := ghub.OpenRepository(path, gitHubToken)
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}

		repository := *repo.GitHubRepository.FullName
		if Repository != "" {
			repository = Repository
		}

		issues, err := ghub.ListIssuesByRepo(repository)
		if err != nil {
			log.Fatal(err)
		}

		for _, issue := range issues {
			fmt.Printf("#%d - %s - %s\n", *issue.Number, *issue.Title, *issue.HTMLURL)
		}
	},
}

IssueListCmd represents the issue list command

var IssueNewCmd = &cobra.Command{
	Use:   "new",
	Short: "Create an issue",
	Long:  `Create an issue`,
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		path := "."
		repo, err := ghub.OpenRepository(path, gitHubToken)
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}

		repository := *repo.GitHubRepository.FullName
		if Repository != "" {
			repository = Repository
		}

		url := repo.GetNewIssueURL(repository)
		automation.OpenURL(url)
	},
}

IssueNewCmd represents the issue start command

var IssueStartCmd = &cobra.Command{
	Use:   "start [issue number]",
	Short: "Start an issue",
	Long:  `Start working on an issue`,
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		if len(args) == 0 {
			fmt.Println(color.RedString("ERROR: %s", "An issue ID is required"))
			os.Exit(1)
		}

		issueID, err := strconv.Atoi(args[0])
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s %q", "Invalid issue ID", args[0]))
			os.Exit(1)
		}

		path := "."
		r, err := ghub.OpenRepository(path, gitHubToken)
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}

		repository := *r.GitHubRepository.FullName
		if Repository != "" {
			repository = Repository
		}

		user, err := ghub.GetAuthenticatedUser()
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}

		org, repo := ghub.ParseRepositoryFullName(repository)
		issue, err := ghub.GetIssue(org, repo, issueID)
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}

		if issue.GetState() != "open" {
			log.Printf("Issue #%d %q is %s, you can't work on it.\n", issue.GetNumber(), issue.GetTitle(), issue.GetState())
			os.Exit(1)
		}

		err = ghub.AssignUserToIssue(org, repo, user, issue)
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}
		fmt.Println("Assigned issue to", user.GetLogin())

		issueBranchName := fmt.Sprintf("issue/%s", ghub.SlugifyIssue(issue))
		if Repository != "" {
			issueBranchName = fmt.Sprintf("issue/%s-%s", ghub.SlugifyRepository(repository), ghub.SlugifyIssue(issue))
		}

		out, err := automation.CreateLocalGitBranch(issueBranchName)
		if err != nil {
			fmt.Println(color.RedString("ERROR: %s", err.Error()))
			os.Exit(1)
		}
		fmt.Println("Creating local branch", issueBranchName)
		fmt.Println(out)

		out, err = automation.PushLocalBranchToOrigin(issueBranchName)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(out)
	},
}

IssueStartCmd represents the issue start command

var ReleaseCmd = &cobra.Command{
	Use:   "release",
	Short: "Manage releases",
	Long:  `Manage repository and Github releases`,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		cmd.Usage()
		os.Exit(0)
	},
}

ReleaseCmd represents the release command

var ReleaseFinishCmd = &cobra.Command{
	Use:   "finish",
	Short: "Finish a release",
	Long:  `Finish and publish a release`,
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		repositoryPath := "."

		ghub.ReleaseFinish(repositoryPath, gitHubToken)
	},
}

ReleaseFinishCmd represents the release finish command

var ReleasePatchCmd = &cobra.Command{
	Use:   "patch",
	Short: "Do a patch release",
	Long:  `Do a new relese only bumping the patch semver part`,
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		repositoryPath := "."

		ghub.ReleaseStart(repositoryPath, gitHubToken)
		ghub.ReleaseFinish(repositoryPath, gitHubToken)
	},
}

ReleasePatchCmd represents the release start command

var ReleaseStartCmd = &cobra.Command{
	Use:   "start",
	Short: "Start a release",
	Long:  `Start working on an release`,
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		gitHubToken := os.Getenv("GITHUB_TOKEN")
		if GitHubToken != "" {
			gitHubToken = GitHubToken
		}
		log.Printf("GitHub Token: %s\n", gitHubToken)

		repositoryPath := "."

		ghub.ReleaseStart(repositoryPath, gitHubToken)
	},
}

ReleaseStartCmd represents the release start command

var Repository string

Repository ...

var RootCmd = &cobra.Command{
	Use:   "git-hub",
	Short: "Automate git and github",
	Long:  `git-hub automates git and github flow of work`,
	Run: func(cmd *cobra.Command, args []string) {
		log.SetFlags(0)

		log.SetOutput(ioutil.Discard)

		if VerboseFlag {
			log.SetOutput(os.Stdout)
		}

		cmd.Usage()
		os.Exit(0)
	},
}

RootCmd represents the base command when called without any subcommands

var VerboseFlag bool

VerboseFlag ...

var VersionCmd = &cobra.Command{
	Use:   "version",
	Short: "Show version information",
	Long:  `Show application version information`,
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("%s %s", "git-hub", RootCmd.Version)
	},
}

VersionCmd represents the version command

Functions

func Execute

func Execute()

Execute adds all child commands to the root command and sets flags appropriately. This is called by main.main(). It only needs to happen once to the rootCmd.