spf13--cobra/cobra/cmd/add.go

// Copyright © 2015 Steve Francia <spf@spf13.com>.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cmd

import (
	"fmt"
	"os"
	"unicode"

	"github.com/spf13/cobra"
)

var (
	packageName string
	parentName  string

	addCmd = &cobra.Command{
		Use:     "add [command name]",
		Aliases: []string{"command"},
		Short:   "Add a command to a Cobra Application",
		Long: `Add (cobra add) will create a new command, with a license and
the appropriate structure for a Cobra-based CLI application,
and register it to its parent (default rootCmd).

If you want your command to be public, pass in the command name
with an initial uppercase letter.

Example: cobra add server -> resulting in a new cmd/server.go`,

		Run: func(cmd *cobra.Command, args []string) {
			if len(args) < 1 {
				cobra.CheckErr(fmt.Errorf("add needs a name for the command"))
			}

			wd, err := os.Getwd()
			cobra.CheckErr(err)

			commandUse := validateCmdName(args[0])
			commandName, commandFileName := generateCmdFileName(commandUse, parentName)

			command := &Command{
				CmdName:     commandName,
				CmdUse:      commandUse,
				CmdFileName: commandFileName,
				CmdParent:   parentName,
				Project: &Project{
					AbsolutePath: wd,
					Legal:        getLicense(),
					Copyright:    copyrightLine(),
				},
			}

			cobra.CheckErr(command.Create())

			fmt.Printf("%s created at %s\n", command.CmdName, command.AbsolutePath)
		},
	}
)

func init() {
	addCmd.Flags().StringVarP(&packageName, "package", "t", "", "target package name (e.g. github.com/spf13/hugo)")
	addCmd.Flags().StringVarP(&parentName, "parent", "p", "rootCmd", "variable name of parent command for this command")
	cobra.CheckErr(addCmd.Flags().MarkDeprecated("package", "this operation has been removed."))
}

// validateCmdName returns source without any dashes and underscore.
// If there will be dash or underscore, next letter will be uppered.
// It supports only ASCII (1-byte character) strings.
// https://github.com/spf13/cobra/issues/269
func validateCmdName(source string) string {
	i := 0
	l := len(source)
	// The output is initialized on demand, then first dash or underscore
	// occurs.
	var output string

	for i < l {
		if source[i] == '-' || source[i] == '_' {
			if output == "" {
				output = source[:i]
			}

			// If it's last rune and it's dash or underscore,
			// don't add it output and break the loop.
			if i == l-1 {
				break
			}

			// If next character is dash or underscore,
			// just skip the current character.
			if source[i+1] == '-' || source[i+1] == '_' {
				i++
				continue
			}

			// If the current character is dash or underscore,
			// upper next letter and add to output.
			output += string(unicode.ToUpper(rune(source[i+1])))
			// We know, what source[i] is dash or underscore and source[i+1] is
			// uppered character, so make i = i+2.
			i += 2
			continue
		}

		// If the current character isn't dash or underscore,
		// just add it.
		if output != "" {
			output += string(source[i])
		}
		i++
	}

	if output == "" {
		return source // source is initially valid name.
	}
	return output
}

// generateCmdFileName returns a lowerCamelCase command name and a snake_case
// file name, combining the given command name and the parent command name.
func generateCmdFileName(cmd, parent string) (string, string) {
	var cmdName string
	var cmdFileName string

	if parent == "rootCmd" {
		return cmd, cmd
	}

	l := len(parent)
	if parent[l-3:] == "Cmd" {
		parent = parent[:l-3]
	}

	upperCmd := string(unicode.ToUpper(rune(cmd[0]))) + cmd[1:]
	lowerParent := string(unicode.ToLower(rune(parent[0]))) + parent[1:]
	cmdName = lowerParent + upperCmd

	l = len(cmdName)
	cmdFileName = string(cmdName[0])
	for i := 1; i < l; i++ {
		if unicode.IsUpper(rune(cmdName[i])) {
			cmdFileName += "_"
		}
		cmdFileName += string(unicode.ToLower(rune(cmdName[i])))
	}

	l = len(cmdFileName)
	if cmdFileName[l-5:] == "_test" {
		cmdFileName += "cmd"
	}

	return cmdName, cmdFileName
}