Merge pull request #53 from snyk/feat/version-slice

feat: VersionSlice supporting sort and search

Author: cmars

resource.go

@@ -26,7 +26,7 @@ const (
 type Resource struct {
 	*Document
 	Name         string
-	Version      *Version
+	Version      Version
 	sourcePrefix string
 }
 
@@ -58,8 +58,8 @@ func (e *ResourceVersions) Name() string {
 }
 
 // Versions returns a slice containing each Version defined for this endpoint.
-func (e *ResourceVersions) Versions() []*Version {
-	result := make([]*Version, len(e.versions))
+func (e *ResourceVersions) Versions() []Version {
+	result := make([]Version, len(e.versions))
 	for i := range e.versions {
 		result[i] = e.versions[i].Version
 	}
@@ -84,7 +84,7 @@ func (e *ResourceVersions) At(vs string) (*Resource, error) {
 	}
 	for i := len(e.versions) - 1; i >= 0; i-- {
 		ev := e.versions[i].Version
-		if (ev.Date.Before(v.Date) || ev.Date.Equal(v.Date)) && v.Stability.Compare(ev.Stability) <= 0 {
+		if dateCmp, stabilityCmp := ev.compareDateStability(v); dateCmp <= 0 && stabilityCmp >= 0 {
 			return e.versions[i], nil
 		}
 	}
@@ -94,19 +94,11 @@ func (e *ResourceVersions) At(vs string) (*Resource, error) {
 type resourceVersionSlice []*Resource
 
 func (e resourceVersionSlice) Less(i, j int) bool {
-	return e[i].Version.Compare(e[j].Version) < 0
+	return e[i].Version.Compare(&e[j].Version) < 0
 }
 func (e resourceVersionSlice) Len() int      { return len(e) }
 func (e resourceVersionSlice) Swap(i, j int) { e[i], e[j] = e[j], e[i] }
 
-type versionSlice []*Version
-
-func (vs versionSlice) Less(i, j int) bool {
-	return vs[i].Compare(vs[j]) < 0
-}
-func (vs versionSlice) Len() int      { return len(vs) }
-func (vs versionSlice) Swap(i, j int) { vs[i], vs[j] = vs[j], vs[i] }
-
 // LoadResourceVersions returns a ResourceVersions slice parsed from a
 // directory structure of resource specs. This directory will be of the form:
 //
@@ -209,7 +201,7 @@ func loadResource(specPath string, versionStr string) (*Resource, error) {
 		return nil, fmt.Errorf("failed to localize refs: %w", err)
 	}
 
-	ep := &Resource{Name: name, Document: doc, Version: version}
+	ep := &Resource{Name: name, Document: doc, Version: *version}
 	for path := range doc.T.Paths {
 		doc.T.Paths[path].ExtensionProps.Extensions[ExtSnykApiVersion] = version.String()
 	}

resource_test.go

@@ -15,7 +15,7 @@ func TestResource(t *testing.T) {
 	c := qt.New(t)
 	eps, err := LoadResourceVersions(testdata.Path("resources/_examples/hello-world"))
 	c.Assert(err, qt.IsNil)
-	c.Assert(eps.Versions(), qt.DeepEquals, []*Version{{
+	c.Assert(eps.Versions(), qt.DeepEquals, []Version{{
 		Date:      time.Date(2021, time.June, 1, 0, 0, 0, 0, time.UTC),
 		Stability: StabilityGA,
 	}, {

spec.go

@@ -93,21 +93,21 @@ func (s *SpecVersions) Resources() []*ResourceVersions {
 
 // Versions returns a slice containing each Version defined by an Resource in
 // this specification. Versions are sorted in ascending order.
-func (s *SpecVersions) Versions() []*Version {
+func (s *SpecVersions) Versions() []Version {
 	vset := map[Version]bool{}
 	for _, eps := range s.resources {
 		for i := range eps.versions {
-			vset[*eps.versions[i].Version] = true
+			vset[eps.versions[i].Version] = true
 		}
 	}
-	versions := make([]*Version, len(vset))
+	versions := make([]Version, len(vset))
 	i := 0
 	for k := range vset {
 		v := k
-		versions[i] = &v
+		versions[i] = v
 		i++
 	}
-	sort.Sort(versionSlice(versions))
+	sort.Sort(VersionSlice(versions))
 	return versions
 }
 

spec_test.go

@@ -15,7 +15,7 @@ func TestSpecs(t *testing.T) {
 	c.Assert(err, qt.IsNil)
 	versions := specs.Versions()
 	c.Assert(versions, qt.HasLen, 4)
-	c.Assert(versions, qt.ContentEquals, []*Version{
+	c.Assert(versions, qt.ContentEquals, []Version{
 		mustParseVersion("2021-06-01"),
 		mustParseVersion("2021-06-04~experimental"),
 		mustParseVersion("2021-06-07"),

version.go

@@ -115,19 +115,30 @@ func (s Stability) Compare(sr Stability) int {
 // Compare returns -1 if the given version is less than, 0 if equal to, and 1
 // if greater than the caller target version.
 func (v *Version) Compare(vr *Version) int {
-	if v.Date.Before(vr.Date) {
-		return -1
+	dateCmp, stabilityCmp := v.compareDateStability(vr)
+	if dateCmp != 0 {
+		return dateCmp
 	}
-	if v.Date.After(vr.Date) {
-		return 1
+	return stabilityCmp
+}
+
+// compareDateStability returns the comparison of both the date and stability
+// between two versions. Used internally where these need to be evaluated
+// independently, such as when searching for the best matching version.
+func (v *Version) compareDateStability(vr *Version) (int, int) {
+	dateCmp := 0
+	if v.Date.Before(vr.Date) {
+		dateCmp = -1
+	} else if v.Date.After(vr.Date) {
+		dateCmp = 1
 	}
-	// Dates are equal
-	return 0 - v.Stability.Compare(vr.Stability)
+	stabilityCmp := v.Stability.Compare(vr.Stability)
+	return dateCmp, stabilityCmp
 }
 
 // VersionDateStrings returns a slice of distinct version date strings for a
 // slice of Versions. Consecutive duplicate dates are removed.
-func VersionDateStrings(vs []*Version) []string {
+func VersionDateStrings(vs []Version) []string {
 	var result []string
 	for i := range vs {
 		ds := vs[i].DateString()
@@ -137,3 +148,53 @@ func VersionDateStrings(vs []*Version) []string {
 	}
 	return result
 }
+
+// VersionSlice is a sortable, searchable slice of Versions.
+type VersionSlice []Version
+
+// Resolve returns the most recent Version in the slice with equal or greater
+// stability.
+//
+// This method requires that the VersionSlice has already been sorted with
+// sort.Sort, otherwise behavior is undefined.
+func (vs VersionSlice) Resolve(q Version) (*Version, error) {
+	lower, curr, upper := 0, len(vs)/2, len(vs)
+	if upper == 0 {
+		// Nothing matches an empty slice.
+		return nil, ErrNoMatchingVersion
+	}
+	for curr < upper && lower != upper-1 {
+		dateCmp, stabilityCmp := vs[curr].compareDateStability(&q)
+		if dateCmp > 0 {
+			// Current version is more recent than the query, so it's our new
+			// upper (exclusive) range limit to search.
+			upper = curr
+			curr = lower + (upper-lower)/2
+		} else if dateCmp <= 0 {
+			if stabilityCmp >= 0 {
+				// Matching version found, so it's our new lower (inclusive)
+				// range limit to search.
+				lower = curr
+			}
+			// The edge is somewhere between here and the upper limit.
+			curr = curr + (upper-curr)/2 + (upper-curr)%2
+		}
+	}
+	// Did we find a match?
+	dateCmp, stabilityCmp := vs[lower].compareDateStability(&q)
+	if dateCmp <= 0 && stabilityCmp >= 0 {
+		return &vs[lower], nil
+	}
+	return nil, ErrNoMatchingVersion
+}
+
+// Len implements sort.Interface.
+func (vs VersionSlice) Len() int { return len(vs) }
+
+// Less implements sort.Interface.
+func (vs VersionSlice) Less(i, j int) bool {
+	return vs[i].Compare(&vs[j]) < 0
+}
+
+// Swap implements sort.Interface.
+func (vs VersionSlice) Swap(i, j int) { vs[i], vs[j] = vs[j], vs[i] }

version_test.go

@@ -1,6 +1,7 @@
 package vervet_test
 
 import (
+	"sort"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
@@ -43,12 +44,12 @@ func TestParseVersion(t *testing.T) {
 	}
 }
 
-func mustParseVersion(s string) *Version {
+func mustParseVersion(s string) Version {
 	v, err := ParseVersion(s)
 	if err != nil {
 		panic(err)
 	}
-	return v
+	return *v
 }
 
 func TestVersionOrder(t *testing.T) {
@@ -64,25 +65,25 @@ func TestVersionOrder(t *testing.T) {
 	}, {
 		l: "2021-01-01", r: "2021-01-01", cmp: 0,
 	}, {
-		l: "9999-12-31", r: "9999-12-31~beta", cmp: -1,
+		l: "9999-12-31", r: "9999-12-31~beta", cmp: 1,
 	}, {
 		// Compare date versions and special tags
-		l: "9999-12-31~beta", r: "9999-12-31", cmp: 1,
+		l: "9999-12-31~beta", r: "9999-12-31", cmp: -1,
 	}, {
-		l: "9999-12-31", r: "9999-12-31~experimental", cmp: -1,
+		l: "9999-12-31", r: "9999-12-31~experimental", cmp: 1,
 	}, {
-		l: "9999-12-31~experimental", r: "9999-12-31", cmp: 1,
+		l: "9999-12-31~experimental", r: "9999-12-31", cmp: -1,
 		// Compare special tags
 	}, {
-		l: "2021-08-01~beta", r: "2021-08-01~experimental", cmp: -1,
+		l: "2021-08-01~beta", r: "2021-08-01~experimental", cmp: 1,
 	}, {
-		l: "2021-08-01~experimental", r: "2021-08-01~beta", cmp: 1,
+		l: "2021-08-01~experimental", r: "2021-08-01~beta", cmp: -1,
 	}, {
 		l: "2021-08-01~beta", r: "2021-08-01~beta", cmp: 0,
 	}, {
 		l: "2021-08-01~experimental", r: "2021-08-01~experimental", cmp: 0,
 	}, {
-		l: "2021-08-01~wip", r: "2021-08-01~experimental", cmp: 1,
+		l: "2021-08-01~wip", r: "2021-08-01~experimental", cmp: -1,
 	}}
 	for i := range tests {
 		c.Logf("test %d %#v", i, tests[i])
@@ -96,7 +97,7 @@ func TestVersionOrder(t *testing.T) {
 
 func TestVersionDateStrings(t *testing.T) {
 	c := qt.New(t)
-	c.Assert(VersionDateStrings([]*Version{
+	c.Assert(VersionDateStrings([]Version{
 		mustParseVersion("2021-06-01~wip"),
 		mustParseVersion("2021-06-01~beta"),
 		mustParseVersion("2021-06-10~beta"),
@@ -106,3 +107,117 @@ func TestVersionDateStrings(t *testing.T) {
 		mustParseVersion("2021-07-12~beta"),
 	}), qt.ContentEquals, []string{"2021-06-01", "2021-06-10", "2021-07-12"})
 }
+
+func TestVersionSlice(t *testing.T) {
+	type matchTest struct {
+		match  string
+		result string
+		err    string
+	}
+	tests := []struct {
+		versions   VersionSlice
+		first      string
+		last       string
+		matchTests []matchTest
+	}{{
+		versions: VersionSlice{
+			mustParseVersion("2021-07-12~experimental"),
+			mustParseVersion("2021-06-01~beta"),
+			mustParseVersion("2021-07-12~beta"),
+			mustParseVersion("2021-06-10"),
+			mustParseVersion("2021-06-01~wip"),
+			mustParseVersion("2021-07-12~wip"),
+			mustParseVersion("2021-06-10~beta"),
+		},
+		first: "2021-06-01~wip",
+		last:  "2021-07-12~beta",
+		matchTests: []matchTest{{
+			match:  "2021-06-10",
+			result: "2021-06-10",
+		}, {
+			match:  "2021-06-10~beta",
+			result: "2021-06-10",
+		}, {
+			match:  "2021-06-10~experimental",
+			result: "2021-06-10",
+		}, {
+			match:  "2021-06-11~experimental",
+			result: "2021-06-10",
+		}, {
+			match: "2021-01-01",
+			err:   "no matching version",
+		}, {
+			match:  "2022-01-01",
+			result: "2021-06-10",
+		}, {
+			match:  "2022-01-01~experimental",
+			result: "2021-07-12~beta",
+		}},
+	}, {
+		versions: VersionSlice{
+			mustParseVersion("2021-06-10~beta"),
+		},
+		first: "2021-06-10~beta",
+		last:  "2021-06-10~beta",
+		matchTests: []matchTest{{
+			match: "2021-06-10",
+			err:   "no matching version",
+		}, {
+			match:  "2021-06-10~beta",
+			result: "2021-06-10~beta",
+		}, {
+			match:  "2021-06-10~experimental",
+			result: "2021-06-10~beta",
+		}, {
+			match:  "2021-06-11~wip",
+			result: "2021-06-10~beta",
+		}, {
+			match: "2021-01-01",
+			err:   "no matching version",
+		}, {
+			match:  "2022-01-01~wip",
+			result: "2021-06-10~beta",
+		}},
+	}, {
+		versions: VersionSlice{
+			mustParseVersion("2021-06-10~beta"),
+			mustParseVersion("2022-01-10~experimental"),
+		},
+		first: "2021-06-10~beta",
+		last:  "2022-01-10~experimental",
+		matchTests: []matchTest{{
+			match: "2021-04-10",
+			err:   "no matching version",
+		}, {
+			match:  "2021-08-10~beta",
+			result: "2021-06-10~beta",
+		}, {
+			match:  "2022-02-10~wip",
+			result: "2022-01-10~experimental",
+		}, {
+			match: "2021-01-30",
+			err:   "no matching version",
+		}},
+	}}
+	c := qt.New(t)
+	for _, t := range tests {
+		sort.Sort(t.versions)
+		c.Assert(t.versions[0].String(), qt.Equals, t.first)
+		c.Assert(t.versions[len(t.versions)-1].String(), qt.Equals, t.last)
+		for _, mt := range t.matchTests {
+			match := mustParseVersion(mt.match)
+			result, err := t.versions.Resolve(match)
+			if err != nil {
+				c.Assert(err, qt.ErrorMatches, mt.err)
+			} else {
+				c.Assert(result.String(), qt.Equals, mt.result)
+			}
+		}
+	}
+}
+
+func TestVersionSliceResolveEmpty(t *testing.T) {
+	c := qt.New(t)
+	_, err := VersionSlice{}.Resolve(mustParseVersion("2021-10-31"))
+	c.Assert(err, qt.ErrorMatches, "no matching version")
+}