Jonathan Bernard
281 lines
9.0 KiB
Nim
281 lines
9.0 KiB
Nim
import std/[dirs, json, paths, sequtils, strutils, syncio, tables]
|
|
import std/nre except toSeq
|
|
import docopt, zero_functional
|
|
|
|
const USAGE = """Usage:
|
|
update_nim_package_version bump <part> [<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:
|
|
|
|
-d, --dir <dir> Use the given directory as the project root (defaults
|
|
to the current working directory).
|
|
|
|
-l, --lang <language> Choose the language/ecosystem to consider. Valid
|
|
values are: 'nim' or 'node'. If not provided, this
|
|
is auto-detected by the presence of either a *.nimble
|
|
or package.json file.
|
|
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 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
|
|
|
|
get
|
|
|
|
Just return the existing version.
|
|
|
|
interactive
|
|
|
|
Update the version interactively.
|
|
|
|
<src-file>
|
|
|
|
Sometimes it is useful to encode the version in source files via constants.
|
|
Passing arguments as <src-files> instructs update_version to modify these
|
|
source files directly. It does so by matching constant assignments via
|
|
regex and replacing the previous version string with the new version
|
|
string. When inspecting the provided files, update_version matches the
|
|
following patterns for constanst assignments to consider:
|
|
|
|
const <package-name>_VERSION* = "<prev-version-string>"
|
|
export const <package-name>_VERSION = "<prev-version-string>"
|
|
|
|
Specifically it uses the following regexes:
|
|
|
|
TODO
|
|
"""
|
|
|
|
const UV_VERSION = "1.0.0"
|
|
|
|
type
|
|
LangType = enum lNim, lNode
|
|
SemVerParts = enum major, minor, patch, prerelease, buildmetadata
|
|
|
|
type PackageVersion = object
|
|
file: Path
|
|
version: string
|
|
name: string
|
|
|
|
case lang: LangType
|
|
of lNim:
|
|
lines: seq[string]
|
|
versionLine: int
|
|
of lNode:
|
|
nodePackage: JsonNode
|
|
|
|
|
|
# Taken from
|
|
# https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
|
|
#
|
|
# 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-]+)*))?$"
|
|
|
|
proc parseNimblePackage(dir: Path): PackageVersion =
|
|
result = PackageVersion(lang: lNim)
|
|
|
|
for fe in walkDir(dir):
|
|
if fe.kind == pcFile and
|
|
fe.path.splitFile.ext == ".nimble":
|
|
|
|
result.lines = readFile($fe.path).splitLines
|
|
for idx, l in result.lines:
|
|
if l.startsWith("version"):
|
|
result.versionLine = idx
|
|
result.version = l.split("=")[^1].strip(chars = {' ', '"'})
|
|
result.name = $fe.path.splitFile.name
|
|
result.file = fe.path
|
|
return result
|
|
|
|
raise newException(IOError, "No valid .nimble file found in $#" % [$dir])
|
|
|
|
|
|
proc parseNodePackage(dir: Path): PackageVersion =
|
|
result = PackageVersion(
|
|
file: dir / Path("package.json"),
|
|
lang: lNode,
|
|
nodePackage: parseFile($result.file))
|
|
|
|
if not result.nodePackage.hasKey("name") or
|
|
not result.nodePackage.hasKey("version") or
|
|
result.nodePackage["name"].kind != JString or
|
|
result.nodePackage["version"].kind != JString:
|
|
raise newException(ValueError,
|
|
"package.json does not have valid 'name' and 'version' fields.")
|
|
|
|
result.name = result.nodePackage{"name"}.getStr
|
|
result.version = result.nodePackage{"version"}.getStr
|
|
|
|
|
|
proc detectAndParsePackage(dir: Path): PackageVersion =
|
|
try: result = parseNimblePackage(dir)
|
|
except:
|
|
let nimEx = getCurrentException()
|
|
try: result = parseNodePackage(dir)
|
|
except:
|
|
let nodeEx = getCurrentException()
|
|
stderr.writeLine(
|
|
"Unable to find a package definitions file. Errors:\n\t$#\n\t$#" %
|
|
[nimEx.msg, nodeEx.msg])
|
|
|
|
|
|
proc writePackage(pkg: PackageVersion) =
|
|
if pkg.lang == lNim:
|
|
var lines = pkg.lines
|
|
lines[pkg.versionLine] = "version = \"$#\"" % pkg.version
|
|
writeFile($pkg.file, lines.join("\p"))
|
|
elif pkg.lang == lNode:
|
|
pkg.nodePackage["version"] = %pkg.version
|
|
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])
|
|
return
|
|
version[0..<lastVersionPartMatch.captureBounds[1].a] &
|
|
$(lastVersionPartInt + 1) &
|
|
version[lastVersionPartMatch.captureBounds[1].b+1 .. ^1]
|
|
|
|
|
|
let VERSION_DEFAULTS: TableRef[SemVerParts, string] = newTable([
|
|
(major, "0"),
|
|
(minor, "0"),
|
|
(patch, "0"),
|
|
(prerelease, ""),
|
|
(buildmetadata, "")])
|
|
|
|
|
|
proc incrementSemverPart(
|
|
version: string,
|
|
part: SemVerParts,
|
|
defaults = VERSION_DEFAULTS): string =
|
|
|
|
result = ""
|
|
|
|
let matchOpt = match(version, SemVerPattern)
|
|
|
|
if matchOpt.isNone:
|
|
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:
|
|
if m.captures.contains($p):
|
|
versionParts[p] = incrementLastVersionPart(m.captures[$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]
|
|
|
|
|
|
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(".")
|
|
|
|
var pkg =
|
|
if args["--lang"] and $args["--lang"] == "nim":
|
|
parseNimblePackage(dir)
|
|
elif args["--lang"] and $args["--lang"] == "node":
|
|
parseNodePackage(dir)
|
|
else:
|
|
detectAndParsePackage(dir)
|
|
|
|
if args["bump"]:
|
|
if $args["<part>"] == "last":
|
|
pkg.version = incrementLastVersionPart(pkg.version)
|
|
else:
|
|
let part = parseEnum[SemVerParts]($args["<part>"])
|
|
pkg.version = incrementSemverPart(pkg.version, part)
|
|
|
|
writePackage(pkg)
|
|
echo pkg.version
|
|
|
|
elif args["set"]:
|
|
pkg.version = $args["<new-version>"]
|
|
writePackage(pkg)
|
|
echo pkg.version
|
|
|
|
elif args["get"]: echo pkg.version
|
|
|
|
elif args["interactive"]:
|
|
var acceptNewVersion = false
|
|
var newVersion = pkg.version
|
|
while not acceptNewVersion:
|
|
stdout.writeLine "Current version is " & pkg.version
|
|
stdout.write "New version? "
|
|
newVersion = 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)
|
|
|
|
pkg.version = newVersion
|
|
echo "Updating version definition in " & $pkg.file
|
|
writePackage(pkg)
|
|
|
|
# TODO:
|
|
# for f in filesToUpdate:
|
|
# echo "Updating version definition in " & $f
|
|
# updateVersionInFile(f)
|