Migrate to nitely/nim-regex away from std/nre.

- Move unittests to a dedicated file.
- Rework CLI making version part selection an option that can be passed
  into many commands.
- Add support for updates to version constants defined in soruce files.

.gitea/workflows/pr-validation.yaml

@@ -0,0 +1,34 @@
+---
+name: PR Validation
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  unittest:
+    name: Unit Tests
+    runs-on: [pbm_api_cicd]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4
+
+      - name: Cache dependecies
+        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684  # v4
+        with:
+          path: |
+            ~/.nimble
+          key: ${{ runner.os }}-nimble-${{ hashFiles('update_version.nimble') }}
+        restore-keys: |
+          ${{ runner.os }}-nimble-
+
+      - name: Build unittests
+        run: |
+          printf "🔨\033[0;32m Compiling unit tests...\033[0m\n" >&1
+          nimble c tupdate_version.nim
+
+      - name: Run unittests
+        run: |
+          printf "🧪\033[0;32m Running unit tests...\033[0m\n" >&1
+          ./tupdate_version

.gitignore

@@ -1,2 +1,3 @@
 .*sw?
 update_version
+tupdate_version

tupdate_version.nim

@@ -0,0 +1,98 @@
+import std/[paths, tables, unittest]
+import ./update_version
+
+suite "update_version":
+
+  test "incrementLastVersionPart":
+    check:
+      incrementLastVersionPart("1.0.0") == "1.0.1"
+      incrementLastVersionPart("1.0.0-alpha.1") == "1.0.0-alpha.2"
+      incrementLastVersionPart("cicd_alpha.1-prerelease") == "cicd_alpha.2-prerelease"
+      incrementLastVersionPart("2024.04.1") == "2024.04.2"
+
+  test "incrementSemverPart":
+    check:
+      incrementSemverPart("1.0.0", major) == "2.0.0"
+      incrementSemverPart("1.0.0", minor) == "1.1.0"
+      incrementSemverPart("1.0.0", patch) == "1.0.1"
+      incrementSemverPart("1.5.10", patch) == "1.5.11"
+      incrementSemverPart("1.5.10", minor) == "1.6.0"
+      incrementSemverPart("1.5.10-alpha.1", prerelease) == "1.5.10-alpha.2"
+      incrementSemverPart("1.5.10-alpha.1+build.10", prerelease) == "1.5.10-alpha.2"
+      incrementSemverPart("1.5.10-alpha.1+build.10", buildmetadata) == "1.5.10-alpha.1+build.11"
+      incrementSemverPart("1.5.10", buildmetadata) == "1.5.10+build.0"
+
+  test "fmtSemver":
+    check:
+      fmtSemver(newTable([
+          (major, "5"), (minor, "2"), (patch, "62"),
+          (prerelease, "alpha.59"), (buildmetadata, "githash_123098")])) ==
+        "5.2.62-alpha.59+githash_123098"
+
+  test "setLastVersionPart":
+    check:
+      setLastVersionPart("1.0.0", "5") == "1.0.5"
+      setLastVersionPart("cicd.2", "3-alpha.1") == "cicd.3-alpha.1"
+
+  test "setSemverPart":
+    check:
+      setSemverPart("1.4.2-alpha.5+a3e4b69", minor, "7") == "1.7.0"
+      setSemverPart("1.4.2-alpha.5+a3e4b69", major, "3") == "3.0.0"
+      setSemverPart("1.4.2-alpha.5+a3e4b69", prerelease, "beta.1") == "1.4.2-beta.1"
+      setSemverPart("1.4.2-alpha.5+a3e4b69", buildmetadata, "testbuild") == "1.4.2-alpha.5+testbuild"
+
+  test "replaceVersionInSource - Nim":
+    let pkgVersion = PackageVersion(
+      lang: lNim,
+      file: Path("./testpackage.nimble"),
+      version: "1.0.3",
+      name: "testpackage")
+
+    let source = """
+import std/[sequtils, strutils]
+
+const IGNORED_VERSION* = "1.0.0"
+const OTHER_PKG_VERSION* = "4.2.1"
+const TESTPKG_VERSION* = "1.0.2"
+
+when isMainModule:
+  echo "sample file"
+"""
+
+    check replaceVersionInSource(source, pkgVersion, "1.0.2") == """
+import std/[sequtils, strutils]
+
+const IGNORED_VERSION* = "1.0.0"
+const OTHER_PKG_VERSION* = "4.2.1"
+const TESTPKG_VERSION* = "1.0.3"
+
+when isMainModule:
+  echo "sample file"
+"""
+
+  test "replaceVersionInSource - JavaScript":
+    let pkgVersion = PackageVersion(
+      lang: lNode,
+      file: Path("./package.json"),
+      version: "1.0.3",
+      name: "testpackage")
+
+    let source = """
+import { createApp } from 'vue'
+import './styles/main.css'
+import App from './App.vue'
+
+export const TESTPACKAGE_VERSION = "1.0.2"
+
+createApp(App)
+"""
+
+    check replaceVersionInSource(source, pkgVersion, "1.0.2") == """
+import { createApp } from 'vue'
+import './styles/main.css'
+import App from './App.vue'
+
+export const TESTPACKAGE_VERSION = "1.0.3"
+
+createApp(App)
+"""

