1 files changed, 82 insertions, 38 deletions

diff --git a/vendor/github.com/spf13/cobra/cobra/cmd/add.go b/vendor/github.com/spf13/cobra/cobra/cmd/add.go
index b89d4c474..8897f8ff0 100644
--- a/vendor/github.com/spf13/cobra/cobra/cmd/add.go
+++ b/vendor/github.com/spf13/cobra/cobra/cmd/add.go
@@ -15,20 +15,19 @@ package cmd
 
 import (
 	"fmt"
+	"os"
 	"path/filepath"
-	"strings"
+	"unicode"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 func init() {
-	RootCmd.AddCommand(addCmd)
+	addCmd.Flags().StringVarP(&parentName, "parent", "p", "RootCmd", "name of parent command for this command")
 }
 
-var pName string
+var parentName string
 
-// initialize Command
 var addCmd = &cobra.Command{
 	Use:     "add [command name]",
 	Aliases: []string{"command"},
@@ -40,37 +39,84 @@ 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
-  `,
+Example: cobra add server -> resulting in a new cmd/server.go`,
 
 	Run: func(cmd *cobra.Command, args []string) {
-		if len(args) != 1 {
+		if len(args) < 1 {
 			er("add needs a name for the command")
 		}
-		guessProjectPath()
-		createCmdFile(args[0])
+		wd, err := os.Getwd()
+		if err != nil {
+			er(err)
+		}
+		project := NewProjectFromPath(wd)
+
+		cmdName := validateCmdName(args[0])
+		cmdPath := filepath.Join(project.CmdPath(), cmdName+".go")
+		createCmdFile(project.License(), cmdPath, cmdName)
+
+		fmt.Fprintln(cmd.OutOrStdout(), cmdName, "created at", cmdPath)
 	},
 }
 
-func init() {
-	addCmd.Flags().StringVarP(&pName, "parent", "p", "RootCmd", "name of parent command for this command")
-}
+// 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
+		}
 
-func parentName() string {
-	if !strings.HasSuffix(strings.ToLower(pName), "cmd") {
-		return pName + "Cmd"
+		// If the current character isn't dash or underscore,
+		// just add it.
+		if output != "" {
+			output += string(source[i])
+		}
+		i++
 	}
 
-	return pName
+	if output == "" {
+		return source // source is initially valid name.
+	}
+	return output
 }
 
-func createCmdFile(cmdName string) {
-	lic := getLicense()
+func createCmdFile(license License, path, cmdName string) {
+	template := `{{comment .copyright}}
+{{comment .license}}
 
-	template := `{{ comment .copyright }}
-{{ comment .license }}
-
-package cmd
+package {{.cmdPackage}}
 
 import (
 	"fmt"
@@ -79,8 +125,8 @@ import (
 )
 
 // {{.cmdName}}Cmd represents the {{.cmdName}} command
-var {{ .cmdName }}Cmd = &cobra.Command{
-	Use:   "{{ .cmdName }}",
+var {{.cmdName}}Cmd = &cobra.Command{
+	Use:   "{{.cmdName}}",
 	Short: "A brief description of your command",
 	Long: ` + "`" + `A longer description that spans multiple lines and likely contains examples
 and usage of using your command. For example:
@@ -89,13 +135,12 @@ Cobra is a CLI library for Go that empowers applications.
 This application is a tool to generate the needed files
 to quickly create a Cobra application.` + "`" + `,
 	Run: func(cmd *cobra.Command, args []string) {
-		// TODO: Work your own magic here
-		fmt.Println("{{ .cmdName }} called")
+		fmt.Println("{{.cmdName}} called")
 	},
 }
 
 func init() {
-	{{ .parentName }}.AddCommand({{ .cmdName }}Cmd)
+	{{.parentName}}.AddCommand({{.cmdName}}Cmd)
 
 	// Here you will define your flags and configuration settings.
 
@@ -106,23 +151,22 @@ func init() {
 	// Cobra supports local flags which will only run when this command
 	// is called directly, e.g.:
 	// {{.cmdName}}Cmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
-
 }
 `
 
-	var data map[string]interface{}
-	data = make(map[string]interface{})
-
+	data := make(map[string]interface{})
 	data["copyright"] = copyrightLine()
-	data["license"] = lic.Header
-	data["appName"] = projectName()
-	data["viper"] = viper.GetBool("useViper")
-	data["parentName"] = parentName()
+	data["license"] = license.Header
+	data["cmdPackage"] = filepath.Base(filepath.Dir(path)) // last dir of path
+	data["parentName"] = parentName
 	data["cmdName"] = cmdName
 
-	err := writeTemplateToFile(filepath.Join(ProjectPath(), guessCmdDir()), cmdName+".go", template, data)
+	cmdScript, err := executeTemplate(template, data)
+	if err != nil {
+		er(err)
+	}
+	err = writeStringToFile(path, cmdScript)
 	if err != nil {
 		er(err)
 	}
-	fmt.Println(cmdName, "created at", filepath.Join(ProjectPath(), guessCmdDir(), cmdName+".go"))
 }