sys: add simple deps update checker script (#6542)
Co-authored-by: Anton Kochkov <anton.kochkov@gmail.com>
This commit is contained in:
NOT XVilka
GitHub
parent
c351d5f32a
commit
51414a4eb3
1 changed files with 768 additions and 0 deletions
768
sys/check_outdated_subprojects.py
Executable file
768
sys/check_outdated_subprojects.py
Executable file
|
|
@ -0,0 +1,768 @@
|
|||
#!/usr/bin/env python3
|
||||
# SPDX-FileCopyrightText: 2026 RizinOrg <info@rizin.re>
|
||||
# SPDX-License-Identifier: LGPL-3.0-only
|
||||
"""
|
||||
check_outdated_subprojects.py
|
||||
|
||||
Check whether Rizin's Meson subproject wraps (subprojects/*.wrap) are outdated.
|
||||
|
||||
It understands the three ways a wrap can pin an upstream:
|
||||
|
||||
* [wrap-file] -> a versioned tarball (e.g. zstd-1.5.7). The current
|
||||
version is read from the wrap and compared against
|
||||
the newest upstream tag.
|
||||
* [wrap-git] + tag -> e.g. revision = v1.11. Compared against newest tag.
|
||||
* [wrap-git] + commit -> a 40-char SHA. Compared against the tip of the
|
||||
tracked branch (newer commits == "behind").
|
||||
* [wrap-git] + branch -> e.g. revision = main. Always builds the branch tip,
|
||||
so it is reported as "tracking" (never "outdated").
|
||||
|
||||
Exit status is 1 if any wrap is OUTDATED (a newer release exists), else 0,
|
||||
which makes it usable as a CI check. "behind"/"tracking"/"unknown" do not fail.
|
||||
|
||||
Usage:
|
||||
python3 check_outdated_subprojects.py [PATH] [options]
|
||||
|
||||
PATH may be a rizin checkout, its subprojects/ dir, or omitted (auto-detect).
|
||||
|
||||
Options:
|
||||
--json Emit machine-readable JSON instead of a report.
|
||||
--include-prerelease Flag newer pre-releases (alpha/beta/rc) as updates
|
||||
even when the current pin is a stable release.
|
||||
--jobs N Parallel ls-remote workers (default 8).
|
||||
--timeout S Per-repo ls-remote timeout in seconds (default 30).
|
||||
--no-color Disable ANSI colors.
|
||||
--self-test Run the built-in unit tests (no network) and exit.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import concurrent.futures
|
||||
import configparser
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
GIT = "git"
|
||||
|
||||
# Upstreams whose wrap does not reference a git host we can ls-remote
|
||||
# (e.g. zlib points only at tarball mirrors). Map wrap stem -> git URL.
|
||||
UPSTREAM_OVERRIDES = {
|
||||
"zlib": "https://github.com/madler/zlib.git",
|
||||
}
|
||||
|
||||
HEX40 = re.compile(r"^[0-9a-fA-F]{40}$")
|
||||
GITHUB_RE = re.compile(r"github\.com[/:]+([^/]+)/([^/#?]+?)(?:\.git)?(?:[/#?]|$)")
|
||||
|
||||
# Matches the leading numeric, dot-separated part of a version string, e.g.
|
||||
# the "5.8.1" in "5.8.1-Alpha9". It is anchored at the start of the (already
|
||||
# prefix-stripped) core and has no nested or overlapping quantifiers, so it
|
||||
# always runs in linear time.
|
||||
_REL_RE = re.compile(r"\d+(?:\.\d+)*")
|
||||
_ARCHIVE_EXTS = (
|
||||
".tar.gz",
|
||||
".tar.xz",
|
||||
".tar.bz2",
|
||||
".tar.zst",
|
||||
".tgz",
|
||||
".txz",
|
||||
".tbz2",
|
||||
".zip",
|
||||
".gz",
|
||||
".xz",
|
||||
".bz2",
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Version parsing & comparison
|
||||
# --------------------------------------------------------------------------- #
|
||||
def _chunks(s):
|
||||
"""Split a pre-release string into comparable (is_alpha, num, text) units."""
|
||||
out = []
|
||||
for part in re.findall(r"\d+|[^\d]+", s):
|
||||
if part.isdigit():
|
||||
out.append((0, int(part), ""))
|
||||
else:
|
||||
out.append((1, 0, part))
|
||||
return tuple(out)
|
||||
|
||||
|
||||
def _version_core(tag):
|
||||
"""Return the version core of *tag* with any name prefix and leading "v"
|
||||
removed, e.g. "xz-5.8.1" -> "5.8.1", "v1.3" -> "1.3", "6.0.0-Alpha9"
|
||||
unchanged. Returns None if *tag* has no version core.
|
||||
|
||||
The name prefix is stripped with a plain left-to-right string scan rather
|
||||
than a regular expression, so this is guaranteed to run in linear time and
|
||||
cannot suffer from catastrophic backtracking (ReDoS).
|
||||
"""
|
||||
if not tag:
|
||||
return None
|
||||
s = tag.strip()
|
||||
start = 0
|
||||
if not (s[:1].isdigit() or (s[:1] in "vV" and s[1:2].isdigit())):
|
||||
# There is a name prefix. The version begins right after the first
|
||||
# "-"/"_" that is followed by an optional "v" and a digit; everything
|
||||
# before it (e.g. "tree-sitter-") is the name. Stopping at the *first*
|
||||
# such separator mirrors the original regex, whose name segments each
|
||||
# had to start with a letter -- so a dash-separated numeric tail like
|
||||
# "rel-0-11-18" keeps its leading "0" rather than collapsing to "18".
|
||||
boundary = -1
|
||||
for i, ch in enumerate(s):
|
||||
if ch in "-_":
|
||||
j = i + 1
|
||||
if j < len(s) and s[j] in "vV":
|
||||
j += 1
|
||||
if j < len(s) and s[j].isdigit():
|
||||
boundary = i
|
||||
break
|
||||
if boundary < 0:
|
||||
return None
|
||||
start = boundary + 1
|
||||
core = s[start:]
|
||||
if core[:1] in "vV" and core[1:2].isdigit():
|
||||
core = core[1:]
|
||||
return core if core[:1].isdigit() else None
|
||||
|
||||
|
||||
def parse_version(tag):
|
||||
"""Return (release_tuple, is_final, prerelease_chunks) or None if not a version."""
|
||||
core = _version_core(tag)
|
||||
if core is None:
|
||||
return None
|
||||
m = _REL_RE.match(core)
|
||||
if not m:
|
||||
return None
|
||||
release = tuple(int(x) for x in m.group(0).split("."))
|
||||
pre = core[m.end() :].lstrip("-._").lower()
|
||||
return (release, pre == "", _chunks(pre) if pre else ())
|
||||
|
||||
|
||||
def version_key(parsed):
|
||||
"""Sort key: higher == newer. A final release outranks its pre-releases."""
|
||||
release, is_final, pre = parsed
|
||||
return (release, 1 if is_final else 0, pre)
|
||||
|
||||
|
||||
def version_display(tag):
|
||||
"""Human-friendly version core (drops name prefixes / leading v)."""
|
||||
core = _version_core(tag)
|
||||
return core if core is not None else tag
|
||||
|
||||
|
||||
def best_tag(tags, include_pre):
|
||||
"""Return (raw_tag, key) for the newest version-like tag, or (None, None)."""
|
||||
best, best_key = None, None
|
||||
for t in tags:
|
||||
p = parse_version(t)
|
||||
if p is None:
|
||||
continue
|
||||
if not include_pre and not p[1]: # skip pre-releases unless asked
|
||||
continue
|
||||
k = version_key(p)
|
||||
if best_key is None or k > best_key:
|
||||
best, best_key = t, k
|
||||
return best, best_key
|
||||
|
||||
|
||||
def compare_to_tags(current_raw, tags, include_pre):
|
||||
"""Compare a current version string against a set of upstream tags."""
|
||||
cur = parse_version(current_raw)
|
||||
if cur is None:
|
||||
return "unknown", None, "could not parse current version %r" % current_raw
|
||||
inc = (not cur[1]) or include_pre # if current is a pre-release, consider all
|
||||
best, best_key = best_tag(tags, inc)
|
||||
if best is None: # no stable tags? fall back to anything parseable
|
||||
best, best_key = best_tag(tags, True)
|
||||
if best is None:
|
||||
return "unknown", None, "no version-like tags found upstream"
|
||||
if best_key > version_key(cur):
|
||||
return "outdated", best, None
|
||||
return "up-to-date", best, None
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# git ls-remote
|
||||
# --------------------------------------------------------------------------- #
|
||||
def remote_refs(url, timeout):
|
||||
"""Return {'heads':{}, 'tags':{}, 'default':str, 'head':sha} or {'error':...}."""
|
||||
try:
|
||||
p = subprocess.run(
|
||||
[GIT, "ls-remote", "--symref", url],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=timeout,
|
||||
)
|
||||
except subprocess.TimeoutExpired:
|
||||
return {"error": "timeout after %ss" % timeout}
|
||||
except FileNotFoundError:
|
||||
return {"error": "the `git` binary was not found"}
|
||||
if p.returncode != 0:
|
||||
tail = (p.stderr or "").strip().splitlines()
|
||||
return {"error": tail[-1] if tail else "git ls-remote rc=%d" % p.returncode}
|
||||
|
||||
heads, tags, default, head = {}, {}, None, None
|
||||
for line in p.stdout.splitlines():
|
||||
line = line.rstrip()
|
||||
if not line:
|
||||
continue
|
||||
if line.startswith("ref: "):
|
||||
try:
|
||||
ref, name = line[5:].split("\t", 1)
|
||||
except ValueError:
|
||||
continue
|
||||
if name == "HEAD" and ref.startswith("refs/heads/"):
|
||||
default = ref[len("refs/heads/") :]
|
||||
continue
|
||||
parts = line.split("\t")
|
||||
if len(parts) != 2:
|
||||
continue
|
||||
sha, ref = parts
|
||||
if ref == "HEAD":
|
||||
head = sha
|
||||
elif ref.startswith("refs/heads/"):
|
||||
heads[ref[len("refs/heads/") :]] = sha
|
||||
elif ref.startswith("refs/tags/"):
|
||||
name = ref[len("refs/tags/") :]
|
||||
peeled = name.endswith("^{}")
|
||||
if peeled:
|
||||
name = name[:-3]
|
||||
if peeled or name not in tags: # prefer the dereferenced commit
|
||||
tags[name] = sha
|
||||
if default is None and head is not None:
|
||||
for n, s in heads.items():
|
||||
if s == head:
|
||||
default = n
|
||||
break
|
||||
return {"heads": heads, "tags": tags, "default": default, "head": head}
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Wrap parsing & analysis
|
||||
# --------------------------------------------------------------------------- #
|
||||
def load_wrap(path):
|
||||
cp = configparser.ConfigParser(strict=False, delimiters=("=",), interpolation=None)
|
||||
cp.optionxform = str # keep key case as-is
|
||||
cp.read(path, encoding="utf-8")
|
||||
return cp
|
||||
|
||||
|
||||
def strip_archive_ext(name):
|
||||
low = name.lower()
|
||||
for ext in _ARCHIVE_EXTS:
|
||||
if low.endswith(ext):
|
||||
return name[: -len(ext)]
|
||||
return name
|
||||
|
||||
|
||||
def github_url(urls):
|
||||
for u in urls:
|
||||
if not u:
|
||||
continue
|
||||
m = GITHUB_RE.search(u)
|
||||
if m:
|
||||
return "https://github.com/%s/%s.git" % (
|
||||
m.group(1),
|
||||
m.group(2),
|
||||
), "%s/%s" % (m.group(1), m.group(2))
|
||||
return None, None
|
||||
|
||||
|
||||
def current_version_from_file(sec):
|
||||
"""Best-effort current version for a [wrap-file]."""
|
||||
candidates = [
|
||||
sec.get("directory", ""),
|
||||
strip_archive_ext(sec.get("source_filename", "")),
|
||||
]
|
||||
for c in candidates:
|
||||
if parse_version(c):
|
||||
return c
|
||||
# Fall back to a version-looking path segment in the URLs
|
||||
# (e.g. zydis: .../download/v4.1.0/zydis-amalgamated.tar.gz).
|
||||
for key in ("source_url", "source_fallback_url"):
|
||||
for part in sec.get(key, "").split("/"):
|
||||
if parse_version(part):
|
||||
return part
|
||||
return ""
|
||||
|
||||
|
||||
def preferred_branch(stem, heads, default):
|
||||
"""Pick the branch a commit-pinned wrap most likely tracks."""
|
||||
chosen = default
|
||||
for seg in re.split(r"[-_]", stem):
|
||||
if seg in heads:
|
||||
chosen = seg # last matching segment wins (e.g. capstone-"next")
|
||||
if chosen in heads:
|
||||
return chosen
|
||||
return default if default in heads else None
|
||||
|
||||
|
||||
def short(sha):
|
||||
return sha[:10] if sha else sha
|
||||
|
||||
|
||||
def analyze(path, args):
|
||||
"""Return a result dict for a single wrap file."""
|
||||
stem = os.path.basename(path)[:-5] # drop ".wrap"
|
||||
res = {
|
||||
"name": stem,
|
||||
"repo": None,
|
||||
"category": None,
|
||||
"current": None,
|
||||
"latest": None,
|
||||
"status": "unknown",
|
||||
"detail": None,
|
||||
}
|
||||
try:
|
||||
cp = load_wrap(path)
|
||||
except configparser.Error as e:
|
||||
res["detail"] = "failed to parse wrap: %s" % e
|
||||
return res
|
||||
|
||||
if cp.has_section("wrap-file"):
|
||||
sec = cp["wrap-file"]
|
||||
res["category"] = "version"
|
||||
res["current"] = version_display(current_version_from_file(sec))
|
||||
url, repo = github_url(
|
||||
[sec.get("source_url", ""), sec.get("source_fallback_url", "")]
|
||||
)
|
||||
if url is None and stem in UPSTREAM_OVERRIDES:
|
||||
url = UPSTREAM_OVERRIDES[stem]
|
||||
repo = re.sub(r"^https?://github\.com/|\.git$", "", url)
|
||||
res["repo"] = repo or "(unknown upstream)"
|
||||
if url is None:
|
||||
res["detail"] = "no upstream git repo found in wrap"
|
||||
return res
|
||||
refs = remote_refs(url, args.timeout)
|
||||
if "error" in refs:
|
||||
res["detail"] = refs["error"]
|
||||
return res
|
||||
status, best, detail = compare_to_tags(
|
||||
current_version_from_file(sec), set(refs["tags"]), args.include_prerelease
|
||||
)
|
||||
res["status"] = status
|
||||
res["detail"] = detail
|
||||
if best is not None:
|
||||
res["latest"] = version_display(best)
|
||||
return res
|
||||
|
||||
if cp.has_section("wrap-git"):
|
||||
sec = cp["wrap-git"]
|
||||
url = sec.get("url", "").strip()
|
||||
revision = sec.get("revision", "").strip()
|
||||
res["repo"] = re.sub(r"^https?://(?:github\.com/)?|\.git$", "", url) or url
|
||||
if not url or not revision:
|
||||
res["detail"] = "wrap-git missing url or revision"
|
||||
return res
|
||||
refs = remote_refs(url, args.timeout)
|
||||
if "error" in refs:
|
||||
res["detail"] = refs["error"]
|
||||
return res
|
||||
|
||||
if HEX40.match(revision): # pinned commit
|
||||
res["category"] = "commit"
|
||||
res["current"] = short(revision)
|
||||
branch = preferred_branch(stem, refs["heads"], refs["default"])
|
||||
if branch is None:
|
||||
res["detail"] = "could not determine a branch to compare against"
|
||||
return res
|
||||
tip = refs["heads"][branch]
|
||||
res["latest"] = short(tip)
|
||||
if tip.lower() == revision.lower():
|
||||
res["status"] = "up-to-date"
|
||||
res["detail"] = "at tip of %s" % branch
|
||||
else:
|
||||
res["status"] = "behind"
|
||||
res["detail"] = "pinned %s, %s tip is %s" % (
|
||||
short(revision),
|
||||
branch,
|
||||
short(tip),
|
||||
)
|
||||
return res
|
||||
|
||||
if revision in refs["heads"]: # tracks a moving branch
|
||||
res["category"] = "branch"
|
||||
res["current"] = revision
|
||||
res["latest"] = short(refs["heads"][revision])
|
||||
res["status"] = "tracking"
|
||||
res["detail"] = "builds latest commit of branch %r" % revision
|
||||
return res
|
||||
|
||||
# otherwise treat as a tag (it is in refs/tags, or just looks like a version)
|
||||
res["category"] = "tag"
|
||||
res["current"] = version_display(revision)
|
||||
if revision not in refs["tags"] and parse_version(revision) is None:
|
||||
res["detail"] = "revision %r is not a known tag/branch/commit" % revision
|
||||
return res
|
||||
status, best, detail = compare_to_tags(
|
||||
revision, set(refs["tags"]), args.include_prerelease
|
||||
)
|
||||
res["status"] = status
|
||||
res["detail"] = detail
|
||||
if best is not None:
|
||||
res["latest"] = version_display(best)
|
||||
return res
|
||||
|
||||
res["detail"] = "no [wrap-file] or [wrap-git] section"
|
||||
return res
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Discovery, reporting, CLI
|
||||
# --------------------------------------------------------------------------- #
|
||||
def find_subprojects_dir(path):
|
||||
if path is None:
|
||||
for cand in ("subprojects", "."):
|
||||
if os.path.isdir(cand) and any(
|
||||
f.endswith(".wrap") for f in os.listdir(cand)
|
||||
):
|
||||
return cand
|
||||
return None
|
||||
sub = os.path.join(path, "subprojects")
|
||||
if os.path.isdir(sub):
|
||||
return sub
|
||||
if os.path.isdir(path) and any(f.endswith(".wrap") for f in os.listdir(path)):
|
||||
return path
|
||||
return None
|
||||
|
||||
|
||||
# status -> (symbol, label, color)
|
||||
_STATUS = {
|
||||
"outdated": ("[!]", "OUTDATED", "\033[31m"), # red
|
||||
"behind": ("[~]", "BEHIND", "\033[33m"), # yellow
|
||||
"tracking": ("[>]", "TRACKING", "\033[36m"), # cyan
|
||||
"up-to-date": ("[+]", "UP TO DATE", "\033[32m"), # green
|
||||
"unknown": ("[?]", "UNKNOWN", "\033[35m"), # magenta
|
||||
}
|
||||
_ORDER = ["outdated", "behind", "unknown", "tracking", "up-to-date"]
|
||||
_RESET = "\033[0m"
|
||||
|
||||
|
||||
def render(results, use_color):
|
||||
def c(text, code):
|
||||
return "%s%s%s" % (code, text, _RESET) if use_color else text
|
||||
|
||||
width = max((len(r["name"]) for r in results), default=4)
|
||||
by_status = {}
|
||||
for r in results:
|
||||
by_status.setdefault(r["status"], []).append(r)
|
||||
|
||||
lines = []
|
||||
for status in _ORDER:
|
||||
group = by_status.get(status)
|
||||
if not group:
|
||||
continue
|
||||
sym, label, color = _STATUS[status]
|
||||
lines.append("")
|
||||
lines.append(c("%s %s" % (sym, label), color))
|
||||
for r in sorted(group, key=lambda x: x["name"]):
|
||||
cur = r["current"] or "?"
|
||||
if r["status"] in ("outdated",):
|
||||
ver = "%s -> %s" % (cur, r["latest"] or "?")
|
||||
elif r["status"] == "behind":
|
||||
ver = "%s -> %s" % (cur, r["latest"] or "?")
|
||||
elif r["status"] in ("up-to-date", "tracking"):
|
||||
ver = cur
|
||||
else:
|
||||
ver = cur
|
||||
detail = " (%s)" % r["detail"] if r["detail"] else ""
|
||||
lines.append(
|
||||
" %-*s %-22s %s%s"
|
||||
% (width, r["name"], ver, r["repo"] or "", c(detail, "\033[90m"))
|
||||
)
|
||||
|
||||
n_out = len(by_status.get("outdated", []))
|
||||
n_behind = len(by_status.get("behind", []))
|
||||
n_unknown = len(by_status.get("unknown", []))
|
||||
lines.append("")
|
||||
lines.append("-" * 60)
|
||||
summary = "%d outdated, %d behind, %d tracking, %d up-to-date, %d unknown" % (
|
||||
n_out,
|
||||
n_behind,
|
||||
len(by_status.get("tracking", [])),
|
||||
len(by_status.get("up-to-date", [])),
|
||||
n_unknown,
|
||||
)
|
||||
lines.append(c(summary, "\033[1m") if use_color else summary)
|
||||
return "\n".join(lines), n_out
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Built-in unit tests (run with --self-test; no network required)
|
||||
# --------------------------------------------------------------------------- #
|
||||
def run_self_tests():
|
||||
"""Exercise the offline version/wrap logic with inline unit tests.
|
||||
|
||||
Only the pure helpers are covered (parsing, comparison, classification,
|
||||
URL/version extraction); the ls-remote layer needs the network and is left
|
||||
out. Returns 0 if every check passes and 1 otherwise, so it can be wired
|
||||
into CI as ``check_outdated_subprojects.py --self-test``.
|
||||
"""
|
||||
import time
|
||||
|
||||
checks = []
|
||||
|
||||
def eq(label, got, want):
|
||||
checks.append(got == want)
|
||||
if got != want:
|
||||
print("FAIL %s" % label)
|
||||
print(" got: %r" % (got,))
|
||||
print(" want: %r" % (want,))
|
||||
|
||||
def ok(label, cond):
|
||||
checks.append(bool(cond))
|
||||
if not cond:
|
||||
print("FAIL %s" % label)
|
||||
|
||||
# -- parse_version: name prefixes, leading "v", pre-releases, non-versions --
|
||||
eq("parse xz-5.8.1", parse_version("xz-5.8.1"), ((5, 8, 1), True, ()))
|
||||
eq("parse v1.3.1", parse_version("v1.3.1"), ((1, 3, 1), True, ()))
|
||||
eq("parse zstd-1.5.7", parse_version("zstd-1.5.7"), ((1, 5, 7), True, ()))
|
||||
eq(
|
||||
"parse tree-sitter-0.25.3",
|
||||
parse_version("tree-sitter-0.25.3"),
|
||||
((0, 25, 3), True, ()),
|
||||
)
|
||||
eq("parse pcre2-10.47", parse_version("pcre2-10.47"), ((10, 47), True, ()))
|
||||
eq("parse v1.11", parse_version("v1.11"), ((1, 11), True, ()))
|
||||
eq(
|
||||
"parse capstone-6.0.0-Alpha9",
|
||||
parse_version("capstone-6.0.0-Alpha9"),
|
||||
((6, 0, 0), False, ((1, 0, "alpha"), (0, 9, ""))),
|
||||
)
|
||||
# A dash-separated numeric tail (libzip's rel-* tags) must keep its leading
|
||||
# number instead of collapsing to the last one -- regression guard.
|
||||
eq(
|
||||
"parse rel-0-11-18",
|
||||
parse_version("rel-0-11-18"),
|
||||
((0,), False, ((0, 11, ""), (1, 0, "-"), (0, 18, ""))),
|
||||
)
|
||||
ok("1.0.0 is final", parse_version("1.0.0")[1] is True)
|
||||
ok("1.0.0-rc1 is not final", parse_version("1.0.0-rc1")[1] is False)
|
||||
for nonver in ("main", "dev", "master", "", None, "zydis-amalgamated.tar.gz"):
|
||||
eq("parse %r -> None" % (nonver,), parse_version(nonver), None)
|
||||
|
||||
# -- version_display --
|
||||
eq("display xz-5.8.1", version_display("xz-5.8.1"), "5.8.1")
|
||||
eq("display v5.8.3", version_display("v5.8.3"), "5.8.3")
|
||||
eq(
|
||||
"display capstone-6.0.0-Alpha9",
|
||||
version_display("capstone-6.0.0-Alpha9"),
|
||||
"6.0.0-Alpha9",
|
||||
)
|
||||
eq("display passthrough", version_display("main"), "main")
|
||||
|
||||
# -- ordering: numeric (not lexical) and final outranks pre-release --
|
||||
def newer(a, b):
|
||||
return version_key(parse_version(a)) > version_key(parse_version(b))
|
||||
|
||||
ok("5.8.3 > 5.8.1", newer("5.8.3", "5.8.1"))
|
||||
ok("1.10.0 > 1.9.2 (numeric, not string)", newer("1.10.0", "1.9.2"))
|
||||
ok("1.0.1 > 1.0", newer("1.0.1", "1.0"))
|
||||
ok("6.0.0 > 6.0.0-Alpha9 (final beats pre-release)", newer("6.0.0", "6.0.0-Alpha9"))
|
||||
ok("Alpha9 > Alpha2", newer("6.0.0-Alpha9", "6.0.0-Alpha2"))
|
||||
|
||||
# -- best_tag --
|
||||
eq(
|
||||
"best_tag newest",
|
||||
best_tag(["v1.0.0", "v1.2.0", "v1.10.0", "main"], False)[0],
|
||||
"v1.10.0",
|
||||
)
|
||||
eq(
|
||||
"best_tag skips pre-release by default",
|
||||
best_tag(["1.0.0", "2.0.0-rc1"], False)[0],
|
||||
"1.0.0",
|
||||
)
|
||||
eq(
|
||||
"best_tag includes pre-release on request",
|
||||
best_tag(["1.0.0", "2.0.0-rc1"], True)[0],
|
||||
"2.0.0-rc1",
|
||||
)
|
||||
eq("best_tag no version-like tags", best_tag(["main", "dev"], True), (None, None))
|
||||
|
||||
# -- compare_to_tags: the OUTDATED / UP-TO-DATE / UNKNOWN decision --
|
||||
def status(cur, tags, inc=False):
|
||||
return compare_to_tags(cur, set(tags), inc)[0]
|
||||
|
||||
eq("compare outdated", status("5.8.1", ["v5.8.1", "v5.8.3"]), "outdated")
|
||||
eq(
|
||||
"compare reports newest tag",
|
||||
compare_to_tags("5.8.1", {"v5.8.1", "v5.8.3"}, False)[1],
|
||||
"v5.8.3",
|
||||
)
|
||||
eq(
|
||||
"compare up-to-date (numeric)",
|
||||
status("1.10.0", ["v1.9.2", "v1.10.0"]),
|
||||
"up-to-date",
|
||||
)
|
||||
eq("compare unparseable current -> unknown", status("main", ["v1.0.0"]), "unknown")
|
||||
eq("compare no upstream tags -> unknown", status("1.0.0", []), "unknown")
|
||||
eq(
|
||||
"compare stable pin ignores newer pre-release",
|
||||
status("1.0.0", ["1.0.0", "2.0.0-rc1"], False),
|
||||
"up-to-date",
|
||||
)
|
||||
eq(
|
||||
"compare --include-prerelease flags it",
|
||||
status("1.0.0", ["1.0.0", "2.0.0-rc1"], True),
|
||||
"outdated",
|
||||
)
|
||||
eq(
|
||||
"compare pre-release pin sees newer pre-release",
|
||||
status("6.0.0-Alpha2", ["6.0.0-Alpha2", "6.0.0-Alpha9"]),
|
||||
"outdated",
|
||||
)
|
||||
|
||||
# -- github_url: owner/repo extraction from assorted URL shapes --
|
||||
eq(
|
||||
"github_url release tarball",
|
||||
github_url(
|
||||
["https://github.com/tukaani-project/xz/releases/download/v5.8.1/xz.tar.gz"]
|
||||
)[1],
|
||||
"tukaani-project/xz",
|
||||
)
|
||||
eq(
|
||||
"github_url .git suffix",
|
||||
github_url(["https://github.com/zyantific/zydis.git"])[1],
|
||||
"zyantific/zydis",
|
||||
)
|
||||
eq(
|
||||
"github_url scp syntax",
|
||||
github_url(["git@github.com:foo/bar.git"])[1],
|
||||
"foo/bar",
|
||||
)
|
||||
eq("github_url skips empties", github_url(["", "https://github.com/a/b"])[1], "a/b")
|
||||
eq(
|
||||
"github_url non-github",
|
||||
github_url(["https://zlib.net/zlib.tar.gz"]),
|
||||
(None, None),
|
||||
)
|
||||
|
||||
# -- strip_archive_ext --
|
||||
eq("strip .tar.gz", strip_archive_ext("xz-5.8.1.tar.gz"), "xz-5.8.1")
|
||||
eq("strip .zip", strip_archive_ext("zydis-amalgamated.zip"), "zydis-amalgamated")
|
||||
eq("strip .tar.xz", strip_archive_ext("file.tar.xz"), "file")
|
||||
eq("strip none", strip_archive_ext("plain"), "plain")
|
||||
|
||||
# -- current_version_from_file (a plain dict stands in for a wrap section) --
|
||||
eq(
|
||||
"cvff directory",
|
||||
current_version_from_file({"directory": "xz-5.8.1"}),
|
||||
"xz-5.8.1",
|
||||
)
|
||||
eq(
|
||||
"cvff filename fallback",
|
||||
current_version_from_file(
|
||||
{"directory": "", "source_filename": "lz4-1.10.0.tgz"}
|
||||
),
|
||||
"lz4-1.10.0",
|
||||
)
|
||||
eq(
|
||||
"cvff url fallback (zydis amalgamated)",
|
||||
current_version_from_file(
|
||||
{
|
||||
"directory": "zydis",
|
||||
"source_filename": "zydis-amalgamated.tar.gz",
|
||||
"source_url": "https://github.com/zyantific/zydis/releases/download/v4.1.0/zydis-amalgamated.tar.gz",
|
||||
}
|
||||
),
|
||||
"v4.1.0",
|
||||
)
|
||||
|
||||
# -- preferred_branch --
|
||||
heads = {"master": "a", "next": "b", "main": "c"}
|
||||
eq(
|
||||
"branch segment match",
|
||||
preferred_branch("capstone-next", heads, "master"),
|
||||
"next",
|
||||
)
|
||||
eq("branch default fallback", preferred_branch("blake3", heads, "master"), "master")
|
||||
eq("branch none available", preferred_branch("foo", {"main": "c"}, "master"), None)
|
||||
|
||||
# -- ReDoS guard: adversarial input must still parse in linear time --
|
||||
evil = "a" + "_a" * 10000
|
||||
t0 = time.perf_counter()
|
||||
parsed_evil = parse_version(evil)
|
||||
dt = time.perf_counter() - t0
|
||||
eq("adversarial input -> None", parsed_evil, None)
|
||||
ok("adversarial input parsed in <1s (took %.4fs)" % dt, dt < 1.0)
|
||||
|
||||
total = len(checks)
|
||||
failed = sum(1 for c in checks if not c)
|
||||
print("")
|
||||
if failed:
|
||||
print("self-test: %d of %d checks FAILED" % (failed, total))
|
||||
return 1
|
||||
print("self-test: all %d checks passed" % total)
|
||||
return 0
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
ap = argparse.ArgumentParser(
|
||||
description="Check whether Rizin's Meson subproject wraps are outdated.",
|
||||
epilog="Exit code is 1 if any wrap is OUTDATED, else 0. "
|
||||
"BEHIND/TRACKING/UNKNOWN do not affect the exit code.",
|
||||
)
|
||||
ap.add_argument(
|
||||
"path",
|
||||
nargs="?",
|
||||
default=None,
|
||||
help="rizin checkout or its subprojects/ dir (auto-detected if omitted)",
|
||||
)
|
||||
ap.add_argument("--json", action="store_true", help="emit JSON")
|
||||
ap.add_argument(
|
||||
"--include-prerelease",
|
||||
action="store_true",
|
||||
help="flag newer alpha/beta/rc releases even for stable pins",
|
||||
)
|
||||
ap.add_argument("--jobs", type=int, default=8, help="parallel workers (default 8)")
|
||||
ap.add_argument(
|
||||
"--timeout",
|
||||
type=int,
|
||||
default=30,
|
||||
help="per-repo ls-remote timeout in seconds (default 30)",
|
||||
)
|
||||
ap.add_argument("--no-color", action="store_true", help="disable ANSI colors")
|
||||
ap.add_argument(
|
||||
"--self-test",
|
||||
action="store_true",
|
||||
help="run the built-in unit tests (no network) and exit",
|
||||
)
|
||||
args = ap.parse_args(argv)
|
||||
|
||||
if args.self_test:
|
||||
return run_self_tests()
|
||||
|
||||
sub = find_subprojects_dir(args.path)
|
||||
if sub is None:
|
||||
sys.stderr.write(
|
||||
"error: could not find a subprojects/ directory with "
|
||||
"*.wrap files. Pass the rizin path explicitly.\n"
|
||||
)
|
||||
return 2
|
||||
wraps = sorted(os.path.join(sub, f) for f in os.listdir(sub) if f.endswith(".wrap"))
|
||||
if not wraps:
|
||||
sys.stderr.write("error: no *.wrap files in %s\n" % sub)
|
||||
return 2
|
||||
|
||||
if not args.json:
|
||||
sys.stderr.write("Checking %d wraps in %s ...\n" % (len(wraps), sub))
|
||||
|
||||
workers = max(1, min(args.jobs, len(wraps)))
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as ex:
|
||||
results = list(ex.map(lambda p: analyze(p, args), wraps))
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(results, indent=2))
|
||||
return 1 if any(r["status"] == "outdated" for r in results) else 0
|
||||
|
||||
use_color = (not args.no_color) and sys.stdout.isatty()
|
||||
report, n_out = render(results, use_color)
|
||||
print(report)
|
||||
return 1 if n_out else 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Loading…
Reference in a new issue