github.com/Masterminds/semver/v3 v3.2.0: semver.Collection, semver.NewConstraint, semver.NewVersion

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:golang/github.com/Masterminds/semver/v3@v3.2.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/Masterminds/semver/v3@v3.2.0
Demonstrate these symbols/APIs:
  - semver.Collection
  - semver.NewConstraint
  - semver.NewVersion
  - semver.StrictNewVersion
  - semver.Version.IncMajor
  - semver.Version.IncMinor
  - semver.Version.IncPatch

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:b99d7fb998f67ddefb0d1934e3f0ac79d631a91aafe313d37b420b7774494b8a","contract":["semver.NewVersion parses semantic version strings and extracts major, minor, patch, prerelease, and build metadata components","semver.StrictNewVersion parses strictly formatted versions and rejects invalid versions or leading v prefixes","semver.NewConstraint validates whether versions satisfy range constraints and returns validation error lists","semver.Collection sorts a slice of versions in ascending semantic precedence order","semver.Version increment methods IncMajor, IncMinor, and IncPatch increment segments, reset lower fields, and clear prerelease metadata"],"goal":"verify pkg:golang/github.com/Masterminds/semver/v3@v3.2.0","kind":"HOW","packages":["pkg:golang/github.com/Masterminds/semver/v3@v3.2.0"],"schemaVersion":1,"symbols":["semver.Collection","semver.NewConstraint","semver.NewVersion","semver.StrictNewVersion","semver.Version.IncMajor","semver.Version.IncMinor","semver.Version.IncPatch"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/Masterminds/semver/v3@v3.2.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/Masterminds/semver/v3@v3.2.0","symbols":["semver.Collection","semver.NewConstraint","semver.NewVersion","semver.StrictNewVersion","semver.Version.IncMajor","semver.Version.IncMinor","semver.Version.IncPatch"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26

require github.com/Masterminds/semver/v3 v3.2.0

github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g=
github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ=

package sample

import (
	"fmt"
	"sort"

	"github.com/Masterminds/semver/v3"
)

// ParseVersion parses a semver string and extracts its components.
func ParseVersion(vStr string) (*semver.Version, error) {
	return semver.NewVersion(vStr)
}

// StrictParseVersion parses a strictly formatted semver string.
func StrictParseVersion(vStr string) (*semver.Version, error) {
	return semver.StrictNewVersion(vStr)
}

// CheckConstraint validates if a version satisfies a constraint expression.
func CheckConstraint(vStr, constraintStr string) (bool, error) {
	v, err := semver.NewVersion(vStr)
	if err != nil {
		return false, fmt.Errorf("invalid version %q: %w", vStr, err)
	}
	c, err := semver.NewConstraint(constraintStr)
	if err != nil {
		return false, fmt.Errorf("invalid constraint %q: %w", constraintStr, err)
	}
	return c.Check(v), nil
}

// SortVersionStrings sorts version strings in ascending semver order.
func SortVersionStrings(versions []string) ([]string, error) {
	var vs []*semver.Version
	for _, vStr := range versions {
		v, err := semver.NewVersion(vStr)
		if err != nil {
			return nil, fmt.Errorf("invalid version %q: %w", vStr, err)
		}
		vs = append(vs, v)
	}
	sort.Sort(semver.Collection(vs))
	result := make([]string, len(vs))
	for i, v := range vs {
		result[i] = v.Original()
	}
	return result, nil
}

// IncrementVersions increments major, minor, and patch numbers of a version.
func IncrementVersions(vStr string) (major string, minor string, patch string, err error) {
	v, err := semver.NewVersion(vStr)
	if err != nil {
		return "", "", "", fmt.Errorf("invalid version %q: %w", vStr, err)
	}
	incMaj := v.IncMajor()
	incMin := v.IncMinor()
	incPat := v.IncPatch()
	return incMaj.String(), incMin.String(), incPat.String(), nil
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/github.com/Masterminds/semver/v3@v3.2.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/Masterminds/semver/v3@v3.2.0"
  ],
  "symbols": [
    "semver.Collection",
    "semver.NewConstraint",
    "semver.NewVersion",
    "semver.StrictNewVersion",
    "semver.Version.IncMajor",
    "semver.Version.IncMinor",
    "semver.Version.IncPatch"
  ]
}

package test

import (
	"reflect"
	"sort"
	"testing"

	"github.com/Masterminds/semver/v3"
)

func TestNewVersion(t *testing.T) {
	v, err := semver.NewVersion("v1.2.3-alpha.1+build.42")
	if err != nil {
		t.Fatalf("unexpected error parsing version: %v", err)
	}

	if v.Major() != 1 {
		t.Errorf("expected major 1, got %d", v.Major())
	}
	if v.Minor() != 2 {
		t.Errorf("expected minor 2, got %d", v.Minor())
	}
	if v.Patch() != 3 {
		t.Errorf("expected patch 3, got %d", v.Patch())
	}
	if v.Prerelease() != "alpha.1" {
		t.Errorf("expected prerelease 'alpha.1', got '%s'", v.Prerelease())
	}
	if v.Metadata() != "build.42" {
		t.Errorf("expected metadata 'build.42', got '%s'", v.Metadata())
	}
}

