// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

import (
        "strings"
        "unicode/utf8"
)

// stripRunesFn returns a function which returns -1 (i.e. a value which
// signals deletion in strings.Map) for runes in 'runes', and the rune otherwise.
func stripRunesFn(runes string) func(rune) rune {
        return func(r rune) rune {
                if strings.ContainsRune(runes, r) {
                        return -1
                }
                return r
        }
}

// checkElement checks a given named element matches character and length restrictions.
// Returns true if the given element adheres to the given restrictions, false otherwise.
func checkElement(name, element, allowedRunes string, minRunes, maxRunes int) error {
        numRunes := utf8.RuneCountInString(element)
        if (numRunes < minRunes) || (maxRunes < numRunes) {
                return newErrBadName("%s must be between %d and %d characters in length: %s", name, minRunes, maxRunes, element)
        } else if len(strings.Map(stripRunesFn(allowedRunes), element)) != 0 {
                return newErrBadName("%s can only contain the characters `%s`: %s", name, allowedRunes, element)
        }
        return nil
}

// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

import (
        // nolint: depguard
        _ "crypto/sha256" // Recommended by go-digest.
        "encoding"
        "encoding/json"
        "strings"

        "github.com/opencontainers/go-digest"
)

const digestDelim = "@"

// Digest stores a digest name in a structured form.
type Digest struct {
        Repository
        digest   string
        original string
}

var _ Reference = (*Digest)(nil)
var _ encoding.TextMarshaler = (*Digest)(nil)
var _ encoding.TextUnmarshaler = (*Digest)(nil)
var _ json.Marshaler = (*Digest)(nil)
var _ json.Unmarshaler = (*Digest)(nil)

// Context implements Reference.
func (d Digest) Context() Repository {
        return d.Repository
}

// Identifier implements Reference.
func (d Digest) Identifier() string {
        return d.DigestStr()
}

// DigestStr returns the digest component of the Digest.
func (d Digest) DigestStr() string {
        return d.digest
}

// Name returns the name from which the Digest was derived.
func (d Digest) Name() string {
        return d.Repository.Name() + digestDelim + d.DigestStr()
}

// String returns the original input string.
func (d Digest) String() string {
        return d.original
}

// MarshalJSON formats the digest into a string for JSON serialization.
func (d Digest) MarshalJSON() ([]byte, error) {
        return json.Marshal(d.String())
}

// UnmarshalJSON parses a JSON string into a Digest.
func (d *Digest) UnmarshalJSON(data []byte) error {
        var s string
        if err := json.Unmarshal(data, &s); err != nil {
                return err
        }
        n, err := NewDigest(s)
        if err != nil {
                return err
        }
        *d = n
        return nil
}

// MarshalText formats the digest into a string for text serialization.
func (d Digest) MarshalText() ([]byte, error) {
        return []byte(d.String()), nil
}

// UnmarshalText parses a text string into a Digest.
func (d *Digest) UnmarshalText(data []byte) error {
        n, err := NewDigest(string(data))
        if err != nil {
                return err
        }
        *d = n
        return nil
}

// NewDigest returns a new Digest representing the given name.
func NewDigest(name string, opts ...Option) (Digest, error) {
        // Split on "@"
        parts := strings.Split(name, digestDelim)
        if len(parts) != 2 {
                return Digest{}, newErrBadName("a digest must contain exactly one '@' separator (e.g. registry/repository@digest) saw: %s", name)
        }
        base := parts[0]
        dig := parts[1]
        prefix := digest.Canonical.String() + ":"
        if !strings.HasPrefix(dig, prefix) {
                return Digest{}, newErrBadName("unsupported digest algorithm: %s", dig)
        }
        hex := strings.TrimPrefix(dig, prefix)
        if err := digest.Canonical.Validate(hex); err != nil {
                return Digest{}, err
        }

        tag, err := NewTag(base, opts...)
        if err == nil {
                base = tag.Repository.Name()
        }

        repo, err := NewRepository(base, opts...)
        if err != nil {
                return Digest{}, err
        }
        return Digest{
                Repository: repo,
                digest:     dig,
                original:   name,
        }, nil
}

// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

import (
        "errors"
        "fmt"
)

