Add support for TOML tables to fftoml package

[GeorgeMac]

This adds support for TOML tables. It does so by concatenating nested keys with the - character.

For example:

[a]
b = "c"

Will set the flag -a-b with the value "c".

var b string
flagset.StringVar(&b, "a-b", "a string")
// ...

This swaps to a different toml parser (namely github.com/pelletier/go-toml), however, upon reflection the BurntSushi version is probably still useable. I can swap to attempt that if that would be more preferrable.

[ChrisHines]

Consider using a . (period) separator instead of - for nested keys. This would parallel the way the go tool passes args to the testing package (see https://golang.org/cmd/go/#hdr-Testing_flags) and also has precedence in the prior art as implemented by https://godoc.org/github.com/cespare/flagconf#Parse.

[GeorgeMac]

I'm totally open to . have any reservations on that @peterbourgon ?

[peterbourgon]

I personally never use . in my flag names, but the precedent exists, so I'd love to have it as an option.

[GeorgeMac]

@peterbourgon I could have it attempt both? e.g. try . and if that fails try _.
I believe set() returns a sentinel error to denote flag does not exist, is that correct?

[peterbourgon]

Interesting. That could definitely work, but it feels a bit too... implicit for my taste. I think I'd rather let users set the separator rune (string?) with a default of . — and let name mismatches fail as usual. Does that seem reasonable? How do you think it's best to parameterize that confit, given the constraints of the Parser definition? Maybe another constructor that takes some functional options like this one and returns a Parser func?

[GeorgeMac]

Perhaps an option on the parser itself?

e.g.

package fftoml

func Parser(r io.Reader, set(name, value string) error) error {
    return ParserWith()(r, set)
}

type config struct {
  separator string
}

func FlagSeparator(s string) Option {
    return func(c *config) {
        c.separator = s
    }
}

func ParserWith(opts ...Option) ff.ConfigFileParser {
    config := config{separator: "."}
    for _, opt := range opts {
        opt(&config)
    }

    // ...
}

Then you could do fftoml.ParserWith(fftoml.FlagSeparator("_")) ?

[peterbourgon]

Yeah, that's essentially what I had in mind 👍 unless you can think of a nicer API. (A couple of small nits with the example code, but that's better left for review.)

[GeorgeMac]

@peterbourgon 👍 I like it. I pushed up that change.

[peterbourgon]

I'd rather see this type as exported, so Config, to avoid having functions in the package's API that operate on unexported types

[peterbourgon]

Hmm, I think this name is too vague. Is there a name for the TOML blocking feature, the thing we're segmenting config information with? I'd prefer something like... BlockSeparator?

[ChrisHines]

I believe the correct TOML term is a "table" https://github.com/toml-lang/toml#table.

[GeorgeMac]

How about TableDelimiter(string) ?

[peterbourgon]

Please make this comment a bit more descriptive, and add a sentence like "The default separator is a period .."

[peterbourgon]

Hmm, what do you think about adding a Parse method to the Config struct, matching the ConfigFileParser signature, and returning that? e.g.

func ParserWith(opts ...Option) ff.ConfigFileParser {
    c := Config{
        separator: ".",
    }
    for _, opt := range opts {
        opt(&c)
    }
    return c.Parse
}

[GeorgeMac]

That is nice. Does it continue to make sense to call it Config? Perhaps there is a more suitable name. Perhaps ConfigFileParser to match the ff.ConfigFileParser function signature?

[GeorgeMac]

@peterbourgon I made some adjustments based on your comments :) What do you think?

[peterbourgon]

Two very minor things and then I'm happy to merge. Thanks a bunch!

[peterbourgon]

Cool! Just a minor nit for consistency :)

Suggested change

	func TableDelimeter(d string) Option {
	func WithTableDelimeter(d string) Option {

[peterbourgon]

Suggested change

	// The default delimeter is "."
	// The default delimeter is "."
	//
	// For example, given the following TOML
	//
	// [section.subsection]
	// value = 10
	//
	// Parse will match to a flag with the name `-section.subsection.value` by default.
	// If the delimiter is "-", Parse will match to `-section-subsection-value` instead.

[peterbourgon]

Oh, oops — it's spelled Delimiter, not Delimeter :)

[GeorgeMac]

Ahh good catch 🤦‍♂. Cheers @peterbourgon !