configape

package main

import (
	"fmt"
	"os"

	"github.com/zafnz/configape"
)

func main() {
	cfg := struct {
		Foo       string `name:"foo" default:"baz" help:"This is the help for foo"`
		Bar       int    `default:"42"`
		Test      bool   `default:"true"`
		Verbosity int    `name:"verbose" short:"v" default:"0" cfgtype:"counter" help:"Verbosity level"`
		Baz       string
	}{}
	// Fake the os arguments, here we use --no-test to override
	// the default true value of test, and we increment verbosity twice
	os.Args = []string{"test", "--foo", "bar", "--no-test", "-v", "-v"}
	os.Setenv("CFG_BAZ", "environment")

	configape.Apply(&cfg, nil)

	fmt.Printf("Foo: %s\n", cfg.Foo)
	fmt.Printf("Bar: %d\n", cfg.Bar)
	fmt.Printf("Test: %t\n", cfg.Test)
	fmt.Printf("Baz: %s\n", cfg.Baz)
	fmt.Printf("Verbosity: %d\n", cfg.Verbosity)

}

Output:

Foo: bar
Bar: 42
Test: false
Baz: environment
Verbosity: 2

package main

import (
	"fmt"
	"os"

	"github.com/zafnz/configape"
)

// This example shows how to use configape to parse a complex configuration

// Define a struct to hold the configuration
type ComplexConfig struct {
	// The name tag is used to map the configuration to the struct
	// field. If the name tag is not specified, the field name is
	// used instead.
	// The default tag is used to specify the default value for the
	// field.
	// The help tag is used to specify the help text for the field.
	// The cfgtype tag is used to specify the type of the field.
	// The short tag is used to specify the short name for the field.
	// The env tag is used to specify the environment variable name
	// for the field.
	// The required tag is used to specify that the field must be
	// specified.

	// This can be set with --simple-string or CFG_SIMPLE_STRING
	// or "SimpleString" in the config file.
	SimpleString   string `help:"This is the help for simple string"`
	SimpleInt      int    `default:"42"`     // This will default to 42
	RequiredString string `required:"true"`  // This must be specified
	Different      string `name:"something"` // This can be set with --something or CFG_SOMETHING
	// Here this can be set with --short or -s.
	ShortFlag bool   `name:"short" short:"s" help:"This is the help for the short flag"`
	NotOnCli  string `cli:"-"` // This will not be on the cli, but is settable in the config file

	ConfigFile string `cli:"config" cfgtype:"configfile" help:"Load config from this file"`

	// Example of a sub-configuration. Here all of these settings
	// can be set with a prefix of "--database--" on the cli, or
	// as an object in the config file.
	Database struct {
		// Set with --database-host or CFG_DATABASE_HOST
		Host string `help:"Database host"`
		// Set with --database-port or CFG_DATABASE_PORT
		Port int `help:"Database port"`
	}
}

// Here we can see how to apply the configuration to the struct.
// Note that because we haven't specified a specific name, we can
// use camel case, or underscores, or dashes, for those fields.
var cfgFile = `
{
	"simple_string": "foo",
	"SimpleInt": 69,
	"required_string": "bar",
	"not_on_cli": "set in config file"
}`

func main() {
	// Write out the config as a temporary file to use
	fh, _ := os.CreateTemp("", "configape")
	defer os.Remove(fh.Name())
	fh.WriteString(cfgFile)

	os.Args = []string{"test", "--something", "set on cli", "--database-host", "dbhost", "-s", "--config", fh.Name()}

	cfg := ComplexConfig{}
	err := configape.Apply(&cfg, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Printf("SimpleString: %s\n", cfg.SimpleString)
	fmt.Printf("SimpleInt: %d\n", cfg.SimpleInt)
	fmt.Printf("RequiredString: %s\n", cfg.RequiredString)
	fmt.Printf("Different: %s\n", cfg.Different)
	fmt.Printf("ShortFlag: %t\n", cfg.ShortFlag)
	fmt.Printf("NotOnCli: %s\n", cfg.NotOnCli)
	fmt.Printf("Database.Host: %s\n", cfg.Database.Host)

}

Output:

SimpleString: foo
SimpleInt: 69
RequiredString: bar
Different: set on cli
ShortFlag: true
NotOnCli: set in config file
Database.Host: dbhost

package main

import (
	"fmt"

	"github.com/zafnz/configape"
)

// This example shows how to use configape to parse a complex configuration

// Define a struct to hold the configuration
type HelpExampleConfig struct {
	// This is the same as the complex example, see that for an explanation
	// of all the tags.
	SimpleString   string `help:"This is the help for simple string"`
	SimpleInt      int    `default:"42"`
	RequiredString string `required:"true"`
	Different      string `name:"something"`
	ShortFlag      bool   `name:"short" short:"s" help:"This is the help for the short flag"`
	NotOnCli       string `cli:"-"`

	ConfigFile string `cli:"config" cfgtype:"configfile" help:"Load config from this file"`

	Database struct {
		// Set with --database-host or CFG_DATABASE_HOST
		Host string `help:"Database host to connect to"`
		// Set with --database-port or CFG_DATABASE_PORT
		Port int `help:"Database port to use with the database host"`
	}
}

func main() {
	cfg := HelpExampleConfig{}
	help, _ := configape.Help(cfg, &configape.Options{Name: "example"})
	fmt.Println(help)

}

Output:

example (v0.0.0)

  --simple-string <SimpleString>
    This is the help for simple string
  --simple-int <SimpleInt> (default: 42)
  --required-string <RequiredString>
  --something <something>
  --short, -s
    This is the help for the short flag
  --config <ConfigFile>
    Load config from this file

database

  --database-host <Host>
    Database host to connect to
  --database-port <Port>
    Database port to use with the database host