// ErrBadName is an error for when a bad docker name is supplied.
type ErrBadName struct {
        info string
}

func (e *ErrBadName) Error() string {
        return e.info
}

// Is reports whether target is an error of type ErrBadName
func (e *ErrBadName) Is(target error) bool {
        var berr *ErrBadName
        return errors.As(target, &berr)
}

// newErrBadName returns a ErrBadName which returns the given formatted string from Error().
func newErrBadName(fmtStr string, args ...any) *ErrBadName {
        return &ErrBadName{fmt.Sprintf(fmtStr, args...)}
}

// IsErrBadName returns true if the given error is an ErrBadName.
//
// Deprecated: Use errors.Is.
func IsErrBadName(err error) bool {
        var berr *ErrBadName
        return errors.As(err, &berr)
}

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

func FuzzParseReference(data []byte) int {
        _, _ = ParseReference(string(data))
        return 1
}

// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

const (
        // DefaultRegistry is the registry name that will be used if no registry
        // provided and the default is not overridden.
        DefaultRegistry      = "index.docker.io"
        defaultRegistryAlias = "docker.io"

        // DefaultTag is the tag name that will be used if no tag provided and the
        // default is not overridden.
        DefaultTag = "latest"
)

type options struct {
        strict          bool // weak by default
        insecure        bool // secure by default
        defaultRegistry string
        defaultTag      string
}

func makeOptions(opts ...Option) options {
        opt := options{
                defaultRegistry: DefaultRegistry,
                defaultTag:      DefaultTag,
        }
        for _, o := range opts {
                o(&opt)
        }
        return opt
}

// Option is a functional option for name parsing.
type Option func(*options)

// StrictValidation is an Option that requires image references to be fully
// specified; i.e. no defaulting for registry (dockerhub), repo (library),
// or tag (latest).
func StrictValidation(opts *options) {
        opts.strict = true
}

// WeakValidation is an Option that sets defaults when parsing names, see
// StrictValidation.
func WeakValidation(opts *options) {
        opts.strict = false
}

// Insecure is an Option that allows image references to be fetched without TLS.
func Insecure(opts *options) {
        opts.insecure = true
}

// OptionFn is a function that returns an option.
type OptionFn func() Option

// WithDefaultRegistry sets the default registry that will be used if one is not
// provided.
func WithDefaultRegistry(r string) Option {
        return func(opts *options) {
                opts.defaultRegistry = r
        }
}

// WithDefaultTag sets the default tag that will be used if one is not provided.
func WithDefaultTag(t string) Option {
        return func(opts *options) {
                opts.defaultTag = t
        }
}

// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

import (
        "fmt"
)

// Reference defines the interface that consumers use when they can
// take either a tag or a digest.
type Reference interface {
        fmt.Stringer

        // Context accesses the Repository context of the reference.
        Context() Repository

        // Identifier accesses the type-specific portion of the reference.
        Identifier() string

        // Name is the fully-qualified reference name.
        Name() string

        // Scope is the scope needed to access this reference.
        Scope(string) string
}

// ParseReference parses the string as a reference, either by tag or digest.
func ParseReference(s string, opts ...Option) (Reference, error) {
        if t, err := NewTag(s, opts...); err == nil {
                return t, nil
        }
        if d, err := NewDigest(s, opts...); err == nil {
                return d, nil
        }
        return nil, newErrBadName("could not parse reference: %s", s)
}

type stringConst string

// MustParseReference behaves like ParseReference, but panics instead of
// returning an error. It's intended for use in tests, or when a value is
// expected to be valid at code authoring time.
//
// To discourage its use in scenarios where the value is not known at code
// authoring time, it must be passed a string constant:
//
//        const str = "valid/string"
//        MustParseReference(str)
//        MustParseReference("another/valid/string")
//        MustParseReference(str + "/and/more")
//
// These will not compile:
//
//        var str = "valid/string"
//        MustParseReference(str)
//        MustParseReference(strings.Join([]string{"valid", "string"}, "/"))
func MustParseReference(s stringConst, opts ...Option) Reference {
        ref, err := ParseReference(string(s), opts...)
        if err != nil {
                panic(err)
        }
        return ref
}

// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

