release-tag 0.2.5__py3-none-win_amd64.whl

completion/completion.go

@@ -0,0 +1,75 @@
+package completion
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+func AddCompletionCmd(cmd *cobra.Command) *cobra.Command {
+	var completionCmd = &cobra.Command{
+		Use:   "completion [bash|zsh|fish|powershell]",
+		Short: "Generate completion script",
+		Long: fmt.Sprintf(`To load completions:
+
+Bash:
+
+  $ source <(%[1]s completion bash)
+
+  # To load completions for each session, execute once:
+  # Linux:
+  $ %[1]s completion bash > /etc/bash_completion.d/%[1]s
+  # macOS:
+  $ %[1]s completion bash > $(brew --prefix)/etc/bash_completion.d/%[1]s
+
+Zsh:
+
+  # If shell completion is not already enabled in your environment,
+  # you will need to enable it.  You can execute the following once:
+
+  $ echo "autoload -U compinit; compinit" >> ~/.zshrc
+
+  # To load completions for each session, execute once:
+  $ %[1]s completion zsh > "${fpath[1]}/_%[1]s"
+
+  # You will need to start a new shell for this setup to take effect.
+
+fish:
+
+  $ %[1]s completion fish | source
+
+  # To load completions for each session, execute once:
+  $ %[1]s completion fish > ~/.config/fish/completions/%[1]s.fish
+
+PowerShell:
+
+  PS> %[1]s completion powershell | Out-String | Invoke-Expression
+
+  # To load completions for every new session, run:
+  PS> %[1]s completion powershell > %[1]s.ps1
+  # and source this file from your PowerShell profile.
+`, cmd.Root().Name()),
+		DisableFlagsInUseLine: true,
+		ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
+		Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			switch args[0] {
+			case "bash":
+				err = cmd.Root().GenBashCompletion(os.Stdout)
+			case "zsh":
+				err = cmd.Root().GenZshCompletion(os.Stdout)
+			case "fish":
+				err = cmd.Root().GenFishCompletion(os.Stdout, true)
+			case "powershell":
+				err = cmd.Root().GenPowerShellCompletionWithDesc(os.Stdout)
+			}
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error generating completion: %v\n", err)
+				os.Exit(1)
+			}
+		},
+	}
+	return completionCmd
+}

git/git.go

@@ -0,0 +1,123 @@
+package git
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/jmelahman/tag/semver"
+)
+
+func GetLatestSemverTag() (string, error) {
+	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
+	output, err := cmd.Output()
+	if err != nil {
+		return "v0.0.0", nil
+	}
+
+	tagsAt, err := ListTagsAt(strings.TrimSpace(string(output)))
+	if err != nil {
+		return "v0.0.0", nil
+	}
+
+	var largestTag string
+	var largestVersion *semver.Version
+
+	for _, tag := range tagsAt {
+		if largestTag == "" {
+			largestTag = tag
+		}
+
+		version, err := semver.ParseSemver(tag)
+		if err != nil {
+			continue
+		}
+
+		if largestVersion == nil {
+			largestTag = tag
+			largestVersion = version
+			continue
+		}
+
+		if semver.CompareSemver(version, largestVersion) {
+			largestTag = tag
+			largestVersion = version
+		}
+	}
+
+	return largestTag, nil
+}
+
+// List all git tags
+func ListTags() ([]string, error) {
+	cmd := exec.Command("git", "tag", "-l", "v[0-9]*.[0-9]*.[0-9]*")
+	cmd.Stderr = os.Stderr
+	tagsOutput, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	tagList := strings.Split(strings.TrimSpace(string(tagsOutput)), "\n")
+
+	return tagList, nil
+}
+
+func ListTagsAt(ref string) ([]string, error) {
+	cmd := exec.Command("git", "tag", "--points-at", ref)
+	cmd.Stderr = os.Stderr
+	tagsOutput, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	tagList := strings.Split(strings.TrimSpace(string(tagsOutput)), "\n")
+
+	return tagList, nil
+}
+
+func TagExists(tag string) (bool, error) {
+	cmd := exec.Command("git", "show-ref", "--tags", "--quiet", tag)
+	if err := cmd.Run(); err != nil {
+		if exitError, ok := err.(*exec.ExitError); ok && exitError.ExitCode() == 1 {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}
+
+func CreateAndPushTag(tag string, remote string) error {
+	cmd := exec.Command("git", "tag", tag)
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to create tag: %w", err)
+	}
+
+	cmd = exec.Command("git", "push", "--quiet", remote, tag)
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to push tag to %s: %w", remote, err)
+	}
+
+	return nil
+}
+
+func FetchSemverTags(remote string) error {
+	cmd := exec.Command("git", "fetch", "--quiet", "--prune", remote, "refs/tags/v*:refs/tags/v*")
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to fetch tags from %s: %w", remote, err)
+	}
+	return nil
+}
+
+func IsHEADAlreadyTagged() (bool, error) {
+	cmd := exec.Command("git", "tag", "--points-at", "HEAD")
+	cmd.Stderr = os.Stderr
+	output, err := cmd.Output()
+	if err != nil {
+		return false, fmt.Errorf("failed to check tags for HEAD: %w", err)
+	}
+	return len(strings.TrimSpace(string(output))) > 0, nil
+}

