Stud 3115

.circleci/config.yml

@@ -1,53 +1,30 @@
 version: 2
-
-references:
-  workspace: &workspace
-    /go/src/github.com/spf13/cobra
-
-  run_tests: &run_tests
-    run:
-      name: "All Commands"
-      command: |
-        mkdir -p bin
-        curl -Lso bin/shellcheck https://github.com/caarlos0/shellcheck-docker/releases/download/v0.4.6/shellcheck
-        chmod +x bin/shellcheck
-        go get -t -v ./...
-        PATH=$PATH:$PWD/bin go test -v ./...
-        go build
-        if [ -z $NOVET ]; then
-          diff -u <(echo -n) <(go tool vet . 2>&1 | grep -vE 'ExampleCommand|bash_completions.*Fprint');
-        fi
-
 jobs:
-  go-current:
+  build:
     docker:
-      - image: circleci/golang:1.11
-    working_directory: *workspace
+      # specify the version
+      - image: circleci/golang:1.15
+        auth:
+          username: $DOCKERHUB_USER
+          password: $DOCKERHUB_PASSWORD
+        environment: # environment variables for primary container
+          DEPLOYMENT: test
+
+    #### TEMPLATE_NOTE: go expects specific checkout path representing url
+    #### expecting it in the form of
+    ####   /go/src/github.com/circleci/go-tool
+    ####   /go/src/bitbucket.org/circleci/go-tool
+    working_directory: /go/src/github.com/OneCloudInc/cobra
     steps:
       - checkout
-      - *run_tests
       - run:
-          name: "Check formatting"
-          command: diff -u <(echo -n) <(gofmt -d -s .)
-  go-previous:
-    docker:
-      - image: circleci/golang:1.10
-    working_directory: *workspace
-    steps:
-      - checkout
-      - *run_tests
-  go-latest:
-    docker:
-      - image: circleci/golang:latest
-    working_directory: *workspace
-    steps:
-      - checkout
-      - *run_tests
-
+          name: Run tests
+          command: |
+            go test ./...
 workflows:
   version: 2
-  main:
+  workflow:
     jobs:
-      - go-current
-      - go-previous
-      - go-latest
+      - build:
+          context:
+            - dockerhub

.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: CI process for Cobra
+on: [push, pull_request]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  wayne-test1:
+    runs-on: small
+    container:
+      image: amazonlinux:2023
+    steps:
+      - name: Install dependencies
+        run: |
+          apt-get update && apt-get upgrade -y
+          apt-get update && apt-get upgrade -y

.gitignore

@@ -34,3 +34,6 @@ tags
 *.exe
 
 cobra.test
+
+.idea
+vendor

README.md

@@ -123,7 +123,7 @@ Using Cobra is easy. First, use `go get` to install the latest version
 of the library. This command will install the `cobra` generator executable
 along with the library and its dependencies:
 
-    go get -u github.com/spf13/cobra/cobra
+    go get -u github.com/OneCloudInc/cobra/cobra
 
 Next, include Cobra in your application:
 

cobra/README.md

@@ -5,7 +5,7 @@ commands you want. It's the easiest way to incorporate Cobra into your applicati
 
 In order to use the cobra command, compile it using the following command:
 
-    go get github.com/spf13/cobra/cobra
+    go get github.com/OneCloudInc/cobra/cobra
 
 This will create the cobra executable under your `$GOPATH/bin` directory.
 

cobra/cmd/add.go

@@ -19,15 +19,17 @@ import (
 	"path/filepath"
 	"unicode"
 
-	"github.com/spf13/cobra"
+	"github.com/OneCloudInc/cobra"
 )
 
 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")
+	addCmd.Flags().StringArrayVar(&cmdFlags, "flag", []string{}, `the flags to auto generate.  For each flag do '--flag "flagName:type:description"'`)
 }
 
 var packageName, parentName string
+var cmdFlags []string
 
 var addCmd = &cobra.Command{
 	Use:     "add [command name]",
@@ -128,37 +130,25 @@ package {{.cmdPackage}}
 import (
 	"fmt"
 
-	"github.com/spf13/cobra"
+	"github.com/OneCloudInc/cobra"
 )
 
+{{ printFlagVars .flags }}
+
+func init() {
+	{{.parentName}}.AddCommand({{.cmdName}}Cmd){{ printFlagCreates .flags false }}
+}
+
 // {{.cmdName}}Cmd represents the {{.cmdName}} command
 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:
-
-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) {
-		fmt.Println("{{.cmdName}} called")
+	Short: "{{.cmdName}}",
+	Long: ` + "`" + `Description` + "`" + `,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		fmt.Println("{{.cmdName}} called, place the command logic here")
+		return nil
 	},
 }
