calculator

type BaseVersionCalculator ¶

type BaseVersionCalculator struct {
	// contains filtered or unexported fields
}

BaseVersionCalculator runs all strategies, computes effective versions for ranking, and selects the winning base version.

func NewBaseVersionCalculator(
	store *git.RepositoryStore,
	strategies []strategy.VersionStrategy,
	increment *IncrementStrategyFinder,
) *BaseVersionCalculator

func (c *BaseVersionCalculator) Calculate(
	ctx *context.GitVersionContext,
	ec config.EffectiveConfiguration,
	explain bool,
) (BaseVersionResult, error)

type BaseVersionResult ¶

type BaseVersionResult struct {
	BaseVersion            strategy.BaseVersion
	EffectiveConfiguration config.EffectiveConfiguration
	AllCandidates          []strategy.BaseVersion
}

BaseVersionResult holds the selected base version and its effective config.

type IncrementExplanation ¶

type IncrementExplanation struct {
	Steps []string
}

IncrementExplanation records the reasoning behind an increment decision.

func (e *IncrementExplanation) Add(step string)

func (e *IncrementExplanation) Addf(format string, args ...any)

type IncrementResult ¶

type IncrementResult struct {
	Field       semver.VersionField
	Explanation *IncrementExplanation // nil when explain is false
}

IncrementResult holds the determined increment and optional reasoning.

type IncrementStrategyFinder ¶

type IncrementStrategyFinder struct {
	// contains filtered or unexported fields
}

IncrementStrategyFinder scans commit messages to determine the version bump.

func NewIncrementStrategyFinder(store *git.RepositoryStore) *IncrementStrategyFinder

func (f *IncrementStrategyFinder) AnalyzeCommitIncrement(
	c git.Commit,
	ec config.EffectiveConfiguration,
) semver.VersionField

func (f *IncrementStrategyFinder) DetermineIncrementedField(
	ctx *context.GitVersionContext,
	bv strategy.BaseVersion,
	ec config.EffectiveConfiguration,
) (semver.VersionField, error)

func (f *IncrementStrategyFinder) DetermineIncrementedFieldExplained(
	ctx *context.GitVersionContext,
	bv strategy.BaseVersion,
	ec config.EffectiveConfiguration,
	explain bool,
) (IncrementResult, error)

type MainlineVersionCalculator ¶

type MainlineVersionCalculator struct {
	// contains filtered or unexported fields
}

MainlineVersionCalculator computes versions in mainline mode. Supports two increment modes controlled by ec.MainlineIncrement:

• Aggregate (default): highest increment applied once, commit count in build metadata
• EachCommit: version incremented per commit individually

func NewMainlineVersionCalculator(
	store *git.RepositoryStore,
	increment *IncrementStrategyFinder,
) *MainlineVersionCalculator

func (m *MainlineVersionCalculator) FindMainlineModeVersion(
	ctx *context.GitVersionContext,
	bv strategy.BaseVersion,
	ec config.EffectiveConfiguration,
	explain bool,
) (semver.SemanticVersion, *IncrementExplanation, error)

type NextVersionCalculator ¶

type NextVersionCalculator struct {
	// contains filtered or unexported fields
}

NextVersionCalculator orchestrates the full version calculation pipeline.

func NewNextVersionCalculator(
	store *git.RepositoryStore,
	strategies []strategy.VersionStrategy,
) *NextVersionCalculator

func (c *NextVersionCalculator) Calculate(
	ctx *context.GitVersionContext,
	ec config.EffectiveConfiguration,
	explain bool,
) (VersionResult, error)

type VersionResult ¶

type VersionResult struct {
	Version              semver.SemanticVersion
	BaseVersion          strategy.BaseVersion
	BranchName           string
	CommitsSince         int64
	AllCandidates        []strategy.BaseVersion
	IncrementExplanation *IncrementExplanation // nil when explain is false
	PreReleaseSteps      []string              // nil when explain is false
}

VersionResult holds the calculated version and metadata.