Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/gers2017/flago
🐉 Simple and Flexible Command line flag parser in go (Working on it)
https://github.com/gers2017/flago
command-line command-line-parser flag-parser flags go golang parser
Last synced: about 5 hours ago
JSON representation
🐉 Simple and Flexible Command line flag parser in go (Working on it)
- Host: GitHub
- URL: https://github.com/gers2017/flago
- Owner: Gers2017
- License: mit
- Created: 2022-05-12T00:41:30.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2022-07-29T15:43:20.000Z (over 2 years ago)
- Last Synced: 2024-06-21T09:58:57.693Z (5 months ago)
- Topics: command-line, command-line-parser, flag-parser, flags, go, golang, parser
- Language: Go
- Homepage:
- Size: 56.6 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Flago
### 🐉 Simple and Flexible Command line flag parser
[](https://github.com/Gers2017/flago/stargazers)
[](https://github.com/Gers2017/flago/issues)
[](https://github.com/Gers2017/flago/graphs/contributors)
[](./LICENSE)
[](https://pkg.go.dev/github.com/Gers2017/flago)
## Install ⭐️
```sh
go get github.com/Gers2017/flago
```
## Basic Usage 🔥
Import flago
```go
import (
"github.com/Gers2017/flago"
)
```
Populate the flagset
```go
get := flago.NewFlagSet("get")
get.Bool("all", false)
get.Switch("verbose") // Same as get.Bool("verbose", false)
```
### Builder
```go
get := flago.NewFlagSet("get").
Bool("all", false).
Switch("verbose") // Same as get.Bool("verbose", false)
```
### Using the Cli struct
```go
cli := flago.NewCli()
cli.Handle(get, func(fs *flago.FlagSet) error {
HandleFlagset(fs) // do something with parsed get
return nil
})
if err := cli.Execute(os.Args); err != nil {
log.Fatal(err)
}
```
```go
func HandleFlagset(fs *flago.FlagSet) {
if fs.Bool("help") {
fmt.Println("Some helpful help message")
return
}
// Do something...
fmt.Println(todos)
}
```
### Without the Cli struct
Parse the arguments into flags
```go
// os.Args = []string{ "cli", "all", "help" }
if err := get.ParseFlags(os.Args[1:]); err != nil {
log.Fatal(err)
return
}
```
Then use the parsed flagset
```go
if get.IsParsed("all") {
if get.Bool("help") {
fmt.Println("Some helpful help message")
return
}
// Do something...
fmt.Println(todos)
}
```
## Demo 🐲
A complete example can be found **[here](./demo/demo.go)**
### New FlagSet
```go
get := flago.NewFlagSet("get")
```
### Add flags
```go
get.SetSwitch("verbose")
get.Int("x", 0)
```
### Check if a flag was parsed
It's highly recommended to use this method to check first if a flag was parsed correctly.
```go
get.IsParsed("your-flag-name")
```
The `FlagSet.[Bool, Int, Float, Str]` methods are just a shortcut for:
### Get values
```go
verbose := get.Bool("verbose")
x := get.Int("x")
```
If the flag name inside the getter method is not registered in the flagset, you'll get an error at runtime.
```go
wrong := get.Bool("some-invalid-flag")
```
## About the API
### Why so many strings? Isn't that error-prone?
1) The `FlagSet.[Bool, Int, Float, Str]` method can raise an error at runtine (use `FlagSet.IsParsed` to avoid this)
2) A note on golang's generics
Behind the scenes flago uses maps + generics + type parsing
The `Flag struct` contains a `Value` property of type `any`.
Because if we try to use generics we'd need to declare a map for every type of flag inside Flagset, and `Flags map[string]*Flag` wouldn't work anymore leading to repeated code.
The flag module in the standard library solves this by using pointers to the underliying values.