It's useful to support validated regular expressions in configuration. Previously, we could represent these fields as raw pattern strings and compile them in application code. By supporting Regexp as a first-class field type, we get a smaller application code and more immediate error reporting without complicating the API.

The changes add a new NoFile option and the new fig.ignoreFile field.

Giving this option to Load() will:

• Disable the default file lookup process
• The File and Dir option still work as before but become ineffective in the presence of NoFile option.

Signed-off-by: Ravi Shekhar Jethani [email protected]

Thank you for the library. It is something I've been planning to write myself. But I'd still hope for one more feature. Especially for projects packaged as docker images. Could you support some sort of environment variable interpolation syntax? Like ${FOOBAR} being read from the environment variable FOOBAR?

Howdy,

According to the documentation:

A default key in the field tag makes fig fill the field with the value specified when the field is not otherwise set.

Given the following config.yaml:

itemone:
  enabled: false

With the following program:

package main

import (
    "fmt"
    "github.com/kkyr/fig"
)

type Config struct {
    ItemOne  ItemOne   `default:{}`
    ItemTwo  ItemTwo   `default:{}`

}

type ItemOne struct {
    Enabled     bool    `fig:"enabled" default:true`
}

type ItemTwo struct {
    Enabled     bool    `fig:"enabled" default:true`
}

func main() {
    var conf Config
    err := fig.Load(&conf)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Config %+v", conf)
}

What was expected: Field ItemTwo.Enabled would be set to boolean true.

What actually happened: Field ItemTwo.Enabled is set to boolean false:

Config {ItemOne:{Enabled:false} ItemTwo:{Enabled:false}}

I've slimmed down an existing program to this most basic PoC to rule out other code in my application being a problem, though my usage is perhaps still incorrect.

It would be nice to have an option/function to explicitly load the config file that was provided by user. The idea is to have smth like:

package main

var configFile = flag.String("config", "app.yaml", "Config file to use") // so it may have the value like `/usr/local/etc/name_by_user.yaml`

func main() {
    flag.Parse()
    err := fig.Load(&cfg, fig.File(*configFile))
}

In the current implementation it wouldn't work because fig will search for the file in the current directory (.) only by default. But it also can check for the file existence using only given path:

func (f *fig) findCfgFile() (path string, err error) {
	for _, dir := range f.dirs {
		path = filepath.Join(dir, f.filename)
		if fileExists(path) {
			return
		}
	}
        if path = f.filename; fileExists(path) {
            return
        }
	return "", fmt.Errorf("%s: %w", f.filename, ErrFileNotFound)
}

It would be nice to have an API to create/update a configuration file, keeping constraints in mind.

The call would be something like:

// do something with the settings' attributes
// ....
// Update the configuration file and check the constraints
fig.Update(&cfg, fig.File("settings.json"), fig.Dir("/app/conf"))

The duration parser provided by the standard library fails when it's input doesn't include a time unit. As expected, fig also fails in such a case, but it doesn't when the input is not wrapped in quotes because it's interpreted as an integer and not a string.

For example, given:

// config.yaml
timeout: 1

// main.go
package main

import (
	"fmt"
	"log"
	"time"

	"github.com/kkyr/fig"
)

type Config struct {
	Timeout time.Duration `fig:"timeout" validate:"required"`
}

func main() {
	var cfg Config
	if err := fig.Load(&cfg); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%+v\n", cfg)
}

I would expect it to fail because timeout: 1 doesn't have a time unit, instead the config is parsed without errors and the set value is 1ns.

Maybe this could be fixed by adding a check of Int (and maybe float?) values in StringToTimeDurationHookFunc, although I may be missing some other cases.

Hi,

I would like it, if it would be possible to search for different file names (same as dirs). ex allow ./config.json ./config.yaml and ./config.toml

Thanks for the nice work.

fig uses the very powerful mapstructure under the hood just like viper. But unlike viper or uconfig it does not expose some sort of hook/middleware mechanism so that user defined logic can be executed as part of loading config

Introducing such a behavior might break backwards compatibility but it would be worth it in the long run.

Currently, environment variables can't be used as a full replacement for a config file, only in addition to one. If no config file exists, I think it should just use the defaults from the struct, check environment variables if UseEnv is set, and then return an error if required stuff is not set (e.g. port: required validation failed (using only environment as no config file could be found)).