import (
        "encoding"
        "encoding/json"
        "net"
        "net/url"
        "path"
        "regexp"
        "strings"
)

// Detect more complex forms of local references.
var reLocal = regexp.MustCompile(`.*\.local(?:host)?(?::\d{1,5})?$`)

// Detect the loopback IP (127.0.0.1)
var reLoopback = regexp.MustCompile(regexp.QuoteMeta("127.0.0.1"))

// Detect the loopback IPV6 (::1)
var reipv6Loopback = regexp.MustCompile(regexp.QuoteMeta("::1"))

// Registry stores a docker registry name in a structured form.
type Registry struct {
        insecure bool
        registry string
}

var _ encoding.TextMarshaler = (*Registry)(nil)
var _ encoding.TextUnmarshaler = (*Registry)(nil)
var _ json.Marshaler = (*Registry)(nil)
var _ json.Unmarshaler = (*Registry)(nil)

// RegistryStr returns the registry component of the Registry.
func (r Registry) RegistryStr() string {
        return r.registry
}

// Name returns the name from which the Registry was derived.
func (r Registry) Name() string {
        return r.RegistryStr()
}

func (r Registry) String() string {
        return r.Name()
}

// Repo returns a Repository in the Registry with the given name.
func (r Registry) Repo(repo ...string) Repository {
        return Repository{Registry: r, repository: path.Join(repo...)}
}

// Scope returns the scope required to access the registry.
func (r Registry) Scope(string) string {
        // The only resource under 'registry' is 'catalog'. http://goo.gl/N9cN9Z
        return "registry:catalog:*"
}

func (r Registry) isRFC1918() bool {
        ipStr := strings.Split(r.Name(), ":")[0]
        ip := net.ParseIP(ipStr)
        if ip == nil {
                return false
        }
        for _, cidr := range []string{"10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"} {
                _, block, _ := net.ParseCIDR(cidr)
                if block.Contains(ip) {
                        return true
                }
        }
        return false
}

// Scheme returns https scheme for all the endpoints except localhost or when explicitly defined.
func (r Registry) Scheme() string {
        if r.insecure {
                return "http"
        }
        if r.isRFC1918() {
                return "http"
        }
        if strings.HasPrefix(r.Name(), "localhost:") {
                return "http"
        }
        if reLocal.MatchString(r.Name()) {
                return "http"
        }
        if reLoopback.MatchString(r.Name()) {
                return "http"
        }
        if reipv6Loopback.MatchString(r.Name()) {
                return "http"
        }
        return "https"
}

func checkRegistry(name string) error {
        // Per RFC 3986, registries (authorities) are required to be prefixed with "//"
        // url.Host == hostname[:port] == authority
        if url, err := url.Parse("//" + name); err != nil || url.Host != name {
                return newErrBadName("registries must be valid RFC 3986 URI authorities: %s", name)
        }
        return nil
}

// NewRegistry returns a Registry based on the given name.
// Strict validation requires explicit, valid RFC 3986 URI authorities to be given.
func NewRegistry(name string, opts ...Option) (Registry, error) {
        opt := makeOptions(opts...)
        if opt.strict && len(name) == 0 {
                return Registry{}, newErrBadName("strict validation requires the registry to be explicitly defined")
        }

        if err := checkRegistry(name); err != nil {
                return Registry{}, err
        }

        if name == "" {
                name = opt.defaultRegistry
        }
        // Rewrite "docker.io" to "index.docker.io".
        // See: https://github.com/google/go-containerregistry/issues/68
        if name == defaultRegistryAlias {
                name = DefaultRegistry
        }

        return Registry{registry: name, insecure: opt.insecure}, nil
}

// NewInsecureRegistry returns an Insecure Registry based on the given name.
//
// Deprecated: Use the Insecure Option with NewRegistry instead.
func NewInsecureRegistry(name string, opts ...Option) (Registry, error) {
        opts = append(opts, Insecure)
        return NewRegistry(name, opts...)
}

// MarshalJSON formats the Registry into a string for JSON serialization.
func (r Registry) MarshalJSON() ([]byte, error) { return json.Marshal(r.String()) }

