1 files changed, 140 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/registry/regsrc/friendly_host.go b/vendor/github.com/hashicorp/terraform/registry/regsrc/friendly_host.go
new file mode 100644
index 0000000..14b4dce
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/regsrc/friendly_host.go
@@ -0,0 +1,140 @@
+package regsrc
+
+import (
+        "regexp"
+        "strings"
+
+        "github.com/hashicorp/terraform/svchost"
+)
+
+var (
+        // InvalidHostString is a placeholder returned when a raw host can't be
+        // converted by IDNA spec. It will never be returned for any host for which
+        // Valid() is true.
+        InvalidHostString = "<invalid host>"
+
+        // urlLabelEndSubRe is a sub-expression that matches any character that's
+        // allowed at the start or end of a URL label according to RFC1123.
+        urlLabelEndSubRe = "[0-9A-Za-z]"
+
+        // urlLabelEndSubRe is a sub-expression that matches any character that's
+        // allowed at in a non-start or end of a URL label according to RFC1123.
+        urlLabelMidSubRe = "[0-9A-Za-z-]"
+
+        // urlLabelUnicodeSubRe is a sub-expression that matches any non-ascii char
+        // in an IDN (Unicode) display URL. It's not strict - there are only ~15k
+        // valid Unicode points in IDN RFC (some with conditions). We are just going
+        // with being liberal with matching and then erroring if we fail to convert
+        // to punycode later (which validates chars fully). This at least ensures
+        // ascii chars dissalowed by the RC1123 parts above don't become legal
+        // again.
+        urlLabelUnicodeSubRe = "[^[:ascii:]]"
+
+        // hostLabelSubRe is the sub-expression that matches a valid hostname label.
+        // It does not anchor the start or end so it can be composed into more
+        // complex RegExps below. Note that for sanity we don't handle disallowing
+        // raw punycode in this regexp (esp. since re2 doesn't support negative
+        // lookbehind, but we can capture it's presence here to check later).
+        hostLabelSubRe = "" +
+                // Match valid initial char, or unicode char
+                "(?:" + urlLabelEndSubRe + "|" + urlLabelUnicodeSubRe + ")" +
+                // Optionally, match 0 to 61 valid URL or Unicode chars,
+                // followed by one valid end char or unicode char
+                "(?:" +
+                "(?:" + urlLabelMidSubRe + "|" + urlLabelUnicodeSubRe + "){0,61}" +
+                "(?:" + urlLabelEndSubRe + "|" + urlLabelUnicodeSubRe + ")" +
+                ")?"
+
+        // hostSubRe is the sub-expression that matches a valid host prefix.
+        // Allows custom port.
+        hostSubRe = hostLabelSubRe + "(?:\\." + hostLabelSubRe + ")+(?::\\d+)?"
+
+        // hostRe is a regexp that matches a valid host prefix. Additional
+        // validation of unicode strings is needed for matches.
+        hostRe = regexp.MustCompile("^" + hostSubRe + "$")
+)
+
+// FriendlyHost describes a registry instance identified in source strings by a
+// simple bare hostname like registry.terraform.io.
+type FriendlyHost struct {
+        Raw string
+}
+
+func NewFriendlyHost(host string) *FriendlyHost {
+        return &FriendlyHost{Raw: host}
+}
+
+// ParseFriendlyHost attempts to parse a valid "friendly host" prefix from the
+// given string. If no valid prefix is found, host will be nil and rest will
+// contain the full source string. The host prefix must terminate at the end of
+// the input or at the first / character. If one or more characters exist after
+// the first /, they will be returned as rest (without the / delimiter).
+// Hostnames containing punycode WILL be parsed successfully since they may have
+// come from an internal normalized source string, however should be considered
+// invalid if the string came from a user directly. This must be checked
+// explicitly for user-input strings by calling Valid() on the
+// returned host.
+func ParseFriendlyHost(source string) (host *FriendlyHost, rest string) {
+        parts := strings.SplitN(source, "/", 2)
+
+        if hostRe.MatchString(parts[0]) {
+                host = &FriendlyHost{Raw: parts[0]}
+                if len(parts) == 2 {
+                        rest = parts[1]
+                }
+                return
+        }
+
+        // No match, return whole string as rest along with nil host
+        rest = source
+        return
+}
+
+// Valid returns whether the host prefix is considered valid in any case.
+// Example of invalid prefixes might include ones that don't conform to the host
+// name specifications. Not that IDN prefixes containing punycode are not valid
+// input which we expect to always be in user-input or normalised display form.
+func (h *FriendlyHost) Valid() bool {
+        return svchost.IsValid(h.Raw)
+}
+
+// Display returns the host formatted for display to the user in CLI or web
+// output.
+func (h *FriendlyHost) Display() string {
+        return svchost.ForDisplay(h.Raw)
+}
+
+// Normalized returns the host formatted for internal reference or comparison.
+func (h *FriendlyHost) Normalized() string {
+        host, err := svchost.ForComparison(h.Raw)
+        if err != nil {
+                return InvalidHostString
+        }
+        return string(host)
+}
+
+// String returns the host formatted as the user originally typed it assuming it
+// was parsed from user input.
+func (h *FriendlyHost) String() string {
+        return h.Raw
+}
+
+// Equal compares the FriendlyHost against another instance taking normalization
+// into account. Invalid hosts cannot be compared and will always return false.
+func (h *FriendlyHost) Equal(other *FriendlyHost) bool {
+        if other == nil {
+                return false
+        }
+
+        otherHost, err := svchost.ForComparison(other.Raw)
+        if err != nil {
+                return false
+        }
+
+        host, err := svchost.ForComparison(h.Raw)
+        if err != nil {
+                return false
+        }
+
+        return otherHost == host
+}