Commit 1a38092762b71199d7d0a716a7c4e69e46052594 - golang-github-hashicorp-go-version

New upstream release. Debian Janitor 2 years ago

5 changed file(s) with 213 addition(s) and 15 deletion(s). Raw diff Collapse all Expand all

-0

CHANGELOG.md less more

	0	# 1.4.0 (January 5, 2021)
	1
	2	FEATURES:
	3
	4	- Introduce `MustConstraints()` ([#87](https://github.com/hashicorp/go-version/pull/87))
	5	- `Constraints`: Introduce `Equals()` and `sort.Interface` methods ([#88](https://github.com/hashicorp/go-version/pull/88))
	6
0	7	# 1.3.0 (March 31, 2021)
1	8
2	9	Please note that CHANGELOG.md does not exist in the source code prior to this release.

+97

-11

constraint.go less more

3	3	"fmt"
4	4	"reflect"
5	5	"regexp"
	6	"sort"
6	7	"strings"
7	8	)
8	9

10	11	// ">= 1.0".
11	12	type Constraint struct {
12	13	f constraintFunc
	14	op operator
13	15	check *Version
14	16	original string
	17	}
	18
	19	func (c Constraint) Equals(con Constraint) bool {
	20	return c.op == con.op && c.check.Equal(con.check)
15	21	}
16	22
17	23	// Constraints is a slice of constraints. We make a custom type so that

20	26
21	27	type constraintFunc func(v, c *Version) bool
22	28
23		var constraintOperators map[string]constraintFunc
	29	var constraintOperators map[string]constraintOperation
	30
	31	type constraintOperation struct {
	32	op operator
	33	f constraintFunc
	34	}
24	35
25	36	var constraintRegexp *regexp.Regexp
26	37
27	38	func init() {
28		constraintOperators = map[string]constraintFunc{
29		"": constraintEqual,
30		"=": constraintEqual,
31		"!=": constraintNotEqual,
32		">": constraintGreaterThan,
33		"<": constraintLessThan,
34		">=": constraintGreaterThanEqual,
35		"<=": constraintLessThanEqual,
36		"~>": constraintPessimistic,
	39	constraintOperators = map[string]constraintOperation{
	40	"": {op: equal, f: constraintEqual},
	41	"=": {op: equal, f: constraintEqual},
	42	"!=": {op: notEqual, f: constraintNotEqual},
	43	">": {op: greaterThan, f: constraintGreaterThan},
	44	"<": {op: lessThan, f: constraintLessThan},
	45	">=": {op: greaterThanEqual, f: constraintGreaterThanEqual},
	46	"<=": {op: lessThanEqual, f: constraintLessThanEqual},
	47	"~>": {op: pessimistic, f: constraintPessimistic},
37	48	}
38	49
39	50	ops := make([]string, 0, len(constraintOperators))

65	76	return Constraints(result), nil
66	77	}
67	78
	79	// MustConstraints is a helper that wraps a call to a function
	80	// returning (Constraints, error) and panics if error is non-nil.
	81	func MustConstraints(c Constraints, err error) Constraints {
	82	if err != nil {
	83	panic(err)
	84	}
	85
	86	return c
	87	}
	88
68	89	// Check tests if a version satisfies all the constraints.
69	90	func (cs Constraints) Check(v *Version) bool {
70	91	for _, c := range cs {

76	97	return true
77	98	}
78	99
	100	// Equals compares Constraints with other Constraints
	101	// for equality. This may not represent logical equivalence
	102	// of compared constraints.
	103	// e.g. even though '>0.1,>0.2' is logically equivalent
	104	// to '>0.2' it is NOT treated as equal.
	105	//
	106	// Missing operator is treated as equal to '=', whitespaces
	107	// are ignored and constraints are sorted before comaparison.
	108	func (cs Constraints) Equals(c Constraints) bool {
	109	if len(cs) != len(c) {
	110	return false
	111	}
	112
	113	// make copies to retain order of the original slices
	114	left := make(Constraints, len(cs))
	115	copy(left, cs)
	116	sort.Stable(left)
	117	right := make(Constraints, len(c))
	118	copy(right, c)
	119	sort.Stable(right)
	120
	121	// compare sorted slices
	122	for i, con := range left {
	123	if !con.Equals(right[i]) {
	124	return false
	125	}
	126	}
	127
	128	return true
	129	}
	130
	131	func (cs Constraints) Len() int {
	132	return len(cs)
	133	}
	134
	135	func (cs Constraints) Less(i, j int) bool {
	136	if cs[i].op < cs[j].op {
	137	return true
	138	}
	139	if cs[i].op > cs[j].op {
	140	return false
	141	}
	142
	143	return cs[i].check.LessThan(cs[j].check)
	144	}
	145
	146	func (cs Constraints) Swap(i, j int) {
	147	cs[i], cs[j] = cs[j], cs[i]
	148	}
	149
79	150	// Returns the string format of the constraints
80	151	func (cs Constraints) String() string {
81	152	csStr := make([]string, len(cs))

106	177	return nil, err
107	178	}
108	179
	180	cop := constraintOperators[matches[1]]
	181
109	182	return &Constraint{
110		f: constraintOperators[matches[1]],
	183	f: cop.f,
	184	op: cop.op,
111	185	check: check,
112	186	original: v,
113	187	}, nil

137	211	// Constraint functions
138	212	//-------------------------------------------------------------------
139	213
	214	type operator rune
	215
	216	const (
	217	equal operator = '='
	218	notEqual operator = '≠'
	219	greaterThan operator = '>'
	220	lessThan operator = '<'
	221	greaterThanEqual operator = '≥'
	222	lessThanEqual operator = '≤'
	223	pessimistic operator = '~'
	224	)
	225
140	226	func constraintEqual(v, c *Version) bool {
141	227	return v.Equal(c)
142	228	}

+101

-0

constraint_test.go less more

0	0	package version
1	1
2	2	import (
	3	"fmt"
	4	"reflect"
	5	"sort"
3	6	"testing"
4	7	)
5	8

96	99	}
97	100	}
98	101
	102	func TestConstraintEqual(t *testing.T) {
	103	cases := []struct {
	104	leftConstraint string
	105	rightConstraint string
	106	expectedEqual bool
	107	}{
	108	{
	109	"0.0.1",
	110	"0.0.1",
	111	true,
	112	},
	113	{ // whitespaces
	114	" 0.0.1 ",
	115	"0.0.1",
	116	true,
	117	},
	118	{ // equal op implied
	119	"=0.0.1 ",
	120	"0.0.1",
	121	true,
	122	},
	123	{ // version difference
	124	"=0.0.1",
	125	"=0.0.2",
	126	false,
	127	},
	128	{ // operator difference
	129	">0.0.1",
	130	"=0.0.1",
	131	false,
	132	},
	133	{ // different order
	134	">0.1.0, <=1.0.0",
	135	"<=1.0.0, >0.1.0",
	136	true,
	137	},
	138	}
	139
	140	for _, tc := range cases {
	141	leftCon, err := NewConstraint(tc.leftConstraint)
	142	if err != nil {
	143	t.Fatalf("err: %s", err)
	144	}
	145	rightCon, err := NewConstraint(tc.rightConstraint)
	146	if err != nil {
	147	t.Fatalf("err: %s", err)
	148	}
	149
	150	actual := leftCon.Equals(rightCon)
	151	if actual != tc.expectedEqual {
	152	t.Fatalf("Constraints: %s vs %s\nExpected: %t\nActual: %t",
	153	tc.leftConstraint, tc.rightConstraint, tc.expectedEqual, actual)
	154	}
	155	}
	156	}
	157
	158	func TestConstraint_sort(t *testing.T) {
	159	cases := []struct {
	160	constraint string
	161	expectedConstraints string
	162	}{
	163	{
	164	">= 0.1.0,< 1.12",
	165	"< 1.12,>= 0.1.0",
	166	},
	167	{
	168	"< 1.12,>= 0.1.0",
	169	"< 1.12,>= 0.1.0",
	170	},
	171	{
	172	"< 1.12,>= 0.1.0,0.2.0",
	173	"< 1.12,0.2.0,>= 0.1.0",
	174	},
	175	{
	176	">1.0,>0.1.0,>0.3.0,>0.2.0",
	177	">0.1.0,>0.2.0,>0.3.0,>1.0",
	178	},
	179	}
	180
	181	for i, tc := range cases {
	182	t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
	183	c, err := NewConstraint(tc.constraint)
	184	if err != nil {
	185	t.Fatalf("err: %s", err)
	186	}
	187
	188	sort.Sort(c)
	189
	190	actual := c.String()
	191
	192	if !reflect.DeepEqual(actual, tc.expectedConstraints) {
	193	t.Fatalf("unexpected order\nexpected: %#v\nactual: %#v",
	194	tc.expectedConstraints, actual)
	195	}
	196	})
	197	}
	198	}
	199
99	200	func TestConstraintsString(t *testing.T) {
100	201	cases := []struct {
101	202	constraint string

-0

debian/changelog less more

	0	golang-github-hashicorp-go-version (1.4.0-1) UNRELEASED; urgency=low
	1
	2	* New upstream release.
	3
	4	-- Debian Janitor <janitor@jelmer.uk> Mon, 16 May 2022 08:45:33 -0000
	5
0	6	golang-github-hashicorp-go-version (1.3.0-1) unstable; urgency=medium
1	7
2	8	* Team upload.

-4

version.go less more

63	63	}
64	64	segmentsStr := strings.Split(matches[1], ".")
65	65	segments := make([]int64, len(segmentsStr))
66		si := 0
67	66	for i, str := range segmentsStr {
68	67	val, err := strconv.ParseInt(str, 10, 64)
69	68	if err != nil {

71	70	"Error parsing version: %s", err)
72	71	}
73	72
74		segments[i] = int64(val)
75		si++
	73	segments[i] = val
76	74	}
77	75
78	76	// Even though we could support more than three segments, if we

91	89	metadata: matches[10],
92	90	pre: pre,
93	91	segments: segments,
94		si: si,
	92	si: len(segmentsStr),
95	93	original: v,
96	94	}, nil
97	95	}