github.com/Masterminds/semver/v3 v3.3.0

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.3.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/Masterminds/semver/v3@v3.3.0

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:92b3382c1d1c3937dc3f65434749ef2c208bb7ffc1601254c89c42e1a61562da","contract":["semver.NewVersion parses semantic versions with prerelease and build metadata","semver.StrictNewVersion rejects non-strict semantic version strings","semver.NewConstraint validates versions against complex range and caret constraints","semver.Version compares version precedence and equality","semver.Collection sorts version slices in ascending semantic order","semver.Version creates incremented copies for major, minor, and patch releases"],"goal":"verify pkg:golang/github.com/Masterminds/semver/v3@v3.3.0","kind":"HOW","packages":["pkg:golang/github.com/Masterminds/semver/v3@v3.3.0"],"schemaVersion":1},"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.3.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/Masterminds/semver/v3@v3.3.0","verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

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

github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0=
github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=

package sample

import (
	"fmt"
	"sort"

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

// VersionInfo holds details about a parsed semantic version.
type VersionInfo struct {
	Original   string
	Major      uint64
	Minor      uint64
	Patch      uint64
	Prerelease string
	Metadata   string
}

// ParseVersion parses a version string with lenient prefix handling.
func ParseVersion(vStr string) (*VersionInfo, error) {
	v, err := semver.NewVersion(vStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse version %q: %w", vStr, err)
	}
	return &VersionInfo{
		Original:   v.Original(),
		Major:      v.Major(),
		Minor:      v.Minor(),
		Patch:      v.Patch(),
		Prerelease: v.Prerelease(),
		Metadata:   v.Metadata(),
	}, nil
}

// ParseStrictVersion parses a version string requiring strict SemVer 2.0 conformance.
func ParseStrictVersion(vStr string) (*VersionInfo, error) {
	v, err := semver.StrictNewVersion(vStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse strict version %q: %w", vStr, err)
	}
	return &VersionInfo{
		Original:   v.Original(),
		Major:      v.Major(),
		Minor:      v.Minor(),
		Patch:      v.Patch(),
		Prerelease: v.Prerelease(),
		Metadata:   v.Metadata(),
	}, nil
}

// CheckConstraint checks if a version string satisfies the given 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
}

// SortVersions parses a list of version strings and returns them in ascending semantic order.
func SortVersions(versions []string) ([]string, error) {
	var coll semver.Collection
	for _, vStr := range versions {
		v, err := semver.NewVersion(vStr)
		if err != nil {
			return nil, fmt.Errorf("invalid version %q: %w", vStr, err)
		}
		coll = append(coll, v)
	}
	sort.Sort(coll)
	result := make([]string, len(coll))
	for i, v := range coll {
		result[i] = v.Original()
	}
	return result, nil
}

// BumpVersion returns incremented versions for major, minor, and patch levels.
func BumpVersion(vStr string) (major, minor, patch string, err error) {
	v, err := semver.NewVersion(vStr)
	if err != nil {
		return "", "", "", fmt.Errorf("invalid version %q: %w", vStr, err)
	}
	majVer := v.IncMajor()
	minVer := v.IncMinor()
	patVer := v.IncPatch()
	return majVer.String(), minVer.String(), patVer.String(), nil
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/github.com/Masterminds/semver/v3@v3.3.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/Masterminds/semver/v3@v3.3.0"
  ]
}

package test

