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

4 files changed, 82 insertions, 14 deletions

diff --git a/vendor/github.com/hashicorp/go-version/.travis.yml b/vendor/github.com/hashicorp/go-version/.travis.yml
index 9f30eec..542ca8b 100644
--- a/vendor/github.com/hashicorp/go-version/.travis.yml
+++ b/vendor/github.com/hashicorp/go-version/.travis.yml
@@ -6,6 +6,8 @@ go:
   - 1.2
   - 1.3
   - 1.4
+  - 1.9
+  - "1.10"
   
 script:
   - go test 
diff --git a/vendor/github.com/hashicorp/go-version/constraint.go b/vendor/github.com/hashicorp/go-version/constraint.go
index 8c73df0..d055759 100644
--- a/vendor/github.com/hashicorp/go-version/constraint.go
+++ b/vendor/github.com/hashicorp/go-version/constraint.go
@@ -2,6 +2,7 @@ package version
 
 import (
         "fmt"
+        "reflect"
         "regexp"
         "strings"
 )
@@ -113,6 +114,26 @@ func parseSingle(v string) (*Constraint, error) {
         }, nil
 }
 
+func prereleaseCheck(v, c *Version) bool {
+        switch vPre, cPre := v.Prerelease() != "", c.Prerelease() != ""; {
+        case cPre && vPre:
+                // A constraint with a pre-release can only match a pre-release version
+                // with the same base segments.
+                return reflect.DeepEqual(c.Segments64(), v.Segments64())
+
+        case !cPre && vPre:
+                // A constraint without a pre-release can only match a version without a
+                // pre-release.
+                return false
+
+        case cPre && !vPre:
+                // OK, except with the pessimistic operator
+        case !cPre && !vPre:
+                // OK
+        }
+        return true
+}
+
 //-------------------------------------------------------------------
 // Constraint functions
 //-------------------------------------------------------------------
@@ -126,22 +147,27 @@ func constraintNotEqual(v, c *Version) bool {
 }
 
 func constraintGreaterThan(v, c *Version) bool {
-        return v.Compare(c) == 1
+        return prereleaseCheck(v, c) && v.Compare(c) == 1
 }
 
 func constraintLessThan(v, c *Version) bool {
-        return v.Compare(c) == -1
+        return prereleaseCheck(v, c) && v.Compare(c) == -1
 }
 
 func constraintGreaterThanEqual(v, c *Version) bool {
-        return v.Compare(c) >= 0
+        return prereleaseCheck(v, c) && v.Compare(c) >= 0
 }
 
 func constraintLessThanEqual(v, c *Version) bool {
-        return v.Compare(c) <= 0
+        return prereleaseCheck(v, c) && v.Compare(c) <= 0
 }
 
 func constraintPessimistic(v, c *Version) bool {
+        // Using a pessimistic constraint with a pre-release, restricts versions to pre-releases
+        if !prereleaseCheck(v, c) || (c.Prerelease() != "" && v.Prerelease() == "") {
+                return false
+        }
+
         // If the version being checked is naturally less than the constraint, then there
         // is no way for the version to be valid against the constraint
         if v.LessThan(c) {
diff --git a/vendor/github.com/hashicorp/go-version/go.mod b/vendor/github.com/hashicorp/go-version/go.mod
new file mode 100644
index 0000000..f528555
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-version/go.mod
@@ -0,0 +1 @@
+module github.com/hashicorp/go-version
diff --git a/vendor/github.com/hashicorp/go-version/version.go b/vendor/github.com/hashicorp/go-version/version.go
index ae2f6b6..4d1e6e2 100644
--- a/vendor/github.com/hashicorp/go-version/version.go
+++ b/vendor/github.com/hashicorp/go-version/version.go
@@ -15,8 +15,8 @@ var versionRegexp *regexp.Regexp
 // The raw regular expression string used for testing the validity
 // of a version.
 const VersionRegexpRaw string = `v?([0-9]+(\.[0-9]+)*?)` +
-        `(-?([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
-        `(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
+        `(-([0-9]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)|(-?([A-Za-z\-~]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)))?` +
+        `(\+([0-9A-Za-z\-~]+(\.[0-9A-Za-z\-~]+)*))?` +
         `?`
 
 // Version represents a single version.
@@ -25,6 +25,7 @@ type Version struct {
         pre      string
         segments []int64
         si       int
+        original string
 }
 
 func init() {
@@ -59,11 +60,17 @@ func NewVersion(v string) (*Version, error) {
                 segments = append(segments, 0)
         }
 
+        pre := matches[7]
+        if pre == "" {
+                pre = matches[4]
+        }
+
         return &Version{
-                metadata: matches[7],
-                pre:      matches[4],
+                metadata: matches[10],
+                pre:      pre,
                 segments: segments,
                 si:       si,
+                original: v,
         }, nil
 }
 
@@ -166,24 +173,42 @@ func comparePart(preSelf string, preOther string) int {
                 return 0
         }
 
+        var selfInt int64
+        selfNumeric := true
+        selfInt, err := strconv.ParseInt(preSelf, 10, 64)
+        if err != nil {
+                selfNumeric = false
+        }
+
+        var otherInt int64
+        otherNumeric := true
+        otherInt, err = strconv.ParseInt(preOther, 10, 64)
+        if err != nil {
+                otherNumeric = false
+        }
+
         // if a part is empty, we use the other to decide
         if preSelf == "" {
-                _, notIsNumeric := strconv.ParseInt(preOther, 10, 64)
-                if notIsNumeric == nil {
+                if otherNumeric {
                         return -1
                 }
                 return 1
         }
 
         if preOther == "" {
-                _, notIsNumeric := strconv.ParseInt(preSelf, 10, 64)
-                if notIsNumeric == nil {
+                if selfNumeric {
                         return 1
                 }
                 return -1
         }
 
-        if preSelf > preOther {
+        if selfNumeric && !otherNumeric {
+                return -1
+        } else if !selfNumeric && otherNumeric {
+                return 1
+        } else if !selfNumeric && !otherNumeric && preSelf > preOther {
+                return 1
+        } else if selfInt > otherInt {
                 return 1
         }
 
@@ -283,11 +308,19 @@ func (v *Version) Segments() []int {
 // for a version "1.2.3-beta", segments will return a slice of
 // 1, 2, 3.
 func (v *Version) Segments64() []int64 {
-        return v.segments
+        result := make([]int64, len(v.segments))
+        copy(result, v.segments)
+        return result
 }
 
 // String returns the full version string included pre-release
 // and metadata information.
+//
+// This value is rebuilt according to the parsed segments and other
+// information. Therefore, ambiguities in the version string such as
+// prefixed zeroes (1.04.0 => 1.4.0), `v` prefix (v1.0.0 => 1.0.0), and
+// missing parts (1.0 => 1.0.0) will be made into a canonicalized form
+// as shown in the parenthesized examples.
 func (v *Version) String() string {
         var buf bytes.Buffer
         fmtParts := make([]string, len(v.segments))
@@ -306,3 +339,9 @@ func (v *Version) String() string {
 
         return buf.String()
 }
+
+// Original returns the original parsed version as-is, including any
+// potential whitespace, `v` prefix, etc.
+func (v *Version) Original() string {
+        return v.original
+}