fix handling of redirect from asset download

vendor/github.com/cppforlife/go-semi-semantic/version/ver_seg_comp_int.go

@@ -46,4 +46,6 @@ func (i VerSegCompInt) Compare(other VerSegComp) int {
 	panic("unreachable")
 }
 
+func (i VerSegCompInt) String() string { return i.AsString() }
+
 func (i VerSegCompInt) AsString() string { return strconv.Itoa(i.I) }

vendor/github.com/cppforlife/go-semi-semantic/version/ver_seg_comp_str.go

@@ -40,4 +40,6 @@ func (s VerSegCompStr) Compare(other VerSegComp) int {
 	panic("unreachable")
 }
 
+func (s VerSegCompStr) String() string { return s.AsString() }
+
 func (s VerSegCompStr) AsString() string { return s.S }

vendor/github.com/cppforlife/go-semi-semantic/version/version.go

@@ -20,6 +20,15 @@ type Version struct {
 	Segments []VersionSegment
 }
 
+func MustNewVersionFromString(v string) Version {
+	ver, err := NewVersionFromString(v)
+	if err != nil {
+		panic(fmt.Sprintf("Invalid version '%s': %s", v, err))
+	}
+
+	return ver
+}
+
 func NewVersionFromString(v string) (Version, error) {
 	var err error
 
@@ -76,6 +85,37 @@ func NewVersion(release, preRelease, postRelease VersionSegment) (Version, error
 	return version, nil
 }
 
+func (v Version) IncrementRelease() (Version, error) {
+	incRelease, err := v.Release.Increment()
+	if err != nil {
+		return Version{}, err
+	}
+
+	return NewVersion(incRelease, VersionSegment{}, VersionSegment{})
+}
+
+func (v Version) IncrementPostRelease(defaultPostRelease VersionSegment) (Version, error) {
+	var newPostRelease VersionSegment
+	var err error
+
+	if defaultPostRelease.Empty() {
+		return Version{}, errors.New("Expected default post relase to be non-empty")
+	}
+
+	if v.PostRelease.Empty() {
+		newPostRelease = defaultPostRelease.Copy()
+	} else {
+		newPostRelease, err = v.PostRelease.Increment()
+		if err != nil {
+			return Version{}, err
+		}
+	}
+
+	return NewVersion(v.Release.Copy(), v.PreRelease.Copy(), newPostRelease)
+}
+
+func (v Version) Empty() bool { return len(v.Segments) == 0 }
+
 func (v Version) String() string { return v.AsString() }
 
 func (v Version) AsString() string {

vendor/github.com/cppforlife/go-semi-semantic/version/version_segment.go

@@ -17,6 +17,15 @@ type VersionSegment struct {
 	Components []VerSegComp
 }
 
+func MustNewVersionSegmentFromString(v string) VersionSegment {
+	verSeg, err := NewVersionSegmentFromString(v)
+	if err != nil {
+		panic(fmt.Sprintf("Invalid version segment '%s': %s", v, err))
+	}
+
+	return verSeg
+}
+
 func NewVersionSegmentFromString(v string) (VersionSegment, error) {
 	pieces := strings.Split(v, ".")
 
@@ -57,8 +66,38 @@ func NewVersionSegment(components []VerSegComp) (VersionSegment, error) {
 	return VersionSegment{components}, nil
 }
 
+func (s VersionSegment) Increment() (VersionSegment, error) {
+	if len(s.Components) == 0 {
+		errMsg := "Expected version segment to have at least one component to be incremented"
+		return VersionSegment{}, errors.New(errMsg)
+	}
+
+	lastComp := s.Components[len(s.Components)-1]
+
+	lastCompInt, isInt := lastComp.(VerSegCompInt)
+	if !isInt {
+		errMsg := fmt.Sprintf("Expected version segment '%s' to have last component '%s' to be an integer", s, lastComp)
+		return VersionSegment{}, errors.New(errMsg)
+	}
+
+	copiedComponents := make([]VerSegComp, len(s.Components))
+	copy(copiedComponents, s.Components)
+	copiedComponents[len(copiedComponents)-1] = VerSegCompInt{I: lastCompInt.I + 1}
+
+	return NewVersionSegment(copiedComponents)
+}
+
+func (s VersionSegment) Copy() VersionSegment {
+	// Don't use constructor; assuming that original components are valid
+	copiedComponents := make([]VerSegComp, len(s.Components))
+	copy(copiedComponents, s.Components)
+	return VersionSegment{copiedComponents}
+}
+
 func (s VersionSegment) Empty() bool { return len(s.Components) == 0 }
 
+func (s VersionSegment) String() string { return s.AsString() }
+
 func (s VersionSegment) AsString() string {
 	result := ""
 

vendor/github.com/cppforlife/go-semi-semantic/version/version_sort.go

@@ -0,0 +1,7 @@
+package version
+
+type AscSorting []Version
+
+func (s AscSorting) Len() int           { return len(s) }
+func (s AscSorting) Less(i, j int) bool { return s[i].IsLt(s[j]) }
+func (s AscSorting) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }