From 31f81b782e1dcd1a23fcc81379eba1757929e3e4 Mon Sep 17 00:00:00 2001
From: David Anderson <danderson@tailscale.com>
Date: Fri, 23 Apr 2021 20:54:21 -0700
Subject: [PATCH] util/cmpver: move into OSS from corp repo.

Signed-off-by: David Anderson <danderson@tailscale.com>
---
 util/cmpver/version.go      |  96 ++++++++++++++++++++++++++++++++
 util/cmpver/version_test.go | 106 ++++++++++++++++++++++++++++++++++++
 2 files changed, 202 insertions(+)
 create mode 100644 util/cmpver/version.go
 create mode 100644 util/cmpver/version_test.go

diff --git a/util/cmpver/version.go b/util/cmpver/version.go
new file mode 100644
index 000000000..d58c5aac2
--- /dev/null
+++ b/util/cmpver/version.go
@@ -0,0 +1,96 @@
+// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package cmpver implements a variant of debian version number
+// comparison.
+//
+// A version is a string consisting of alternating non-numeric and
+// numeric fields. When comparing two versions, each one is broken
+// down into its respective fields, and the fields are compared
+// pairwise. The comparison is lexicographic for non-numeric fields,
+// numeric for numeric fields. The first non-equal field pair
+// determines the ordering of the two versions.
+//
+// This comparison scheme is a simplified version of Debian's version
+// number comparisons. Debian differs in a few details of
+// lexicographical field comparison, where certain characters have
+// special meaning and ordering. We don't need that, because Tailscale
+// version numbers don't need it.
+package cmpver
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+// Compare returns an integer comparing two strings as version
+// numbers. The result will be 0 if v1==v2, -1 if v1 < v2, and +1 if
+// v1 > v2.
+func Compare(v1, v2 string) int {
+	notNumber := func(r rune) bool { return !unicode.IsNumber(r) }
+
+	var (
+		f1, f2 string
+		n1, n2 uint64
+		err    error
+	)
+	for v1 != "" || v2 != "" {
+		// Compare the non-numeric character run lexicographically.
+		f1, v1 = splitPrefixFunc(v1, notNumber)
+		f2, v2 = splitPrefixFunc(v2, notNumber)
+
+		if res := strings.Compare(f1, f2); res != 0 {
+			return res
+		}
+
+		// Compare the numeric character run numerically.
+		f1, v1 = splitPrefixFunc(v1, unicode.IsNumber)
+		f2, v2 = splitPrefixFunc(v2, unicode.IsNumber)
+
+		// ParseUint refuses to parse empty strings, which would only
+		// happen if we reached end-of-string. We follow the Debian
+		// convention that empty strings mean zero, because
+		// empirically that produces reasonable-feeling comparison
+		// behavior.
+		n1 = 0
+		if f1 != "" {
+			n1, err = strconv.ParseUint(f1, 10, 64)
+			if err != nil {
+				panic(fmt.Sprintf("all-number string %q didn't parse as string: %s", f1, err))
+			}
+		}
+
+		n2 = 0
+		if f2 != "" {
+			n2, err = strconv.ParseUint(f2, 10, 64)
+			if err != nil {
+				panic(fmt.Sprintf("all-number string %q didn't parse as string: %s", f2, err))
+			}
+		}
+
+		switch {
+		case n1 == n2:
+		case n1 < n2:
+			return -1
+		case n1 > n2:
+			return 1
+		}
+	}
+
+	// Only way to reach here is if v1 and v2 run out of fields
+	// simultaneously - i.e. exactly equal versions.
+	return 0
+}
+
+// splitPrefixFunc splits s at the first rune where f(rune) is false.
+func splitPrefixFunc(s string, f func(rune) bool) (string, string) {
+	for i, r := range s {
+		if !f(r) {
+			return s[:i], s[i:]
+		}
+	}
+	return s, s[:0]
+}
diff --git a/util/cmpver/version_test.go b/util/cmpver/version_test.go
new file mode 100644
index 000000000..26061eac1
--- /dev/null
+++ b/util/cmpver/version_test.go
@@ -0,0 +1,106 @@
+// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cmpver
+
+import "testing"
+
+func TestCompare(t *testing.T) {
+	tests := []struct {
+		name   string
+		v1, v2 string
+		want   int
+	}{
+		{
+			name: "both empty",
+			want: 0,
+		},
+		{
+			name: "v1 empty",
+			v2:   "1.2.3",
+			want: -1,
+		},
+		{
+			name: "v2 empty",
+			v1:   "1.2.3",
+			want: 1,
+		},
+
+		{
+			name: "semver major",
+			v1:   "2.0.0",
+			v2:   "1.9.9",
+			want: 1,
+		},
+		{
+			name: "semver major",
+			v1:   "2.0.0",
+			v2:   "1.9.9",
+			want: 1,
+		},
+		{
+			name: "semver minor",
+			v1:   "1.9.0",
+			v2:   "1.8.9",
+			want: 1,
+		},
+		{
+			name: "semver patch",
+			v1:   "1.9.9",
+			v2:   "1.9.8",
+			want: 1,
+		},
+		{
+			name: "semver equal",
+			v1:   "1.9.8",
+			v2:   "1.9.8",
+			want: 0,
+		},
+
+		{
+			name: "tailscale major",
+			v1:   "1.0-0",
+			v2:   "0.97-105",
+			want: 1,
+		},
+		{
+			name: "tailscale minor",
+			v1:   "0.98-0",
+			v2:   "0.97-105",
+			want: 1,
+		},
+		{
+			name: "tailscale patch",
+			v1:   "0.97-120",
+			v2:   "0.97-105",
+			want: 1,
+		},
+		{
+			name: "tailscale equal",
+			v1:   "0.97-105",
+			v2:   "0.97-105",
+			want: 0,
+		},
+		{
+			name: "tailscale weird extra field",
+			v1:   "0.96.1-0", // more fields == larger
+			v2:   "0.96-105",
+			want: 1,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got := Compare(test.v1, test.v2)
+			if got != test.want {
+				t.Errorf("Compare(%v, %v) = %v, want %v", test.v1, test.v2, got, test.want)
+			}
+			// Reversing the comparison should reverse the outcome.
+			got2 := Compare(test.v2, test.v1)
+			if got2 != -test.want {
+				t.Errorf("Compare(%v, %v) = %v, want %v", test.v2, test.v1, got2, -test.want)
+			}
+		})
+	}
+}