Added EnvConfig wrapper for convenient access to environment settings with fallback to default settings. Also added some tests.

If the config key exists within the environment, it will be returned. Otherwise, the root is checked for the same key.

Usage:

Config:

val: 22
defaultVal: "default"
production:
  val: 333
  strVal: "xx"

envConfig := &EnvConfig{Env: "production", Config: cfg} 
envConfig.UInt("val") // returns 333, not 22
envConfig.UString("strVal") // returns "xx"
envConfig.UString("defaultVal")  // returns "default"

All accessors (string, int, float64, list, map) are duplicated on EnvConfig.

If you load a YAML|JSON with the ParsexxxxFile and then re-write a spurious entitiy of 'root' is added to the YAML|JSON.

This means that if you then subsequently reload the saved file it will have the spurious root, and most likely will then add another root which is pretty nasty.

.Set() does not seem to actually work.

cfg.Set("testVal", "test")
x := cfg.UString("testVal", "")
// X is ""!

Same functionality as Env() except a prefix is used when looking up environment variables to replace with. So a key that is looked up with Env() as FOO_BAR will be BAZ_FOO_BAR if EnvPrefix("baz") is used.

Also updated TestEnv to ensure that the previously set value is overwritten by the environment variable.

I needed this functionality to avoid environment variables clashing, thanks for the useful library 👍

Hi, Would you think a StringList is useful on its own besides List? from my uses, it is very common to have a list of strings in configuration rather than list of interface{}

I'd love to hear your opinion on it Thanks!

This PR contains a new implementation of the Extend function. It makes it possible for lists to be extended as well.

If this PR is merged it will somewhat change the behavior of the function. There are no more errors if the Config structs have a different structure. Look at the description above the implementation for a better overview.

1st, thx 4 giving the great go lib! and i have a question in my dev programs: func List() return a []interface{} for us , but how can i use the var(type []interface) as type []string? hope ur responed

When necessary get key with dots inside, you can use square brackets for example: yaml

root:
  field.with.dots: value

you can get value like this:

  config.UString("root.[field.with.dots]")

The following YAML file:

development:
  database:
    host: localhost
  users:
    - name: calvin
      password: yukon
    - name: hobbes
      password: tuna
production:
  database:
    host: 192.168.1.1

With the following code:

    if cfg, err := config.ParseYaml("config.yml"); err != nil {
        panic(err)
    } else {
        if testValue, err := cfg.Get("development.database.host"); err != nil {
            panic(err)
        } else {
            fmt.Println("test:", testValue)
        }
    }

Fails with the following error: Invalid type at "development": expected []interface{} or map[string]interface{}; got string

Note that using cfg.Get or cfg.String results in the same error. YAML handling is non-functional with this library as of the latest revision. The code I have used is a slightly modified version of what is demonstrated in package godocs.

I've found that when you have a configuration file where a 'm'ap contains a list of maps wich have more than one key/value' the values returned by getKey() are duplicated because of the 'base slice shares its storage array when called recursively and the new keys fit there.

Hope you find this useful and can get it merged in. Thanks for making this open source.

This adds nil to the list of valid simple value types in normalizeValue(). Otherwise the you would get an "Unsupported type" error when parsing yaml/json content.

When extending a config with a second Config object which contains lists, all elements in lists in the second object, except the first element, are lost.

I have narrowed it down to the getKeys function, which generates values like [foo bar 0], [foo bar 1], [foo bar 2], etc : when removing the whole case []interface{}: block in this function, extending seems to work perfectly. I have however not done extensive testing...

Hi,

What about such a YAML config:

part1:
- level1:
 - level2:
   -level3:
       key1: value1
       key2: value2

How to get deeper nested lists? cfg.List("part1.0.0.)

does not seem to work.

The Documentation ommits how to load the yaml/json file into a string,

Here's how I did it:

    file, readErr := ioutil.ReadFile("config.yaml")
    if readErr != nil {
        fmt.Println("Could not read config.yaml:", readErr)
        // Maybe exit the program?
    }
    yamlConfig := string(file)
        // parse the file etc

This would be useful to include in the docs. Also putting some of the documentation's example code into the README.md would be great.