deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

8 files changed, 196 insertions, 65 deletions

diff --git a/vendor/github.com/go-ini/ini/.travis.yml b/vendor/github.com/go-ini/ini/.travis.yml
index 0064ba1..65c872b 100644
--- a/vendor/github.com/go-ini/ini/.travis.yml
+++ b/vendor/github.com/go-ini/ini/.travis.yml
@@ -1,14 +1,15 @@
 sudo: false
 language: go
-
 go:
-  - 1.4
-  - 1.5
-  - 1.6
-  - tip
+  - 1.4.x
+  - 1.5.x
+  - 1.6.x
+  - 1.7.x
+  - master
 
 script: 
-  - go get -v github.com/smartystreets/goconvey
+  - go get golang.org/x/tools/cmd/cover
+  - go get github.com/smartystreets/goconvey
   - go test -v -cover -race
 
 notifications:
diff --git a/vendor/github.com/go-ini/ini/README.md b/vendor/github.com/go-ini/ini/README.md
index 22a4234..8594742 100644
--- a/vendor/github.com/go-ini/ini/README.md
+++ b/vendor/github.com/go-ini/ini/README.md
@@ -1,4 +1,4 @@
-INI [![Build Status](https://travis-ci.org/go-ini/ini.svg?branch=master)](https://travis-ci.org/go-ini/ini)
+INI [![Build Status](https://travis-ci.org/go-ini/ini.svg?branch=master)](https://travis-ci.org/go-ini/ini) [![Sourcegraph](https://sourcegraph.com/github.com/go-ini/ini/-/badge.svg)](https://sourcegraph.com/github.com/go-ini/ini?badge)
 ===
 
 ![](https://avatars0.githubusercontent.com/u/10216035?v=3&s=200)
@@ -106,6 +106,12 @@ cfg, err := LoadSources(LoadOptions{AllowBooleanKeys: true}, "my.cnf"))
 
 The value of those keys are always `true`, and when you save to a file, it will keep in the same foramt as you read.
 
+To generate such keys in your program, you could use `NewBooleanKey`:
+
+```go
+key, err := sec.NewBooleanKey("skip-host-cache")
+```
+
 #### Comment
 
 Take care that following format will be treated as comment:
diff --git a/vendor/github.com/go-ini/ini/README_ZH.md b/vendor/github.com/go-ini/ini/README_ZH.md
index 3b4fb66..163432d 100644
--- a/vendor/github.com/go-ini/ini/README_ZH.md
+++ b/vendor/github.com/go-ini/ini/README_ZH.md
@@ -99,6 +99,12 @@ cfg, err := LoadSources(LoadOptions{AllowBooleanKeys: true}, "my.cnf"))
 
 这些键的值永远为 `true`，且在保存到文件时也只会输出键名。
 
+如果您想要通过程序来生成此类键，则可以使用 `NewBooleanKey`：
+
+```go
+key, err := sec.NewBooleanKey("skip-host-cache")
+```
+
 #### 关于注释
 
 下述几种情况的内容将被视为注释：
diff --git a/vendor/github.com/go-ini/ini/ini.go b/vendor/github.com/go-ini/ini/ini.go
index 77e0dbd..68d73aa 100644
--- a/vendor/github.com/go-ini/ini/ini.go
+++ b/vendor/github.com/go-ini/ini/ini.go
@@ -37,7 +37,7 @@ const (
 
         // Maximum allowed depth when recursively substituing variable names.
         _DEPTH_VALUES = 99
-        _VERSION      = "1.23.1"
+        _VERSION      = "1.25.4"
 )
 
 // Version returns current package version literal.
@@ -176,6 +176,8 @@ type LoadOptions struct {
         // AllowBooleanKeys indicates whether to allow boolean type keys or treat as value is missing.
         // This type of keys are mostly used in my.cnf.
         AllowBooleanKeys bool
+        // AllowShadows indicates whether to keep track of keys with same name under same section.
+        AllowShadows bool
         // Some INI formats allow group blocks that store a block of raw content that doesn't otherwise
         // conform to key/value pairs. Specify the names of those blocks here.
         UnparseableSections []string
@@ -219,6 +221,12 @@ func InsensitiveLoad(source interface{}, others ...interface{}) (*File, error) {
         return LoadSources(LoadOptions{Insensitive: true}, source, others...)
 }
 
+// InsensitiveLoad has exactly same functionality as Load function
+// except it allows have shadow keys.
+func ShadowLoad(source interface{}, others ...interface{}) (*File, error) {
+        return LoadSources(LoadOptions{AllowShadows: true}, source, others...)
+}
+
 // Empty returns an empty file object.
 func Empty() *File {
         // Ignore error here, we sure our data is good.
@@ -441,6 +449,7 @@ func (f *File) WriteToIndent(w io.Writer, indent string) (n int64, err error) {
                 }
                 alignSpaces := bytes.Repeat([]byte(" "), alignLength)
 
+        KEY_LIST:
                 for _, kname := range sec.keyList {
                         key := sec.Key(kname)
                         if len(key.Comment) > 0 {
@@ -467,28 +476,33 @@ func (f *File) WriteToIndent(w io.Writer, indent string) (n int64, err error) {
                         case strings.Contains(kname, "`"):
                                 kname = `"""` + kname + `"""`
                         }
-                        if _, err = buf.WriteString(kname); err != nil {
-                                return 0, err
-                        }
 
-                        if key.isBooleanType {
-                                continue
-                        }
+                        for _, val := range key.ValueWithShadows() {
+                                if _, err = buf.WriteString(kname); err != nil {
+                                        return 0, err
+                                }
 
-                        // Write out alignment spaces before "=" sign
-                        if PrettyFormat {
-                                buf.Write(alignSpaces[:alignLength-len(kname)])
-                        }
+                                if key.isBooleanType {
+                                        if kname != sec.keyList[len(sec.keyList)-1] {
+                                                buf.WriteString(LineBreak)
+                                        }
+                                        continue KEY_LIST
+                                }
 
-                        val := key.value
-                        // In case key value contains "\n", "`", "\"", "#" or ";"
-                        if strings.ContainsAny(val, "\n`") {
-                                val = `"""` + val + `"""`
-                        } else if strings.ContainsAny(val, "#;") {
-                                val = "`" + val + "`"
-                        }
-                        if _, err = buf.WriteString(equalSign + val + LineBreak); err != nil {
-                                return 0, err
+                                // Write out alignment spaces before "=" sign
+                                if PrettyFormat {
+                                        buf.Write(alignSpaces[:alignLength-len(kname)])
+                                }
+
+                                // In case key value contains "\n", "`", "\"", "#" or ";"
+                                if strings.ContainsAny(val, "\n`") {
+                                        val = `"""` + val + `"""`
+                                } else if strings.ContainsAny(val, "#;") {
+                                        val = "`" + val + "`"
+                                }
+                                if _, err = buf.WriteString(equalSign + val + LineBreak); err != nil {
+                                        return 0, err
+                                }
                         }
                 }
 
diff --git a/vendor/github.com/go-ini/ini/key.go b/vendor/github.com/go-ini/ini/key.go
index 9738c55..852696f 100644
--- a/vendor/github.com/go-ini/ini/key.go
+++ b/vendor/github.com/go-ini/ini/key.go
@@ -15,6 +15,7 @@
 package ini
 
 import (
+        "errors"
         "fmt"
         "strconv"
         "strings"
@@ -29,9 +30,42 @@ type Key struct {
         isAutoIncrement bool
         isBooleanType   bool
 
+        isShadow bool
+        shadows  []*Key
+
         Comment string
 }
 
+// newKey simply return a key object with given values.
+func newKey(s *Section, name, val string) *Key {
+        return &Key{
+                s:     s,
+                name:  name,
+                value: val,
+        }
+}
+
+func (k *Key) addShadow(val string) error {
+        if k.isShadow {
+                return errors.New("cannot add shadow to another shadow key")
+        } else if k.isAutoIncrement || k.isBooleanType {
+                return errors.New("cannot add shadow to auto-increment or boolean key")
+        }
+
+        shadow := newKey(k.s, k.name, val)
+        shadow.isShadow = true
+        k.shadows = append(k.shadows, shadow)
+        return nil
+}
+
+// AddShadow adds a new shadow key to itself.
+func (k *Key) AddShadow(val string) error {
+        if !k.s.f.options.AllowShadows {
+                return errors.New("shadow key is not allowed")
+        }
+        return k.addShadow(val)
+}
+
 // ValueMapper represents a mapping function for values, e.g. os.ExpandEnv
 type ValueMapper func(string) string
 
@@ -45,16 +79,29 @@ func (k *Key) Value() string {
         return k.value
 }
 
-// String returns string representation of value.
-func (k *Key) String() string {
-        val := k.value
+// ValueWithShadows returns raw values of key and its shadows if any.
+func (k *Key) ValueWithShadows() []string {
+        if len(k.shadows) == 0 {
+                return []string{k.value}
+        }
+        vals := make([]string, len(k.shadows)+1)
+        vals[0] = k.value
+        for i := range k.shadows {
+                vals[i+1] = k.shadows[i].value
+        }
+        return vals
+}
+
+// transformValue takes a raw value and transforms to its final string.
+func (k *Key) transformValue(val string) string {
         if k.s.f.ValueMapper != nil {
                 val = k.s.f.ValueMapper(val)
         }
-        if strings.Index(val, "%") == -1 {
+
+        // Fail-fast if no indicate char found for recursive value
+        if !strings.Contains(val, "%") {
                 return val
         }
-
         for i := 0; i < _DEPTH_VALUES; i++ {
                 vr := varPattern.FindString(val)
                 if len(vr) == 0 {
@@ -78,6 +125,11 @@ func (k *Key) String() string {
         return val
 }
 
+// String returns string representation of value.
+func (k *Key) String() string {
+        return k.transformValue(k.value)
+}
+
 // Validate accepts a validate function which can
 // return modifed result as key value.
 func (k *Key) Validate(fn func(string) string) string {
@@ -394,11 +446,31 @@ func (k *Key) Strings(delim string) []string {
 
         vals := strings.Split(str, delim)
         for i := range vals {
+                // vals[i] = k.transformValue(strings.TrimSpace(vals[i]))
                 vals[i] = strings.TrimSpace(vals[i])
         }
         return vals
 }
 
+// StringsWithShadows returns list of string divided by given delimiter.
+// Shadows will also be appended if any.
+func (k *Key) StringsWithShadows(delim string) []string {
+        vals := k.ValueWithShadows()
+        results := make([]string, 0, len(vals)*2)
+        for i := range vals {
+                if len(vals) == 0 {
+                        continue
+                }
+
+                results = append(results, strings.Split(vals[i], delim)...)
+        }
+
+        for i := range results {
+                results[i] = k.transformValue(strings.TrimSpace(results[i]))
+        }
+        return results
+}
+
 // Float64s returns list of float64 divided by given delimiter. Any invalid input will be treated as zero value.
 func (k *Key) Float64s(delim string) []float64 {
         vals, _ := k.getFloat64s(delim, true, false)
@@ -407,13 +479,13 @@ func (k *Key) Float64s(delim string) []float64 {
 
 // Ints returns list of int divided by given delimiter. Any invalid input will be treated as zero value.
 func (k *Key) Ints(delim string) []int {
-        vals, _ := k.getInts(delim, true, false)
+        vals, _ := k.parseInts(k.Strings(delim), true, false)
         return vals
 }
 
 // Int64s returns list of int64 divided by given delimiter. Any invalid input will be treated as zero value.
 func (k *Key) Int64s(delim string) []int64 {
-        vals, _ := k.getInt64s(delim, true, false)
+        vals, _ := k.parseInt64s(k.Strings(delim), true, false)
         return vals
 }
 
@@ -452,14 +524,14 @@ func (k *Key) ValidFloat64s(delim string) []float64 {
 // ValidInts returns list of int divided by given delimiter. If some value is not integer, then it will
 // not be included to result list.
 func (k *Key) ValidInts(delim string) []int {
-        vals, _ := k.getInts(delim, false, false)
+        vals, _ := k.parseInts(k.Strings(delim), false, false)
         return vals
 }
 
 // ValidInt64s returns list of int64 divided by given delimiter. If some value is not 64-bit integer,
 // then it will not be included to result list.
 func (k *Key) ValidInt64s(delim string) []int64 {
-        vals, _ := k.getInt64s(delim, false, false)
+        vals, _ := k.parseInt64s(k.Strings(delim), false, false)
         return vals
 }
 
@@ -495,12 +567,12 @@ func (k *Key) StrictFloat64s(delim string) ([]float64, error) {
 
 // StrictInts returns list of int divided by given delimiter or error on first invalid input.
 func (k *Key) StrictInts(delim string) ([]int, error) {
-        return k.getInts(delim, false, true)
+        return k.parseInts(k.Strings(delim), false, true)
 }
 
 // StrictInt64s returns list of int64 divided by given delimiter or error on first invalid input.
 func (k *Key) StrictInt64s(delim string) ([]int64, error) {
-        return k.getInt64s(delim, false, true)
+        return k.parseInt64s(k.Strings(delim), false, true)
 }
 
 // StrictUints returns list of uint divided by given delimiter or error on first invalid input.
@@ -541,9 +613,8 @@ func (k *Key) getFloat64s(delim string, addInvalid, returnOnInvalid bool) ([]flo
         return vals, nil
 }
 
-// getInts returns list of int divided by given delimiter.
-func (k *Key) getInts(delim string, addInvalid, returnOnInvalid bool) ([]int, error) {
-        strs := k.Strings(delim)
+// parseInts transforms strings to ints.
+func (k *Key) parseInts(strs []string, addInvalid, returnOnInvalid bool) ([]int, error) {
         vals := make([]int, 0, len(strs))
         for _, str := range strs {
                 val, err := strconv.Atoi(str)
@@ -557,9 +628,8 @@ func (k *Key) getInts(delim string, addInvalid, returnOnInvalid bool) ([]int, er
         return vals, nil
 }
 
-// getInt64s returns list of int64 divided by given delimiter.
-func (k *Key) getInt64s(delim string, addInvalid, returnOnInvalid bool) ([]int64, error) {
-        strs := k.Strings(delim)
+// parseInt64s transforms strings to int64s.
+func (k *Key) parseInt64s(strs []string, addInvalid, returnOnInvalid bool) ([]int64, error) {
         vals := make([]int64, 0, len(strs))
         for _, str := range strs {
                 val, err := strconv.ParseInt(str, 10, 64)
diff --git a/vendor/github.com/go-ini/ini/parser.go b/vendor/github.com/go-ini/ini/parser.go
index b0aabe3..673ef80 100644
--- a/vendor/github.com/go-ini/ini/parser.go
+++ b/vendor/github.com/go-ini/ini/parser.go
@@ -318,11 +318,14 @@ func (f *File) parse(reader io.Reader) (err error) {
                 if err != nil {
                         // Treat as boolean key when desired, and whole line is key name.
                         if IsErrDelimiterNotFound(err) && f.options.AllowBooleanKeys {
-                                key, err := section.NewKey(string(line), "true")
+                                kname, err := p.readValue(line, f.options.IgnoreContinuation)
+                                if err != nil {
+                                        return err
+                                }
+                                key, err := section.NewBooleanKey(kname)
                                 if err != nil {
                                         return err
                                 }
-                                key.isBooleanType = true
                                 key.Comment = strings.TrimSpace(p.comment.String())
                                 p.comment.Reset()
                                 continue
@@ -338,17 +341,16 @@ func (f *File) parse(reader io.Reader) (err error) {
                         p.count++
                 }
 
-                key, err := section.NewKey(kname, "")
+                value, err := p.readValue(line[offset:], f.options.IgnoreContinuation)
                 if err != nil {
                         return err
                 }
-                key.isAutoIncrement = isAutoIncr
 
-                value, err := p.readValue(line[offset:], f.options.IgnoreContinuation)
+                key, err := section.NewKey(kname, value)
                 if err != nil {
                         return err
                 }
-                key.SetValue(value)
+                key.isAutoIncrement = isAutoIncr
                 key.Comment = strings.TrimSpace(p.comment.String())
                 p.comment.Reset()
         }
diff --git a/vendor/github.com/go-ini/ini/section.go b/vendor/github.com/go-ini/ini/section.go
index 45d2f3b..c9fa27e 100644
--- a/vendor/github.com/go-ini/ini/section.go
+++ b/vendor/github.com/go-ini/ini/section.go
@@ -68,20 +68,33 @@ func (s *Section) NewKey(name, val string) (*Key, error) {
         }
 
         if inSlice(name, s.keyList) {
-                s.keys[name].value = val
+                if s.f.options.AllowShadows {
+                        if err := s.keys[name].addShadow(val); err != nil {
+                                return nil, err
+                        }
+                } else {
+                        s.keys[name].value = val
+                }
                 return s.keys[name], nil
         }
 
         s.keyList = append(s.keyList, name)
-        s.keys[name] = &Key{
-                s:     s,
-                name:  name,
-                value: val,
-        }
+        s.keys[name] = newKey(s, name, val)
         s.keysHash[name] = val
         return s.keys[name], nil
 }
 
+// NewBooleanKey creates a new boolean type key to given section.
+func (s *Section) NewBooleanKey(name string) (*Key, error) {
+        key, err := s.NewKey(name, "true")
+        if err != nil {
+                return nil, err
+        }
+
+        key.isBooleanType = true
+        return key, nil
+}
+
 // GetKey returns key in section by given name.
 func (s *Section) GetKey(name string) (*Key, error) {
         // FIXME: change to section level lock?
diff --git a/vendor/github.com/go-ini/ini/struct.go b/vendor/github.com/go-ini/ini/struct.go
index 5ef38d8..509c682 100644
--- a/vendor/github.com/go-ini/ini/struct.go
+++ b/vendor/github.com/go-ini/ini/struct.go
@@ -78,8 +78,14 @@ func parseDelim(actual string) string {
 var reflectTime = reflect.TypeOf(time.Now()).Kind()
 
 // setSliceWithProperType sets proper values to slice based on its type.
-func setSliceWithProperType(key *Key, field reflect.Value, delim string) error {
-        strs := key.Strings(delim)
+func setSliceWithProperType(key *Key, field reflect.Value, delim string, allowShadow bool) error {
+        var strs []string
+        if allowShadow {
+                strs = key.StringsWithShadows(delim)
+        } else {
+                strs = key.Strings(delim)
+        }
+
         numVals := len(strs)
         if numVals == 0 {
                 return nil
@@ -92,9 +98,9 @@ func setSliceWithProperType(key *Key, field reflect.Value, delim string) error {
         case reflect.String:
                 vals = strs
         case reflect.Int:
-                vals = key.Ints(delim)
+                vals, _ = key.parseInts(strs, true, false)
         case reflect.Int64:
-                vals = key.Int64s(delim)
+                vals, _ = key.parseInt64s(strs, true, false)
         case reflect.Uint:
                 vals = key.Uints(delim)
         case reflect.Uint64:
@@ -133,7 +139,7 @@ func setSliceWithProperType(key *Key, field reflect.Value, delim string) error {
 // setWithProperType sets proper value to field based on its type,
 // but it does not return error for failing parsing,
 // because we want to use default value that is already assigned to strcut.
-func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error {
+func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string, allowShadow bool) error {
         switch t.Kind() {
         case reflect.String:
                 if len(key.String()) == 0 {
@@ -187,13 +193,25 @@ func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim stri
                 }
                 field.Set(reflect.ValueOf(timeVal))
         case reflect.Slice:
-                return setSliceWithProperType(key, field, delim)
+                return setSliceWithProperType(key, field, delim, allowShadow)
         default:
                 return fmt.Errorf("unsupported type '%s'", t)
         }
         return nil
 }
 
+func parseTagOptions(tag string) (rawName string, omitEmpty bool, allowShadow bool) {
+        opts := strings.SplitN(tag, ",", 3)
+        rawName = opts[0]
+        if len(opts) > 1 {
+                omitEmpty = opts[1] == "omitempty"
+        }
+        if len(opts) > 2 {
+                allowShadow = opts[2] == "allowshadow"
+        }
+        return rawName, omitEmpty, allowShadow
+}
+
 func (s *Section) mapTo(val reflect.Value) error {
         if val.Kind() == reflect.Ptr {
                 val = val.Elem()
@@ -209,8 +227,8 @@ func (s *Section) mapTo(val reflect.Value) error {
                         continue
                 }
 
-                opts := strings.SplitN(tag, ",", 2) // strip off possible omitempty
-                fieldName := s.parseFieldName(tpField.Name, opts[0])
+                rawName, _, allowShadow := parseTagOptions(tag)
+                fieldName := s.parseFieldName(tpField.Name, rawName)
                 if len(fieldName) == 0 || !field.CanSet() {
                         continue
                 }
@@ -231,7 +249,8 @@ func (s *Section) mapTo(val reflect.Value) error {
                 }
 
                 if key, err := s.GetKey(fieldName); err == nil {
-                        if err = setWithProperType(tpField.Type, key, field, parseDelim(tpField.Tag.Get("delim"))); err != nil {
+                        delim := parseDelim(tpField.Tag.Get("delim"))
+                        if err = setWithProperType(tpField.Type, key, field, delim, allowShadow); err != nil {
                                 return fmt.Errorf("error mapping field(%s): %v", fieldName, err)
                         }
                 }