version.go

package command

import "bytes"

// versionLess compares keys as version strings (-V): runs of digits compare by
// numeric value so v1.2 < v1.10, while other runs compare as bytes.
func versionLess(a, b []byte) bool {
	for len(a) > 0 && len(b) > 0 {
		cmp, restA, restB := compareChunk(a, b)
		if cmp != 0 {
			return cmp < 0
		}
		a, b = restA, restB
	}
	return len(a) < len(b)
}

// compareChunk compares one aligned chunk from each key and returns its sign
// plus both keys advanced past the consumed bytes.
func compareChunk(a, b []byte) (int, []byte, []byte) {
	if isDigit(keyByte(a[0])) && isDigit(keyByte(b[0])) {
		return compareNumberRun(a, b)
	}
	return int(a[0]) - int(b[0]), a[1:], b[1:]
}

// compareNumberRun compares the leading digit run of each key numerically
// (ignoring leading zeros) and returns the sign plus both keys advanced past
// their runs.
func compareNumberRun(a, b []byte) (int, []byte, []byte) {
	runA, restA := takeDigits(a)
	runB, restB := takeDigits(b)
	return bytes.Compare(runA, runB), restA, restB
}

// takeDigits splits key into its leading digit run and the remaining bytes.
// The run is stripped of leading zeros and left-padded so numeric magnitude
// compares by length then bytes.
func takeDigits(key []byte) ([]byte, []byte) {
	i := 0
	for i < len(key) && isDigit(keyByte(key[i])) {
		i++
	}
	return padLeft(bytes.TrimLeft(key[:i], "0")), key[i:]
}

// padLeft left-pads a stripped digit run to a fixed width so bytes.Compare
// orders by numeric magnitude. Runs longer than the width keep full precision
// because longer runs are always the larger number.
func padLeft(run []byte) []byte {
	const width = 20
	if len(run) >= width {
		return run
	}
	return append(bytes.Repeat([]byte{'0'}, width-len(run)), run...)
}

// keyByte is a single byte of a version-sort comparison key, classified as
// digit or non-digit to select the chunk comparison.
type keyByte byte

// isDigit reports whether c is an ASCII digit.
func isDigit(c keyByte) bool {
	return c >= '0' && c <= '9'
}