go.mod

@@ -0,0 +1,16 @@
+module github.com/jmelahman/tag
+
+go 1.23.4
+
+require (
+	github.com/spf13/cobra v1.8.1
+	github.com/stretchr/testify v1.10.0
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,18 @@
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
+github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -0,0 +1,127 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/jmelahman/tag/completion"
+	"github.com/jmelahman/tag/git"
+	"github.com/jmelahman/tag/semver"
+	"github.com/spf13/cobra"
+)
+
+var (
+	version = "dev"
+	commit  = "none"
+)
+
+func main() {
+	var major, minor, patch, push bool
+	var metadata, suffix, remote string
+
+	rootCmd := &cobra.Command{
+		Use:     "tag",
+		Short:   "Calculate the next semantic version tag",
+		Version: fmt.Sprintf("%s\ncommit %s", version, commit),
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			// Validate that only one version increment flag is set
+			incrementFlags := []bool{major, minor, patch}
+			var setFlags int
+			for _, flag := range incrementFlags {
+				if flag {
+					setFlags++
+				}
+			}
+			if setFlags > 1 {
+				return fmt.Errorf("only one version increment flag (--major, --minor, or --patch) can be used at a time")
+			}
+			return nil
+		},
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := git.FetchSemverTags(remote); err != nil {
+				fmt.Printf("Error fetching tags: %v\n", err)
+				os.Exit(1)
+			}
+
+			// Check if HEAD is already tagged
+			alreadyTagged, err := git.IsHEADAlreadyTagged()
+			if err != nil {
+				fmt.Printf("Error checking tags: %v\n", err)
+				os.Exit(1)
+			}
+			if alreadyTagged {
+				fmt.Println("Error: Current HEAD is already tagged")
+				os.Exit(1)
+			}
+
+			latestTag, err := git.GetLatestSemverTag()
+			if err != nil {
+				fmt.Printf("Error: %v\n", err)
+				os.Exit(1)
+			}
+
+			allTags, err := git.ListTags()
+			if err != nil {
+				fmt.Printf("Error: %v\n", err)
+				os.Exit(1)
+			}
+
+			nextVersion, err := semver.CalculateNextVersion(latestTag, allTags, major, minor, patch, suffix)
+			if err != nil {
+				fmt.Printf("Error: %v\n", err)
+				os.Exit(1)
+			}
+
+			if metadata != "" {
+				nextVersion = fmt.Sprint(nextVersion, "+", metadata)
+			}
+
+			tagExists, err := git.TagExists(nextVersion)
+			if err != nil {
+				fmt.Printf("Error: %v\n", err)
+				os.Exit(1)
+			}
+
+			if tagExists {
+				fmt.Printf("Next tag '%s' already exists.\n", nextVersion)
+				os.Exit(1)
+			}
+
+			if !push {
+				reader := bufio.NewReader(os.Stdin)
+				fmt.Printf("Push tag '%s' to %s? (y/N): ", nextVersion, remote)
+				response, _ := reader.ReadString('\n')
+				response = strings.TrimSpace(strings.ToLower(response))
+
+				if response == "" || response == "y" || response == "yes" {
+					push = true
+				}
+			}
+
+			if push {
+				if err := git.CreateAndPushTag(nextVersion, remote); err != nil {
+					fmt.Printf("Error: %v\n", err)
+					os.Exit(1)
+				}
+				fmt.Printf("Tag '%s' created and pushed to %s.\n", nextVersion, remote)
+			}
+		},
+	}
+
+	rootCmd.Flags().BoolVar(&major, "major", false, "increment the major version")
+	rootCmd.Flags().BoolVar(&minor, "minor", false, "increment the minor version")
+	rootCmd.Flags().BoolVar(&patch, "patch", false, "increment the patch version")
+	rootCmd.Flags().BoolVar(&push, "push", false, "create and push the tag to remote")
+	rootCmd.Flags().StringVar(&suffix, "suffix", "", "set the pre-release suffix (e.g., rc, alpha, beta)")
+	rootCmd.Flags().StringVar(&metadata, "metadata", "", "set the build metadata")
+	rootCmd.Flags().StringVar(&remote, "remote", "origin", "remote repository to push tag to")
+
+	rootCmd.AddCommand(completion.AddCompletionCmd(rootCmd))
+
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Printf("Error: %v\n", err)
+		os.Exit(1)
+	}
+}

