commando/commando.go at master · devproje/commando · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package commando

import (
	"fmt"

	"github.com/devproje/commando/types"
)

type Commando struct {
	args  []string
	nodes []Node
}

type Node struct {
	Name     string
	Desc     string
	Commando *Commando
	Handler  ArgHandler
	SubNodes []Node
	Opts     []types.OptionData
}

type ArgHandler func(n *Node) error

func NewCommando(args []string) *Commando {
	return &Commando{nodes: make([]Node, 0), args: args}
}

func (c *Commando) Args() []string {
	return c.args
}

func (c *Commando) Nodes() []Node {
	return c.nodes
}

func (c *Commando) Execute() error {
	if len(c.args) == 0 {
		return fmt.Errorf("no command specified")
	}

	cmd := c.args[0]
	var node *Node

	for _, n := range c.nodes {
		if n.Name == cmd {
			node = &n
		}
	}

	if node == nil {
		return fmt.Errorf("no command name: %s", cmd)
	}

	var err error
	handler := node.Handler
	if handler == nil {
		if len(node.SubNodes) > 0 {
			if len(c.args) == 1 {
				return fmt.Errorf("no command specified: %s", c.args[0])
			}

			cmd = c.args[1]
			for _, n := range node.SubNodes {
				if n.Name == cmd {
					node = &n
					break
				}
			}

			if node == nil {
				return fmt.Errorf("no command name: %s", cmd)
			}

			handler = node.Handler
			if handler == nil {
				return fmt.Errorf("no command name: %s", cmd)
			}

			err = handler(node)
			if err != nil {
				return err
			}

			return nil
		}

		return fmt.Errorf("no command handler: %s", cmd)
	}

	err = handler(node)
	if err != nil {
		return err
	}

	return nil
}

func (c *Commando) Root(name, desc string, handler ArgHandler, options ...types.OptionData) {
	c.nodes = append(c.nodes, Node{
		Name:     name,
		Desc:     desc,
		Commando: c,
		Handler:  handler,
		SubNodes: nil,
		Opts:     options,
	})
}

func (c *Commando) ComplexRoot(name, desc string, subNodes []Node, options ...types.OptionData) {
	c.nodes = append(c.nodes, Node{
		Name:     name,
		Desc:     desc,
		Commando: c,
		SubNodes: subNodes,
		Opts:     options,
	})
}

func (c *Commando) Then(name, desc string, handler ArgHandler, options ...types.OptionData) Node {
	return Node{
		Name:     name,
		Desc:     desc,
		Commando: c,
		Handler:  handler,
		SubNodes: nil,
		Opts:     options,
	}
}

func (n *Node) MustGetOpt(name string) *types.OptionData {
	for _, opt := range n.Opts {
		if opt.Name == name {
			return &opt
		}
	}

	return nil
}