Update vendored dependencies

vendor/gopkg.in/gcfg.v1/doc.go

@@ -48,6 +48,9 @@
 // When using a map, and there is a section with the same section name but
 // without a subsection name, its values are stored with the empty string used
 // as the key.
+// It is possible to provide default values for subsections in the section
+// "default-<sectionname>" (or by setting values in the corresponding struct
+// field "Default_<sectionname>").
 //
 // The functions in this package panic if config is not a pointer to a struct,
 // or when a field is not of a suitable type (either a struct or a map with
@@ -95,6 +98,30 @@
 // The types subpackage for provides helpers for parsing "enum-like" and integer
 // types.
 //
+// Error handling
+//
+// There are 3 types of errors:
+//
+//  - programmer errors / panics:
+//    - invalid configuration structure
+//  - data errors:
+//    - fatal errors:
+//      - invalid configuration syntax
+//    - warnings:
+//      - data that doesn't belong to any part of the config structure
+//
+// Programmer errors trigger panics. These are should be fixed by the programmer
+// before releasing code that uses gcfg.
+//
+// Data errors cause gcfg to return a non-nil error value. This includes the
+// case when there are extra unknown key-value definitions in the configuration
+// data (extra data).
+// However, in some occasions it is desirable to be able to proceed in
+// situations when the only data error is that of extra data.
+// These errors are handled at a different (warning) priority and can be
+// filtered out programmatically. To ignore extra data warnings, wrap the
+// gcfg.Read*Into invocation into a call to gcfg.FatalOnly.
+//
 // TODO
 //
 // The following is a list of changes under consideration:

vendor/gopkg.in/gcfg.v1/errors.go

@@ -0,0 +1,41 @@
+package gcfg
+
+import (
+	"gopkg.in/warnings.v0"
+)
+
+// FatalOnly filters the results of a Read*Into invocation and returns only
+// fatal errors. That is, errors (warnings) indicating data for unknown
+// sections / variables is ignored. Example invocation:
+//
+//  err := gcfg.FatalOnly(gcfg.ReadFileInto(&cfg, configFile))
+//  if err != nil {
+//      ...
+//
+func FatalOnly(err error) error {
+	return warnings.FatalOnly(err)
+}
+
+func isFatal(err error) bool {
+	_, ok := err.(extraData)
+	return !ok
+}
+
+type extraData struct {
+	section    string
+	subsection *string
+	variable   *string
+}
+
+func (e extraData) Error() string {
+	s := "can't store data at section \"" + e.section + "\""
+	if e.subsection != nil {
+		s += ", subsection \"" + *e.subsection + "\""
+	}
+	if e.variable != nil {
+		s += ", variable \"" + *e.variable + "\""
+	}
+	return s
+}
+
+var _ error = extraData{}

vendor/gopkg.in/gcfg.v1/read.go

@@ -6,11 +6,10 @@ import (
 	"io/ioutil"
 	"os"
 	"strings"
-)
 
-import (
 	"gopkg.in/gcfg.v1/scanner"
 	"gopkg.in/gcfg.v1/token"
+	"gopkg.in/warnings.v0"
 )
 
 var unescape = map[rune]rune{'\\': '\\', '"': '"', 'n': '\n', 't': '\t'}
@@ -49,7 +48,9 @@ func unquote(s string) string {
 	return string(u)
 }
 
