From 45966a4a32c16c979730c9f247ff1f89971cfde3 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Thu, 9 Oct 2014 15:53:01 -0700 Subject: [PATCH 01/13] flag inheritance --- cli/CLI.go | 36 ++++++++++--------- cli/FlagMap.go | 8 +++++ cli/ParamsList.go | 4 +-- cli/flag_access.go | 18 +++++++--- cli/flag_inheritance.go | 49 +++++++++++++++++++++++++ cli/flag_inheritance_test.go | 70 ++++++++++++++++++++++++++++++++++++ cli/flag_parsing.go | 9 +++-- cli/freeform_args_parsing.go | 4 +-- cli/param_definitions.go | 3 +- 9 files changed, 172 insertions(+), 29 deletions(-) create mode 100644 cli/flag_inheritance.go create mode 100644 cli/flag_inheritance_test.go diff --git a/cli/CLI.go b/cli/CLI.go index 2239dc4..8f6d14e 100644 --- a/cli/CLI.go +++ b/cli/CLI.go @@ -14,23 +14,25 @@ import "github.com/jwaldrip/odin/cli/values" type CLI struct { ErrorHandling ErrorHandling - aliases map[rune]*Flag - description string - errOutput io.Writer - flags flagMap - flagsTerminated bool - flagValues map[*Flag]values.Value - fn func(Command) - name string - params paramsList - paramValues map[*Param]values.Value - paramsParsed bool - parent Command - stdOutput io.Writer - subCommands map[string]*SubCommand - unparsedArgs values.List - usage func() - version string + aliases map[rune]*Flag + description string + errOutput io.Writer + flags flagMap + flagsTerminated bool + flagValues map[*Flag]values.Value + fn func(Command) + inheritedFlags flagMap + name string + params paramsList + paramValues map[*Param]values.Value + paramsParsed bool + parent Command + propogatingFlags flagMap + stdOutput io.Writer + subCommands map[string]*SubCommand + unparsedArgs values.List + usage func() + version string } func (cmd *CLI) init(name, desc string, fn func(Command), paramNames ...string) { diff --git a/cli/FlagMap.go b/cli/FlagMap.go index 0996f95..68f7253 100644 --- a/cli/FlagMap.go +++ b/cli/FlagMap.go @@ -20,3 +20,11 @@ func (fm flagMap) Sort() []*Flag { } return result } + +func (fm flagMap) Names() []string { + var keys []string + for k := range fm { + keys = append(keys, k) + } + return keys +} diff --git a/cli/ParamsList.go b/cli/ParamsList.go index 59b6d57..c97618a 100644 --- a/cli/ParamsList.go +++ b/cli/ParamsList.go @@ -26,8 +26,8 @@ func (l paramsList) Compare(Y paramsList) paramsList { // Names returns the list of parameters names as a slice of strings func (l paramsList) Names() []string { var names []string - for i := 0; i < len(l); i++ { - names = append(names, l[i].Name) + for _, item := range l { + names = append(names, item.Name) } return names } diff --git a/cli/flag_access.go b/cli/flag_access.go index 898b90a..6b68e33 100644 --- a/cli/flag_access.go +++ b/cli/flag_access.go @@ -9,10 +9,7 @@ import ( // Flag returns the Value interface to the value of the named flag, // returning nil if none exists. func (cmd *CLI) Flag(name string) values.Value { - flag, ok := cmd.flags[name] - if !ok { - panic(fmt.Sprintf("flag not defined %v", name)) - } + flag := cmd.getFlag(name) value := cmd.flagValues[flag] return value } @@ -25,3 +22,16 @@ func (cmd *CLI) Flags() values.Map { } return flags } + +func (cmd *CLI) getFlag(name string) *Flag { + var ok bool + var flag *Flag + flag, ok = cmd.flags[name] + if !ok { + flag, ok = cmd.inheritedFlags[name] + } + if !ok { + panic(fmt.Sprintf("flag not defined %v", name)) + } + return flag +} diff --git a/cli/flag_inheritance.go b/cli/flag_inheritance.go new file mode 100644 index 0000000..6b50d66 --- /dev/null +++ b/cli/flag_inheritance.go @@ -0,0 +1,49 @@ +package cli + +// InheritFlags allow flag values inherit from the commands parent +func (cmd *CLI) InheritFlags(names ...string) { + for _, name := range names { + cmd.InheritFlag(name) + } +} + +// InheritFlag allows a flags value to inherit from the commands parent +func (cmd *CLI) InheritFlag(name string) { + if cmd.parent == nil { + panic("command does not have a parent") + } + flag := cmd.parent.(*CLI).getFlag(name) + if cmd.inheritedFlags == nil { + cmd.inheritedFlags = make(flagMap) + } + cmd.inheritedFlags[name] = flag +} + +func (cmd *CLI) setFlagValuesFromParent() { + for name, flag := range cmd.inheritedFlags { + cmd.flagValues[flag] = cmd.parent.Flag(name) + } +} + +// SubCommandsInheritFlags tells all subcommands to inherit flags +func (cmd *CLI) SubCommandsInheritFlags(names ...string) { + for _, name := range names { + cmd.SubCommandsInheritFlag(name) + } +} + +// SubCommandsInheritFlag tells all subcommands to inherit a flag +func (cmd *CLI) SubCommandsInheritFlag(name string) { + flag := cmd.getFlag(name) + if cmd.propogatingFlags == nil { + cmd.propogatingFlags = make(flagMap) + } + cmd.propogatingFlags[name] = flag +} + +func (cmd *CLI) copyPropogatingFlags() { + if cmd.parent == nil { + return + } + cmd.InheritFlags(cmd.parent.(*CLI).propogatingFlags.Names()...) +} diff --git a/cli/flag_inheritance_test.go b/cli/flag_inheritance_test.go new file mode 100644 index 0000000..bd8541e --- /dev/null +++ b/cli/flag_inheritance_test.go @@ -0,0 +1,70 @@ +package cli_test + +import ( + . "github.com/jwaldrip/odin/cli" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("CLI Start", func() { + + var cli *CLI + var sub *SubCommand + var cmd Command + var subcmd Command + var didRun bool + var didRunSub bool + + BeforeEach(func() { + didRun = false + runFn := func(c Command) { + cmd = c + didRun = true + } + cli = New("v1.0.0", "sample description", runFn) + cli.ErrorHandling = PanicOnError + cli.Mute() + didRunSub = false + cli.DefineBoolFlag("foo", false, "a foo flag") + cli.DefineStringFlag("bar", "", "a foo flag") + sub = cli.DefineSubCommand("razzle", "razzle dazzle me", func(c Command) { + subcmd = c + didRunSub = true + }) + }) + + Describe("InheritFlag", func() { + It("should properly inherit a flag value from its parent", func() { + sub.InheritFlag("foo") + cli.Start("cmd", "--foo", "razzle") + Expect(subcmd.Flag("foo").Get()).To(Equal(true)) + }) + }) + + Describe("InheritFlags", func() { + It("should properly inherit flag values from its parent", func() { + sub.InheritFlags("foo", "bar") + cli.Start("cmd", "--foo", "--bar=dive", "razzle") + Expect(subcmd.Flag("foo").Get()).To(Equal(true)) + Expect(subcmd.Flag("bar").Get()).To(Equal("dive")) + }) + }) + + Describe("SubCommandsInheritFlag", func() { + It("should propogate its flag to the sub commands", func() { + cli.SubCommandsInheritFlag("foo") + cli.Start("cmd", "--foo", "razzle") + Expect(subcmd.Flag("foo").Get()).To(Equal(true)) + }) + }) + + Describe("SubCommandsInheritFlags", func() { + It("should propogate its flags to the sub commands", func() { + cli.SubCommandsInheritFlags("foo", "bar") + cli.Start("cmd", "--foo", "--bar=dive", "razzle") + Expect(subcmd.Flag("foo").Get()).To(Equal(true)) + Expect(subcmd.Flag("bar").Get()).To(Equal("dive")) + }) + }) +}) diff --git a/cli/flag_parsing.go b/cli/flag_parsing.go index 4b7b169..83d019e 100644 --- a/cli/flag_parsing.go +++ b/cli/flag_parsing.go @@ -86,6 +86,12 @@ func (cmd *CLI) parseFlags(args []string) []string { // Set all the flags to defaults before setting cmd.setFlagDefaults() + // copy propogating flags + cmd.copyPropogatingFlags() + + // Set inherited values + cmd.setFlagValuesFromParent() + // Set each flag by its set value for { // Break if no arguments remain @@ -116,9 +122,8 @@ func (cmd *CLI) parseFlags(args []string) []string { // setAliasValues sets the values of flags from thier aliases func (cmd *CLI) setAliasValues(flags []*Flag, args []string) []string { - for i := 0; i < len(flags); i++ { + for i, flag := range flags { isLastFlag := i == len(flags)-1 - flag := flags[i] if isLastFlag { args = cmd.setFlagValue(flag, args) } else { diff --git a/cli/freeform_args_parsing.go b/cli/freeform_args_parsing.go index c112e3d..9ab106c 100644 --- a/cli/freeform_args_parsing.go +++ b/cli/freeform_args_parsing.go @@ -3,8 +3,8 @@ package cli import "github.com/jwaldrip/odin/cli/values" func (cmd *CLI) assignUnparsedArgs(args []string) { - for i := 0; i < len(args); i++ { + for _, arg := range args { str := "" - cmd.unparsedArgs = append(cmd.unparsedArgs, values.NewString(args[i], &str)) + cmd.unparsedArgs = append(cmd.unparsedArgs, values.NewString(arg, &str)) } } diff --git a/cli/param_definitions.go b/cli/param_definitions.go index b7b6f3d..f073576 100644 --- a/cli/param_definitions.go +++ b/cli/param_definitions.go @@ -3,8 +3,7 @@ package cli // DefineParams sets params names from strings func (cmd *CLI) DefineParams(names ...string) { var params []*Param - for i := 0; i < len(names); i++ { - name := names[i] + for _, name := range names { param := &Param{Name: name} params = append(params, param) } From 2f6ef6c5e657d21e33213ba4173bbbb132866631 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Thu, 9 Oct 2014 15:53:57 -0700 Subject: [PATCH 02/13] bump version --- main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main.go b/main.go index 7e4d312..584e989 100644 --- a/main.go +++ b/main.go @@ -3,7 +3,7 @@ package main import odin "github.com/jwaldrip/odin/cli" // VERSION is the odin version -var VERSION = "1.3.0" +var VERSION = "1.4.0" var cli = odin.New(VERSION, "a command line DSL for go-lang", func(cmd odin.Command) { cmd.Usage() }) From 66f020fe0b00475b3d3d9f24b17db2371abb85dc Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Thu, 9 Oct 2014 16:06:55 -0700 Subject: [PATCH 03/13] ensure deep inheritance --- cli/FlagMap.go | 23 +++++++++++++++-------- cli/flag_inheritance.go | 4 +++- cli/flag_inheritance_test.go | 24 ++++++++++++++++++++++++ 3 files changed, 42 insertions(+), 9 deletions(-) diff --git a/cli/FlagMap.go b/cli/FlagMap.go index 68f7253..7ffb8b1 100644 --- a/cli/FlagMap.go +++ b/cli/FlagMap.go @@ -5,6 +5,21 @@ import "sort" // flagMap is a map of flags with the name as a string key type flagMap map[string]*Flag +func (fm flagMap) Merge(fm2 flagMap) flagMap { + for k, v := range fm2 { + fm[k] = v + } + return fm +} + +func (fm flagMap) Names() []string { + var keys []string + for k := range fm { + keys = append(keys, k) + } + return keys +} + // Sort returns a sorted list of flags func (fm flagMap) Sort() []*Flag { list := make(sort.StringSlice, len(fm)) @@ -20,11 +35,3 @@ func (fm flagMap) Sort() []*Flag { } return result } - -func (fm flagMap) Names() []string { - var keys []string - for k := range fm { - keys = append(keys, k) - } - return keys -} diff --git a/cli/flag_inheritance.go b/cli/flag_inheritance.go index 6b50d66..da97d63 100644 --- a/cli/flag_inheritance.go +++ b/cli/flag_inheritance.go @@ -45,5 +45,7 @@ func (cmd *CLI) copyPropogatingFlags() { if cmd.parent == nil { return } - cmd.InheritFlags(cmd.parent.(*CLI).propogatingFlags.Names()...) + parentPropogatingFlags := cmd.parent.(*CLI).propogatingFlags + cmd.propogatingFlags = parentPropogatingFlags.Merge(cmd.propogatingFlags) + cmd.InheritFlags(parentPropogatingFlags.Names()...) } diff --git a/cli/flag_inheritance_test.go b/cli/flag_inheritance_test.go index bd8541e..886bacb 100644 --- a/cli/flag_inheritance_test.go +++ b/cli/flag_inheritance_test.go @@ -40,6 +40,13 @@ var _ = Describe("CLI Start", func() { cli.Start("cmd", "--foo", "razzle") Expect(subcmd.Flag("foo").Get()).To(Equal(true)) }) + + Context("when there is not parent", func() { + It("should raise an error", func() { + Expect(cli.Parent()).To(BeNil()) + Expect(func() { cli.InheritFlag("") }).Should(Panic()) + }) + }) }) Describe("InheritFlags", func() { @@ -57,6 +64,14 @@ var _ = Describe("CLI Start", func() { cli.Start("cmd", "--foo", "razzle") Expect(subcmd.Flag("foo").Get()).To(Equal(true)) }) + + It("should propogate deeply", func() { + var subsubcmd Command + sub.DefineSubCommand("baz", "a deeper command", func(c Command) { subsubcmd = c }) + cli.SubCommandsInheritFlag("foo") + cli.Start("cmd", "--foo", "razzle", "baz") + Expect(subsubcmd.Flag("foo").Get()).To(Equal(true)) + }) }) Describe("SubCommandsInheritFlags", func() { @@ -66,5 +81,14 @@ var _ = Describe("CLI Start", func() { Expect(subcmd.Flag("foo").Get()).To(Equal(true)) Expect(subcmd.Flag("bar").Get()).To(Equal("dive")) }) + + It("should propogate deeply", func() { + var subsubcmd Command + sub.DefineSubCommand("baz", "a deeper command", func(c Command) { subsubcmd = c }) + cli.SubCommandsInheritFlags("foo", "bar") + cli.Start("cmd", "--foo", "--bar=dive", "razzle", "baz") + Expect(subsubcmd.Flag("foo").Get()).To(Equal(true)) + Expect(subsubcmd.Flag("bar").Get()).To(Equal("dive")) + }) }) }) From b9383aed3b90284b71f8e4cb33f7f2790d0ef99f Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Thu, 9 Oct 2014 21:25:16 -0700 Subject: [PATCH 04/13] use gopkg.in --- README.md | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 632aaa7..246fd5e 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,13 @@ A go-lang library to help build self documenting command line applications. get the package with: ``` -go get github.com/jwaldrip/odin/cli +go get gopkg.in/jwaldrip/odin.v1/cli +``` + +import it with: + +```go +import "gopkg.in/jwaldrip/odin.v1/cli" ``` ## Usage @@ -87,7 +93,7 @@ package main import ( "fmt" - "github.com/jwaldrip/odin/cli" + "gopkg.in/jwaldrip/odin.v1/cli" ) // CLI is the odin CLI From 5875526b4e842138e290fb7d7ad38f7bb8c7c155 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:19:41 -0700 Subject: [PATCH 05/13] simplify check --- cli/flag_access.go | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/cli/flag_access.go b/cli/flag_access.go index 6b68e33..2137307 100644 --- a/cli/flag_access.go +++ b/cli/flag_access.go @@ -26,10 +26,7 @@ func (cmd *CLI) Flags() values.Map { func (cmd *CLI) getFlag(name string) *Flag { var ok bool var flag *Flag - flag, ok = cmd.flags[name] - if !ok { - flag, ok = cmd.inheritedFlags[name] - } + flag, ok = cmd.inheritedFlags.Merge(cmd.flags)[name] if !ok { panic(fmt.Sprintf("flag not defined %v", name)) } From 0b7b3fc7e7b23e5c46a0eecc2d0153f4a3b3ea37 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:19:58 -0700 Subject: [PATCH 06/13] propogation edge cases --- cli/flag_inheritance_test.go | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/cli/flag_inheritance_test.go b/cli/flag_inheritance_test.go index 886bacb..2f4c442 100644 --- a/cli/flag_inheritance_test.go +++ b/cli/flag_inheritance_test.go @@ -72,6 +72,35 @@ var _ = Describe("CLI Start", func() { cli.Start("cmd", "--foo", "razzle", "baz") Expect(subsubcmd.Flag("foo").Get()).To(Equal(true)) }) + + It("should not propogate to parents", func() { + var subsubcmd Command + cli.SubCommandsInheritFlag("foo") + sub.DefineStringFlag("raz", "", "a foo flag") + sub.SubCommandsInheritFlag("raz") + sub.DefineSubCommand("baz", "a deeper command", func(c Command) { subsubcmd = c }) + cli.Start("cmd", "razzle", "--raz=taz", "baz") + Expect(func() { cmd.Flag("raz") }).To(Panic()) + Expect(subsubcmd.Flag("raz").Get()).To(Equal("taz")) + }) + + It("should allow overridding", func() { + var subsubcmd Command + cli.SubCommandsInheritFlag("foo") + sub.DefineStringFlag("foo", "", "a foo flag") + sub.DefineSubCommand("baz", "a deeper command", func(c Command) { subsubcmd = c }) + cli.Start("cmd", "--foo", "razzle", "--foo=bizare") + Expect(subcmd.Flag("foo").Get()).To(Equal("bizare")) + }) + + It("overriding should stop propogation", func() { + var subsubcmd Command + cli.SubCommandsInheritFlag("foo") + sub.DefineStringFlag("foo", "", "a foo flag") + sub.DefineSubCommand("baz", "a deeper command", func(c Command) { subsubcmd = c }) + cli.Start("cmd", "--foo", "razzle", "--foo=bizare", "baz") + Expect(func() { subsubcmd.Flag("foo") }).To(Panic()) + }) }) Describe("SubCommandsInheritFlags", func() { From 3457374a717d3b45e031448c42f7b8f3207513d8 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:21:23 -0700 Subject: [PATCH 07/13] flag propogation edge case stop any further flag propogation if the current command redefines the flag. --- cli/flag_inheritance.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/flag_inheritance.go b/cli/flag_inheritance.go index da97d63..525b956 100644 --- a/cli/flag_inheritance.go +++ b/cli/flag_inheritance.go @@ -46,6 +46,6 @@ func (cmd *CLI) copyPropogatingFlags() { return } parentPropogatingFlags := cmd.parent.(*CLI).propogatingFlags - cmd.propogatingFlags = parentPropogatingFlags.Merge(cmd.propogatingFlags) + cmd.propogatingFlags = parentPropogatingFlags.Without(cmd.flags).Merge(cmd.propogatingFlags) cmd.InheritFlags(parentPropogatingFlags.Names()...) } From ef053ca56491eacb7c618ecc273873a39561f9cd Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:21:48 -0700 Subject: [PATCH 08/13] allow for overrides --- cli/flag_inheritance.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/cli/flag_inheritance.go b/cli/flag_inheritance.go index 525b956..3a8e31d 100644 --- a/cli/flag_inheritance.go +++ b/cli/flag_inheritance.go @@ -21,7 +21,9 @@ func (cmd *CLI) InheritFlag(name string) { func (cmd *CLI) setFlagValuesFromParent() { for name, flag := range cmd.inheritedFlags { - cmd.flagValues[flag] = cmd.parent.Flag(name) + if _, exist := cmd.flags[name]; !exist { + cmd.flagValues[flag] = cmd.parent.Flag(name) + } } } From f4a00633ae215b8bcdb5554b7469db925d47a473 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:22:06 -0700 Subject: [PATCH 09/13] Add Merge and Without methods --- cli/FlagMap.go | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/cli/FlagMap.go b/cli/FlagMap.go index 7ffb8b1..13b37a8 100644 --- a/cli/FlagMap.go +++ b/cli/FlagMap.go @@ -6,10 +6,18 @@ import "sort" type flagMap map[string]*Flag func (fm flagMap) Merge(fm2 flagMap) flagMap { - for k, v := range fm2 { - fm[k] = v + mergedMap := make(flagMap) + if fm != nil { + for k, v := range fm { + mergedMap[k] = v + } } - return fm + if fm2 != nil { + for k, v := range fm2 { + mergedMap[k] = v + } + } + return mergedMap } func (fm flagMap) Names() []string { @@ -35,3 +43,19 @@ func (fm flagMap) Sort() []*Flag { } return result } + +func (fm flagMap) Without(fm2 flagMap) flagMap { + diffedMap := make(flagMap) + if fm == nil { + return diffedMap + } + if fm2 == nil { + return fm + } + for k, v := range fm { + if _, exist := fm2[k]; !exist { + diffedMap[k] = v + } + } + return diffedMap +} From 8955be348b1f28296c347a9db20aba71d09a304d Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:22:15 -0700 Subject: [PATCH 10/13] fix issue --- cli/subCommand_parsing.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/subCommand_parsing.go b/cli/subCommand_parsing.go index c912b6a..b75bb0a 100644 --- a/cli/subCommand_parsing.go +++ b/cli/subCommand_parsing.go @@ -7,7 +7,7 @@ func (cmd *CLI) parseSubCommands(args []string) ([]string, bool) { name := args[0] subcmd, ok := cmd.subCommands[name] if !ok { - subcmd.errf("invalid command: %s", name) + cmd.errf("invalid command: %s", name) } subcmd.Start(args...) From 1c07d845a127045c96fc1f4debe88b3a5b426e67 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:22:33 -0700 Subject: [PATCH 11/13] must install deps yourself --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 8549d08..a696666 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -test: install-deps +test: @clear goop exec sh -c "cd cli && go test" From 99d6b553e8ed6a05a67dfa914601703abb614738 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Fri, 10 Oct 2014 01:32:38 -0700 Subject: [PATCH 12/13] update deps --- Goopfile | 1 + Goopfile.lock | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/Goopfile b/Goopfile index 5e44e6b..2b5efd0 100644 --- a/Goopfile +++ b/Goopfile @@ -1,3 +1,4 @@ github.com/onsi/ginkgo github.com/onsi/gomega github.com/mattn/goveralls +code.google.com/p/go.tools/cmd/cover diff --git a/Goopfile.lock b/Goopfile.lock index 1e3af96..cf144b7 100644 --- a/Goopfile.lock +++ b/Goopfile.lock @@ -1,4 +1,8 @@ code.google.com/p/go-uuid #7dda39b2e7d5e265014674c5af696ba4186679e9 +code.google.com/p/go.net #9cbdc6102a92af1201a1dbe68587693f2684e8a1 +code.google.com/p/go.tools/cmd/cover #a9cbf58422bba01fd4a6c6db5c95530003e31c3a +code.google.com/p/goauth2 #afe77d958c701557ec5dc56f6936fcc194d15520 +code.google.com/p/google-api-go-client #11626ef0c2fd66fd8c9a128f6ae38b77cd101f30 github.com/mattn/goveralls #89ffc28b5e4c741a73c4ce4dd63dcf5695ca627d github.com/onsi/ginkgo #6bd31378f9b5c099a60ab96b89f8fa9b48678d44 github.com/onsi/gomega #a0ee4df1f2d58a75dd9d74e755615706d68e9ce9 From 0528a451d5f5140f3e64c2b9708a30f5a9a1b7f3 Mon Sep 17 00:00:00 2001 From: Jason Waldrip Date: Sat, 11 Oct 2014 06:45:22 -0600 Subject: [PATCH 13/13] show example of flag inheritence --- README.md | 65 ++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 55 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 246fd5e..fd050d1 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,13 @@ import it with: import "gopkg.in/jwaldrip/odin.v1/cli" ``` +or using a a package manager like [Goop](https://github.com/nitrous-io/goop): + +``` +# Goopfile +github.com/jwaldrip/odin #v1.4.0 +``` + ## Usage > [Creating a new CLI](#creating-a-new-cli) | [Flags](#flags) | [Required Parameters](#required-parameters) | [Freeform Parameters](#freeform-parameters) | [Sub Commands](#sub-commands) | [Self Documentation](#self-documentation) @@ -97,33 +104,33 @@ import ( ) // CLI is the odin CLI -var CLI = cli.New("0.0.1", "my cli", func(c cli.Command){ +var app = cli.New("0.0.1", "my cli", func(c cli.Command){ if c.Flag("gopher").Get() == true { - fmt.Println("IT IS JUST GOPHERTASTIC!!!") + fmt.Println(IS JUST GOPHERTASTIC!!!") } else { - fmt.Println("It is just fine") + fmt.Println("Is pretty dandy") } }) func init(){ - CLI.DefineBoolFlag("gopher", false, "is it gophertastic?") - CLI.FlagAlias('g', "gopher") + app.DefineBoolFlag("gopher", false, "is it gophertastic?") + app.FlagAlias('g', "gopher") } func main(){ - CLI.Start() + app.Start() } ``` ``` $ mycli -It is just fine +Is pretty dandy $ mycli --gopher -IT IS JUST GOPHERTASTIC!!! +IS JUST GOPHERTASTIC!!! $ mycli -g -IT IS JUST GOPHERTASTIC!!! +IS JUST GOPHERTASTIC!!! ``` ### Required Parameters @@ -141,7 +148,7 @@ cli.New(version string, description string, fn func(Command), params ...string) *or at a later time...* ```go -cli.DefineParams(params ...string) +app.DefineParams(params ...string) ``` #### Accessing @@ -202,6 +209,43 @@ cmd.Parent().Param("name") cmd.Parent().Flag("name") ``` +#### Flag Inheritence + +In addition to accesing the parent params via the `Parent()` you can instruct a sub command to inherit a flag from its parent. + +**example:** + +```go +package main + +import ( + "fmt" + "github.com/jwaldrip/odin" +) + +var app = cli.New("0.0.1", "sample command", func(Command){}) + +func init(){ + app.DefineStringFlag("user", "", "the user") + subcmd := app.DefineSubCommand("action", "perform an action", func(c cli.Command){ + fmt.Println("the user is:", c.Flag("user")) + fmt.Println("the action is:", c.Param("actionName")) + }) + subcmd.DefineParams("actionName") + subcmd.InheritFlag("user") +} + +func main(){ + app.Start() +} +``` + +``` +$ mycmd --user=jason action hello +the user is: jason +the action is: hello +``` + ### Self Documentation #### Usage @@ -247,6 +291,7 @@ greet-with 1.0.0 * Bash Completion * Zsh Completion * CLI Bootstrapping +* Param Inheritence ## Contributing