update_version.nim

@@ -1,13 +1,11 @@
 import std/[dirs, json, paths, sequtils, strutils, syncio, tables]
-import std/nre except toSeq
-import docopt, zero_functional
+import docopt, regex, zero_functional
 
 const USAGE = """Usage:
-  update_nim_package_version bump <part> [<src-file> ...] [options]
+  update_nim_package_version bump [<src-file> ...] [options]
   update_nim_package_version set <new-version> [<src-file> ...] [options]
   update_nim_package_version get [<src-file> ...] [options]
   update_nim_package_version interactive [<src-file> ...] [options]
-  update_nim_package_version test
 
 Options:
 
@@ -18,22 +16,47 @@ Options:
                           values are: 'nim' or 'node'. If not provided, this
                           is auto-detected by the presence of either a *.nimble
                           or package.json file.
+
+  -p, --part <part>       Choose which part of the version string to set or
+                          bump. Valid options are: 'major', 'minor', 'patch',
+                          'prerelease', 'buildmetadata', and 'last'. Defaults
+                          to 'last'
+
+  --skip-package-file     Don't write changes to the package file (*.nimble or
+                          package.json). This is useful mostly in temporary
+                          circumstances where you want to update other source
+                          files without updating the package file. Be careful
+                          in these cases, however, as update_version uses the
+                          current version (as reported in the package file) as
+                          the canonical version. When updating versions in
+                          other source files, update_version ignores lines that
+                          do not match the current version. Consider the
+                          following:
+
+                              update_version set 1.0.4 file1.nim, file2.nim --skip-package-file # works
+                              update_version set 1.0.0 file1.nim, file2.nim --skip-package-file # fails
+
+                          The second command will *not* rewrite the version
+                          strings in file1.nim and file2.nim because the
+                          versions in those files (1.0.4) do not match what is
+                          in the package.
 Details:
 
   bump
 
     Assuming the project with a semver-like versioning scheme, update one of
-    the version parts by one. <version-part> must be one of 'major', 'minor',
-    'patch', or 'last'. Semver looks like 'major.minor.patch' Last is a special
-    case to support looser version strings that end in '.x' like 'alpha.1' or
-    '1.5' and matches '.*(\.\d+)$'
+    the version parts by one. <part> must be one of 'major', 'minor', 'patch',
+    'prerelease', 'buildmetadata', or 'last'. Semver looks like
+    'major.minor.patch-prerelease+buildmetadata' Last is a special case to
+    support looser version strings that end in '.x' like 'alpha.1' or '1.5' and
+    matches '.*(\.\d+)$'
 
     The matched portion is interpreted as an integer and incremented by one.
 
   set
 
-    Update the version string entirely with a new string. In this case, the
-    versioning scheme of the project doesn't matter
+    Update the version string with a new string. If --part is supplied, only
+    that part is updated. Otherwise the entire version string is replaced.
 
   get
 
@@ -57,21 +80,22 @@ Details:
 
     Specifically it uses the following regexes:
 
-      TODO
+        Nim:   ^\s*const\s+\S*VERSION\S*\*?\s*=\s*"(<old-version>)"\s*$
+        Node:  ^\s*export\s+const\s+\S*VERSION\S*\s*=\s*"(<old-version>)"\s*;?$
 """
 
-const UV_VERSION = "1.0.0"
+const UV_VERSION = "1.2.2"
 
 type