// UnmarshalJSON parses a JSON string into a Registry.
func (r *Registry) UnmarshalJSON(data []byte) error {
        var s string
        if err := json.Unmarshal(data, &s); err != nil {
                return err
        }
        n, err := NewRegistry(s)
        if err != nil {
                return err
        }
        *r = n
        return nil
}

// MarshalText formats the registry into a string for text serialization.
func (r Registry) MarshalText() ([]byte, error) { return []byte(r.String()), nil }

// UnmarshalText parses a text string into a Registry.
func (r *Registry) UnmarshalText(data []byte) error {
        n, err := NewRegistry(string(data))
        if err != nil {
                return err
        }
        *r = n
        return nil
}

// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

import (
        "encoding"
        "encoding/json"
        "fmt"
        "strings"
)

const (
        defaultNamespace = "library"
        repositoryChars  = "abcdefghijklmnopqrstuvwxyz0123456789_-./"
        regRepoDelimiter = "/"
)

// Repository stores a docker repository name in a structured form.
type Repository struct {
        Registry
        repository string
}

var _ encoding.TextMarshaler = (*Repository)(nil)
var _ encoding.TextUnmarshaler = (*Repository)(nil)
var _ json.Marshaler = (*Repository)(nil)
var _ json.Unmarshaler = (*Repository)(nil)

// See https://docs.docker.com/docker-hub/official_repos
func hasImplicitNamespace(repo string, reg Registry) bool {
        return !strings.ContainsRune(repo, '/') && reg.RegistryStr() == DefaultRegistry
}

// RepositoryStr returns the repository component of the Repository.
func (r Repository) RepositoryStr() string {
        if hasImplicitNamespace(r.repository, r.Registry) {
                return fmt.Sprintf("%s/%s", defaultNamespace, r.repository)
        }
        return r.repository
}

// Name returns the name from which the Repository was derived.
func (r Repository) Name() string {
        regName := r.Registry.Name()
        if regName != "" {
                return regName + regRepoDelimiter + r.RepositoryStr()
        }
        // TODO: As far as I can tell, this is unreachable.
        return r.RepositoryStr()
}

func (r Repository) String() string {
        return r.Name()
}

// Scope returns the scope required to perform the given action on the registry.
// TODO(jonjohnsonjr): consider moving scopes to a separate package.
func (r Repository) Scope(action string) string {
        return fmt.Sprintf("repository:%s:%s", r.RepositoryStr(), action)
}

func checkRepository(repository string) error {
        return checkElement("repository", repository, repositoryChars, 2, 255)
}

// NewRepository returns a new Repository representing the given name, according to the given strictness.
func NewRepository(name string, opts ...Option) (Repository, error) {
        opt := makeOptions(opts...)
        if len(name) == 0 {
                return Repository{}, newErrBadName("a repository name must be specified")
        }

        var registry string
        repo := name
        parts := strings.SplitN(name, regRepoDelimiter, 2)
        if len(parts) == 2 && (strings.ContainsRune(parts[0], '.') || strings.ContainsRune(parts[0], ':')) {
                // The first part of the repository is treated as the registry domain
                // iff it contains a '.' or ':' character, otherwise it is all repository
                // and the domain defaults to Docker Hub.
                registry = parts[0]
                repo = parts[1]
        }

        if err := checkRepository(repo); err != nil {
                return Repository{}, err
        }

        reg, err := NewRegistry(registry, opts...)
        if err != nil {
                return Repository{}, err
        }
        if hasImplicitNamespace(repo, reg) && opt.strict {
                return Repository{}, newErrBadName("strict validation requires the full repository path (missing 'library')")
        }
        return Repository{reg, repo}, nil
}

// Tag returns a Tag in this Repository.
func (r Repository) Tag(identifier string) Tag {
        t := Tag{
                tag:        identifier,
                Repository: r,
        }
        t.original = t.Name()
        return t
}

// Digest returns a Digest in this Repository.
func (r Repository) Digest(identifier string) Digest {
        d := Digest{
                digest:     identifier,
                Repository: r,
        }
        d.original = d.Name()
        return d
}

// MarshalJSON formats the Repository into a string for JSON serialization.
func (r Repository) MarshalJSON() ([]byte, error) { return json.Marshal(r.String()) }

