main.go

package main

import (
	"errors"
	"flag"
	"fmt"
	"io"
	"io/fs"
	"math/rand/v2"
	"os"
	"path/filepath"
	"syscall"

	"github.com/linkdata/gitsemver/internal/gitsemver"
)

var writeFileFn = os.WriteFile
var removeFileFn = os.Remove

func replaceFile(source, target string) (err error) {
	bakname := fmt.Sprintf("%s.gitsemver-%x", target, rand.Uint64())                                       // #nosec G404
	if renameerr := os.Rename(target, bakname); renameerr == nil || errors.Is(renameerr, fs.ErrNotExist) { // #nosec G703
		if err = os.Rename(source, target); err == nil { // #nosec G703
			if renameerr == nil {
				// The replacement already succeeded. Treat backup deletion as best-effort.
				_ = removeFileFn(bakname) // #nosec G703
			}
			return
		}
		if renameerr == nil {
			_ = os.Rename(bakname, target)
		}
	} else {
		err = renameerr
	}
	return
}

func prepareOutput(fileName, content string) (publish func() error, cleanup func(), err error) {
	cleanup = func() {}
	publish = func() error {
		_, err := os.Stdout.WriteString(content)
		return err
	}
	if fileName != "" {
		fileName = filepath.Clean(fileName)
		if fi, statErr := os.Stat(fileName); statErr == nil { // #nosec G703
			if fi.IsDir() {
				err = fmt.Errorf("%q is a directory", fileName)
				return
			}
		} else if !errors.Is(statErr, fs.ErrNotExist) {
			err = statErr
			return
		}
		// File output is always staged: write to temp first, then publish by replace.
		var f *os.File
		if f, err = os.CreateTemp(filepath.Dir(fileName), filepath.Base(fileName)+".gitsemver-*"); err == nil {
			tempFile := f.Name()
			_ = f.Close()
			cleanup = func() {
				_ = os.Remove(tempFile) // #nosec G703
			}
			if err = writeFileFn(tempFile, []byte(content), 0o600); err == nil {
				publish = func() error {
					return replaceFile(tempFile, fileName)
				}
				return
			}
			cleanup()
		}
	}
	return
}

var (
	flagGit       = flag.String("git", "git", "path to Git executable")
	flagOut       = flag.String("out", "", "write to file instead of stdout (relative paths are relative to repo)")
	flagName      = flag.String("name", "", "set the PkgName used in gopackage, default is to use last portion of module in go.mod")
	flagPackage   = flag.String("package", "", "override the go package used in gopackage, default is to use last portion of module in go.mod")
	flagDebug     = flag.Bool("debug", false, "write debug info to stderr")
	flagGoPackage = flag.Bool("gopackage", false, "write Go source with PkgName and PkgVersion")
	flagNoFetch   = flag.Bool("nofetch", false, "don't fetch remote tags")
	flagNoNewline = flag.Bool("nonewline", false, "don't print a newline after the output")
	flagIncPatch  = flag.Bool("incpatch", false, "increment the patch level and create a new tag")
	flagIncMinor  = flag.Bool("incminor", false, "increment the minor level and create a new tag")
	flagBranch    = flag.Bool("branch", false, "print the current branch name")
	flagVersion   = flag.Bool("version", false, "print the version of gitsemver and exit")
)

var exitFn func(int) = os.Exit
var testMode bool

func exitCodeForError(err error) int {
	retv := 125
	var errno syscall.Errno
	if errors.As(err, &errno) {
		retv = int(errno) // #nosec G115
	}
	return retv
}

func mainfn() int {
	repoDir := os.ExpandEnv(flag.Arg(0))
	if repoDir == "" {
		repoDir = "."
	}

	var debugOut io.Writer
	if *flagDebug {
		debugOut = os.Stderr
	}

	if *flagVersion {
		fmt.Println(gitsemver.PkgName, gitsemver.PkgVersion)
		return 0
	}

	vs, err := gitsemver.New(*flagGit, debugOut)
	if err == nil {
		var createTag string
		if repoDir, err = vs.Git.CheckGitRepo(repoDir); err == nil {
			if !*flagNoFetch {
				err = vs.Git.FetchTags(repoDir)
			}
			if err == nil {
				var vi gitsemver.VersionInfo
				if vi, err = vs.GetVersion(repoDir); err == nil {
					if *flagIncPatch && *flagIncMinor {
						err = errors.New("cannot use both -incpatch and -incminor")
					}
					if err == nil && (*flagIncPatch || *flagIncMinor) {
						var clean bool
						if clean, err = vs.Git.CleanStatus(repoDir, true); err == nil {
							if clean {
								if *flagIncPatch {
									createTag = vi.IncPatch()
								}
								if *flagIncMinor {
									createTag = vi.IncMinor()
								}
								if testMode {
									createTag = ""
								}
							} else {
								err = errors.New("cannot bump version with uncommitted changes")
							}
						}
					}
					content := vi.Version()
					if *flagBranch {
						content = vi.Branch
					}
					if *flagGoPackage {
						content, err = vi.GoPackage(repoDir, *flagName, *flagPackage, createTag)
					}
					if err == nil {
						outpath := os.ExpandEnv(*flagOut)
						if outpath != "" && !filepath.IsAbs(outpath) {
							outpath = filepath.Join(repoDir, outpath)
						}
						if !*flagNoNewline {
							content += "\n"
						}
						var publish func() error
						var cleanup func()
						if publish, cleanup, err = prepareOutput(outpath, content); err == nil {
							defer cleanup()
							var preRunHead, afterHead string
							if preRunHead, err = vs.Git.GetHead(repoDir, createTag == ""); err == nil {
								if err = publish(); err == nil {
									if err = vs.Git.Commit(repoDir, outpath, createTag); err == nil {
										if afterHead, err = vs.Git.GetHead(repoDir, createTag == ""); err == nil {
											if err = vs.Git.CreateTag(repoDir, createTag); err == nil {
												if err = vs.Git.PushTag(repoDir, createTag); err == nil {
													return 0
												}
												// remove the tag
												err = errors.Join(err, vs.Git.DeleteTag(repoDir, createTag))
												err = errors.Join(err, vs.Git.DeleteRemoteTag(repoDir, createTag))
											}
										}
									}
									// revert the commit
									if outpath != "" && preRunHead != afterHead {
										err = errors.Join(err, vs.Git.ResetHard(repoDir, preRunHead))
									}
								}
							}
						}
					}
				}
			}
		}
	}

	fmt.Fprintln(os.Stderr, err.Error()) // #nosec G705
	return exitCodeForError(err)
}

func main() {
	flag.Parse()
	exitFn(mainfn())
}