v/vlib/cli/command.v

306 lines
7.7 KiB
V
Raw Normal View History

2019-11-21 13:03:12 +01:00
module cli
2020-08-20 23:14:53 +02:00
type FnCommandCallback = fn (cmd Command) ?
// str returns the `string` representation of the callback.
pub fn (f FnCommandCallback) str() string {
return 'FnCommandCallback=>' + ptr_str(f)
}
2020-04-16 14:50:04 +02:00
// Command is a structured representation of a single command
// or chain of commands.
2019-11-21 13:03:12 +01:00
pub struct Command {
pub mut:
name string
usage string
description string
version string
pre_execute FnCommandCallback
execute FnCommandCallback
post_execute FnCommandCallback
disable_help bool
2019-11-21 13:03:12 +01:00
disable_version bool
disable_flags bool
sort_flags bool = true
sort_commands bool = true
parent &Command = 0
commands []Command
flags []Flag
2020-08-20 23:14:53 +02:00
required_args int
args []string
}
// 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 << ' disable_help: $cmd.disable_help'
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 cmd.parent == 0 {
res << ' parent: &Command(0)'
} else {
res << ' parent: &Command{$cmd.parent.name ...}'
}
res << ' commands: $cmd.commands'
res << ' flags: $cmd.flags'
2020-08-20 23:14:53 +02:00
res << ' required_args: $cmd.required_args'
res << ' args: $cmd.args'
res << '}'
return res.join('\n')
}
2019-11-21 13:03:12 +01:00
// 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()
2019-11-21 13:03:12 +01:00
}
// full_name returns the full `string` representation of all commands int the chain.
2019-11-21 13:03:12 +01:00
pub fn (cmd Command) full_name() string {
if cmd.is_root() {
2019-11-21 13:03:12 +01:00
return cmd.name
}
return cmd.parent.full_name() + ' $cmd.name'
2019-11-21 13:03:12 +01:00
}
// 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)
2019-11-21 13:03:12 +01:00
}
}
// add_command adds `command` as a sub-command of this `Command`.
2020-05-17 13:51:18 +02:00
pub fn (mut cmd Command) add_command(command Command) {
2020-08-20 23:14:53 +02:00
mut subcmd := command
if cmd.commands.contains(subcmd.name) {
println('Command with the name `$subcmd.name` already exists')
exit(1)
}
2020-08-20 23:14:53 +02:00
subcmd.parent = cmd
cmd.commands << subcmd
2019-11-21 13:03:12 +01:00
}
// setup ensures that all sub-commands of this `Command`
// is linked as a chain.
2021-01-05 12:25:25 +01:00
pub fn (mut cmd Command) setup() {
for mut subcmd in cmd.commands {
subcmd.parent = cmd
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`.
2020-05-17 13:51:18 +02:00
pub fn (mut cmd Command) add_flag(flag Flag) {
2020-08-20 23:14:53 +02:00
if cmd.flags.contains(flag.name) {
println('Flag with the name `$flag.name` already exists')
exit(1)
}
2019-11-21 13:03:12 +01:00
cmd.flags << flag
}
// parse parses `args` into this structured `Command`.
2020-05-17 13:51:18 +02:00
pub fn (mut cmd Command) parse(args []string) {
if !cmd.disable_flags {
cmd.add_default_flags()
}
2019-11-21 13:03:12 +01:00
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)
}
2019-11-30 10:37:34 +01:00
cmd.args = args[1..]
if !cmd.disable_flags {
cmd.parse_flags()
}
2019-11-21 13:03:12 +01:00
cmd.parse_commands()
}
// add_default_flags adds the commonly used `-h`/`--help` and
// `-v`/`--version` flags to the `Command`.
2020-05-17 13:51:18 +02:00
fn (mut cmd Command) add_default_flags() {
if !cmd.disable_help && !cmd.flags.contains('help') {
2020-08-20 23:14:53 +02:00
use_help_abbrev := !cmd.flags.contains('h') && cmd.flags.have_abbrev()
cmd.add_flag(help_flag(use_help_abbrev))
2019-11-21 13:03:12 +01:00
}
2020-08-20 23:14:53 +02:00
if !cmd.disable_version && cmd.version != '' && !cmd.flags.contains('version') {
use_version_abbrev := !cmd.flags.contains('v') && cmd.flags.have_abbrev()
cmd.add_flag(version_flag(use_version_abbrev))
2019-11-21 13:03:12 +01:00
}
}
// add_default_commands adds the command functions of the
// commonly used `help` and `version` flags to the `Command`.
2020-05-17 13:51:18 +02:00
fn (mut cmd Command) add_default_commands() {
if !cmd.disable_help && !cmd.commands.contains('help') && cmd.is_root() {
2019-11-21 13:03:12 +01:00
cmd.add_command(help_cmd())
}
2020-08-20 23:14:53 +02:00
if !cmd.disable_version && cmd.version != '' && !cmd.commands.contains('version') {
2019-11-21 13:03:12 +01:00
cmd.add_command(version_cmd())
}
}
2020-05-17 13:51:18 +02:00
fn (mut cmd Command) parse_flags() {
2019-11-21 13:03:12 +01:00
for {
if cmd.args.len < 1 || !cmd.args[0].starts_with('-') {
break
}
mut found := false
for i in 0 .. cmd.flags.len {
unsafe {
2020-12-21 20:23:40 +01:00
mut flag := &cmd.flags[i]
if flag.matches(cmd.args, cmd.flags.have_abbrev()) {
found = true
flag.found = true
cmd.args = flag.parse(cmd.args, cmd.flags.have_abbrev()) or {
println('Failed to parse flag `${cmd.args[0]}`: $err')
exit(1)
}
break
2019-11-21 13:03:12 +01:00
}
}
}
if !found {
2020-08-20 23:14:53 +02:00
println('Command `$cmd.name` has no flag `${cmd.args[0]}`')
2019-11-21 13:03:12 +01:00
exit(1)
}
}
}
fn (mut cmd Command) parse_commands() {
global_flags := cmd.flags.filter(it.global)
2019-11-21 13:03:12 +01:00
cmd.check_help_flag()
cmd.check_version_flag()
for i in 0 .. cmd.args.len {
2019-11-21 13:03:12 +01:00
arg := cmd.args[i]
for j in 0 .. cmd.commands.len {
2019-11-21 13:03:12 +01:00
mut command := cmd.commands[j]
if command.name == arg {
for flag in global_flags {
command.add_flag(flag)
}
2019-11-30 10:37:34 +01:00
command.parse(cmd.args[i..])
2019-11-21 13:03:12 +01:00
return
}
}
}
if cmd.is_root() && int(cmd.execute) == 0 {
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('Command `$cmd.name` needs at least $cmd.required_args arguments')
exit(1)
2020-08-20 23:14:53 +02:00
}
}
cmd.check_required_flags()
if int(cmd.pre_execute) > 0 {
cmd.pre_execute(*cmd) or {
eprintln('cli preexecution error: $err')
exit(1)
}
}
if int(cmd.execute) > 0 {
cmd.execute(*cmd) or {
eprintln('cli execution error: $err')
exit(1)
2020-03-10 16:11:17 +01:00
}
}
if int(cmd.post_execute) > 0 {
cmd.post_execute(*cmd) or {
eprintln('cli postexecution error: $err')
exit(1)
2020-03-10 16:11:17 +01:00
}
2019-11-21 13:03:12 +01:00
}
}
fn (cmd Command) check_help_flag() {
if !cmd.disable_help && cmd.flags.contains('help') {
2020-12-21 20:23:40 +01:00
help_flag := cmd.flags.get_bool('help') or { return } // ignore error and handle command normally
2019-11-21 13:03:12 +01:00
if help_flag {
cmd.execute_help()
2019-11-21 13:03:12 +01:00
exit(0)
}
}
}
fn (cmd Command) check_version_flag() {
2020-08-20 23:14:53 +02:00
if !cmd.disable_version && cmd.version != '' && cmd.flags.contains('version') {
2020-12-21 20:23:40 +01:00
version_flag := cmd.flags.get_bool('version') or { return } // ignore error and handle command normally
2019-11-21 13:03:12 +01:00
if version_flag {
2020-12-21 20:23:40 +01:00
version_cmd := cmd.commands.get('version') or { return } // ignore error and handle command normally
version_cmd.execute(version_cmd)
2019-11-21 13:03:12 +01:00
exit(0)
}
}
}
fn (cmd Command) check_required_flags() {
2019-11-21 13:03:12 +01:00
for flag in cmd.flags {
if flag.required && flag.value == '' {
full_name := cmd.full_name()
2020-08-20 23:14:53 +02:00
println('Flag `$flag.name` is required by `$full_name`')
2019-11-21 13:03:12 +01:00
exit(1)
}
}
}
// execute_help executes the callback registered
// for the `-h`/`--help` flag option.
2021-01-07 20:33:15 +01:00
pub fn (cmd Command) execute_help() {
if cmd.commands.contains('help') {
2020-12-21 20:23:40 +01:00
help_cmd := cmd.commands.get('help') or { return } // ignore error and handle command normally
help_cmd.execute(help_cmd)
} else {
print(cmd.help_message())
}
}
fn (cmds []Command) get(name string) ?Command {
2019-11-21 13:03:12 +01:00
for cmd in cmds {
if cmd.name == name {
return cmd
2019-11-21 13:03:12 +01:00
}
}
return error('Command `$name` not found in $cmds')
2019-11-21 13:03:12 +01:00
}
fn (cmds []Command) contains(name string) bool {
2019-11-21 13:03:12 +01:00
for cmd in cmds {
if cmd.name == name {
return true
2019-11-21 13:03:12 +01:00
}
}
return false
}