// UnmarshalJSON parses a JSON string into a Repository.
func (r *Repository) UnmarshalJSON(data []byte) error {
        var s string
        if err := json.Unmarshal(data, &s); err != nil {
                return err
        }
        n, err := NewRepository(s)
        if err != nil {
                return err
        }
        *r = n
        return nil
}

// MarshalText formats the repository name into a string for text serialization.
func (r Repository) MarshalText() ([]byte, error) { return []byte(r.String()), nil }

// UnmarshalText parses a text string into a Repository.
func (r *Repository) UnmarshalText(data []byte) error {
        n, err := NewRepository(string(data))
        if err != nil {
                return err
        }
        *r = n
        return nil
}

// Copyright 2018 Google LLC All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package name

import (
        "encoding"
        "encoding/json"
        "strings"
)

const (
        // TODO(dekkagaijin): use the docker/distribution regexes for validation.
        tagChars = "abcdefghijklmnopqrstuvwxyz0123456789_-.ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        tagDelim = ":"
)

// Tag stores a docker tag name in a structured form.
type Tag struct {
        Repository
        tag      string
        original string
}

var _ Reference = (*Tag)(nil)
var _ encoding.TextMarshaler = (*Tag)(nil)
var _ encoding.TextUnmarshaler = (*Tag)(nil)
var _ json.Marshaler = (*Tag)(nil)
var _ json.Unmarshaler = (*Tag)(nil)

// Context implements Reference.
func (t Tag) Context() Repository {
        return t.Repository
}

// Identifier implements Reference.
func (t Tag) Identifier() string {
        return t.TagStr()
}

// TagStr returns the tag component of the Tag.
func (t Tag) TagStr() string {
        return t.tag
}

// Name returns the name from which the Tag was derived.
func (t Tag) Name() string {
        return t.Repository.Name() + tagDelim + t.TagStr()
}

// String returns the original input string.
func (t Tag) String() string {
        return t.original
}

// Scope returns the scope required to perform the given action on the tag.
func (t Tag) Scope(action string) string {
        return t.Repository.Scope(action)
}

func checkTag(name string) error {
        return checkElement("tag", name, tagChars, 1, 128)
}

// NewTag returns a new Tag representing the given name, according to the given strictness.
func NewTag(name string, opts ...Option) (Tag, error) {
        opt := makeOptions(opts...)
        base := name
        tag := ""

        // Split on ":"
        parts := strings.Split(name, tagDelim)
        // Verify that we aren't confusing a tag for a hostname w/ port for the purposes of weak validation.
        if len(parts) > 1 && !strings.Contains(parts[len(parts)-1], regRepoDelimiter) {
                base = strings.Join(parts[:len(parts)-1], tagDelim)
                tag = parts[len(parts)-1]
                if tag == "" {
                        return Tag{}, newErrBadName("%s must specify a tag name after the colon", name)
                }
        }

        // We don't require a tag, but if we get one check it's valid,
        // even when not being strict.
        // If we are being strict, we want to validate the tag regardless in case
        // it's empty.
        if tag != "" || opt.strict {
                if err := checkTag(tag); err != nil {
                        return Tag{}, err
                }
        }

        if tag == "" {
                tag = opt.defaultTag
        }

        repo, err := NewRepository(base, opts...)
        if err != nil {
                return Tag{}, err
        }
        return Tag{
                Repository: repo,
                tag:        tag,
                original:   name,
        }, nil
}

// MarshalJSON formats the Tag into a string for JSON serialization.
func (t Tag) MarshalJSON() ([]byte, error) { return json.Marshal(t.String()) }

// UnmarshalJSON parses a JSON string into a Tag.
func (t *Tag) UnmarshalJSON(data []byte) error {
        var s string
        if err := json.Unmarshal(data, &s); err != nil {
                return err
        }
        n, err := NewTag(s)
        if err != nil {
                return err
        }
        *t = n
        return nil
}

// MarshalText formats the tag into a string for text serialization.
func (t Tag) MarshalText() ([]byte, error) { return []byte(t.String()), nil }

// UnmarshalText parses a text string into a Tag.
func (t *Tag) UnmarshalText(data []byte) error {
        n, err := NewTag(string(data))
        if err != nil {
                return err
        }
        *t = n
        return nil
}