cmder

package main

import (
	"context"
	"fmt"

	"github.com/brandon1024/cmder"
)

const BaseCommandExampleHelpText = `
'base-command' demonstrates how to build commands and subcommands with BaseCommand.
`

const BaseCommandExampleExamples = `
# broadcast hello to the world
base-command from cmder
`

type BaseCommandExample struct {
	cmder.BaseCommand
}

func (c *BaseCommandExample) Run(ctx context.Context, args []string) error {
	fmt.Printf("%s: %v\n", c.Name(), args)
	return nil
}

func main() {
	cmd := &BaseCommandExample{
		BaseCommand: cmder.BaseCommand{
			CommandName: "base-command",
			Usage:       "base-command [<args>...]",
			ShortHelp:   "Simple demonstration of BaseCommand",
			Help:        BaseCommandExampleHelpText,
			Examples:    BaseCommandExampleExamples,
			Children: []cmder.Command{
				&cmder.BaseCommand{
					CommandName: "child",
					Usage:       "child [<args>...]",
					ShortHelp:   "A child command with simple behaviour",
					Help:        "I'm a simple subcommand with simple behaviour!",
					RunFunc: func(ctx context.Context, args []string) error {
						fmt.Printf("child: %v\n", args)
						return nil
					},
				},
			},
		},
	}

	args := []string{"child", "cmder"}
	if err := cmder.Execute(context.Background(), cmd, cmder.WithArgs(args)); err != nil {
		fmt.Printf("unexpected error occurred: %v", err)
	}

}

Output:

child: [cmder]

package main

import (
	"context"
	"fmt"

	"github.com/brandon1024/cmder"
)

const HelloWorldCommandUsageLine = `hello-world [<args>...]`

const HelloWorldCommandShortHelpText = `Simple demonstration of cmder`

const HelloWorldCommandHelpText = `
'hello-world' demonstrates the simplest usage of cmder. This example defines a single command 'hello-world' that
implements the Runnable and Documented interfaces.
`

const HelloWorldCommandExamples = `
# broadcast hello to the world
hello-world from cmder
`

type HelloWorldCommand struct{}

func (c *HelloWorldCommand) Name() string {
	return "hello-world"
}

func (c *HelloWorldCommand) Run(ctx context.Context, args []string) error {
	fmt.Printf("%s: %v\n", c.Name(), args)
	return nil
}

func (c *HelloWorldCommand) UsageLine() string {
	return HelloWorldCommandUsageLine
}

func (c *HelloWorldCommand) ShortHelpText() string {
	return HelloWorldCommandShortHelpText
}

func (c *HelloWorldCommand) HelpText() string {
	return HelloWorldCommandHelpText
}

func (c *HelloWorldCommand) main() string {
	return HelloWorldCommandExamples
}

func (c *HelloWorldCommand) Hidden() bool {
	return false
}

func main() {
	args := []string{"from", "cmder"}
	cmd := &HelloWorldCommand{}

	if err := cmder.Execute(context.Background(), cmd, cmder.WithArgs(args)); err != nil {
		fmt.Printf("unexpected error occurred: %v", err)
	}

}

Output:

hello-world: [from cmder]

package main

import (
	"context"
	"fmt"

	"github.com/brandon1024/cmder"
	"github.com/brandon1024/cmder/flag"
)

// === PARENT COMMAND ===

const ParentFlagsCommandUsageLine = `parent-flags [<subcommand>] [<args>...]`

const ParentFlagsCommandShortHelpText = `Example of parent command with flags`

const ParentFlagsCommandHelpText = `
'parent-flags' demonstrates an example of a command with subcommands and flags. Commands can define flags by
implementing the FlagInitializer interface. During execution, flags are parsed at each level in the command tree and
can be accessed by the command's Run routine.
`

const ParentFlagsCommandExamples = `
# run the parent 'Run' routine with flags
parent-flags --option string

# run the child 'Run' routine with flags
parent-flags child-flags --count 1

# run with some additional args
parent-flags --option string hello-world
parent-flags --option string child-flags --count 1 hello-world
`

type ParentFlagsCommand struct {
	cmder.BaseCommand

	option string
}

func (c *ParentFlagsCommand) Initialize(ctx context.Context, args []string) error {
	fmt.Printf("%s: init [%s] %v\n", c.Name(), c.option, args)
	return nil
}

func (c *ParentFlagsCommand) Run(ctx context.Context, args []string) error {
	fmt.Printf("%s: run [%s] %v\n", c.Name(), c.option, args)
	return nil
}

