From cb20135e28f9ec2381e975667be575507d50fcb0 Mon Sep 17 00:00:00 2001
From: Katy Moe <katy@katy.moe>
Date: Tue, 30 Mar 2021 12:17:31 +0100
Subject: [PATCH] add Base func

Adds a Base function to Version, which returns a new Version created from only
the MAJOR.MINOR.PATCH segments of the original version, without prerelease or
metadata strings.

Consumers of go-version often want to treat prereleases of versions as equal to
non-prerelease versions, e.g. 0.15.0-dev as equal to 0.15.0. The present
functionality is intended as an easy way to opt in to this behaviour.
---
 version.go      |  8 ++++++++
 version_test.go | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/version.go b/version.go
index 09703e8..8b329e0 100644
--- a/version.go
+++ b/version.go
@@ -278,6 +278,14 @@ func comparePrereleases(v string, other string) int {
 	return 0
 }
 
+// Base returns a new version constructed from only the MAJOR.MINOR.PATCH
+// segments of the version, without prerelease or metadata.
+func (v *Version) Base() *Version {
+	segments := v.Segments64()
+	segmentsOnly := fmt.Sprintf("%d.%d.%d", segments[0], segments[1], segments[2])
+	return Must(NewVersion(segmentsOnly))
+}
+
 // Equal tests if two versions are equal.
 func (v *Version) Equal(o *Version) bool {
 	if v == nil || o == nil {
diff --git a/version_test.go b/version_test.go
index cbbeac8..a5179d5 100644
--- a/version_test.go
+++ b/version_test.go
@@ -87,6 +87,38 @@ func TestNewSemver(t *testing.T) {
 	}
 }
 
+func TestBase(t *testing.T) {
+	cases := []struct {
+		v1 string
+		v2 string
+	}{
+		{"1.2.3", "1.2.3"},
+		{"2.3.4-alpha1", "2.3.4"},
+		{"3.4.5alpha1", "3.4.5"},
+		{"1.2.3-2", "1.2.3"},
+		{"4.5.6-beta1+meta", "4.5.6"},
+		{"5.6.7.1.2.3", "5.6.7"},
+	}
+
+	for _, tc := range cases {
+		v1, err := NewVersion(tc.v1)
+		if err != nil {
+			t.Fatalf("error for version %q: %s", tc.v1, err)
+		}
+		v2, err := NewVersion(tc.v2)
+		if err != nil {
+			t.Fatalf("error for version %q: %s", tc.v2, err)
+		}
+
+		actual := v1.Base()
+		expected := v2
+
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("expected: %s\nactual: %s", expected, actual)
+		}
+	}
+}
+
 func TestVersionCompare(t *testing.T) {
 	cases := []struct {
 		v1       string