1 files changed, 205 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/registry/regsrc/module.go b/vendor/github.com/hashicorp/terraform/registry/regsrc/module.go
new file mode 100644
index 0000000..325706e
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/registry/regsrc/module.go
@@ -0,0 +1,205 @@
+package regsrc
+
+import (
+        "errors"
+        "fmt"
+        "regexp"
+        "strings"
+
+        "github.com/hashicorp/terraform/svchost"
+)
+
+var (
+        ErrInvalidModuleSource = errors.New("not a valid registry module source")
+
+        // nameSubRe is the sub-expression that matches a valid module namespace or
+        // name. It's strictly a super-set of what GitHub allows for user/org and
+        // repo names respectively, but more restrictive than our original repo-name
+        // regex which allowed periods but could cause ambiguity with hostname
+        // prefixes. It does not anchor the start or end so it can be composed into
+        // more complex RegExps below. Alphanumeric with - and _ allowed in non
+        // leading or trailing positions. Max length 64 chars. (GitHub username is
+        // 38 max.)
+        nameSubRe = "[0-9A-Za-z](?:[0-9A-Za-z-_]{0,62}[0-9A-Za-z])?"
+
+        // providerSubRe is the sub-expression that matches a valid provider. It
+        // does not anchor the start or end so it can be composed into more complex
+        // RegExps below. Only lowercase chars and digits are supported in practice.
+        // Max length 64 chars.
+        providerSubRe = "[0-9a-z]{1,64}"
+
+        // moduleSourceRe is a regular expression that matches the basic
+        // namespace/name/provider[//...] format for registry sources. It assumes
+        // any FriendlyHost prefix has already been removed if present.
+        moduleSourceRe = regexp.MustCompile(
+                fmt.Sprintf("^(%s)\\/(%s)\\/(%s)(?:\\/\\/(.*))?$",
+                        nameSubRe, nameSubRe, providerSubRe))
+
+        // NameRe is a regular expression defining the format allowed for namespace
+        // or name fields in module registry implementations.
+        NameRe = regexp.MustCompile("^" + nameSubRe + "$")
+
+        // ProviderRe is a regular expression defining the format allowed for
+        // provider fields in module registry implementations.
+        ProviderRe = regexp.MustCompile("^" + providerSubRe + "$")
+
+        // these hostnames are not allowed as registry sources, because they are
+        // already special case module sources in terraform.
+        disallowed = map[string]bool{
+                "github.com":    true,
+                "bitbucket.org": true,
+        }
+)
+
+// Module describes a Terraform Registry Module source.
+type Module struct {
+        // RawHost is the friendly host prefix if one was present. It might be nil
+        // if the original source had no host prefix which implies
+        // PublicRegistryHost but is distinct from having an actual pointer to
+        // PublicRegistryHost since it encodes the fact the original string didn't
+        // include a host prefix at all which is significant for recovering actual
+        // input not just normalized form. Most callers should access it with Host()
+        // which will return public registry host instance if it's nil.
+        RawHost      *FriendlyHost
+        RawNamespace string
+        RawName      string
+        RawProvider  string
+        RawSubmodule string
+}
+
+// NewModule construct a new module source from separate parts. Pass empty
+// string if host or submodule are not needed.
+func NewModule(host, namespace, name, provider, submodule string) (*Module, error) {
+        m := &Module{
+                RawNamespace: namespace,
+                RawName:      name,
+                RawProvider:  provider,
+                RawSubmodule: submodule,
+        }
+        if host != "" {
+                h := NewFriendlyHost(host)
+                if h != nil {
+                        fmt.Println("HOST:", h)
+                        if !h.Valid() || disallowed[h.Display()] {
+                                return nil, ErrInvalidModuleSource
+                        }
+                }
+                m.RawHost = h
+        }
+        return m, nil
+}
+
+// ParseModuleSource attempts to parse source as a Terraform registry module
+// source. If the string is not found to be in a valid format,
+// ErrInvalidModuleSource is returned. Note that this can only be used on
+// "input" strings, e.g. either ones supplied by the user or potentially
+// normalised but in Display form (unicode). It will fail to parse a source with
+// a punycoded domain since this is not permitted input from a user. If you have
+// an already normalized string internally, you can compare it without parsing
+// by comparing with the normalized version of the subject with the normal
+// string equality operator.
+func ParseModuleSource(source string) (*Module, error) {
+        // See if there is a friendly host prefix.
+        host, rest := ParseFriendlyHost(source)
+        if host != nil {
+                if !host.Valid() || disallowed[host.Display()] {
+                        return nil, ErrInvalidModuleSource
+                }
+        }
+
+        matches := moduleSourceRe.FindStringSubmatch(rest)
+        if len(matches) < 4 {
+                return nil, ErrInvalidModuleSource
+        }
+
+        m := &Module{
+                RawHost:      host,
+                RawNamespace: matches[1],
+                RawName:      matches[2],
+                RawProvider:  matches[3],
+        }
+
+        if len(matches) == 5 {
+                m.RawSubmodule = matches[4]
+        }
+
+        return m, nil
+}
+
+// Display returns the source formatted for display to the user in CLI or web
+// output.
+func (m *Module) Display() string {
+        return m.formatWithPrefix(m.normalizedHostPrefix(m.Host().Display()), false)
+}
+
+// Normalized returns the source formatted for internal reference or comparison.
+func (m *Module) Normalized() string {
+        return m.formatWithPrefix(m.normalizedHostPrefix(m.Host().Normalized()), false)
+}
+
+// String returns the source formatted as the user originally typed it assuming
+// it was parsed from user input.
+func (m *Module) String() string {
+        // Don't normalize public registry hostname - leave it exactly like the user
+        // input it.
+        hostPrefix := ""
+        if m.RawHost != nil {
+                hostPrefix = m.RawHost.String() + "/"
+        }
+        return m.formatWithPrefix(hostPrefix, true)
+}
+
+// Equal compares the module source against another instance taking
+// normalization into account.
+func (m *Module) Equal(other *Module) bool {
+        return m.Normalized() == other.Normalized()
+}
+
+// Host returns the FriendlyHost object describing which registry this module is
+// in. If the original source string had not host component this will return the
+// PublicRegistryHost.
+func (m *Module) Host() *FriendlyHost {
+        if m.RawHost == nil {
+                return PublicRegistryHost
+        }
+        return m.RawHost
+}
+
+func (m *Module) normalizedHostPrefix(host string) string {
+        if m.Host().Equal(PublicRegistryHost) {
+                return ""
+        }
+        return host + "/"
+}
+
+func (m *Module) formatWithPrefix(hostPrefix string, preserveCase bool) string {
+        suffix := ""
+        if m.RawSubmodule != "" {
+                suffix = "//" + m.RawSubmodule
+        }
+        str := fmt.Sprintf("%s%s/%s/%s%s", hostPrefix, m.RawNamespace, m.RawName,
+                m.RawProvider, suffix)
+
+        // lower case by default
+        if !preserveCase {
+                return strings.ToLower(str)
+        }
+        return str
+}
+
+// Module returns just the registry ID of the module, without a hostname or
+// suffix.
+func (m *Module) Module() string {
+        return fmt.Sprintf("%s/%s/%s", m.RawNamespace, m.RawName, m.RawProvider)
+}
+
+// SvcHost returns the svchost.Hostname for this module. Since FriendlyHost may
+// contain an invalid hostname, this also returns an error indicating if it
+// could be converted to a svchost.Hostname. If no host is specified, the
+// default PublicRegistryHost is returned.
+func (m *Module) SvcHost() (svchost.Hostname, error) {
+        if m.RawHost == nil {
+                return svchost.ForComparison(PublicRegistryHost.Raw)
+        }
+        return svchost.ForComparison(m.RawHost.Raw)
+}