import (
	"reflect"
	"testing"

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

func TestVersionParsing(t *testing.T) {
	// Lenient parsing handles leading 'v' and build metadata
	info, err := sample.ParseVersion("v2.4.1-rc.2+x86.64")
	if err != nil {
		t.Fatalf("unexpected error parsing version: %v", err)
	}
	if info.Major != 2 || info.Minor != 4 || info.Patch != 1 {
		t.Errorf("unexpected version components: got %d.%d.%d, expected 2.4.1", info.Major, info.Minor, info.Patch)
	}
	if info.Prerelease != "rc.2" {
		t.Errorf("unexpected prerelease: got %q, expected 'rc.2'", info.Prerelease)
	}
	if info.Metadata != "x86.64" {
		t.Errorf("unexpected metadata: got %q, expected 'x86.64'", info.Metadata)
	}

	// Strict parsing accepts standard SemVer 2.0
	strictInfo, err := sample.ParseStrictVersion("1.0.0-alpha+001")
	if err != nil {
		t.Fatalf("unexpected error parsing strict version: %v", err)
	}
	if strictInfo.Major != 1 || strictInfo.Minor != 0 || strictInfo.Patch != 0 {
		t.Errorf("unexpected strict components: got %d.%d.%d", strictInfo.Major, strictInfo.Minor, strictInfo.Patch)
	}

	// Strict parsing rejects leading 'v'
	_, err = sample.ParseStrictVersion("v1.0.0")
	if err == nil {
		t.Errorf("expected strict parser to reject leading 'v'")
	}
}

func TestConstraintEvaluation(t *testing.T) {
	// Caret constraint: ^1.2.3 matches >= 1.2.3 < 2.0.0
	match, err := sample.CheckConstraint("1.5.0", "^1.2.3")
	if err != nil || !match {
		t.Errorf("expected 1.5.0 to match ^1.2.3, got match=%v err=%v", match, err)
	}

	match, err = sample.CheckConstraint("2.0.0", "^1.2.3")
	if err != nil || match {
		t.Errorf("expected 2.0.0 not to match ^1.2.3, got match=%v err=%v", match, err)
	}

	// Tilde constraint: ~1.2.3 matches >= 1.2.3 < 1.3.0
	match, err = sample.CheckConstraint("1.2.9", "~1.2.3")
	if err != nil || !match {
		t.Errorf("expected 1.2.9 to match ~1.2.3, got match=%v err=%v", match, err)
	}

	match, err = sample.CheckConstraint("1.3.0", "~1.2.3")
	if err != nil || match {
		t.Errorf("expected 1.3.0 not to match ~1.2.3, got match=%v err=%v", match, err)
	}

	// Range constraint
	match, err = sample.CheckConstraint("3.1.4", ">= 2.0.0, <= 3.1.4")
	if err != nil || !match {
		t.Errorf("expected 3.1.4 to match range, got match=%v err=%v", match, err)
	}

	// Validation errors on invalid constraints
	_, err = sample.CheckConstraint("1.0.0", "invalid @# constraint")
	if err == nil {
		t.Errorf("expected error on invalid constraint string")
	}
}

func TestVersionComparisonAndSorting(t *testing.T) {
	v1, err := semver.NewVersion("1.0.0-alpha")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	v2, err := semver.NewVersion("1.0.0-beta")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	v3, err := semver.NewVersion("1.0.0")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if !v1.LessThan(v2) {
		t.Errorf("expected 1.0.0-alpha < 1.0.0-beta")
	}
	if !v2.LessThan(v3) {
		t.Errorf("expected 1.0.0-beta < 1.0.0")
	}
	if v3.Compare(v1) != 1 {
		t.Errorf("expected v3.Compare(v1) == 1, got %d", v3.Compare(v1))
	}
	if !v3.Equal(v3) {
		t.Errorf("expected v3 to equal v3")
	}

	raw := []string{"2.0.0", "1.0.0-beta", "0.5.0", "1.0.0", "1.0.0-alpha"}
	sorted, err := sample.SortVersions(raw)
	if err != nil {
		t.Fatalf("unexpected error sorting versions: %v", err)
	}

	expected := []string{"0.5.0", "1.0.0-alpha", "1.0.0-beta", "1.0.0", "2.0.0"}
	if !reflect.DeepEqual(sorted, expected) {
		t.Errorf("expected sorted versions %v, got %v", expected, sorted)
	}
}

func TestVersionIncrement(t *testing.T) {
	maj, min, pat, err := sample.BumpVersion("1.2.3-beta.1")
	if err != nil {
		t.Fatalf("unexpected error bumping version: %v", err)
	}
	if maj != "2.0.0" {
		t.Errorf("expected bumped major to be '2.0.0', got %q", maj)
	}
	if min != "1.3.0" {
		t.Errorf("expected bumped minor to be '1.3.0', got %q", min)
	}
	if pat != "1.2.3" {
		t.Errorf("expected bumped patch to be '1.2.3', got %q", pat)
	}

	maj2, min2, pat2, err := sample.BumpVersion("1.2.3")
	if err != nil {
		t.Fatalf("unexpected error bumping version: %v", err)
	}
	if maj2 != "2.0.0" || min2 != "1.3.0" || pat2 != "1.2.4" {
		t.Errorf("expected 2.0.0, 1.3.0, 1.2.4; got %s, %s, %s", maj2, min2, pat2)
	}
}