-func readInto(config interface{}, fset *token.FileSet, file *token.File, src []byte) error {
+func readIntoPass(c *warnings.Collector, config interface{}, fset *token.FileSet,
+	file *token.File, src []byte, subsectPass bool) error {
+	//
 	var s scanner.Scanner
 	var errs scanner.ErrorList
 	s.Init(file, src, func(p token.Position, m string) { errs.Add(p, m) }, 0)
@@ -60,7 +61,9 @@ func readInto(config interface{}, fset *token.FileSet, file *token.File, src []b
 	}
 	for {
 		if errs.Len() > 0 {
-			return errs.Err()
+			if err := c.Collect(errs.Err()); err != nil {
+				return err
+			}
 		}
 		switch tok {
 		case token.EOF:
@@ -70,46 +73,64 @@ func readInto(config interface{}, fset *token.FileSet, file *token.File, src []b
 		case token.LBRACK:
 			pos, tok, lit = s.Scan()
 			if errs.Len() > 0 {
-				return errs.Err()
+				if err := c.Collect(errs.Err()); err != nil {
+					return err
+				}
 			}
 			if tok != token.IDENT {
-				return errfn("expected section name")
+				if err := c.Collect(errfn("expected section name")); err != nil {
+					return err
+				}
 			}
 			sect, sectsub = lit, ""
 			pos, tok, lit = s.Scan()
 			if errs.Len() > 0 {
-				return errs.Err()
+				if err := c.Collect(errs.Err()); err != nil {
+					return err
+				}
 			}
 			if tok == token.STRING {
 				sectsub = unquote(lit)
 				if sectsub == "" {
-					return errfn("empty subsection name")
+					if err := c.Collect(errfn("empty subsection name")); err != nil {
+						return err
+					}
 				}
 				pos, tok, lit = s.Scan()
 				if errs.Len() > 0 {
-					return errs.Err()
+					if err := c.Collect(errs.Err()); err != nil {
+						return err
+					}
 				}
 			}
 			if tok != token.RBRACK {
 				if sectsub == "" {
-					return errfn("expected subsection name or right bracket")
+					if err := c.Collect(errfn("expected subsection name or right bracket")); err != nil {
+						return err
+					}
+				}
+				if err := c.Collect(errfn("expected right bracket")); err != nil {
+					return err
 				}
-				return errfn("expected right bracket")
 			}
 			pos, tok, lit = s.Scan()
 			if tok != token.EOL && tok != token.EOF && tok != token.COMMENT {
-				return errfn("expected EOL, EOF, or comment")
+				if err := c.Collect(errfn("expected EOL, EOF, or comment")); err != nil {
+					return err
+				}
 			}
 			// If a section/subsection header was found, ensure a
 			// container object is created, even if there are no
 			// variables further down.
-			err := set(config, sect, sectsub, "", true, "")
+			err := c.Collect(set(c, config, sect, sectsub, "", true, "", subsectPass))
 			if err != nil {
 				return err
 			}
 		case token.IDENT:
 			if sect == "" {
-				return errfn("expected section header")
+				if err := c.Collect(errfn("expected section header")); err != nil {
+					return err
+				}
 			}
 			n := lit
 			pos, tok, lit = s.Scan()
@@ -119,38 +140,67 @@ func readInto(config interface{}, fset *token.FileSet, file *token.File, src []b
 			blank, v := tok == token.EOF || tok == token.EOL || tok == token.COMMENT, ""
 			if !blank {
 				if tok != token.ASSIGN {
-					return errfn("expected '='")
+					if err := c.Collect(errfn("expected '='")); err != nil {
+						return err
+					}
 				}
 				pos, tok, lit = s.Scan()
 				if errs.Len() > 0 {
-					return errs.Err()
+					if err := c.Collect(errs.Err()); err != nil {
+						return err
+					}
 				}
 				if tok != token.STRING {
-					return errfn("expected value")
+					if err := c.Collect(errfn("expected value")); err != nil {
+						return err
+					}
 				}
 				v = unquote(lit)
 				pos, tok, lit = s.Scan()
 				if errs.Len() > 0 {
-					return errs.Err()
+					if err := c.Collect(errs.Err()); err != nil {
+						return err
+					}
 				}
 				if tok != token.EOL && tok != token.EOF && tok != token.COMMENT {
-					return errfn("expected EOL, EOF, or comment")
+					if err := c.Collect(errfn("expected EOL, EOF, or comment")); err != nil {
+						return err
+					}
 				}
 			}
-			err := set(config, sect, sectsub, n, blank, v)
+			err := set(c, config, sect, sectsub, n, blank, v, subsectPass)
 			if err != nil {
 				return err
 			}
 		default:
 			if sect == "" {
-				return errfn("expected section header")
+				if err := c.Collect(errfn("expected section header")); err != nil {
+					return err
+				}
+			}
+			if err := c.Collect(errfn("expected section header or variable declaration")); err != nil {
+				return err
 			}
-			return errfn("expected section header or variable declaration")
 		}
 	}
 	panic("never reached")
 }
 
+func readInto(config interface{}, fset *token.FileSet, file *token.File,
+	src []byte) error {
+	//
+	c := warnings.NewCollector(isFatal)
+	err := readIntoPass(c, config, fset, file, src, false)
+	if err != nil {
+		return err
+	}
+	err = readIntoPass(c, config, fset, file, src, true)
+	if err != nil {
+		return err
+	}
+	return c.Done()
+}
+
 // ReadInto reads gcfg formatted data from reader and sets the values into the
 // corresponding fields in config.
 func ReadInto(config interface{}, reader io.Reader) error {

vendor/gopkg.in/gcfg.v1/set.go

@@ -1,6 +1,8 @@
 package gcfg
 
 import (
+	"bytes"
+	"encoding/gob"
 	"fmt"
 	"math/big"
 	"reflect"
@@ -9,6 +11,7 @@ import (
 	"unicode/utf8"
 
 	"gopkg.in/gcfg.v1/types"
+	"gopkg.in/warnings.v0"
 )
 
 type tag struct {
@@ -189,7 +192,30 @@ func scanSetter(d interface{}, blank bool, val string, tt tag) error {
 	return types.ScanFully(d, val, 'v')
 }
 
-func set(cfg interface{}, sect, sub, name string, blank bool, value string) error {
+func newValue(sect string, vCfg reflect.Value, vType reflect.Type) (reflect.Value, error) {
+	pv := reflect.New(vType)
+	dfltName := "default-" + sect
+	dfltField, _ := fieldFold(vCfg, dfltName)
+	var err error
+	if dfltField.IsValid() {
+		b := bytes.NewBuffer(nil)
+		ge := gob.NewEncoder(b)
+		err = ge.EncodeValue(dfltField)
+		if err != nil {
+			return pv, err
+		}
+		gd := gob.NewDecoder(bytes.NewReader(b.Bytes()))
+		err = gd.DecodeValue(pv.Elem())
+		if err != nil {
+			return pv, err
+		}
+	}
+	return pv, nil
+}
+
+func set(c *warnings.Collector, cfg interface{}, sect, sub, name string,
+	blank bool, value string, subsectPass bool) error {
+	//
 	vPCfg := reflect.ValueOf(cfg)
 	if vPCfg.Kind() != reflect.Ptr || vPCfg.Elem().Kind() != reflect.Struct {
 		panic(fmt.Errorf("config must be a pointer to a struct"))
@@ -197,9 +223,14 @@ func set(cfg interface{}, sect, sub, name string, blank bool, value string) erro
 	vCfg := vPCfg.Elem()
 	vSect, _ := fieldFold(vCfg, sect)
 	if !vSect.IsValid() {
-		return fmt.Errorf("invalid section: section %q", sect)
+		err := extraData{section: sect}
+		return c.Collect(err)
 	}
-	if vSect.Kind() == reflect.Map {
+	isSubsect := vSect.Kind() == reflect.Map
+	if subsectPass != isSubsect {
+		return nil
+	}
+	if isSubsect {
 		vst := vSect.Type()
 		if vst.Key().Kind() != reflect.String ||
 			vst.Elem().Kind() != reflect.Ptr ||
@@ -214,7 +245,11 @@ func set(cfg interface{}, sect, sub, name string, blank bool, value string) erro
 		pv := vSect.MapIndex(k)
 		if !pv.IsValid() {
 			vType := vSect.Type().Elem().Elem()
-			pv = reflect.New(vType)
+			var err error
+			pv, err = newValue(sect, vCfg, vType)
+			if err != nil {
+				return err
+			}
 			vSect.SetMapIndex(k, pv)
 		}
 		vSect = pv.Elem()
@@ -222,8 +257,8 @@ func set(cfg interface{}, sect, sub, name string, blank bool, value string) erro
 		panic(fmt.Errorf("field for section must be a map or a struct: "+
 			"section %q", sect))
 	} else if sub != "" {
-		return fmt.Errorf("invalid subsection: "+
-			"section %q subsection %q", sect, sub)
+		err := extraData{section: sect, subsection: &sub}
+		return c.Collect(err)
 	}
 	// Empty name is a special value, meaning that only the
 	// section/subsection object is to be created, with no values set.
@@ -232,8 +267,13 @@ func set(cfg interface{}, sect, sub, name string, blank bool, value string) erro
 	}
 	vVar, t := fieldFold(vSect, name)
 	if !vVar.IsValid() {
-		return fmt.Errorf("invalid variable: "+
-			"section %q subsection %q variable %q", sect, sub, name)
+		var err error
+		if isSubsect {
+			err = extraData{section: sect, subsection: &sub, variable: &name}
+		} else {
+			err = extraData{section: sect, variable: &name}
+		}
+		return c.Collect(err)
 	}
 	// vVal is either single-valued var, or newly allocated value within multi-valued var
 	var vVal reflect.Value