-  LangType = enum lNim, lNode
-  SemVerParts = enum major, minor, patch, prerelease, buildmetadata
+  LangType* = enum lNim, lNode
+  SemverParts* = enum major, minor, patch, prerelease, buildmetadata
 
-type PackageVersion = object
-  file: Path
-  version: string
-  name: string
+type PackageVersion* = object
+  file*: Path
+  version*: string
+  name*: string
 
-  case lang: LangType
+  case lang*: LangType
   of lNim:
     lines: seq[string]
     versionLine: int
@@ -85,8 +109,28 @@ type PackageVersion = object
 # See also:
 #   https://regex101.com/r/Ly7O1x/3/
 #
-let SemVerPattern =
-  re"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
+const SemverRegex =
+  re2"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
+
+let NimConstPattern = "^\\s*const\\s+\\S*VERSION\\S*\\*?\\s*=\\s*\"($#)\"\\s*$"
+let NodeConstPattern =
+  "^\\s*export\\s+const\\s+\\S*VERSION\\S*\\s*=\\s*\"($#)\"\\s*;?$"
+
+let VERSION_DEFAULTS: TableRef[SemverParts, string] = newTable([
+  (major, "0"),
+  (minor, "0"),
+  (patch, "0"),
+  (prerelease, ""),
+  (buildmetadata, "")])
+
+
+proc parseSemverPart(str: string): SemverParts =
+  try: parseEnum[SemverParts](str)
+  except:
+    stderr.writeLine(
+      "update_version: Invalid --part value: '" & str & "'. Valid values are:" &
+      "\n\tmajor, minor, patch, prerelease, buildmetadata, last")
+    quit(QuitFailure)
 
 proc parseNimblePackage(dir: Path): PackageVersion =
   result = PackageVersion(lang: lNim)
@@ -110,8 +154,9 @@ proc parseNimblePackage(dir: Path): PackageVersion =
 proc parseNodePackage(dir: Path): PackageVersion =
   result = PackageVersion(
     file: dir / Path("package.json"),
-    lang: lNode,
-    nodePackage: parseFile($result.file))
+    lang: lNode)
+
+  result.nodePackage = parseFile($result.file)
 
   if not result.nodePackage.hasKey("name") or
      not result.nodePackage.hasKey("version") or
@@ -129,7 +174,7 @@ proc detectAndParsePackage(dir: Path): PackageVersion =
   except:
     let nimEx = getCurrentException()
     try: result = parseNodePackage(dir)
