v/vlib/cli/command.v

205 lines
4.4 KiB
V
Raw Normal View History

2019-11-21 13:03:12 +01:00
module cli
2020-04-16 14:50:04 +02:00
type CallbackFn fn(cmd Command)
2019-11-21 13:03:12 +01:00
pub struct Command {
pub mut:
name string
description string
version string
2020-04-16 14:50:04 +02:00
pre_execute CallbackFn
execute CallbackFn
post_execute CallbackFn
2019-11-21 13:03:12 +01:00
disable_help bool
disable_version bool
parent &Command
commands []Command
flags []Flag
args []string
}
pub fn (cmd Command) full_name() string {
if isnil(cmd.parent) {
return cmd.name
}
return cmd.parent.full_name() + ' ${cmd.name}'
}
pub fn (cmd Command) root() Command {
if isnil(cmd.parent) {
return cmd
}
return cmd.parent.root()
}
pub fn (cmd mut Command) add_command(command Command) {
cmd.commands << command
}
pub fn (cmd mut Command) add_flag(flag Flag) {
cmd.flags << flag
}
pub fn (cmd mut Command) parse(args []string) {
cmd.add_default_flags()
cmd.add_default_commands()
2019-11-30 10:37:34 +01:00
cmd.args = args[1..]
for i in 0..cmd.commands.len {
2019-11-21 13:03:12 +01:00
cmd.commands[i].parent = cmd
}
cmd.parse_flags()
cmd.parse_commands()
}
fn (cmd mut Command) add_default_flags() {
if !cmd.disable_help && !cmd.flags.contains('help') && !cmd.flags.contains('h') {
cmd.add_flag(help_flag())
}
if !cmd.disable_version && cmd.version != '' && !cmd.flags.contains('version') && !cmd.flags.contains('v') {
cmd.add_flag(version_flag())
}
}
fn (cmd mut Command) add_default_commands() {
if !cmd.disable_help && !cmd.commands.contains('help') {
cmd.add_command(help_cmd())
}
if !cmd.disable_version && cmd.version != '' && !cmd.commands.contains('version') {
cmd.add_command(version_cmd())
}
}
fn (cmd mut 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 {
2019-11-21 13:03:12 +01:00
mut flag := &cmd.flags[i]
if flag.matches(cmd.args) {
found = true
2019-12-06 17:12:01 +01:00
args := flag.parse(cmd.args) or { // TODO: fix once options types can be assigned to struct variables
2019-11-21 13:03:12 +01:00
println('failed to parse flag ${cmd.args[0]}: ${err}')
exit(1)
}
cmd.args = args
break
}
}
if !found {
println('invalid flag: ${cmd.args[0]}')
exit(1)
}
}
}
2019-12-06 17:12:01 +01:00
fn (cmd &Command) parse_commands() {
2019-11-21 13:03:12 +01:00
flags := cmd.flags
global_flags := flags.filter(it.global) // TODO: fix once filter can be applied to struct variable
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 no further command was found execute current command
if int(cmd.execute) == 0 {
if !cmd.disable_help {
help_cmd := cmd.commands.get('help') or { return } // ignore error and handle command normally
execute := help_cmd.execute
execute(help_cmd)
}
} else {
cmd.check_required_flags()
2020-03-10 16:11:17 +01:00
if int(cmd.pre_execute) > 0 {
pre_execute := cmd.pre_execute
pre_execute(cmd)
}
2019-11-21 13:03:12 +01:00
execute := cmd.execute
execute(cmd) // TODO: fix once higher order function can be execute on struct variable
2020-03-10 16:11:17 +01:00
if int(cmd.post_execute) > 0 {
post_execute := cmd.post_execute
post_execute(cmd)
}
2019-11-21 13:03:12 +01:00
}
}
2019-12-06 17:12:01 +01:00
fn (cmd &Command) check_help_flag() {
2019-11-21 13:03:12 +01:00
if cmd.disable_help {
return
}
if cmd.flags.contains('help') {
help_flag := cmd.flags.get_bool('help') or { return } // ignore error and handle command normally
if help_flag {
help_cmd := cmd.commands.get('help') or { return } // ignore error and handle command normally
execute := help_cmd.execute
execute(help_cmd)
exit(0)
}
}
}
2019-12-06 17:12:01 +01:00
fn (cmd &Command) check_version_flag() {
2019-11-21 13:03:12 +01:00
if cmd.disable_version {
return
}
if 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
execute := version_cmd.execute
execute(version_cmd)
exit(0)
}
}
}
2019-12-06 17:12:01 +01:00
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()
println('flag \'${flag.name}\' is required by \'${full_name}\'')
exit(1)
}
}
}
fn (cmds []Command) contains(name string) bool {
for cmd in cmds {
if cmd.name == name {
return true
}
}
return false
}
fn (cmds []Command) get(name string) ?Command {
for cmd in cmds {
if cmd.name == name {
return cmd
}
}
return error('command \'${name}\' not found.')
2019-11-30 10:37:34 +01:00
}