1 files changed, 95 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/config/module/versions.go b/vendor/github.com/hashicorp/terraform/config/module/versions.go
new file mode 100644
index 0000000..8348d4b
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/module/versions.go
@@ -0,0 +1,95 @@
+package module
+
+import (
+        "errors"
+        "fmt"
+        "sort"
+
+        version "github.com/hashicorp/go-version"
+        "github.com/hashicorp/terraform/registry/response"
+)
+
+const anyVersion = ">=0.0.0"
+
+// return the newest version that satisfies the provided constraint
+func newest(versions []string, constraint string) (string, error) {
+        if constraint == "" {
+                constraint = anyVersion
+        }
+        cs, err := version.NewConstraint(constraint)
+        if err != nil {
+                return "", err
+        }
+
+        switch len(versions) {
+        case 0:
+                return "", errors.New("no versions found")
+        case 1:
+                v, err := version.NewVersion(versions[0])
+                if err != nil {
+                        return "", err
+                }
+
+                if !cs.Check(v) {
+                        return "", fmt.Errorf("no version found matching constraint %q", constraint)
+                }
+                return versions[0], nil
+        }
+
+        sort.Slice(versions, func(i, j int) bool {
+                // versions should have already been validated
+                // sort invalid version strings to the end
+                iv, err := version.NewVersion(versions[i])
+                if err != nil {
+                        return true
+                }
+                jv, err := version.NewVersion(versions[j])
+                if err != nil {
+                        return true
+                }
+                return iv.GreaterThan(jv)
+        })
+
+        // versions are now in order, so just find the first which satisfies the
+        // constraint
+        for i := range versions {
+                v, err := version.NewVersion(versions[i])
+                if err != nil {
+                        continue
+                }
+                if cs.Check(v) {
+                        return versions[i], nil
+                }
+        }
+
+        return "", nil
+}
+
+// return the newest *moduleVersion that matches the given constraint
+// TODO: reconcile these two types and newest* functions
+func newestVersion(moduleVersions []*response.ModuleVersion, constraint string) (*response.ModuleVersion, error) {
+        var versions []string
+        modules := make(map[string]*response.ModuleVersion)
+
+        for _, m := range moduleVersions {
+                versions = append(versions, m.Version)
+                modules[m.Version] = m
+        }
+
+        match, err := newest(versions, constraint)
+        return modules[match], err
+}
+
+// return the newest moduleRecord that matches the given constraint
+func newestRecord(moduleVersions []moduleRecord, constraint string) (moduleRecord, error) {
+        var versions []string
+        modules := make(map[string]moduleRecord)
+
+        for _, m := range moduleVersions {
+                versions = append(versions, m.Version)
+                modules[m.Version] = m
+        }
+
+        match, err := newest(versions, constraint)
+        return modules[match], err
+}