base version after testing

.github/workflows/simver.yaml

@@ -0,0 +1,48 @@
+{
+    name: simver,
+    concurrency: { group: simver, cancel-in-progress: false },
+    permissions: { id-token: write, contents: write, pull-requests: read },
+    on:
+        {
+            workflow_dispatch: null,
+            workflow_call: null,
+            push: { branches: [main] },
+            pull_request: { types: [opened, synchronize, reopened, closed] },
+        },
+    defaults: { run: { shell: bash } },
+    jobs:
+        {
+            simver:
+                {
+                    runs-on: ubuntu-latest,
+
+                    steps:
+                        [
+                            {
+                                name: checkout code,
+                                uses: "actions/checkout@v4",
+                                with: { fetch-depth: 0 },
+                            },
+                            {
+                                name: setup golang,
+                                uses: "actions/setup-go@v4",
+                                with: { go-version: 1.21.4 },
+                            },
+                            {
+                                name: install simver,
+                                run: "go install github.com/walteh/simver/cmd/[email protected]",
+                            },
+                            {
+                                name: run simver,
+                                id: simver,
+                                env:
+                                    {
+                                        SIMVER_READ_ONLY: false,
+                                        GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}",
+                                    },
+                                run: simver_github_actions,
+                            },
+                        ],
+                },
+        },
+}

.vscode/simver.code-workspace

@@ -10,6 +10,7 @@
 							VSCODE
 		////////////////////////////////////////////// */
 		"workbench.tree.indent": 16,
+		"editor.defaultFormatter": "esbenp.prettier-vscode",
 		"editor.formatOnSave": true,
 		"search.useIgnoreFiles": true,
 		"debug.console.wordWrap": false,
@@ -25,17 +26,17 @@
 		/* //////////////////////////////////////////////
 							YAML
 		////////////////////////////////////////////// */
-		"yaml.format.enable": true,
-		"[yaml]": {
-			"editor.defaultFormatter": "redhat.vscode-yaml",
-			"editor.bracketPairColorization.enabled": true,
-			"editor.formatOnSave": true,
-		},
-		"yaml.style.flowSequence": "allow",
-		"yaml.style.flowMapping": "allow",
-		"yaml.format.proseWrap": "preserve",
-		"yaml.format.singleQuote": false,
-		"yaml.extension.recommendations": true,
+		// "yaml.format.enable": true,
+		// "[yaml]": {
+		// 	"editor.defaultFormatter": "esbenp.prettier-vscode",
+		// 	"editor.bracketPairColorization.enabled": true,
+		// 	"editor.formatOnSave": true,
+		// },
+		// "yaml.style.flowSequence": "allow",
+		// "yaml.style.flowMapping": "allow",
+		// "yaml.format.proseWrap": "preserve",
+		// "yaml.format.singleQuote": false,
+		// "yaml.extension.recommendations": true,
 		/* //////////////////////////////////////////////
 							DOCKER
 		////////////////////////////////////////////// */

README.md

@@ -4,7 +4,10 @@ simple, pr based, semver git tagging logic
 
 # definitions
 
-## when is mmrt valid? 
+        # how can we make sure that a version is reserved - and if it is not reserved we need to bump it
+
+
+## when is mmrt valid?
 1. it exists
 2. it is higher than the mrlt
 
@@ -33,7 +36,18 @@ inside this commits tree, the highest '*-pr.N+(this)' is the mmrbn.
 note each of the nvt, mrrt, mrlt, and mmrt are saved as valid semvers, so "X.Y.Z"
 the mmrbn is an integer, so "N"
 
------------
+------------
+
+two bugs:
+- need to make sure merges do not have build numbers
+- need to make sure that build nums are picked up
+
+# probs to test
+1. make sure that a new pr to main does a minor bump
+2. make sure that a new pr not to main does a patch bump
+3. make sure that a new commit to a pr who has been tagged with a version and was last used for it does a patch bump
+1. make sure if reserved is set, but others are not that it does not loop infinitely
+
 
 # process
 
@@ -86,3 +100,10 @@ the mmrbn is an integer, so "N"
 1. find the mrrt and mrlt, calculate the nvt
 2. create a new tag (based on nvt) on the head commit with no build number or prerelease
 
+when you merge a pr:
+- find the mmrt or the pr branch, and we need to start using that for this branch
+- the base branch should inherit the mmrt from the pr branch
+- so we need to create:
+	1. a new "base" tag for the base branch with the mmrt of the pr branch
+	2. create a new build tag using the mmrt
+

