ReleaseKit/check.go

package releasekit

import (
	"context"
	"io"

	internalbuild "gitea.maximumdirect.net/eric/ReleaseKit/internal/build"
	"gitea.maximumdirect.net/eric/ReleaseKit/internal/candidate"
	"gitea.maximumdirect.net/eric/ReleaseKit/internal/validation"
)

// ErrInvalidVersion reports a version that is not stable vMAJOR.MINOR.PATCH.
var ErrInvalidVersion = candidate.ErrInvalidVersion

// Candidate identifies one committed local source revision selected for
// validation.
type Candidate struct {
	RepositoryDir string
	Commit        string
	Version       string
}

// ReleaseRequest contains the inputs used to validate and optionally build one
// local candidate. Remote is retained for publication operations; Check makes
// no remote availability claim.
type ReleaseRequest struct {
	RepositoryDir string
	Product       string
	Version       string
	Remote        string
	// Validation selects optional checks run against the captured candidate.
	Validation ValidationSpec
	// AdditionalChecks optionally runs product checks after shared validation.
	AdditionalChecks func(context.Context, Candidate) error
	Build            *BuildSpec // optional selected-target build after validation.
	Output           io.Writer
}

// ValidationSpec selects optional shared validation checks. Its zero value
// preserves the current validation behavior.
type ValidationSpec struct {
	Go GoValidationSpec
}

// GoValidationSpec selects checks performed by the Go toolchain.
type GoValidationSpec struct {
	// Race runs the one standard Go test suite with the race detector enabled.
	Race bool
	// FullVet runs go vet after the suite instead of the test-time vet pass.
	// Failures use the go-vet validation check identity.
	FullVet bool
	// CompileTargets checks that every package builds for each complete target
	// pair after testing and vet. Compilation uses CGO_ENABLED=0 and does not
	// produce artifacts or execute target binaries. Failures use the
	// package-compile validation check identity.
	CompileTargets []Target
}

// Check validates one local, committed release candidate. It requires a clean
// worktree and index on main, a committed note matching Product and Version,
// and an unused local tag. It always runs the offline Go test suite with the
// available compatible local Go toolchain and Go host target, then calls
// AdditionalChecks when supplied. Validation.Go.Race runs that one suite with
// the race detector, Validation.Go.FullVet runs go vet after the suite instead
// of test-time vet, and Validation.Go.CompileTargets compiles all packages for
// each selected GOOS/GOARCH pair after tests and vet with cgo disabled. Package
// compilation produces no artifacts and does not execute target binaries.
// Their zero values preserve the ordinary suite. If
// Build selects targets, Check builds them after validation in temporary
// storage outside the worktree, then rechecks
// branch, HEAD, worktree, index, and local tag state. Success establishes local
// candidate evidence only; it does not establish remote availability.
func Check(ctx context.Context, request ReleaseRequest) (Candidate, error) {
	checked, err := candidate.Check(ctx, candidateRequest(request))
	if err != nil {
		return Candidate{}, convertValidationError(err)
	}
	return Candidate{
		RepositoryDir: checked.RepositoryDir,
		Commit:        checked.Commit,
		Version:       checked.Version,
	}, nil
}

func candidateRequest(request ReleaseRequest) candidate.Request {
	result := candidate.Request{
		RepositoryDir: request.RepositoryDir,
		Product:       request.Product,
		Version:       request.Version,
		Validation: validation.Settings{
			Race:           request.Validation.Go.Race,
			FullVet:        request.Validation.Go.FullVet,
			CompileTargets: make([]validation.Target, len(request.Validation.Go.CompileTargets)),
		},
		AdditionalChecks: candidateChecks(request.AdditionalChecks),
		AfterValidate:    internalbuild.CandidateCallback(internalBuildSpec(request.Build), request.Output),
		Output:           request.Output,
	}
	for index, target := range request.Validation.Go.CompileTargets {
		result.Validation.CompileTargets[index] = validation.Target{OS: target.OS, Arch: target.Arch}
	}
	return result
}

func candidateChecks(checks func(context.Context, Candidate) error) func(context.Context, candidate.Candidate) error {
	if checks == nil {
		return nil
	}
	return func(ctx context.Context, captured candidate.Candidate) error {
		return checks(ctx, Candidate{
			RepositoryDir: captured.RepositoryDir,
			Commit:        captured.Commit,
			Version:       captured.Version,
		})
	}
}