func TestStrictNewVersion(t *testing.T) {
	v, err := semver.StrictNewVersion("1.2.3-beta.2")
	if err != nil {
		t.Fatalf("unexpected error parsing strict version: %v", err)
	}
	if v.Major() != 1 || v.Minor() != 2 || v.Patch() != 3 {
		t.Errorf("unexpected components in strict parsed version: %v", v)
	}

	// StrictNewVersion rejects versions with a leading 'v' or non-semver strings
	_, err = semver.StrictNewVersion("v1.2.3")
	if err == nil {
		t.Errorf("expected error for StrictNewVersion with 'v' prefix, got nil")
	}

	_, err = semver.StrictNewVersion("invalid.semver")
	if err == nil {
		t.Errorf("expected error for StrictNewVersion with invalid string, got nil")
	}
}

func TestNewConstraint(t *testing.T) {
	c, err := semver.NewConstraint(">= 1.2.0, < 2.0.0")
	if err != nil {
		t.Fatalf("unexpected error creating constraint: %v", err)
	}

	vMatch, err := semver.NewVersion("1.5.2")
	if err != nil {
		t.Fatalf("failed to parse valid version: %v", err)
	}
	if !c.Check(vMatch) {
		t.Errorf("expected %s to satisfy constraint %s", vMatch, c)
	}

	vFail, err := semver.NewVersion("2.0.0")
	if err != nil {
		t.Fatalf("failed to parse valid version: %v", err)
	}
	if c.Check(vFail) {
		t.Errorf("expected %s NOT to satisfy constraint %s", vFail, c)
	}

	// Validate method returns valid bool and validation error list
	valid, errs := c.Validate(vFail)
	if valid {
		t.Errorf("expected valid to be false for non-matching version")
	}
	if len(errs) == 0 {
		t.Errorf("expected validation errors for non-matching version, got none")
	}
}

func TestCollection(t *testing.T) {
	raw := []string{"3.0.0", "1.0.0-rc.1", "1.0.0", "2.1.0", "1.0.0-alpha"}
	var vs []*semver.Version
	for _, s := range raw {
		v, err := semver.NewVersion(s)
		if err != nil {
			t.Fatalf("failed to parse version %s: %v", s, err)
		}
		vs = append(vs, v)
	}

	sort.Sort(semver.Collection(vs))

	var sorted []string
	for _, v := range vs {
		sorted = append(sorted, v.Original())
	}

	expected := []string{"1.0.0-alpha", "1.0.0-rc.1", "1.0.0", "2.1.0", "3.0.0"}
	if !reflect.DeepEqual(sorted, expected) {
		t.Errorf("expected sorted %v, got %v", expected, sorted)
	}
}

func TestVersionIncrementMethods(t *testing.T) {
	// Release version increments
	vRelease, err := semver.NewVersion("1.2.3")
	if err != nil {
		t.Fatalf("failed to parse release version: %v", err)
	}

	incPatchRel := vRelease.IncPatch()
	if incPatchRel.String() != "1.2.4" {
		t.Errorf("expected IncPatch() on release to yield '1.2.4', got '%s'", incPatchRel.String())
	}

	incMinorRel := vRelease.IncMinor()
	if incMinorRel.String() != "1.3.0" {
		t.Errorf("expected IncMinor() on release to yield '1.3.0', got '%s'", incMinorRel.String())
	}

	incMajorRel := vRelease.IncMajor()
	if incMajorRel.String() != "2.0.0" {
		t.Errorf("expected IncMajor() on release to yield '2.0.0', got '%s'", incMajorRel.String())
	}

	// Prerelease version increments: IncPatch removes prerelease tag
	vPre, err := semver.NewVersion("1.2.3-alpha.1+build.10")
	if err != nil {
		t.Fatalf("failed to parse prerelease version: %v", err)
	}

	incPatchPre := vPre.IncPatch()
	if incPatchPre.String() != "1.2.3" {
		t.Errorf("expected IncPatch() on prerelease to yield '1.2.3', got '%s'", incPatchPre.String())
	}

	incMinorPre := vPre.IncMinor()
	if incMinorPre.String() != "1.3.0" {
		t.Errorf("expected IncMinor() on prerelease to yield '1.3.0', got '%s'", incMinorPre.String())
	}

	incMajorPre := vPre.IncMajor()
	if incMajorPre.String() != "2.0.0" {
		t.Errorf("expected IncMajor() on prerelease to yield '2.0.0', got '%s'", incMajorPre.String())
	}
}