-    except:
+    except Exception:
       let nodeEx = getCurrentException()
       stderr.writeLine(
         "Unable to find a package definitions file.  Errors:\n\t$#\n\t$#" %
@@ -146,89 +191,116 @@ proc writePackage(pkg: PackageVersion) =
     writeFile($pkg.file, pkg.nodePackage.pretty)
 
 
-proc incrementLastVersionPart(version: string): string =
-  let versionParts = toSeq(findIter(version, re"([^\d.]+)?\.?(\d+)"))
-  let lastVersionPartMatch = versionParts[^1]
-  let lastVersionPartInt = parseInt(lastVersionPartMatch.captures[1])
+proc replaceVersionInSource*(
+    source: string,
+    pkg: PackageVersion,
+    vOld: string): string =
+
+  let rgx =
+    case pkg.lang
+    of lNim: re2(NimConstPattern % [vOld.replace(".", "\\.")])
+    of lNode: re2(NodeConstPattern % [vOld.replace(".", "\\.")])
+
+  var newLines = newSeq[string]()
+  for l in source.splitLines():
+    var m = RegexMatch2()
+    if match(l, rgx, m):
+      newLines.add(
+        l[0..<m.group(0).a] &
+        pkg.version &
+        l[m.group(0).b+1 .. ^1])
+    else: newLines.add(l)
+
+  return newLines.join("\p")
+
+proc replaceVersionInFile(file: Path, pkg: PackageVersion, vOld: string) =
+  writeFile($file, replaceVersionInSource(readFile($file), pkg, vOld))
+
+
+proc fmtSemver*(semver: TableRef[SemverParts, string]): string =
+  result = "$#.$#.$#" % [
+    semver[major], semver[minor], semver[patch] ]
+
+  if semver[prerelease].len > 0:
+    result &= "-" & semver[prerelease]
+
+  if semver[buildmetadata].len > 0:
+    result &= "+" & semver[buildmetadata]
+
+
+
+proc setLastVersionPart*(version: string, newVersion: string): string =
+  let versionParts = findAll(version, re2"([^\d.]+)?\.?(\d+)")
+  let lastVersionPart = versionParts[^1]
   return
-    version[0..<lastVersionPartMatch.captureBounds[1].a] &
-    $(lastVersionPartInt + 1) &
-    version[lastVersionPartMatch.captureBounds[1].b+1 .. ^1]
+    version[0..<lastVersionPart.group(1).a] &
+    newVersion &
+    version[lastVersionPart.group(1).b+1 .. ^1]
 
 
-let VERSION_DEFAULTS: TableRef[SemVerParts, string] = newTable([
-  (major, "0"),
-  (minor, "0"),
-  (patch, "0"),
-  (prerelease, ""),
-  (buildmetadata, "")])
-
-
-proc incrementSemverPart(
+proc setSemverPart*(
     version: string,
-    part: SemVerParts,
+    part: SemverParts,
+    newVersionPart: string,
     defaults = VERSION_DEFAULTS): string =
 
-  result = ""
-
-  let matchOpt = match(version, SemVerPattern)
-
-  if matchOpt.isNone:
+  var m: RegexMatch2
+  if not match(version, SemverRegex, m):
     raise newException(ValueError,
       "Version [$#] is not a valid Semantic Version number" % version)
 
-  let m = matchOpt.get
+  let versionParts = newTable[SemverParts, string]()
+  for p in SemverParts.items:
+    if p == part: versionParts[p] = newVersionPart
+    elif m.group($p).b < m.group($p).a or p > part: versionParts[p] = defaults[p]
+    else: versionParts[p] = version[m.group($p)]
 
-  let versionParts = newTable[SemVerParts, string]()
-  for p in SemVerParts.items:
+  result = fmtSemver(versionParts)
+  if not match(result, SemverRegex):
+    raise newException(ValueError,
+      "Refusing to update: Version [$#] would not be a valid Semantic Version number" % result)
+
+
+proc incrementLastVersionPart*(version: string): string =
+  let versionParts = findAll(version, re2"([^\d.]+)?\.?(\d+)")
+  let lastVersionPart = versionParts[^1]
+  let lastVersionPartInt = parseInt(version[lastVersionPart.group(1)])
+
+  return
+    version[0..<lastVersionPart.group(1).a] &
+    $(lastVersionPartInt + 1) &
+    version[lastVersionPart.group(1).b+1 .. ^1]
+
+
+proc incrementSemverPart*(
+    version: string,
+    part: SemverParts,
+    defaults = VERSION_DEFAULTS): string =
+
+  var m: RegexMatch2
+  if not match(version, SemverRegex, m):
+    raise newException(ValueError,
+      "Version [$#] is not a valid Semantic Version number" % version)
+
+  let versionParts = newTable[SemverParts, string]()
+  for p in SemverParts.items:
     if p == part:
-      if m.captures.contains($p):
-        versionParts[p] = incrementLastVersionPart(m.captures[$p])
+      if not m.group($p).b < m.group($p).a:
+        versionParts[p] = incrementLastVersionPart(version[m.group($p)])
       elif p < prerelease or defaults[p].len > 0:
         versionParts[p] = defaults[p]
       # if this part specifically has been requested to be incremented but
       # the default is empty, we are still going to give it *something*
       elif p == prerelease:     versionParts[p] = "prerelease.0"
       elif p == buildmetadata:  versionParts[p] = "build.0"
-    elif not m.captures.contains($p) or p > part: versionParts[p] = defaults[p]
-    else: versionParts[p] = m.captures[$p]
-
-  result = "$#.$#.$#" % [
-    versionParts[major], versionParts[minor], versionParts[patch] ]
-
-  if versionParts[prerelease].len > 0:
-    result &= "-" & versionParts[prerelease]
-
-  if versionParts[buildmetadata].len > 0:
-    result &= "+" & versionParts[buildmetadata]
+    elif m.group($p).b < m.group($p).a or p > part: versionParts[p] = defaults[p]
+    else: versionParts[p] = version[m.group($p)]
 
+  return fmtSemver(versionParts)
 
 when isMainModule:
   let args = docopt(USAGE, version = UV_VERSION)
 
-  if args["test"]:
-
-    # incrementLastVersionPart
-    assert incrementLastVersionPart("1.0.0") == "1.0.1"
-    assert incrementLastVersionPart("1.0.0-alpha.1") == "1.0.0-alpha.2"
-    assert incrementLastVersionPart("cicd_alphe.1-prerelease") == "cicd_alphe.2-prerelease"
-    assert incrementLastVersionPart("2024.04.1") == "2024.04.2"
-
-    # incrementSemverPart
-    assert incrementSemverPart("1.0.0", major) == "2.0.0"
-    assert incrementSemverPart("1.0.0", minor) == "1.1.0"
-    assert incrementSemverPart("1.0.0", patch) == "1.0.1"
-    assert incrementSemverPart("1.5.10", patch) == "1.5.11"
-    assert incrementSemverPart("1.5.10", minor) == "1.6.0"
-    assert incrementSemverPart("1.5.10-alpha.1", prerelease) == "1.5.10-alpha.2"
-    assert incrementSemverPart("1.5.10-alpha.1+build.10", prerelease) == "1.5.10-alpha.2"
-    assert incrementSemverPart("1.5.10-alpha.1+build.10", buildmetadata) == "1.5.10-alpha.1+build.11"
-    assert incrementSemverPart("1.5.10", buildmetadata) == "1.5.10+build.0"
-
-    echo "All tests passed."
-    quit(QuitSuccess)
-
-
   let dir =
     if args["--dir"]: Path($args["--dir"])
     else: Path(".")
@@ -241,18 +313,41 @@ when isMainModule:
     else:
       detectAndParsePackage(dir)
 
+  let oldVersion = pkg.version
+
   if args["bump"]:
-    if $args["<part>"] == "last":
+    let partName =
+      if args["--part"]: $args["--part"]
+      else: "last"
+
+    if partName == "last":
       pkg.version = incrementLastVersionPart(pkg.version)
     else:
-      let part = parseEnum[SemVerParts]($args["<part>"])
+      let part = parseSemverPart(partName)
       pkg.version = incrementSemverPart(pkg.version, part)
 
+    if not args["--skip-package-file"]:
       writePackage(pkg)
+
+    for filePath in args["<src-file>"]:
+      replaceVersionInFile(Path(filePath), pkg, oldVersion)
+
     echo pkg.version
 
   elif args["set"]:
+
+    if not args["--part"]:
       pkg.version = $args["<new-version>"]
+    elif $args["--part"] == "last":
+      pkg.version = setLastVersionPart(pkg.version, $args["<new-version>"])
+    else:
+      let part = parseSemverPart($args["--part"])
+      pkg.version = setSemverPart(pkg.version, part, $args["<new-version>"])
+
+    for filePath in args["<src-file>"]:
+      replaceVersionInFile(Path(filePath), pkg, oldVersion)
+
+    if not args["--skip-package-file"]:
       writePackage(pkg)
     echo pkg.version
 
@@ -260,21 +355,19 @@ when isMainModule:
 
   elif args["interactive"]:
     var acceptNewVersion = false
-    var newVersion = pkg.version
     while not acceptNewVersion:
-      stdout.writeLine "Current version is " & pkg.version
+      stdout.writeLine "Current version is " & oldVersion
       stdout.write "New version? "
-      newVersion  = stdin.readLine
+      pkg.version  = stdin.readLine
 
       stdout.write "New version will be set to '" & pkg.version & "'. Is this correct (yes/no)? "
       let isCorrect = stdin.readLine
-      let acceptNewVersion = "yes".startsWith(isCorrect.toLower)
+      acceptNewVersion = "yes".startsWith(isCorrect.toLower)
 
-    pkg.version = newVersion
+    if not args["--skip-package-file"]:
       echo "Updating version definition in " & $pkg.file
       writePackage(pkg)
 
-    # TODO:
-    # for f in filesToUpdate:
-    #   echo "Updating version definition in " & $f
-    #   updateVersionInFile(f)
+    for filePath in args["<src-file>"]:
+      echo "Updating version definition in " & $filePath
+      replaceVersionInFile(Path(filePath), pkg, oldVersion)

update_version.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version       = "1.0.1"
+version       = "1.2.2"
 author        = "Jonathan Bernard"
 description   = "Small util to update version consistently for nim and node packages."
 license       = "MIT"
@@ -10,4 +10,4 @@ bin           = @["update_version"]
 
 # Dependencies
 
-requires @["nim >= 1.0.4", "docopt >= 0.7.1", "zero_functional"]
+requires @["nim >= 1.0.4", "docopt >= 0.7.1", "regex", "zero_functional"]