337 lines
8.6 KiB
V
337 lines
8.6 KiB
V
module cli
|
|
|
|
import term
|
|
|
|
type FnCommandCallback = fn (cmd Command) ?
|
|
|
|
// str returns the `string` representation of the callback.
|
|
pub fn (f FnCommandCallback) str() string {
|
|
return 'FnCommandCallback=>' + ptr_str(f)
|
|
}
|
|
|
|
// Command is a structured representation of a single command
|
|
// or chain of commands.
|
|
pub struct Command {
|
|
pub mut:
|
|
name string
|
|
usage string
|
|
description string
|
|
man_description string
|
|
version string
|
|
pre_execute FnCommandCallback
|
|
execute FnCommandCallback
|
|
post_execute FnCommandCallback
|
|
disable_help bool
|
|
disable_man bool
|
|
disable_version bool
|
|
disable_flags bool
|
|
sort_flags bool
|
|
sort_commands bool
|
|
parent &Command = 0
|
|
commands []Command
|
|
flags []Flag
|
|
required_args int
|
|
args []string
|
|
posix_mode bool
|
|
}
|
|
|
|
// str returns the `string` representation of the `Command`.
|
|
pub fn (cmd Command) str() string {
|
|
mut res := []string{}
|
|
res << 'Command{'
|
|
res << ' name: "$cmd.name"'
|
|
res << ' usage: "$cmd.usage"'
|
|
res << ' version: "$cmd.version"'
|
|
res << ' description: "$cmd.description"'
|
|
res << ' man_description: "$cmd.man_description"'
|
|
res << ' disable_help: $cmd.disable_help'
|
|
res << ' disable_man: $cmd.disable_man'
|
|
res << ' disable_flags: $cmd.disable_flags'
|
|
res << ' disable_version: $cmd.disable_version'
|
|
res << ' sort_flags: $cmd.sort_flags'
|
|
res << ' sort_commands: $cmd.sort_commands'
|
|
res << ' cb execute: $cmd.execute'
|
|
res << ' cb pre_execute: $cmd.pre_execute'
|
|
res << ' cb post_execute: $cmd.post_execute'
|
|
if unsafe { cmd.parent == 0 } {
|
|
res << ' parent: &Command(0)'
|
|
} else {
|
|
res << ' parent: &Command{$cmd.parent.name ...}'
|
|
}
|
|
res << ' commands: $cmd.commands'
|
|
res << ' flags: $cmd.flags'
|
|
res << ' required_args: $cmd.required_args'
|
|
res << ' args: $cmd.args'
|
|
res << '}'
|
|
return res.join('\n')
|
|
}
|
|
|
|
// is_root returns `true` if this `Command` has no parents.
|
|
pub fn (cmd Command) is_root() bool {
|
|
return isnil(cmd.parent)
|
|
}
|
|
|
|
// root returns the root `Command` of the command chain.
|
|
pub fn (cmd Command) root() Command {
|
|
if cmd.is_root() {
|
|
return cmd
|
|
}
|
|
return cmd.parent.root()
|
|
}
|
|
|
|
// full_name returns the full `string` representation of all commands int the chain.
|
|
pub fn (cmd Command) full_name() string {
|
|
if cmd.is_root() {
|
|
return cmd.name
|
|
}
|
|
return cmd.parent.full_name() + ' $cmd.name'
|
|
}
|
|
|
|
// add_commands adds the `commands` array of `Command`s as sub-commands.
|
|
pub fn (mut cmd Command) add_commands(commands []Command) {
|
|
for command in commands {
|
|
cmd.add_command(command)
|
|
}
|
|
}
|
|
|
|
// add_command adds `command` as a sub-command of this `Command`.
|
|
pub fn (mut cmd Command) add_command(command Command) {
|
|
mut subcmd := command
|
|
if cmd.commands.contains(subcmd.name) {
|
|
eprintln_exit('Command with the name `$subcmd.name` already exists')
|
|
}
|
|
subcmd.parent = unsafe { cmd }
|
|
cmd.commands << subcmd
|
|
}
|
|
|
|
// setup ensures that all sub-commands of this `Command`
|
|
// is linked as a chain.
|
|
pub fn (mut cmd Command) setup() {
|
|
for mut subcmd in cmd.commands {
|
|
subcmd.parent = unsafe { cmd }
|
|
subcmd.posix_mode = cmd.posix_mode
|
|
subcmd.setup()
|
|
}
|
|
}
|
|
|
|
// add_flags adds the array `flags` to this `Command`.
|
|
pub fn (mut cmd Command) add_flags(flags []Flag) {
|
|
for flag in flags {
|
|
cmd.add_flag(flag)
|
|
}
|
|
}
|
|
|
|
// add_flag adds `flag` to this `Command`.
|
|
pub fn (mut cmd Command) add_flag(flag Flag) {
|
|
if cmd.flags.contains(flag.name) {
|
|
eprintln_exit('Flag with the name `$flag.name` already exists')
|
|
}
|
|
cmd.flags << flag
|
|
}
|
|
|
|
// parse parses `args` into this structured `Command`.
|
|
pub fn (mut cmd Command) parse(args []string) {
|
|
if !cmd.disable_flags {
|
|
cmd.add_default_flags()
|
|
}
|
|
cmd.add_default_commands()
|
|
if cmd.sort_flags {
|
|
cmd.flags.sort(a.name < b.name)
|
|
}
|
|
if cmd.sort_commands {
|
|
cmd.commands.sort(a.name < b.name)
|
|
}
|
|
cmd.args = args[1..]
|
|
if !cmd.disable_flags {
|
|
cmd.parse_flags()
|
|
}
|
|
cmd.parse_commands()
|
|
}
|
|
|
|
// add_default_flags adds the commonly used `-h`/`--help` and
|
|
// `-v`/`--version` flags to the `Command`.
|
|
fn (mut cmd Command) add_default_flags() {
|
|
if !cmd.disable_help && !cmd.flags.contains('help') {
|
|
use_help_abbrev := !cmd.flags.contains('h') && cmd.posix_mode
|
|
cmd.add_flag(help_flag(use_help_abbrev))
|
|
}
|
|
if !cmd.disable_version && cmd.version != '' && !cmd.flags.contains('version') {
|
|
use_version_abbrev := !cmd.flags.contains('v') && cmd.posix_mode
|
|
cmd.add_flag(version_flag(use_version_abbrev))
|
|
}
|
|
if !cmd.disable_man && !cmd.flags.contains('man') {
|
|
cmd.add_flag(man_flag())
|
|
}
|
|
}
|
|
|
|
// add_default_commands adds the command functions of the
|
|
// commonly used `help` and `version` flags to the `Command`.
|
|
fn (mut cmd Command) add_default_commands() {
|
|
if !cmd.disable_help && !cmd.commands.contains('help') && cmd.is_root() {
|
|
cmd.add_command(help_cmd())
|
|
}
|
|
if !cmd.disable_version && cmd.version != '' && !cmd.commands.contains('version') {
|
|
cmd.add_command(version_cmd())
|
|
}
|
|
if !cmd.disable_man && !cmd.commands.contains('man') && cmd.is_root() {
|
|
cmd.add_command(man_cmd())
|
|
}
|
|
}
|
|
|
|
fn (mut cmd Command) parse_flags() {
|
|
for {
|
|
if cmd.args.len < 1 || !cmd.args[0].starts_with('-') {
|
|
break
|
|
}
|
|
mut found := false
|
|
for i in 0 .. cmd.flags.len {
|
|
unsafe {
|
|
mut flag := &cmd.flags[i]
|
|
if flag.matches(cmd.args, cmd.posix_mode) {
|
|
found = true
|
|
flag.found = true
|
|
cmd.args = flag.parse(cmd.args, cmd.posix_mode) or {
|
|
eprintln_exit('Failed to parse flag `${cmd.args[0]}`: $err')
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !found {
|
|
eprintln_exit('Command `$cmd.name` has no flag `${cmd.args[0]}`')
|
|
}
|
|
}
|
|
}
|
|
|
|
fn (mut cmd Command) parse_commands() {
|
|
global_flags := cmd.flags.filter(it.global)
|
|
cmd.check_help_flag()
|
|
cmd.check_version_flag()
|
|
cmd.check_man_flag()
|
|
for i in 0 .. cmd.args.len {
|
|
arg := cmd.args[i]
|
|
for j in 0 .. cmd.commands.len {
|
|
mut command := cmd.commands[j]
|
|
if command.name == arg {
|
|
for flag in global_flags {
|
|
command.add_flag(flag)
|
|
}
|
|
command.parse(cmd.args[i..])
|
|
return
|
|
}
|
|
}
|
|
}
|
|
if cmd.is_root() && isnil(cmd.execute) {
|
|
if !cmd.disable_help {
|
|
cmd.execute_help()
|
|
return
|
|
}
|
|
}
|
|
// if no further command was found, execute current command
|
|
if cmd.required_args > 0 {
|
|
if cmd.required_args > cmd.args.len {
|
|
eprintln_exit('Command `$cmd.name` needs at least $cmd.required_args arguments')
|
|
}
|
|
}
|
|
cmd.check_required_flags()
|
|
|
|
cmd.handle_cb(cmd.pre_execute, 'preexecution')
|
|
cmd.handle_cb(cmd.execute, 'execution')
|
|
cmd.handle_cb(cmd.post_execute, 'postexecution')
|
|
}
|
|
|
|
fn (mut cmd Command) handle_cb(cb FnCommandCallback, label string) {
|
|
if !isnil(cb) {
|
|
cb(*cmd) or {
|
|
label_message := term.ecolorize(term.bright_red, 'cli $label error:')
|
|
eprintln_exit('$label_message $err')
|
|
}
|
|
}
|
|
}
|
|
|
|
fn (cmd Command) check_help_flag() {
|
|
if !cmd.disable_help && cmd.flags.contains('help') {
|
|
help_flag := cmd.flags.get_bool('help') or { return } // ignore error and handle command normally
|
|
if help_flag {
|
|
cmd.execute_help()
|
|
exit(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn (cmd Command) check_man_flag() {
|
|
if !cmd.disable_man && cmd.flags.contains('man') {
|
|
man_flag := cmd.flags.get_bool('man') or { return } // ignore error and handle command normally
|
|
if man_flag {
|
|
cmd.execute_man()
|
|
exit(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn (cmd Command) check_version_flag() {
|
|
if !cmd.disable_version && cmd.version != '' && cmd.flags.contains('version') {
|
|
version_flag := cmd.flags.get_bool('version') or { return } // ignore error and handle command normally
|
|
if version_flag {
|
|
version_cmd := cmd.commands.get('version') or { return } // ignore error and handle command normally
|
|
version_cmd.execute(version_cmd) or { panic(err) }
|
|
exit(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn (cmd Command) check_required_flags() {
|
|
for flag in cmd.flags {
|
|
if flag.required && flag.value.len == 0 {
|
|
full_name := cmd.full_name()
|
|
eprintln_exit('Flag `$flag.name` is required by `$full_name`')
|
|
}
|
|
}
|
|
}
|
|
|
|
// execute_help executes the callback registered
|
|
// for the `-h`/`--help` flag option.
|
|
pub fn (cmd Command) execute_help() {
|
|
if cmd.commands.contains('help') {
|
|
help_cmd := cmd.commands.get('help') or { return } // ignore error and handle command normally
|
|
help_cmd.execute(help_cmd) or { panic(err) }
|
|
} else {
|
|
print(cmd.help_message())
|
|
}
|
|
}
|
|
|
|
// execute_help executes the callback registered
|
|
// for the `-man` flag option.
|
|
pub fn (cmd Command) execute_man() {
|
|
if cmd.commands.contains('man') {
|
|
man_cmd := cmd.commands.get('man') or { return }
|
|
man_cmd.execute(man_cmd) or { panic(err) }
|
|
} else {
|
|
print(cmd.manpage())
|
|
}
|
|
}
|
|
|
|
fn (cmds []Command) get(name string) ?Command {
|
|
for cmd in cmds {
|
|
if cmd.name == name {
|
|
return cmd
|
|
}
|
|
}
|
|
return error('Command `$name` not found in $cmds')
|
|
}
|
|
|
|
fn (cmds []Command) contains(name string) bool {
|
|
for cmd in cmds {
|
|
if cmd.name == name {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
[noreturn]
|
|
fn eprintln_exit(message string) {
|
|
eprintln(message)
|
|
exit(1)
|
|
}
|