-
-func init() {
-	{{.parentName}}.AddCommand({{.cmdName}}Cmd)
-
-	// Here you will define your flags and configuration settings.
-
-	// Cobra supports Persistent Flags which will work for this command
-	// and all subcommands, e.g.:
-	// {{.cmdName}}Cmd.PersistentFlags().String("foo", "", "A help for foo")
-
-	// 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")
-}
 `
 
 	data := make(map[string]interface{})
@@ -167,6 +157,15 @@ func init() {
 	data["cmdPackage"] = filepath.Base(filepath.Dir(path)) // last dir of path
 	data["parentName"] = parentName
 	data["cmdName"] = cmdName
+	flags := []flagDefinition{}
+	for _, value := range cmdFlags {
+		f, err := buildFlag(value, cmdName)
+		if err != nil {
+			er(err)
+		}
+		flags = append(flags, f)
+	}
+	data["flags"] = flags
 
 	cmdScript, err := executeTemplate(template, data)
 	if err != nil {

cobra/cmd/add_test.go

@@ -10,13 +10,13 @@ import (
 	"github.com/spf13/viper"
 )
 
-// TestGoldenAddCmd initializes the project "github.com/spf13/testproject"
+// TestGoldenAddCmd initializes the project "github.com/OneCloudInc/testproject"
 // in GOPATH, adds "test" command
 // and compares the content of all files in cmd directory of testproject
 // with appropriate golden files.
 // Use -update to update existing golden files.
 func TestGoldenAddCmd(t *testing.T) {
-	projectName := "github.com/spf13/testproject"
+	projectName := "github.com/OneCloudInc/testproject"
 	project := NewProject(projectName)
 	defer os.RemoveAll(project.AbsPath())
 
@@ -46,7 +46,7 @@ func TestGoldenAddCmd(t *testing.T) {
 		}
 
 		// Make path relative to project.CmdPath().
-		// E.g. path = "/home/user/go/src/github.com/spf13/testproject/cmd/root.go"
+		// E.g. path = "/home/user/go/src/github.com/OneCloudInc/testproject/cmd/root.go"
 		// then it returns just "root.go".
 		relPath, err := filepath.Rel(project.CmdPath(), path)
 		if err != nil {

cobra/cmd/flag_helpers.go

@@ -0,0 +1,89 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+var specialFlagTypes = []string{"stringMapFlag", "genericMapFlag"}
+
+// Indexes for flag definition string after split {name}:{type}:{description}
+const (
+	FlagDefLength = 3
+	FlagDefSeparator = ":"
+	FlagDefault = ` "",`
+	FlagNameIndex = 0
+	FlagTypeIndex = 1
+	FlagDescriptionIndex = 2
+)
+
+type flagDefinition struct {
+	Name string
+	FlagType string
+	FlagDescription string
+	CreateFn string
+	VarName string
+	Default string
+	CmdName string
+}
+
+func printFlagVars(iFlags interface{}) string {
+	flags := toFlagArray(iFlags)
+	varDefs := ""
+	for _, f := range flags {
+		varDefs += fmt.Sprintf("var %s %s\r\n", f.VarName, f.FlagType)
+	}
+	return varDefs
+}
+
+func printFlagCreates(iFlags interface{}, persistent bool) string {
+	flags := toFlagArray(iFlags)
+	createStrs := ""
+	flagsFn := "Flags"
+	if persistent {
+		flagsFn = "PersistentFlags"
+	}
+	for _, f := range flags {
+		createStrs += fmt.Sprintf( `
+%sCmd.%s().%s(&%s, "%s",%s "%s")`,
+			f.CmdName,
+			flagsFn,
+			f.CreateFn,
+			f.VarName,
+			f.Name,
+			f.Default,
+			f.FlagDescription)
+	}
+	return createStrs
+}
+
+func toFlagArray(value interface{}) []flagDefinition {
+	switch v := value.(type) {
+	case []flagDefinition:
+		return v
+	// Add whatever other types you need
+	default:
+		return []flagDefinition{}
+	}
+}
+
+func buildFlag(in, cmdName string) (flagDefinition, error) {
+	var def flagDefinition
+	values := strings.Split(in, FlagDefSeparator)
+	if len(values) != FlagDefLength {
+		return def, errors.New("invalid flag definition, make sure to specify flags as 'name:type:definition' they are all required")
+	}
+	name, flagType, desc := values[FlagNameIndex], values[FlagTypeIndex],values[FlagDescriptionIndex]
+	def = flagDefinition{
+		Name: name,
+		FlagType: flagType,
+		FlagDescription: desc,
+		CreateFn: fmt.Sprintf("%s%s", strings.Title(flagType), "Var"),
+		VarName: fmt.Sprintf("%s%sFlag", cmdName, name),
+		Default:FlagDefault,
+		CmdName: cmdName,
+	}
+
+	return def, nil
+}

cobra/cmd/helpers.go

@@ -111,7 +111,7 @@ func exists(path string) bool {
 }
 
 func executeTemplate(tmplStr string, data interface{}) (string, error) {
-	tmpl, err := template.New("").Funcs(template.FuncMap{"comment": commentifyString}).Parse(tmplStr)
+	tmpl, err := template.New("").Funcs(template.FuncMap{"comment": commentifyString, "printFlagVars": printFlagVars, "printFlagCreates": printFlagCreates}).Parse(tmplStr)
 	if err != nil {
 		return "", err
 	}