clir

The PostRun method allows you to specify a custom function that executes immediately after a command has finished running. The function receives a *clir.Cli parameter. Use this for tasks such as resource cleanup, closing database connections, or post-processing command output.

func main() {
    cli := clir.NewCli("MyApp", "My CLI application")

    // Define a command
    cmd := cli.NewSubCommand("mycommand", "Description of mycommand")

    // Add flags, actions, and other configurations for the command

    // Define a PostRun function for the command
    cmd.PostRun(func(c *clir.Cli) error {
        // Perform cleanup or post-processing here
        fmt.Println("Running PostRun for 'mycommand'")
        return nil // Return an error if something goes wrong
    })

    // Run the CLI application
    if err := cli.Run(os.Args[1:]...); err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
}

You can replace the default application banner by providing a custom function to SetBannerFunction. This function is called by the application and must return a string representing the banner content. The function receives a pointer to the *clir.Cli instance, allowing you to dynamically include information like the application version or short description in your banner.

The function must match the signature: func (*clir.Cli) string.

package main

import (
	"log"

	"github.com/leaanthony/clir"
)

// customBanner must match the signature: func (*clir.Cli) string
func customBanner(cli *clir.Cli) string {
	return `
 ______   __  __   ______   _________  ______   ___ __ __     
/_____/\ /_\/_/\ /_____/\ /________\/\_____/\ /__//_//_/_/\    
\:::__\/ \:\ \:\ \\::::_/\_\__.::.__\/\:::_ \\::\| \| \ \   
 \:\ \  __\:\ \:\ \\:\/___/\  \::\ \   \:\ \ \ \\:.      \ \  
  \:\ \/_/\\:\ \:\ \\_::._\:\  \::\ \   \:\ \ \ \\:.\-/:/  \ \ 
   \:\_\ \ \\:\_\:\ \ /____\:\  \::\ \   \:\_\ \ \\. \  \  \ \
    \_____\/ \_____\/ \_____\/   \__\/    \_____\/ \__\/ \__\/
     ` + cli.Version() + " - " + cli.ShortDescription()
}

func main() {
	// Create new cli
	cli := clir.NewCli("Banner", "A custom banner example", "v0.0.1")

	// Set the custom banner
	cli.SetBannerFunction(customBanner)

  // Run the application
  err := cli.Run()
  if err != nil {
    log.Fatal(err)
  }
}

You can define individual flags for your CLI application by calling specific type methods on the Cli instance. These methods take the flag name, a description, and a pointer to a variable where the parsed value will be stored.

Supported types include:

• StringFlag for string values.
• IntFlag for int values.
• BoolFlag for bool values (used as a toggle).

Example usage:

cli := clir.NewCli("Flags", "A simple example", "v0.0.1")

var name string
cli.StringFlag("name", "Your name", &name)

var age int
cli.IntFlag("age", "Your age", &age)

var awesome bool
cli.BoolFlag("awesome", "Are you awesome?", &awesome)

err := cli.Run()

package main

import "github.com/leaanthony/clir"
import "log"

func main() {
  
  // Create the application
  cli := clir.NewCli("Flags", "A simple example", "v0.0.1")

  // Add a string flag
  var name string
  cli.StringFlag("name", "Your name", &name)

  // Add an int flag
  var age int
  cli.IntFlag("age", "Your age", &age)

  // Add a bool flag
  var awesome bool
  cli.BoolFlag("awesome", "Are you awesome?", &awesome)

  // Run the application
  err := cli.Run()
  if err != nil {
    // We had an error
    log.Fatal(err)
  }
}

You can create a simple CLI application by initializing a new CLI instance with clir.NewCli, defining flags (such as StringFlag), setting an execution logic with cli.Action, and finally executing the application with cli.Run().

In the example below, a string flag named name is defined. When the application runs, the provided action function is executed, accessing the value stored in the name variable.

package main

import (
	"fmt"
	"log"

	"github.com/leaanthony/clir"
)

func main() {

    // Create new cli
    cli := clir.NewCli("Flags", "A simple example", "v0.0.1")
    
    // Name
    name := "Anonymous"
    cli.StringFlag("name", "Your name", &name)
    
    // Define action for the command
    cli.Action(func() error {
        fmt.Printf("Hello %s!\n", name)
        return nil
    })
    
    // Run the application
    err := cli.Run()
    if err != nil {
        // We had an error
        log.Fatal(err)
    }

}

For cleaner code and easier management, you can define multiple flags at once using a struct. This is particularly useful for subcommands.

Use the AddFlags method on a subcommand (or the main CLI) and pass a pointer to a struct. The struct fields must be decorated with the following tags:

• name: The flag name (defaults to the field name if omitted).
• description: The help text for the flag.
• default: (Optional) The default value for the flag.
• pos: (Optional) The positional argument index (e.g., "1", "2").

Note: You must pass a pointer to the struct to AddFlags, otherwise the method will panic.

type Flags struct {
	Name string `name:"name" description:"The name of the person"`
	Age  int    `name:"age" description:"The age of the person"`
}

// ... inside main ...
cli := clir.NewCli("flagstruct", "An example", "v0.0.1")
init := cli.NewSubCommand("create", "Create a person")
person := &Flags{
	Age: 20,
}
init.AddFlags(person)
init.Action(func() error {
	println("Name:", person.Name, "Age:", person.Age)
	return nil
})

if err := cli.Run(); err != nil {
	panic(err)
}