calculate.go

@@ -1,28 +1,60 @@
 package simver
 
 import (
+	"context"
 	"fmt"
 
+	"github.com/rs/zerolog"
 	"github.com/walteh/terrors"
 	"golang.org/x/mod/semver"
 )
 
 type Calculation struct {
-	MyMostRecentTag       MMRT
-	MostRecentLiveTag     MRLT
-	MyMostRecentBuild     MMRBN
-	MostRecentReservedTag MRRT
-	PR                    int
-	NextValidTag          NVT
+	MyMostRecentTag   MMRT
+	MostRecentLiveTag MRLT
+	MyMostRecentBuild MMRBN
+	PR                int
+	NextValidTag      NVT
+	IsMerge           bool
+	ForcePatch        bool
 }
 
 var (
 	ErrValidatingCalculation = terrors.New("ErrValidatingCalculation")
 )
 
-func (me *Calculation) CalculateNewTagsRaw() ([]string, []string) {
-	baseTags := make([]string, 0)
-	headTags := make([]string, 0)
+type CalculationOutput struct {
+	BaseTags  []string
+	HeadTags  []string
+	RootTags  []string
+	MergeTags []string
+}
+
+func (out *CalculationOutput) ApplyRefs(opts RefProvider) Tags {
+	tags := make(Tags, 0)
+	for _, tag := range out.BaseTags {
+		tags = append(tags, Tag{Name: tag, Ref: opts.Base()})
+	}
+
+	for _, tag := range out.HeadTags {
+		tags = append(tags, Tag{Name: tag, Ref: opts.Head()})
+	}
+	for _, tag := range out.RootTags {
+		tags = append(tags, Tag{Name: tag, Ref: opts.Root()})
+	}
+	for _, tag := range out.MergeTags {
+		tags = append(tags, Tag{Name: tag, Ref: opts.Merge()})
+	}
+	return tags
+}
+
+func (me *Calculation) CalculateNewTagsRaw(ctx context.Context) *CalculationOutput {
+	out := &CalculationOutput{
+		BaseTags:  []string{},
+		HeadTags:  []string{},
+		RootTags:  []string{},
+		MergeTags: []string{},
+	}
 
 	nvt := string(me.NextValidTag)
 
@@ -42,15 +74,42 @@ func (me *Calculation) CalculateNewTagsRaw() ([]string, []string) {
 		validMmrt = true
 	}
 
+	// force patch is ignored if this is a merge
+	if me.ForcePatch && !me.IsMerge {
+		nvt = BumpPatch(mmrt)
+		validMmrt = false
+	}
+
 	// if mmrt is invalid, then we need to reserve a new mmrt (which is the same as nvt)
 	if !validMmrt {
 		mmrt = nvt
-		baseTags = append(baseTags, nvt+"-reserved")
-		baseTags = append(baseTags, nvt+fmt.Sprintf("-pr%d+base", me.PR))
+		// pr will be 0 if this is not a and is a push to the root branch
+		if me.PR != 0 {
+			out.RootTags = append(out.RootTags, nvt+"-reserved")
+			out.BaseTags = append(out.BaseTags, nvt+fmt.Sprintf("-pr%d+base", me.PR))
+		}
+	}
+
+	if me.IsMerge {
+		out.MergeTags = append(out.MergeTags, mmrt)
+	} else {
+		if me.PR == 0 {
+			out.HeadTags = append(out.HeadTags, mmrt)
+		} else {
+			out.HeadTags = append(out.HeadTags, mmrt+fmt.Sprintf("-pr%d+%d", me.PR, int(me.MyMostRecentBuild)+1))
+		}
 	}
 
-	// then finally we tag mmrt
-	headTags = append(headTags, mmrt+fmt.Sprintf("-pr%d+%d", me.PR, int(me.MyMostRecentBuild)+1))
+	zerolog.Ctx(ctx).Debug().
+		Any("calculation", me).
+		Any("output", out).
+		Str("mmrt", mmrt).
+		Str("mrlt", mrlt).
+		Str("nvt", nvt).
+		Str("pr", fmt.Sprintf("%d", me.PR)).
+		Bool("isMerge", me.IsMerge).
+		Bool("forcePatch", me.ForcePatch).
+		Msg("CalculateNewTagsRaw")
 
-	return baseTags, headTags
+	return out
 }