func (c *ParentFlagsCommand) Destroy(ctx context.Context, args []string) error {
	fmt.Printf("%s: destroy [%s] %v\n", c.Name(), c.option, args)
	return nil
}

func (c *ParentFlagsCommand) InitializeFlags(fs *flag.FlagSet) {
	fs.StringVar(&c.option, "option", "", "parent command option string argument")
}

func NewParentFlagsCommand() *ParentFlagsCommand {
	return &ParentFlagsCommand{
		BaseCommand: cmder.BaseCommand{
			CommandName: "parent-flags",
			Usage:       ParentFlagsCommandUsageLine,
			ShortHelp:   ParentFlagsCommandShortHelpText,
			Help:        ParentFlagsCommandHelpText,
			Examples:    ParentFlagsCommandExamples,
			Children: []cmder.Command{
				NewChildFlagsCommand(),
			},
		},
	}
}

// === CHILD COMMAND ===

const ChildFlagsCommandUsageLine = `child-flags [<args>...]`

const ChildFlagsCommandShortHelpText = `Example of child command`

const ChildFlagsCommandHelpText = `
'child-flags' is the subcommand of 'parent-flags'.
`

const ChildFlagsCommandExamples = `
# run the child 'Run' routine with flags
parent-flags child-flags --count 1

# run with some additional args
parent-flags --option string child-flags --count 1 hello-world
`

type ChildFlagsCommand struct {
	cmder.BaseCommand

	count int
}

func (c *ChildFlagsCommand) Initialize(ctx context.Context, args []string) error {
	fmt.Printf("%s: init [%d] %v\n", c.Name(), c.count, args)
	return nil
}

func (c *ChildFlagsCommand) Run(ctx context.Context, args []string) error {
	fmt.Printf("%s: run [%d] %v\n", c.Name(), c.count, args)
	return nil
}

func (c *ChildFlagsCommand) Destroy(ctx context.Context, args []string) error {
	fmt.Printf("%s: destroy [%d] %v\n", c.Name(), c.count, args)
	return nil
}

func (c *ChildFlagsCommand) InitializeFlags(fs *flag.FlagSet) {
	fs.IntVar(&c.count, "count", 0, "child command count integer argument")
}

func NewChildFlagsCommand() *ChildFlagsCommand {
	return &ChildFlagsCommand{
		BaseCommand: cmder.BaseCommand{
			CommandName: "child-flags",
			Usage:       ChildFlagsCommandUsageLine,
			ShortHelp:   ChildFlagsCommandShortHelpText,
			Help:        ChildFlagsCommandHelpText,
			Examples:    ChildFlagsCommandExamples,
		},
	}
}

// === EXAMPLE ===

func main() {
	cmd := NewParentFlagsCommand()

	args := []string{"--option", "test=1", "child-flags", "--count", "1", "hello-world"}
	if err := cmder.Execute(context.Background(), cmd, cmder.WithArgs(args)); err != nil {
		fmt.Printf("unexpected error occurred: %v", err)
	}

}

Output:

parent-flags: init [test=1] [child-flags --count 1 hello-world]
child-flags: init [1] [hello-world]
child-flags: run [1] [hello-world]
child-flags: destroy [1] [hello-world]
parent-flags: destroy [test=1] [child-flags --count 1 hello-world]

package main

import (
	"context"
	"fmt"

	"github.com/brandon1024/cmder"
)

// === PARENT COMMAND ===

const ParentCommandUsageLine = `parent [<subcommand>] [<args>...]`

const ParentCommandShortHelpText = `Example of parent command`

const ParentCommandHelpText = `
'parent' demonstrates an example of a command with subcommands. When executed without any arguments, the parent's Run
routine is executed, but if the child subcommand is provided the child subcommand Run routine will be exeuted instead.

The parent implements RootCommand indicating that it is a root command with runnable subcommands. The child does not
implement RootCommand, indicating it is a leaf command.

In this example, the parent and child commands implement RunnableLifecycle, and their respective init/destroy routines
are invoked in this order:

  1. parent Initialize
  2. child Initialize
  3. child Run
  4. child Destroy
  5. parent Destroy
`

const ParentCommandExamples = `
# run the parent 'Run' routine
parent

# run the child 'Run' routine
parent child

# run with some additional args
parent hello-world
parent child hello-world
`

type ParentCommand struct {
	subcommands []cmder.Command
}

func (c *ParentCommand) Name() string {
	return "parent"
}

func (c *ParentCommand) Initialize(ctx context.Context, args []string) error {
	fmt.Printf("%s: init %v\n", c.Name(), args)
	return nil
}

