drone-docker/tags.go

package docker

import (
	"errors"
	"fmt"
	"strings"

	"github.com/coreos/go-semver/semver"
)

// DefaultTagSuffix returns a set of default suggested tags
// based on the commit ref with an attached suffix.
func DefaultTagSuffix(ref, suffix string, allTags []string) ([]string, error) {
	if ref == "" {
		if suffix == "" {
			return nil, ErrRefTypeUnsupported{}
		}
		return []string{suffix}, nil
	}
	tags, err := DefaultTags(ref, allTags)
	if err != nil {
		return nil, err
	}
	if len(suffix) == 0 {
		return tags, nil
	}
	for i, tag := range tags {
		if tag == "latest" {
			tags[i] = suffix
		} else {
			tags[i] = fmt.Sprintf("%s-%s", tag, suffix)
		}
	}
	return tags, nil
}

func splitOff(input string, delim string) string {
	parts := strings.SplitN(input, delim, 2)

	if len(parts) == 2 {
		return parts[0]
	}

	return input
}

func findLatestStableTag(tags []string) (string, error) {
	if len(tags) == 0 {
		return "", errors.New("")
	}

	var latestStableTag *semver.Version
	for _, tag := range tags[1:] {
		tag = strings.TrimPrefix(tag, "v")
		version, err := semver.NewVersion(tag)
		if err != nil {
			return "", err
		}
		if version.PreRelease != "" {
			continue
		}
		if latestStableTag == nil || version.Compare(*latestStableTag) > 0 {
			latestStableTag = version
		}
	}
	if latestStableTag != nil {
		return latestStableTag.String(), nil
	}
	return "", nil
}

const (
	GitBranch = iota
	GitTag
	GitUnknown
)

func RefType(ref string) int {
	switch {
	case strings.HasPrefix(ref, "refs/tags/"):
		return GitTag
	case strings.HasPrefix(ref, "refs/heads/"):
		return GitBranch
	default:
		return GitUnknown
	}
}

type ErrRefTypeUnsupported struct {
	Ref string
}

func (err ErrRefTypeUnsupported) Error() string {
	return fmt.Sprintf("%s is unsupported reference type", err.Ref)
}

// DefaultTags returns a set of default suggested tags based on
// the commit ref.
/*
Tagging a dev version which ends with -dev
It will produce the tags: <original_tag>
Tagging a pre-release version which ends with -rcx, x start from 1 to bigger number
It will produce the tags: <original_tag>
Tagging a latest stable release, we need to know if the version is the newest
It will produce the tags: <original_tag>, 1.1x, 1, latest
Tagging a low version stable release
It will produce the tags: <original_tag>, 1.1x
*/
func DefaultTags(ref string, allTags []string) ([]string, error) {
	tp := RefType(ref)
	if tp == GitBranch {
		return BranchTags(ref), nil
	} else if tp == GitTag {
		return GitTagTags(ref, allTags)
	}
	return nil, ErrRefTypeUnsupported{Ref: ref}
}

const l = len("refs/heads/release/v")

/*
Tagging main branch
It will produce the tags: dev.
Tagging release/vxxx branch
It will produce the tags: 1.1x-dev
*/
func BranchTags(ref string) []string {
	if ref == "refs/heads/main" {
		return []string{"dev"}
	} else if strings.HasPrefix(ref, "refs/heads/release/v") {
		return []string{ref[l:] + "-dev"}
	}
	return nil
}

func GitTagTags(ref string, allTags []string) ([]string, error) {
	v := stripTagPrefix(ref)
	if strings.HasSuffix(ref, "-dev") {
		return []string{v}, nil
	}

	version, err := semver.NewVersion(v)
	if err != nil {
		return nil, err
	}
	if version.PreRelease != "" {
		return []string{v}, nil
	}

	v = splitOff(splitOff(v, "+"), "-")
	dotParts := strings.SplitN(v, ".", 3)

	tags := []string{
		fmt.Sprintf("%0*d.%0*d", len(dotParts[0]), version.Major, len(dotParts[1]), version.Minor),
		fmt.Sprintf("%0*d.%0*d.%0*d", len(dotParts[0]), version.Major, len(dotParts[1]), version.Minor, len(dotParts[2]), version.Patch),
	}

	if version.Major == 0 {
		return tags, nil
	}

	latestStableTag, err := findLatestStableTag(allTags)
	if err != nil {
		return nil, err
	}
	if latestStableTag == v {
		tags = append(tags, fmt.Sprintf("%0*d", len(dotParts[0]), version.Major), "latest")
	}
	return tags, nil
}

// UseDefaultTag for keep only default branch for latest tag
func UseDefaultTag(ref, defaultBranch string) bool {
	if strings.HasPrefix(ref, "refs/tags/") {
		return true
	}
	if stripHeadPrefix(ref) == defaultBranch {
		return true
	}
	return false
}

func stripHeadPrefix(ref string) string {
	return strings.TrimPrefix(ref, "refs/heads/")
}

func stripTagPrefix(ref string) string {
	ref = strings.TrimPrefix(ref, "refs/tags/")
	ref = strings.TrimPrefix(ref, "v")
	return ref
}