semver_compare.rego

package semver_compare

is_greater_or_equal(a, b) = result {
	result := {
		is_greater(a, b),
		is_equal(a, b),
	} & { true } == { true }
}
is_lesser_or_equal(a, b) = result {
	result := {
		is_lesser(a, b),
		is_equal(a, b),
	} & { true } == { true }
}
is_greater(a, b) = result {
	result := {
		{ is_key_greater("major", a, b) },
		{ is_key_equal("major", a, b), is_key_greater("minor", a, b) },
		{ is_key_equal("major", a, b), is_key_equal("minor", a, b), is_key_greater("patch", a, b) },
	} & { { true } } == { { true } }
}
is_lesser(a, b) = result {
	result := {
		is_greater(a, b) == false,
		is_equal(a, b) == false,
	} == { true }
}
is_equal(a, b) = result {
	keys := ["major", "minor", "patch"]
	result := { r | key := keys[_]; r := is_key_equal(key, a, b) } == { true }
}
is_key_greater(key, a, b) = result {
	result := a[key] > b[key]
}
is_key_equal(key, a, b) = result {
	result := a[key] == b[key]
}
parse_version_string(version_string) = version {
	components := split(version_string, ".")
	version := new_version_from_components(components, count(components))
}
new_version_from_components(components, 1) = version {
	version := new_version(components[0], 0, 0)
}
new_version_from_components(components, 2) = version {
	version := new_version(components[0], components[1], 0)
}
new_version_from_components(components, 3) = version {
	version := new_version(components[0], components[1], components[2])
}
new_version(major, minor, patch) = version {
	version := {
			"major": to_number(trim_prefix(sprintf("%v", [major]), "v")),
			"minor": to_number(minor),
			"patch": to_number(patch)
		}
}

semver_compare_test.rego

package semver_compare

assert_equal(a, b) = result {
	result := a == b
	trace(
		sprintf(
			"%v : %v", [ a, b ]
		)
	)
}

test_is_greater_or_equal {
	cases := [
		# base cases
		["1.0.0", "0.0.0", true],
		["1.0.0", "2.0.0", false],
		["1.0.0", "1.0.0", true],
		# partial versions
		["1.0",   "1.0.0", true],
		["1",     "1.0.0", true],
		["1",     "2.0.0", false],
		["1.0",   "1",     true],
		["1",     "2.0",   false],
		# different prefixes
		["v1.0",  "1.0.0",  true],
		["1.0.0", "v2.0.0", false],
		# same major
		["1.1.0", "1.0.0", true],
		["1.1.0", "1.2.0", false],
		# same minor
		["1.1.1", "1.1.0", true],
		["1.1.0", "1.1.1", false],
		# same patch
		["1.1.1", "1.1.1", true],
		["1.1.1", "2.1.1", false],
		# big versions
		["999.1.1", "888.1.1", true],
		["999.1.1", "999.999.999", false],
	]

	passing_cases := [case |
		case := cases[_];
		version_a := parse_version_string(case[0])
		version_b := parse_version_string(case[1])
		trace(sprintf("%v >= %v == %v", [case[0], case[1], case[2]]))
		assert_equal(is_greater_or_equal(version_a, version_b), case[2]) == true
	]

	count(passing_cases) == count(cases)
}
test_is_lesser_or_equal {
	cases := [
		["1.0.0", "0.0.0", false],
		["1.0.0", "2.0.0", true],
		["1.0.0", "1.0.0", true],
	]

	passing_cases := [case |
		case := cases[_];
		version_a := parse_version_string(case[0])
		version_b := parse_version_string(case[1])
		trace(sprintf("%v <= %v == %v", [case[0], case[1], case[2]]))
		assert_equal(is_lesser_or_equal(version_a, version_b), case[2]) == true
	]

	count(passing_cases) == count(cases)
}
test_parse_version_string {
	assert_equal(parse_version_string("1"), new_version(1, 0, 0))
	assert_equal(parse_version_string("2"), new_version(2, 0, 0))
	assert_equal(parse_version_string("2.2"), new_version(2, 2, 0))
	assert_equal(parse_version_string("2.2.2"), new_version(2, 2, 2))
	assert_equal(parse_version_string("v2.2.2"), new_version(2, 2, 2))
	assert_equal(parse_version_string("v999.999.999"), new_version(999, 999, 999))
}
test_new_version {
	new_version(1, 0, 0) == {
			"major": 1,
			"minor": 0,
			"patch": 0
		}
}