go>> clap>> 返回
项目作者: rmite

项目描述 :
Libreria go per gestire gli argomenti della linea di comando
高级语言: Go
项目地址: git://github.com/rmite/clap.git
创建时间: 2019-04-06T19:21:16Z
项目社区:https://github.com/rmite/clap

开源协议:Other

下载


Package clap

Libreria go per gestire gli argomenti della linea di comando

Go Report Card GoDoc

Descrizione

Il package clap ti permette di acquisire gli argomenti della linea di comando dalla console definendo comandi per ogni azione della tua applicazione.

L’analisi degli argomenti con il package clap individua il comando in base ad una parola iniziale e acquisisce i valori della linea di comando per passarli ad una funzione di elaborazione personale.

La sequenza è questa:

  1. comando argomenti [argomenti opzionali] [opzioni]

dove “comando” è la parola identificativa del comando, “argomenti” sono gli argomenti obbligatori a cui seguono quelli opzionali e poi le opzioni.

Gli argomenti catturano un valore. Possono essere nominali oppure no. Gli argomenti nominali sono identificati da una parola con la sintassi:

  1. parola=valore

mentre gli argomenti generici prevedono solo il valore:

  1. valore

Le opzioni invece sono sempre identificate da una parola a cui può seguire un valore booleano:

  1. parola[=bool]

se non specificato, l’opzione acquisisce il valore default MatchValue impostato nella sua definizione.

Un’opzione può avere anche una serie di argomenti che devono essere indicati dopo essa nella riga di comando.

I valori acquisiti sono passati in puntatori a variabili impostati nella definizione di argomenti e opzioni.

Il package inoltre permette di:

  • usare un comando default, cioè riconosciuto anche senza la parola identificativa
  • definire argomenti e opzioni dei comandi sia in anticipo sia in maniera dinamica, cioè quando il comando deve essere eseguito
  • evidenziare la mancanza di argomenti necessari
  • mostrare la sintassi dei comandi
  • mostrare un help generale

Per ulteriori informazioni, consulta la documentazione del package.

Esempio

Definizione di comando e argomenti prima di chiamare Parse

  1. var commands clap.CommandMap
  2. func main() {
  3. cmdHelp := clap.NewCommand("-h", "Help", "Mostra l'help generale o per un comando.")
  4. cmdHelp.Data = new(string)
  5. cmdHelp.Exec = showHelp
  6. cmdHelp.AppendNewArg("", "cmd", false, cmdHelp.Data, "comando da descrivere")
  7. cmdVersion := clap.NewCommand("-v", "Versione", "Mostra la versione.")
  8. cmdVersion.Exec = showVersion
  9. commands = clap.NewCommandMap(2)
  10. commands.Insert(cmdHelp)
  11. commands.Insert(cmdVersion)
  12. var cmd *clap.Command
  13. var err error
  14. if cmd, err = clap.Parse(os.Args[1:], commands, nil); err != nil {
  15. fmt.Println(err)
  16. fmt.Println("")
  17. fmt.Println("Usa -h per vedere l'help.")
  18. return
  19. }
  20. if cmd != nil {
  21. cmd.Execute()
  22. } else {
  23. fmt.Println("Specifica un comando. Usa -h per vedere l'help.")
  24. }
  25. }
  26. func showHelp(data interface{}) {
  27. var str string
  28. if data != nil {
  29. str = *data.(*string)
  30. }
  31. if str != "" {
  32. if cmd, ok := commands[str]; ok {
  33. cmd.ShowFullHelp()
  34. } else {
  35. fmt.Printf("Comando inesistente: %s\n", str)
  36. }
  37. return
  38. }
  39. fmt.Println("Help generale")
  40. commands.ShowHelp()
  41. }
  42. func showVersion(data interface{}) {
  43. fmt.Println("Versione 1.0")
  44. }

e in maniera dinamica

  1. type fixArgs struct {
  2. input string
  3. output string
  4. encoding string
  5. overwrite bool
  6. appendText bool
  7. }
  8. var commands clap.CommandMap
  9. func main() {
  10. [...]
  11. cmdFix := clap.NewCommand("-fix", "Fix", "Sistema la codifica.")
  12. cmdFix.Prep = prepareFixArgs
  13. cmdFix.Exec = doFix
  14. commands = clap.NewCommandMap(3)
  15. commands.Insert(cmdHelp)
  16. commands.Insert(cmdVersion)
  17. commands.Insert(cmdFix) // non inserire il comando cmdFix nel map se vuoi usarlo solo come default con Parse
  18. var cmd *clap.Command
  19. var err error
  20. if cmd, err = clap.Parse(os.Args[1:], commands, cmdFix); err != nil {
  21. fmt.Println(err)
  22. fmt.Println("")
  23. fmt.Println("Usa -h per vedere l'help.")
  24. return
  25. }
  26. if cmd != nil {
  27. cmd.Execute()
  28. } else {
  29. fmt.Println("Specifica un comando. Usa -h per vedere l'help.")
  30. }
  31. }
  32. [...]
  33. // esempio comando
  34. // -fix input output [-enc=value] [-w] [-a]
  35. func prepareFixArgs(cmd *clap.Command) {
  36. fixdata := fixArgs{input: "none", output: "none", encoding: "none"}
  37. cmd.AppendNewArg("", "input", true, &fixdata.input, "file sorgente")
  38. cmd.AppendNewArg("", "output", true, &fixdata.output, "file destinazione")
  39. cmd.AppendNewArg("-enc", "encoding", false, &fixdata.encoding, "codifica")
  40. cmd.AppendNewOpt("-w", "overwrite", &fixdata.overwrite, "sovrascrivi")
  41. cmd.AppendNewOpt("-a", "append", &fixdata.appendText, "aggiungi")
  42. cmd.Data = &fixdata
  43. }
  44. func doFix(data interface{}) {
  45. if d, ok := data.(*fixArgs); ok {
  46. fmt.Printf("Input: '%s'\n", d.input)
  47. fmt.Printf("Output: '%s'\n", d.output)
  48. fmt.Printf("Encoding: '%s'\n", d.encoding)
  49. fmt.Printf("Overwrite: %v\n", d.overwrite)
  50. fmt.Printf("Append: %v\n", d.appendText)
  51. //codice...
  52. }
  53. }

Avendo specificato cmdFix come comando default nella chiamata a Parse, il comando può essere riconosciuto sia con la sua parola -fix

-fix source.txt dest.txt -enc=UTF8 -a

sia senza, ovvero la linea di comando contiene direttamente i suoi argomenti

source.txt dest.txt -enc=UTF8 -a

questo è l’unico modo possibile se cmdFix non fosse stato aggiunto al map commands.

Se cmdFix non fosse specificato come default, per essere riconosciuto dovrebbe essere aggiunto al map commands e la sua parola sarebbe obbligatoria.