func (c *ParentCommand) Run(ctx context.Context, args []string) error {
	fmt.Printf("%s: run %v\n", c.Name(), args)
	return nil
}

func (c *ParentCommand) Destroy(ctx context.Context, args []string) error {
	fmt.Printf("%s: destroy %v\n", c.Name(), args)
	return nil
}

func (c *ParentCommand) UsageLine() string {
	return ParentCommandUsageLine
}

func (c *ParentCommand) ShortHelpText() string {
	return ParentCommandShortHelpText
}

func (c *ParentCommand) HelpText() string {
	return ParentCommandHelpText
}

func (c *ParentCommand) main() string {
	return ParentCommandExamples
}

func (c *ParentCommand) Hidden() bool {
	return false
}

func (c *ParentCommand) Subcommands() []cmder.Command {
	return c.subcommands
}

// === CHILD COMMAND ===

const ChildCommandUsageLine = `child [<args>...]`

const ChildCommandShortHelpText = `Example of child command`

const ChildCommandHelpText = `
'child' is the subcommand of 'parent'.
`

const ChildCommandExamples = `
# run the child 'Run' routine
parent child

# run with some additional args
parent child hello-world
`

type ChildCommand struct{}

func (c *ChildCommand) Name() string {
	return "child"
}

func (c *ChildCommand) Initialize(ctx context.Context, args []string) error {
	fmt.Printf("%s: init %v\n", c.Name(), args)
	return nil
}

func (c *ChildCommand) Run(ctx context.Context, args []string) error {
	fmt.Printf("%s: run %v\n", c.Name(), args)
	return nil
}

func (c *ChildCommand) Destroy(ctx context.Context, args []string) error {
	fmt.Printf("%s: destroy %v\n", c.Name(), args)
	return nil
}

func (c *ChildCommand) UsageLine() string {
	return ChildCommandUsageLine
}

func (c *ChildCommand) ShortHelpText() string {
	return ChildCommandShortHelpText
}

func (c *ChildCommand) HelpText() string {
	return ChildCommandHelpText
}

func (c *ChildCommand) main() string {
	return ChildCommandExamples
}

func (c *ChildCommand) Hidden() bool {
	return false
}

// === EXAMPLE ===

func main() {
	cmd := &ParentCommand{
		subcommands: []cmder.Command{&ChildCommand{}},
	}

	args := []string{"child", "hello-world"}
	if err := cmder.Execute(context.Background(), cmd, cmder.WithArgs(args)); err != nil {
		fmt.Printf("unexpected error occurred: %v", err)
	}

}

Output:

parent: init [child hello-world]
child: init [hello-world]
child: run [hello-world]
child: destroy [hello-world]
parent: destroy [child hello-world]

package main

import (
	"context"
	"fmt"

	"github.com/brandon1024/cmder"
)

const LifecycleCommandUsageLine = `lifecycle [<args>...]`

const LifecycleCommandShortHelpText = `Example command with lifecycle routines`

const LifecycleCommandHelpText = `
'lifecycle' demonstrates a command that implements the RunnableLifecycle interface, defining initialization and
destroy routines.
`

const LifecycleCommandExamples = `
# demonstrate initialization and teardown
lifecycle
`

type LifecycleCommand struct{}

func (c *LifecycleCommand) Name() string {
	return "lifecycle"
}

func (c *LifecycleCommand) Initialize(ctx context.Context, args []string) error {
	fmt.Println("lifecycle: initializing")
	return nil
}

func (c *LifecycleCommand) Run(ctx context.Context, args []string) error {
	fmt.Println("lifecycle: running")
	return nil
}

func (c *LifecycleCommand) Destroy(ctx context.Context, args []string) error {
	fmt.Println("lifecycle: shutting down")
	return nil
}

func (c *LifecycleCommand) UsageLine() string {
	return LifecycleCommandUsageLine
}

func (c *LifecycleCommand) ShortHelpText() string {
	return LifecycleCommandShortHelpText
}

func (c *LifecycleCommand) HelpText() string {
	return LifecycleCommandHelpText
}

func (c *LifecycleCommand) main() string {
	return LifecycleCommandExamples
}

func (c *LifecycleCommand) Hidden() bool {
	return false
}

func main() {
	args := []string{}

	cmd := &LifecycleCommand{}

	if err := cmder.Execute(context.Background(), cmd, cmder.WithArgs(args)); err != nil {
		fmt.Printf("unexpected error occurred: %v", err)
	}

}

Output:

lifecycle: initializing
lifecycle: running
lifecycle: shutting down