release_tag-0.2.5.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: release-tag
+Version: 0.2.5
+Summary: Automatically create semantic version git tags
+Project-URL: Repository, https://github.com/jmelahman/tag
+Author-email: Jamison Lahman <jamison@lahman.dev>
+License: MIT License
+        
+        Copyright (c) 2024 Jamison Lahman
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: git,git tags,release,releasing,semver,tagging
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Go
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# Tag Release
+
+[![Test status](https://github.com/jmelahman/tag/actions/workflows/test.yml/badge.svg)](https://github.com/jmelahman/tag/actions)
+[![Deploy Status](https://github.com/jmelahman/tag/actions/workflows/release.yml/badge.svg)](https://github.com/jmelahman/tag/actions)
+[![Go Reference](https://pkg.go.dev/badge/github.com/jmelahman/tag.svg)](https://pkg.go.dev/github.com/jmelahman/tag)
+[![Arch User Repsoitory](https://img.shields.io/aur/version/release-tag)](https://aur.archlinux.org/packages/release-tag)
+[![PyPI](https://img.shields.io/pypi/v/release-tag.svg)]()
+[![Go Report Card](https://goreportcard.com/badge/github.com/jmelahman/tag)](https://goreportcard.com/report/github.com/jmelahman/tag)
+
+Automatically create [semantic version](https://semver.org/) git tags.
+
+```text
+$ tag
+Push tag 'v1.0.1' to origin? (y/N): y
+Tag 'v1.0.1' created and pushed to origin.
+```
+
+## Usage
+
+By default, `tag` will increment the smallest digit following [SemVer precedence](https://semver.org/#semantic-versioning-specification-semver).
+Incrementing a specific is achieved by passing the respective flag: `--major`, `--minor`, `--patch`.
+
+Tags can be automatically pushed to a remote repository by passing `--push`.
+
+`tag` supports [pre-release](https://semver.org/#spec-item-9) versions.
+Creating a pre-release tag is achieved by the using the `--suffix` flag.
+For example, `--suffix="alpha"` will create a tag like `v1.0.0-alpha`.
+If the previous tag was for a pre-release, that suffix is preferred.
+This behavior can be overridden by passing `--patch` or `--suffix=""`.
+Only incrementing the trailing pre-release identifier is currently supported.
+
+`tag` authoritatively discourages duplicate tags for a single commit.
+
+### Autocomplete
+
+`tag` provides autocomplete for `bash`, `fish`, `powershell` and `zsh` shells.
+For example, to enable autocomplete for the `bash` shell,
+
+```shell
+tag completion bash | sudo tee /etc/bash_completion.d/tag > /dev/null
+```
+
+_Note: bash completion requires the [bash-completion](https://github.com/scop/bash-completion/) package be installed._
+
+For more information, see `tag completion <shell> --help` for your respective `<shell>`.
+
+## Install
+
+**AUR:**
+
+`tag` is available from the [Arch User Repository](https://aur.archlinux.org/packages/release-tag).
+
+```shell
+yay -S release-tag
+```
+
+**pip:**
+
+`tag` is available as a [pypi package](https://pypi.org/project/release-tag/).
+
+```shell
+pip install release-tag
+```
+
+**go:**
+
+```shell
+go install github.com/jmelahman/tag@latest
+```
+
+**github:**
+
+Prebuilt packages are available from [Github Releases](https://github.com/jmelahman/tag/releases).

release_tag-0.2.5.dist-info/RECORD

@@ -0,0 +1,12 @@
+go.mod,sha256=yqrrzLAqT2bxEcjq-XEp7hRrtrLVgyozVrUUSo-UE9Y,371
+go.sum,sha256=NhTyKeYVMD29_XicuWpg9bSSxCALHSPAHkAtC8AZO9I,1592
+main.go,sha256=wrz-whOruIWj-1lRCyDNqS2DNHRf8o99hsW1l62MHGs,3377
+completion/completion.go,sha256=5d7jq9-sQATbG2jqEnhmLvoBBKpkP0HrCs2B9EeTwDM,2055
+git/git.go,sha256=LKx7fmBwa2jgRkZJwUfDeelke0ryTwPeQ2isfCBuB0E,2733
+semver/semver.go,sha256=LQgpwqqne2NV312U8_6AMQvS-VSh6TD2Dg6AtuDmYOA,3046
+semver/semver_test.go,sha256=XosZIXKOZeK1x6r9W1GUBdghXXKYtFeXD1YjwlHq8kU,5793
+release_tag-0.2.5.data/scripts/tag,sha256=-Oqz4POzs3jNRktwBILkiVrMpav5-zS-iMihgerH75Q,4009472
+release_tag-0.2.5.dist-info/METADATA,sha256=NUM0ZWh-xy_aGV79N5X_8ZuKz7TL_T0eebJbiCj2DzU,4378
+release_tag-0.2.5.dist-info/WHEEL,sha256=Vhj7RpPOKCXcsr4rUs7q4pISuo5nT6VsOuaQwH9GILY,94
+release_tag-0.2.5.dist-info/licenses/LICENSE,sha256=P_te03YIieIzk4EnP3-blVrdJGbhityi_YcHwxaL7gk,1071
+release_tag-0.2.5.dist-info/RECORD,,

release_tag-0.2.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64

release_tag-0.2.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jamison Lahman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

semver/semver.go

@@ -0,0 +1,127 @@
+package semver
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+)
+
+type Version struct {
+	Major         int
+	Minor         int
+	Patch         int
+	PreRelease    string
+	PreReleaseNum int
+}
+
+func ParseSemver(tag string) (*Version, error) {
+	re := regexp.MustCompile(`v(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z]+)(?:\.(\d+))?)?`)
+	matches := re.FindStringSubmatch(tag)
+	if matches == nil {
+		return nil, fmt.Errorf("invalid semver tag: %s", tag)
+	}
+
+	major, _ := strconv.Atoi(matches[1])
+	minor, _ := strconv.Atoi(matches[2])
+	patch, _ := strconv.Atoi(matches[3])
+	preRelease := matches[4]
+	preReleaseNum := 0
+	if len(matches) > 5 && matches[5] != "" {
+		preReleaseNum, _ = strconv.Atoi(matches[5])
+	}
+
+	return &Version{
+		Major:         major,
+		Minor:         minor,
+		Patch:         patch,
+		PreRelease:    preRelease,
+		PreReleaseNum: preReleaseNum,
+	}, nil
+}
+
+func CompareSemver(v1, v2 *Version) bool {
+	if v1.Major > v2.Major {
+		return true
+	}
+	if v1.Major < v2.Major {
+		return false
+	}
+	if v1.Minor > v2.Minor {
+		return true
+	}
+	if v1.Minor < v2.Minor {
+		return false
+	}
+	if v1.Patch > v2.Patch {
+		return true
+	}
+	if v1.Patch < v2.Patch {
+		return false
+	}
+
+	// Handle pre-release versions
+	if v1.PreRelease == "" && v2.PreRelease != "" {
+		return true
+	}
+	if v1.PreRelease != "" && v2.PreRelease == "" {
+		return false
+	}
+	if v1.PreRelease == v2.PreRelease {
+		return v1.PreReleaseNum > v2.PreReleaseNum
+	}
+	return false
+}
+
+func CalculateNextVersion(tag string, allTags []string, incMajor, incMinor, incPatch bool, suffix string) (string, error) {
+	// Parse the current version
+	version, err := ParseSemver(tag)
+	if err != nil {
+		return "", err
+	}
+
+	// Increment version based on flags
+	if incMajor {
+		version.Major++
+		version.Minor = 0
+		version.Patch = 0
+		version.PreReleaseNum = 0
+	} else if incMinor {
+		version.Minor++
+		version.Patch = 0
+		version.PreReleaseNum = 0
+	} else if incPatch {
+		version.Patch++
+		version.PreReleaseNum = 0
+	} else if suffix == "" && version.PreRelease == "" {
+		version.Patch++
+	} else if suffix != "" && version.PreRelease != suffix {
+		// Find the largest PreReleaseNum for the given suffix
+		largestPreReleaseNum := 0
+		for _, existingTag := range allTags {
+			existingVersion, err := ParseSemver(existingTag)
+			if err == nil && existingVersion.PreRelease == suffix {
+				if existingVersion.PreReleaseNum > largestPreReleaseNum {
+					largestPreReleaseNum = existingVersion.PreReleaseNum
+				}
+			}
+		}
+		if largestPreReleaseNum > 0 {
+			version.PreReleaseNum = largestPreReleaseNum + 1
+		}
+	} else {
+		version.PreReleaseNum++
+	}
+
+	if suffix != "" {
+		version.PreRelease = suffix
+	}
+
+	// Construct the version string
+	if version.PreRelease != "" {
+		if version.PreReleaseNum > 0 {
+			return fmt.Sprintf("v%d.%d.%d-%s.%d", version.Major, version.Minor, version.Patch, version.PreRelease, version.PreReleaseNum), nil
+		}
+		return fmt.Sprintf("v%d.%d.%d-%s", version.Major, version.Minor, version.Patch, version.PreRelease), nil
+	}
+	return fmt.Sprintf("v%d.%d.%d", version.Major, version.Minor, version.Patch), nil
+}

semver/semver_test.go

@@ -0,0 +1,261 @@
+package semver
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseSemver(t *testing.T) {
+	testCases := []struct {
+		name        string
+		tag         string
+		expectedVer *Version
+		expectError bool
+	}{
+		{
+			name: "Standard version",
+			tag:  "v1.2.3",
+			expectedVer: &Version{
+				Major: 1,
+				Minor: 2,
+				Patch: 3,
+			},
+		},
+		{
+			name: "Pre-release version",
+			tag:  "v1.2.3-rc",
+			expectedVer: &Version{
+				Major:         1,
+				Minor:         2,
+				Patch:         3,
+				PreRelease:    "rc",
+				PreReleaseNum: 0,
+			},
+		},
+		{
+			name: "Pre-release version",
+			tag:  "v1.2.3-rc.1",
+			expectedVer: &Version{
+				Major:         1,
+				Minor:         2,
+				Patch:         3,
+				PreRelease:    "rc",
+				PreReleaseNum: 1,
+			},
+		},
+		{
+			name: "Build metadata version",
+			tag:  "v1.2.3+21AF26D3",
+			expectedVer: &Version{
+				Major:         1,
+				Minor:         2,
+				Patch:         3,
+				PreRelease:    "",
+				PreReleaseNum: 0,
+			},
+		},
+		{
+			name:        "Invalid version",
+			tag:         "invalid-tag",
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			version, err := ParseSemver(tc.tag)
+
+			if tc.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expectedVer, version)
+			}
+		})
+	}
+}
+
+func TestCompareSemver(t *testing.T) {
+	testCases := []struct {
+		name     string
+		v1       *Version
+		v2       *Version
+		expected bool
+	}{
+		{
+			name:     "v1 major version higher",
+			v1:       &Version{Major: 2, Minor: 0, Patch: 0},
+			v2:       &Version{Major: 1, Minor: 9, Patch: 9},
+			expected: true,
+		},
+		{
+			name:     "v1 minor version higher",
+			v1:       &Version{Major: 1, Minor: 2, Patch: 0},
+			v2:       &Version{Major: 1, Minor: 1, Patch: 9},
+			expected: true,
+		},
+		{
+			name:     "v1 patch version higher",
+			v1:       &Version{Major: 1, Minor: 1, Patch: 2},
+			v2:       &Version{Major: 1, Minor: 1, Patch: 1},
+			expected: true,
+		},
+		{
+			name:     "v1 pre-release version higher",
+			v1:       &Version{Major: 1, Minor: 1, Patch: 1, PreRelease: "rc", PreReleaseNum: 2},
+			v2:       &Version{Major: 1, Minor: 1, Patch: 1, PreRelease: "rc", PreReleaseNum: 1},
+			expected: true,
+		},
+		{
+			name:     "Identical versions",
+			v1:       &Version{Major: 1, Minor: 1, Patch: 1},
+			v2:       &Version{Major: 1, Minor: 1, Patch: 1},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := CompareSemver(tc.v1, tc.v2)
+			assert.Equal(t, tc.expected, result)
+		})
+	}
+}
+
+func TestCalculateNextVersion(t *testing.T) {
+	testCases := []struct {
+		name        string
+		currentTag  string
+		incMajor    bool
+		incMinor    bool
+		incPatch    bool
+		suffix      string
+		allTags     []string
+		expectedTag string
+		expectError bool
+	}{
+		{
+			name:        "Invalid tag format",
+			currentTag:  "invalid-tag",
+			expectError: true,
+		},
+		{
+			name:        "Next tag already exists error",
+			currentTag:  "v1.2.3",
+			allTags:     []string{"v1.2.3", "v1.3.0"},
+			expectedTag: "v1.2.4",
+		},
+		{
+			name:        "Patch increment",
+			currentTag:  "v1.2.3",
+			expectedTag: "v1.2.4",
+		},
+		{
+			name:        "Patch increment with incPatch",
+			currentTag:  "v1.2.3",
+			incPatch:    true,
+			expectedTag: "v1.2.4",
+		},
+		{
+			name:        "Patch increment with suffix",
+			currentTag:  "v1.2.3",
+			incPatch:    true,
+			suffix:      "alpha",
+			expectedTag: "v1.2.4-alpha",
+		},
+		{
+			name:        "Minor increment",
+			currentTag:  "v1.2.3",
+			incMinor:    true,
+			expectedTag: "v1.3.0",
+		},
+		{
+			name:        "Minor increment with suffix",
+			currentTag:  "v1.2.3",
+			incMinor:    true,
+			suffix:      "alpha",
+			expectedTag: "v1.3.0-alpha",
+		},
+		{
+			name:        "Major increment",
+			currentTag:  "v1.2.3",
+			incMajor:    true,
+			expectedTag: "v2.0.0",
+		},
+		{
+			name:        "Major increment with suffix",
+			currentTag:  "v1.2.3",
+			incMajor:    true,
+			suffix:      "alpha",
+			expectedTag: "v2.0.0-alpha",
+		},
+		{
+			name:        "Pre-release increment with pre-release version",
+			currentTag:  "v1.2.3-rc.1",
+			suffix:      "rc",
+			expectedTag: "v1.2.3-rc.2",
+		},
+		{
+			name:        "Pre-release increment with patch version",
+			currentTag:  "v1.2.3-rc.1",
+			incPatch:    true,
+			expectedTag: "v1.2.4-rc",
+		},
+		{
+			name:        "Pre-release increment with minor version",
+			currentTag:  "v1.2.3-rc.1",
+			incMinor:    true,
+			expectedTag: "v1.3.0-rc",
+		},
+		{
+			name:        "Pre-release increment with major version",
+			currentTag:  "v1.2.3-rc.1",
+			incMajor:    true,
+			expectedTag: "v2.0.0-rc",
+		},
+		{
+			name:        "Pre-release without number",
+			currentTag:  "v1.2.3-rc",
+			expectedTag: "v1.2.3-rc.1",
+		},
+		{
+			name:        "Add suffix to version",
+			currentTag:  "v1.2.3",
+			suffix:      "beta",
+			expectedTag: "v1.2.3-beta",
+		},
+		{
+			name:        "Add suffix to pre-release version",
+			currentTag:  "v1.1.1-beta",
+			suffix:      "beta",
+			expectedTag: "v1.1.1-beta.1",
+		},
+		{
+			name:        "Override existing pre-release with suffix",
+			currentTag:  "v1.2.3-rc.1",
+			suffix:      "beta",
+			expectedTag: "v1.2.3-beta.1",
+		},
+		{
+			name:        "Override existing pre-release with suffix",
+			currentTag:  "v1.2.3-rc.1",
+			suffix:      "beta",
+			allTags:     []string{"v1.2.3-rc.1", "v1.2.3-beta.2"},
+			expectedTag: "v1.2.3-beta.3",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			nextVersion, err := CalculateNextVersion(tc.currentTag, tc.allTags, tc.incMajor, tc.incMinor, tc.incPatch, tc.suffix)
+
+			if tc.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expectedTag, nextVersion)
+			}
+		})
+	}
+}