hurdle-gate 0.3.1__py3-none-any.whl

hurdle/__init__.py

@@ -0,0 +1,3 @@
+"""hurdle — static-analysis gate for source↔test file existence mapping."""
+
+__version__ = "0.3.1"

hurdle/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from hurdle.cli import main
+
+sys.exit(main())

hurdle/cli.py

@@ -0,0 +1,519 @@
+#!/usr/bin/env python3
+"""hurdle — minimal test gap scanner (stdlib only).
+
+hurdle scan PATH [--json FILE] [--strict] [--config FILE] [--diff BASE]
+Maps source files to their conventional test counterparts and reports gaps.
+Go: *_test.go in the same directory (package-level convention).
+Python: test_{stem}.py / {stem}_test.py next to the file, tests/test_{stem}.py
+relative to the file's directory or the scan root; variant names
+tests/test_{stem}_*.py and tests/test_*_{stem}.py match via fnmatch (the
+required '_' separators keep {stem} on word boundaries). "__init__.py" is a
+package marker (excluded) unless strict_init=true; non-test .py files under a
+configured test_dirs directory (default ["tests","test"]) are excluded as
+test-support modules.
+JS/TS: {stem}.test.{ext} / {stem}.spec.{ext} next to the file.
+C/shell (.c .h .cc .cpp .sh): module-aggregated heuristic mode. The module is
+the directory holding the source file; a module is ok (confidence=heuristic)
+when a registered module_map keyword appears in some C test file path or
+content (content read with errors='replace', files up to 1MB only), or the
+module name appears in some C test file path. Files named test_*/..._test or
+living under tests/, test/ or kunit/ are C test files, not sources.
+Config (--config FILE; default: PATH/.hurdle.json when present):
+  exclude:   trailing "/" matches a directory name anywhere in the path;
+             otherwise fnmatch glob matched against the relpath and the file
+             name. Matching sources get status=excluded (counted, not gaps).
+  allowlist: {"rel/path": "reason"} — exact relpath match; status=allowed
+              with the reason shown in the report (wins over exclude).
+  test_dirs:  directory names marking test context (default ["tests","test"]);
+              non-test .py files under them are excluded as test-support.
+  strict_init: when true, __init__.py is judged as a normal source file
+              instead of a package marker.
+  module_map: {"module-relpath-or-name": ["keyword", ...]} for the C heuristic.
+--diff BASE: only judge files added/modified/renamed between BASE and HEAD,
+plus uncommitted working-tree changes vs BASE; test existence matching still
+uses the full worktree. PATH must be a git work tree (exit 2 otherwise).
+Unmappable extensions are reported separately as "unmapped", not gaps.
+"""
+
+import argparse
+import datetime
+import fnmatch
+import json
+import os
+import subprocess
+import sys
+
+JS_EXTS = {"ts", "tsx", "js", "jsx"}
+C_EXTS = {"c", "h", "cc", "cpp", "sh"}
+C_TEST_DIR_COMPONENTS = {"tests", "test", "kunit"}
+MAX_CONTENT_BYTES = 1024 * 1024
+DEFAULT_CONFIG_NAME = ".hurdle.json"
+
+
+def die(msg):
+    print("hurdle: %s" % msg, file=sys.stderr)
+    sys.exit(2)
+
+
+class Config:
+    """Parsed .hurdle.json content; all keys optional."""
+
+    def __init__(self, data):
+        data = data or {}
+        self.exclude = list(data.get("exclude") or [])
+        self.allowlist = dict(data.get("allowlist") or {})
+        self.module_map = dict(data.get("module_map") or {})
+        self.strict_init = bool(data.get("strict_init", False))
+        self.test_dirs = list(data.get("test_dirs") or ["tests", "test"])
+
+    def exclusion_hit(self, rel):
+        parts = rel.split("/")
+        base = parts[-1]
+        for pat in self.exclude:
+            if pat.endswith("/"):
+                if pat[:-1] in parts:
+                    return True
+            elif fnmatch.fnmatch(rel, pat) or fnmatch.fnmatch(base, pat):
+                return True
+        return False
+
+    def allow_reason(self, rel):
+        return self.allowlist.get(rel)
+
+    def under_test_dir(self, rel):
+        return any(p in self.test_dirs for p in rel.split("/"))
+
+    def module_keywords(self, module_rel, module_name):
+        kws = self.module_map.get(module_rel)
+        if kws is None:
+            kws = self.module_map.get(module_name)
+        if kws is None:
+            return []
+        if isinstance(kws, str):
+            kws = [kws]
+        return list(kws)
+
+
+def load_config(path):
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            return Config(json.load(fh))
+    except (OSError, ValueError) as exc:
+        die("cannot load config %s: %s" % (path, exc))
+
+
+def classify(name, rel=None):
+    """Return (lang, kind); kind is one of source/test/other."""
+    root, ext = os.path.splitext(name)
+    ext = ext.lstrip(".").lower()
+    if ext == "go":
+        return ("go", "test" if root.endswith("_test") else "source")
+    if ext == "py":
+        if name == "conftest.py" or root.startswith("test_") or root.endswith("_test"):
+            return ("py", "test")
+        if name == "__init__.py":
+            return ("py", "marker")
+        return ("py", "source")
+    if ext in JS_EXTS:
+        if root.endswith(".test") or root.endswith(".spec"):
+            return (ext, "test")
+        return (ext, "source")
+    if ext in C_EXTS:
+        parts = (rel or name).split("/")
+        if (
+            root.startswith("test_")
+            or root.endswith("_test")
+            or any(p in C_TEST_DIR_COMPONENTS for p in parts[:-1])
+        ):
+            return ("c", "test")
+        return ("c", "source")
+    return (ext, "other")
+
+
+def walk(root):
+    """Recursively collect file paths under root, skipping symlinks and hidden entries."""
+    files = []
+    stack = [root]
+    while stack:
+        d = stack.pop()
+        try:
+            entries = list(os.scandir(d))
+        except OSError:
+            continue
+        for e in entries:
+            if e.name.startswith(".") or e.is_symlink():
+                continue
+            if e.is_dir(follow_symlinks=False):
+                stack.append(e.path)
+            elif e.is_file(follow_symlinks=False):
+                files.append(e.path)
+    return sorted(files)
+
+
+def go_tests_in_dir(d):
+    try:
+        return sorted(
+            e.name
+            for e in os.scandir(d)
+            if e.name.endswith("_test.go") and e.is_file(follow_symlinks=False)
+        )
+    except OSError:
+        return []
+
+
+def test_candidates(path, lang, scan_root):
+    d, name = os.path.split(path)
+    stem, ext = os.path.splitext(name)
+    if lang == "py":
+        return [
+            os.path.join(d, "test_" + stem + ".py"),
+            os.path.join(d, stem + "_test.py"),
+            os.path.join(d, "tests", "test_" + stem + ".py"),
+            os.path.join(scan_root, "tests", "test_" + stem + ".py"),
+        ]
+    if lang in JS_EXTS:
+        return [
+            os.path.join(d, stem + ".test" + ext),
+            os.path.join(d, stem + ".spec" + ext),
+        ]
+    return []
+
+
+def py_variant_test(d, stem, scan_root, cfg, listing):
+    """Variant test lookup for Python sources (v0.2.0).
+
+    Matches tests/test_{stem}_*.py and tests/test_*_{stem}.py via fnmatch
+    inside the configured test dirs next to the file (d) and at the scan
+    root; the required '_' separators keep {stem} on word boundaries.
+    Returns the matched absolute path or None.
+    """
+    patterns = ("test_%s_*.py" % stem, "test_*_%s.py" % stem)
+    seen = set()
+    for base in (d, scan_root):
+        for td in cfg.test_dirs:
+            tdir = os.path.normpath(os.path.join(base, td))
+            if tdir in seen:
+                continue
+            seen.add(tdir)
+            for fname in listing(tdir):
+                if any(fnmatch.fnmatch(fname, p) for p in patterns):
+                    return os.path.join(tdir, fname)
+    return None
+
+
+def c_module_status(rel, c_tests, read_content, cfg):
+    """Heuristic verdict for one C/shell source file. Returns (status, matched_test)."""
+    d = os.path.dirname(rel)
+    module_rel = d if d else "."
+    module_name = os.path.basename(d) if d else os.path.splitext(os.path.basename(rel))[0]
+    for kw in cfg.module_keywords(module_rel, module_name):
+        for t in c_tests:
+            if kw in t:
+                return "ok", t
+        for t in c_tests:
+            content = read_content(t)
+            if content and kw in content:
+                return "ok", t
+    for t in c_tests:
+        if module_name and module_name in t:
+            return "ok", t
+    return "gap", None
+
+
+def check_git_repo(path):
+    proc = subprocess.run(
+        ["git", "-C", path, "rev-parse", "--is-inside-work-tree"],
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0 or proc.stdout.strip() != "true":
+        die("%s is not a git work tree" % path)
+
+
+def changed_files(path, base):
+    """AMR files changed BASE...HEAD, plus uncommitted working-tree changes vs BASE."""
+    cmds = (
+        ["git", "-C", path, "diff", "--name-only", "--relative", "--diff-filter=AMR", base + "...HEAD"],
+        ["git", "-C", path, "diff", "--name-only", "--relative", "--diff-filter=AMR", base],
+    )
+    changed = set()
+    for cmd in cmds:
+        proc = subprocess.run(cmd, capture_output=True, text=True)
+        if proc.returncode != 0:
+            die("git diff failed (%s): %s" % (base, proc.stderr.strip()))
+        changed.update(line for line in proc.stdout.splitlines() if line)
+    return changed
+
+
+def scan(path, cfg=None, diff_base=None):
+    root = os.path.abspath(path)
+    if cfg is None:
+        cfg = Config({})
+    results = []
+    go_cache = {}
+    c_tests = []  # C/shell test relpaths, collected in pass 1
+    c_contents = {}  # C test relpath -> content str, or None if too big/unreadable
+
+    def read_c_test_content(rel):
+        if rel not in c_contents:
+            full = os.path.join(root, *rel.split("/"))
+            try:
+                if os.path.getsize(full) <= MAX_CONTENT_BYTES:
+                    with open(full, "r", encoding="utf-8", errors="replace") as fh:
+                        c_contents[rel] = fh.read()
+                else:
+                    c_contents[rel] = None
+            except OSError:
+                c_contents[rel] = None
+        return c_contents[rel]
+
+    # Pass 1: collect the C/shell test universe so module judgment sees it all.
+    for f in walk(root):
+        rel = os.path.relpath(f, root).replace(os.sep, "/")
+        lang, kind = classify(os.path.basename(f), rel)
+        if kind == "test":
+            if lang == "c":
+                c_tests.append(rel)
+            continue
+
+    # Pass 2: judge every non-test file.
+    py_dir_cache = {}
+
+    def tests_dir_listing(dirpath):
+        if dirpath not in py_dir_cache:
+            try:
+                py_dir_cache[dirpath] = sorted(
+                    e.name
+                    for e in os.scandir(dirpath)
+                    if e.is_file(follow_symlinks=False) and e.name.endswith(".py")
+                )
+            except OSError:
+                py_dir_cache[dirpath] = []
+        return py_dir_cache[dirpath]
+
+    for f in walk(root):
+        rel = os.path.relpath(f, root).replace(os.sep, "/")
+        lang, kind = classify(os.path.basename(f), rel)
+        if kind == "test":
+            continue
+        if kind == "marker" and cfg.strict_init:
+            kind = "source"
+        if kind == "source" and lang == "py" and cfg.under_test_dir(rel):
+            kind = "support"
+        entry = {"path": rel, "lang": lang}
+        if kind == "other":
+            entry.update(status="unmapped", matched_test=None, confidence="exact")
+            results.append(entry)
+            continue
+        reason = cfg.allow_reason(rel)
+        if reason is not None:
+            entry.update(
+                status="allowed", matched_test=None, confidence="exact", reason=reason
+            )
+            results.append(entry)
+            continue
+        if kind in ("marker", "support"):
+            entry.update(
+                status="excluded",
+                matched_test=None,
+                confidence="exact",
+                reason=(
+                    "package marker (__init__.py)"
+                    if kind == "marker"
+                    else "test-support module under test dir"
+                ),
+            )
+            results.append(entry)
+            continue
+        if cfg.exclusion_hit(rel):
+            entry.update(status="excluded", matched_test=None, confidence="exact")
+            results.append(entry)
+            continue
+        if lang == "c":
+            status, matched = c_module_status(rel, c_tests, read_c_test_content, cfg)
+            entry.update(status=status, matched_test=matched, confidence="heuristic")
+            results.append(entry)
+            continue
+        d, name = os.path.split(f)
+        status, matched = "gap", None
+        if lang == "go":
+            if d not in go_cache:
+                go_cache[d] = go_tests_in_dir(d)
+            tests = go_cache[d]
+            if tests:
+                status = "ok"
+                matched = name[:-3] + "_test.go" if (name[:-3] + "_test.go") in tests else tests[0]
+        else:
+            for cand in test_candidates(f, lang, root):
+                if os.path.isfile(cand) and not os.path.islink(cand):
+                    status = "ok"
+                    matched = os.path.relpath(cand, root).replace(os.sep, "/")
+                    break
+            if status == "gap" and lang == "py":
+                stem = os.path.splitext(name)[0]
+                hit = py_variant_test(d, stem, root, cfg, tests_dir_listing)
+                if hit:
+                    status = "ok"
+                    matched = os.path.relpath(hit, root).replace(os.sep, "/")
+        entry.update(status=status, matched_test=matched, confidence="exact")
+        results.append(entry)
+
+    if diff_base is not None:
+        changed = changed_files(root, diff_base)
+        results = [r for r in results if r["path"] in changed]
+    return root, results
+
+
+def summarize(results):
+    by_lang = {}
+    ok = gap = unmapped = excluded = allowed = 0
+    for r in results:
+        st = r["status"]
+        if st == "unmapped":
+            unmapped += 1
+            continue
+        if st == "excluded":
+            excluded += 1
+        elif st == "allowed":
+            allowed += 1
+        elif st == "ok":
+            ok += 1
+        else:
+            gap += 1
+        cnt = by_lang.setdefault(
+            r["lang"], {"ok": 0, "gap": 0, "excluded": 0, "allowed": 0}
+        )
+        cnt[st] += 1
+    return {
+        "total": len(results),
+        "ok": ok,
+        "gap": gap,
+        "unmapped": unmapped,
+        "excluded": excluded,
+        "allowed": allowed,
+        "by_lang": by_lang,
+    }
+
+
+def report(root, results, summary, mode="full", base=None, config_path=None):
+    print("hurdle scan: %s" % root)
+    meta = "mode=%s" % mode
+    if mode == "diff" and base:
+        meta += " (base=%s)" % base
+    if config_path:
+        meta += " config=%s" % config_path
+    print(meta)
+    print(
+        "total=%(total)d ok=%(ok)d gap=%(gap)d unmapped=%(unmapped)d"
+        " excluded=%(excluded)d allowed=%(allowed)d" % summary
+    )
+    for lang in sorted(summary["by_lang"]):
+        c = summary["by_lang"][lang]
+        line = "  %s: ok=%d gap=%d" % (lang, c["ok"], c["gap"])
+        if c["excluded"]:
+            line += " excluded=%d" % c["excluded"]
+        if c["allowed"]:
+            line += " allowed=%d" % c["allowed"]
+        print(line)
+    allowed = [r for r in results if r["status"] == "allowed"]
+    if allowed:
+        print("allowed (allowlisted):")
+        for r in allowed[:20]:
+            print("  %s — %s" % (r["path"], r.get("reason", "")))
+    gaps = [r for r in results if r["status"] == "gap"]
+    if gaps:
+        dirs = {}
+        for r in gaps:
+            d = os.path.dirname(r["path"]) or "."
+            dirs[d] = dirs.get(d, 0) + 1
+        print("gap Top 10 directories:")
+        ranked = sorted(dirs.items(), key=lambda kv: (-kv[1], kv[0]))[:10]
+        for d, n in ranked:
+            print("  %4d  %s" % (n, d))
+        print("gap files (up to 50 of %d):" % len(gaps))
+        for r in gaps[:50]:
+            print("  %s" % r["path"])
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="hurdle", description="minimal test gap scanner"
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+    scan_p = sub.add_parser("scan", help="scan PATH for untested source files")
+    scan_p.add_argument("path", help="directory tree to scan")
+    scan_p.add_argument("--json", dest="json_out", metavar="FILE", help="write JSON report")
+    scan_p.add_argument(
+        "--strict", action="store_true", help="exit 1 when at least one gap exists"
+    )
+    scan_p.add_argument(
+        "--config",
+        metavar="FILE",
+        help="config file (default: PATH/.hurdle.json when present)",
+    )
+    scan_p.add_argument(
+        "--diff",
+        metavar="BASE",
+        help="only judge files added/modified/renamed vs BASE (git; exit 2 if not a repo)",
+    )
+    uni_p = sub.add_parser(
+        "universe",
+        help="check universe coverage — every item covered, wildcarded or allowlisted",
+    )
+    uni_p.add_argument(
+        "name", help="universe name defined under 'universes' in .hurdle.json"
+    )
+    uni_p.add_argument(
+        "path", nargs="?", default=".", help="scan root (default: current directory)"
+    )
+    uni_p.add_argument("--json", dest="json_out", metavar="FILE", help="write JSON report")
+    uni_p.add_argument(
+        "--strict", action="store_true", help="exit 1 when at least one gap exists"
+    )
+    args = parser.parse_args(argv)
+
+    if args.command == "universe":
+        from hurdle import universe
+
+        return universe.run(
+            args.name, args.path, json_out=args.json_out, strict=args.strict
+        )
+
+    config_path = args.config
+    if config_path is None:
+        auto = os.path.join(os.path.abspath(args.path), DEFAULT_CONFIG_NAME)
+        config_path = auto if os.path.isfile(auto) else None
+    cfg = load_config(config_path) if config_path else Config({})
+    if args.diff:
+        check_git_repo(args.path)
+
+    root, results = scan(args.path, cfg, diff_base=args.diff)
+    summary = summarize(results)
+    report(
+        root,
+        results,
+        summary,
+        mode="diff" if args.diff else "full",
+        base=args.diff,
+        config_path=config_path,
+    )
+
+    if args.json_out:
+        payload = {
+            "path": root,
+            "generated_at": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+            "mode": "diff" if args.diff else "full",
+            "base": args.diff,
+            "config": config_path,
+            "summary": summary,
+            "files": results,
+        }
+        with open(args.json_out, "w", encoding="utf-8") as fh:
+            json.dump(payload, fh, ensure_ascii=False, indent=2)
+            fh.write("\n")
+
+    return 1 if args.strict and summary["gap"] >= 1 else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hurdle/universe.py

@@ -0,0 +1,319 @@
+"""hurdle universe — completeness gate over a defined item set (stdlib only).
+
+hurdle universe NAME [PATH] [--json FILE] [--strict]
+
+A "universe" is a set of items whose completeness is defined externally
+(e.g. every command and event of a protocol). The check extracts a usage
+set from string literals in the configured sources and computes
+intersection coverage. Gate rule: every item must be covered, covered via
+a domain wildcard, or allowlisted with a reason — a silent gap is the
+failure mode this command exists to catch.
+
+Usage set extraction (literal-intersection strategy):
+  1. every file whose relpath matches an include pattern is read whole
+     (errors='replace', at most cli.MAX_CONTENT_BYTES, like scan);
+  2. every quoted string literal of up to 120 characters whose text
+     matches literal_shape is collected (one regex, quote-paired single/
+     double variants);
+  3. collected literals ∩ items = covered — universe membership itself
+     separates commands from events because their literal shapes are
+     identical;
+  4. wildcard_patterns: substituting {domain} with each item's domain
+     (the part before the first '.') yields a regex; a content match
+     marks that domain's items status=wildcard;
+  5. extra_usage: explicit declarations, the escape hatch for methods
+     composed dynamically (missed by literal extraction) — an exact name
+     counts as covered, a glob such as "Runtime.*" as wildcard.
+
+Status precedence: covered > wildcard > allowed > gap (usage evidence
+outranks an excuse; an excuse outranks silence). The universe is defined
+under the "universes" key of .hurdle.json (auto-discovered at
+PATH/.hurdle.json, the same rule as scan):
+
+  "universes": {
+    "cdp-commands": {
+      "items_file": "universes/cdp-commands.json",
+      "include": ["src/**/*.py"],
+      "literal_shape": "^[A-Z][A-Za-z0-9]*\\.[a-zA-Z][A-Za-z0-9]+$",
+      "wildcard_patterns": ["\\.subscribe\\(\\s*\"({domain})\\.\\*\""],
+      "extra_usage": ["Page.javascriptDialogOpening"],
+      "allowlist": {"Tracing.*": "out of scope"}
+    }
+  }
+
+items_file holds a bare JSON array or {"items": [...], "meta": {...}}
+(meta passes through to the report); its path is relative to the scan
+root. include patterns are fnmatch globs matched against the relpath —
+"**/" additionally matches zero directories, and the global exclude /
+allowlist config is deliberately NOT applied to this scan. literal_shape,
+wildcard_patterns, extra_usage and allowlist are optional (the shape
+shown above is the default; allowlist values are the reasons, matched
+with fnmatch against item names).
+
+--strict exits 1 when at least one gap remains. Config, items-file or
+regex errors exit 2 via die(), including an unknown universe name.
+"""
+
+import fnmatch
+import json
+import os
+import re
+
+from .cli import DEFAULT_CONFIG_NAME, MAX_CONTENT_BYTES, die, walk
+
+LITERAL_RE = re.compile(
+    r'"([^"\n]{1,120})"' + r"|" + r"'([^'\n]{1,120})'"
+)
+DEFAULT_LITERAL_SHAPE = r"^[A-Z][A-Za-z0-9]*\.[a-zA-Z][A-Za-z0-9]+$"
+
+
+def _domain(item):
+    return item.split(".", 1)[0]
+
+
+def _glob_match(rel, pattern):
+    """fnmatch on the relpath; '**/' additionally matches zero directories."""
+    if fnmatch.fnmatch(rel, pattern):
+        return True
+    return "**/" in pattern and fnmatch.fnmatch(rel, pattern.replace("**/", ""))
+
+
+def _compile(pattern, what, name):
+    try:
+        return re.compile(pattern)
+    except re.error as exc:
+        die("universe '%s': invalid %s %r: %s" % (name, what, pattern, exc))
+
+
+def _str_list(setting, key, name, required=False):
+    """Read key as a list of non-empty strings; a lone string is wrapped."""
+    val = setting.get(key)
+    if val is None:
+        if required:
+            die("universe '%s': %s is required" % (name, key))
+        return []
+    if isinstance(val, str):
+        return [val]
+    if not isinstance(val, list) or not all(
+        isinstance(v, str) and v for v in val
+    ):
+        die("universe '%s': %s must be a list of non-empty strings" % (name, key))
+    return list(val)
+
+
+def _settings(raw_cfg, cfg_path, name):
+    universes = raw_cfg.get("universes") or {}
+    if not isinstance(universes, dict):
+        die("config %s: 'universes' must be an object" % cfg_path)
+    if name not in universes:
+        known = ", ".join(sorted(universes)) or "none defined"
+        die("universe '%s' not found in %s (known: %s)" % (name, cfg_path, known))
+    setting = universes[name]
+    if not isinstance(setting, dict):
+        die("universe '%s': definition must be an object" % name)
+    return setting
+
+
+def _load_items(root, setting, name):
+    """Return (ordered unique items, meta) from the items_file."""
+    rel = setting.get("items_file")
+    if not isinstance(rel, str) or not rel:
+        die("universe '%s': items_file is required" % name)
+    full = os.path.join(root, rel)
+    try:
+        with open(full, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except (OSError, ValueError) as exc:
+        die("cannot load items_file %s: %s" % (rel, exc))
+    if isinstance(data, dict):
+        meta = data.get("meta")
+        items = data.get("items")
+    else:
+        meta = None
+        items = data
+    if not isinstance(items, list) or not items:
+        die(
+            "items_file %s: expected a non-empty JSON array or"
+            " {'items': [...], 'meta': {...}}" % rel
+        )
+    ordered = []
+    seen = set()
+    for item in items:
+        if not isinstance(item, str) or not item:
+            die("items_file %s: items must be non-empty strings (got %r)" % (rel, item))
+        if item not in seen:
+            seen.add(item)
+            ordered.append(item)
+    return ordered, meta
+
+
+def _collect_literals(root, include, shape_re):
+    """Scan include-matched files; return (shape-valid literals, contents, file count)."""
+    literals = set()
+    contents = []
+    files = 0
+    for f in walk(root):
+        rel = os.path.relpath(f, root).replace(os.sep, "/")
+        if not any(_glob_match(rel, p) for p in include):
+            continue
+        files += 1
+        try:
+            if os.path.getsize(f) > MAX_CONTENT_BYTES:
+                continue
+            with open(f, "r", encoding="utf-8", errors="replace") as fh:
+                text = fh.read()
+        except OSError:
+            continue
+        contents.append(text)
+        for m in LITERAL_RE.finditer(text):
+            s = m.group(1) or m.group(2)
+            if shape_re.fullmatch(s):
+                literals.add(s)
+    return literals, contents, files
+
+
+def _wildcard_domains(contents, patterns, domains, name):
+    """Domains whose wildcard pattern matches any scanned content."""
+    hits = set()
+    for pat in patterns:
+        for dom in sorted(domains):
+            cre = _compile(pat.replace("{domain}", dom), "wildcard_pattern", name)
+            if any(cre.search(text) for text in contents):
+                hits.add(dom)
+    return hits
+
+
+def _evaluate(items, literals, wildcard_doms, extra_exact, extra_globs, allow_pairs):
+    rows = []
+    for item in items:
+        dom = _domain(item)
+        if item in literals or item in extra_exact:
+            status, reason = "covered", None
+        elif dom in wildcard_doms or any(
+            fnmatch.fnmatch(item, g) for g in extra_globs
+        ):
+            status, reason = "wildcard", None
+        else:
+            reason = None
+            for pat, why in allow_pairs:
+                if fnmatch.fnmatch(item, pat):
+                    reason = why
+                    break
+            status = "allowed" if reason is not None else "gap"
+        rows.append(
+            {"name": item, "domain": dom, "status": status, "allow_reason": reason}
+        )
+    return rows
+
+
+def _rollup(rows):
+    summary = {"total": len(rows), "covered": 0, "wildcard": 0, "allowed": 0, "gap": 0}
+    by_domain = {}
+    for r in rows:
+        summary[r["status"]] += 1
+        c = by_domain.setdefault(
+            r["domain"],
+            {"total": 0, "covered": 0, "wildcard": 0, "allowed": 0, "gap": 0},
+        )
+        c["total"] += 1
+        c[r["status"]] += 1
+    return summary, by_domain
+
+
+def _print_report(name, root, cfg_path, summary, by_domain, rows, files):
+    print("hurdle universe: %s" % name)
+    print("root=%s config=%s" % (root, cfg_path))
+    print("scanned files=%d" % files)
+    print(
+        "total=%(total)d covered=%(covered)d wildcard=%(wildcard)d"
+        " allowed=%(allowed)d gap=%(gap)d" % summary
+    )
+    ranked = sorted(by_domain.items(), key=lambda kv: (-kv[1]["gap"], kv[0]))[:15]
+    if ranked:
+        print("domain Top %d by gap:" % len(ranked))
+        print(
+            "  %-24s %5s %4s %4s %6s %5s"
+            % ("domain", "total", "cov", "wc", "allow", "gap")
+        )
+        for dom, c in ranked:
+            print(
+                "  %-24s %5d %4d %4d %6d %5d"
+                % (
+                    dom,
+                    c["total"],
+                    c["covered"],
+                    c["wildcard"],
+                    c["allowed"],
+                    c["gap"],
+                )
+            )
+    allowed = [r for r in rows if r["status"] == "allowed"]
+    if allowed:
+        print("allowed (allowlisted):")
+        for r in allowed[:20]:
+            print("  %s — %s" % (r["name"], r.get("allow_reason") or ""))
+    gaps = [r for r in rows if r["status"] == "gap"]
+    if gaps:
+        print("gap items (up to 50 of %d):" % len(gaps))
+        for r in gaps[:50]:
+            print("  %s" % r["name"])
+
+
+def run(name, path=".", json_out=None, strict=False):
+    root = os.path.abspath(path)
+    cfg_path = os.path.join(root, DEFAULT_CONFIG_NAME)
+    if not os.path.isfile(cfg_path):
+        die(
+            "no %s in %s — universe definitions require config"
+            % (DEFAULT_CONFIG_NAME, root)
+        )
+    try:
+        with open(cfg_path, "r", encoding="utf-8") as fh:
+            raw = json.load(fh)
+    except (OSError, ValueError) as exc:
+        die("cannot load config %s: %s" % (cfg_path, exc))
+    if not isinstance(raw, dict):
+        die("config %s: expected a JSON object" % cfg_path)
+    setting = _settings(raw, cfg_path, name)
+
+    items, meta = _load_items(root, setting, name)
+    include = _str_list(setting, "include", name, required=True)
+    shape = setting.get("literal_shape") or DEFAULT_LITERAL_SHAPE
+    if not isinstance(shape, str):
+        die("universe '%s': literal_shape must be a string" % name)
+    shape_re = _compile(shape, "literal_shape", name)
+    patterns = _str_list(setting, "wildcard_patterns", name)
+    extra_usage = _str_list(setting, "extra_usage", name)
+    allow = setting.get("allowlist") or {}
+    if not isinstance(allow, dict) or not all(
+        isinstance(k, str) and isinstance(v, str) and k for k, v in allow.items()
+    ):
+        die(
+            "universe '%s': allowlist must map item-name globs to reason strings"
+            % name
+        )
+    allow_pairs = list(allow.items())
+
+    literals, contents, files = _collect_literals(root, include, shape_re)
+    domains = {_domain(i) for i in items}
+    wildcard_doms = _wildcard_domains(contents, patterns, domains, name)
+    extra_exact = {e for e in extra_usage if not any(c in e for c in "*?[")}
+    extra_globs = [e for e in extra_usage if any(c in e for c in "*?[")]
+
+    rows = _evaluate(items, literals, wildcard_doms, extra_exact, extra_globs, allow_pairs)
+    summary, by_domain = _rollup(rows)
+    _print_report(name, root, cfg_path, summary, by_domain, rows, files)
+
+    if json_out:
+        payload = {
+            "universe": name,
+            "meta": meta,
+            "summary": summary,
+            "by_domain": by_domain,
+            "items": rows,
+        }
+        with open(json_out, "w", encoding="utf-8") as fh:
+            json.dump(payload, fh, ensure_ascii=False, indent=2)
+            fh.write("\n")
+
+    return 1 if strict and summary["gap"] >= 1 else 0

hurdle_gate-0.3.1.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: hurdle-gate
+Version: 0.3.1
+Summary: Static-analysis gate for source↔test file existence mapping
+License-Expression: Apache-2.0
+Keywords: testing,test-coverage,static-analysis,ci,quality-gate
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# hurdle
+
+A source ↔ test **existence mapping** tool. A single-file executable that finds
+source files added without tests (Python 3 standard library only, zero external
+dependencies).
+
+**What it does** — decides from filename/path conventions alone whether each
+source file has a corresponding test, and reports the gaps (untested sources).
+Text is the default output; `--json` produces a machine-readable report.
+
+**What it does not do**
+- Does not **run** tests — existence only; whether tests pass is out of scope.
+- Does not measure **coverage** — this is a different (and far cheaper) signal
+  than line/branch coverage: "does this file have any test at all?"
+- Does not judge code **quality** — a test file that exists but is thin will
+  not be caught.
+
+## Installation
+
+```bash
+# Recommended: isolated install via pipx
+pipx install .
+
+# Development: venv + editable install (includes dev extras)
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e .[dev]
+
+# Environments where pip is unavailable (PEP 668 etc.): runs without installing
+PYTHONPATH=src python3 -m hurdle scan .
+```
+
+## Quick start
+
+```bash
+# 1) Full scan — gap report for the whole repository (use this to create a baseline)
+hurdle scan ~/study/kopia --json kopia.json
+
+# 2) diff mode — evaluate only sources new/changed vs. a base point (core of the local/CI gate)
+hurdle scan . --diff origin/main
+
+# 3) strict mode — fail (non-zero exit code) if any evaluated file has a gap
+hurdle scan . --diff origin/main --strict --config .hurdle.json
+```
+
+Reading the output: the report shows a per-file status (`matched` / `gap` /
+`unmapped` — files with unknown extensions are counted only as `unmapped` and
+excluded from language totals), each file's matching test and confidence
+(`exact`/`heuristic`), and per-language totals. Exit codes under `--strict`:
+no gaps = 0, gaps present = failure, runtime error (e.g. `--diff` outside a
+git repository) = 2. CI decides pass/fail from the strict-mode exit code.
+
+## Verdict rules (per language)
+
+| Language | Test-existence verdict | confidence |
+|---|---|---|
+| **go** | Package-level: an exact `{stem}_test.go` match wins first; otherwise covered if any `*_test.go` exists in the same package (directory) | exact |
+| **py** | Probes 4 pytest-convention candidate paths — beside the file / in a `tests/` directory × `test_{stem}.py` / `{stem}_test.py` combinations — plus variant names `tests/test_{stem}_*.py` and `tests/test_*_{stem}.py` (v0.2.0). `__init__.py` counts as a package marker and non-test files under `test_dirs` (default `tests`, `test`) count as test-support — both excluded rather than gapped (config: `strict_init`, `test_dirs`) | exact |
+| **ts/js** | Naming conventions: the `*.test.ts(x)` / `*.spec.ts(x)` families | exact |
+| **c / shell** | File-to-file mapping is impossible in trees like lustre (centralized `lustre/tests/` + `kunit/`), so coverage is aggregated per module/directory (heuristic). Listing module→test keywords in `module_map` improves accuracy | heuristic |
+
+## Configuration (.hurdle.json)
+
+Passed via `--config`. See `.hurdle.example.json` in this repository for a
+minimal example and `baselines/*.hurdle.json` for real-world ones.
+
+```jsonc
+{
+  "exclude": ["vendor/", "**/*_pb.go"],        // kept out of the scan
+  "allowlist": { "cmd/legacy/main.go": "thin wrapper; covered in pkg/" },
+  "module_map": { "lustre/osd-zfs": ["osd", "conf-sanity"] }
+}
+```
+
+| Key | Format | Description |
+|---|---|---|
+| `exclude` | array of strings | Directories are excluded wholesale with a trailing `/` in the name (`vendor/`). Everything else is an fnmatch pattern matched against full paths/filenames (`**/*_pb.go`) |
+| `allowlist` | relpath → reason string | Do not count this file as a gap (escape hatch). Checked **before exclude**, so a file with an explicit reason survives even broad exclude patterns. The reason stays on record in commit history |
+| `module_map` | module relpath → keyword array | Feeds the C/shell heuristic. List the test-suite keywords that cover a module (e.g. `["sanity", "conf-sanity"]`) and module coverage is looked up in the centralized tests/ directory |
+
+## Baseline → gate workflow
+
+The core design is a **ratchet**: existing gaps are frozen, and only new gaps
+are blocked.
+
+1. **Capture a baseline** — run a full scan, commit the resulting JSON gap
+   report (covering all existing code) to the repository. This becomes a
+   de-facto allowlist. The actual results of doing this for the kopia/lustre/
+   longhorn-manager/velero repositories are in [BASELINES.md](BASELINES.md)
+   and `baselines/*.json`.
+2. **Classify with config** — filter generated code (`*_pb.go` etc.), vendor,
+   and test-support code (`internal/testutil` etc.) via `exclude`/`allowlist`
+   so that only files with genuinely no corresponding test remain in the
+   baseline.
+3. **diff + strict gate** — in CI, `--diff origin/<base> --strict` judges only
+   the files changed now. Legacy gaps never show up in the diff and are
+   ignored; only new/modified files are forced to carry tests. The gap count
+   decreases monotonically.
+
+## CI integration
+
+Copy `ci/test-exist-gate.yml` to `.github/workflows/test-exist-gate.yml` in the
+target repository and follow the 4 steps in the comment block at the top of
+the file (swap the URL, commit the config, mark the check as required). The
+flow: `fetch-depth: 0` checkout → install hurdle → run
+`scan . --diff origin/base --strict --config .hurdle.json --json` → upload the
+report artifact even on failure (`if: always()`).
+
+## pre-commit local hook
+
+Copy `ci/pre-commit-hook.sh` to `.git/hooks/pre-commit`, or use this minimal
+3-line form:
+
+```bash
+#!/bin/sh
+[ -n "$(git diff --name-only --diff-filter=ACMR HEAD)" ] || exit 0
+exec hurdle scan . --diff HEAD --strict
+```
+
+## Limitations (honestly)
+
+- **It only checks file existence.** It never sees whether tests run, pass, or
+  assert anything meaningful. It is a minimal gate against "source added with
+  no test" — not a coverage replacement.
+- **Heuristic module verdicts can over- and under-count.** The module-aggregated
+  C/shell verdict depends on `module_map` keywords: keywords that are too
+  broad over-report coverage; a missing per-module suite under-reports it.
+  Treat the report's confidence markers as the trust boundary.
+- **The only escape hatch is the allowlist.** When a rule misjudges a file,
+  allowlisting it with a reason is the sole exception path — hiding it with
+  exclude removes it from the scan entirely and breaks gap tracking.
+
+## License
+
+Apache-2.0 — see the [LICENSE](LICENSE) file for the full text.
+
+## Universe coverage (`hurdle universe`)
+
+Beyond per-file test existence, hurdle can enforce coverage of a
+**defined universe** — a complete set of items every one of which must be
+either used, wildcard-covered, or explicitly allowlisted. The motivating
+case: CDP protocol commands/events (`protocol.json` defines the complete
+universe, so "missing something" is well-defined).
+
+```jsonc
+// .hurdle.json
+"universes": {
+  "cdp-commands": {
+    "items_file": "universes/cdp-commands.json",   // bare array or {"items":[], "meta":{}}
+    "include": ["src/**/*.py"],
+    "literal_shape": "^[A-Z][A-Za-z0-9]*\\.[a-zA-Z][A-Za-z0-9]+$",
+    "wildcard_patterns": ["\\.subscribe\\(\\s*\"({domain})\\.\\*\""],
+    "extra_usage": ["Page.javascriptDialogOpening"],
+    "allowlist": {"Tracing.*": "out of scope — low-level tracing"}
+  }
+}
+```
+
+```bash
+hurdle universe cdp-commands . --strict --json report.json
+```
+
+- Usage extraction collects shape-matched string literals (module
+  constants are picked up at their definition site) and intersects them
+  with the universe — universe membership itself disambiguates commands
+  vs events that share the `Domain.name` shape.
+- Statuses: `covered` / `wildcard` (a `Domain.*` subscription) /
+  `allowed` (fnmatch on item names, reason recorded) / `gap`.
+- `--strict` exits 1 on any gap that is not allowlisted — newly added
+  universe items cannot appear silently.

hurdle_gate-0.3.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+hurdle/__init__.py,sha256=i5u-ZMlsWeUMLmVdE6IWWnuhQfntLDtLRuzX-y3SW_8,103
+hurdle/__main__.py,sha256=MjfbwyISQsdxEbdSL5Wgy-NfqO4NFj-yPFPkYCArzMI,58
+hurdle/cli.py,sha256=GBXNTrgIakAaoRNQXdR45hR6Bf8zrhpnYi4asOMEvBw,18703
+hurdle/universe.py,sha256=qKp4DMqijkW3kmuEQwsPs8Xhu3VZPpZCJQQxtkW9990,11898
+hurdle_gate-0.3.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+hurdle_gate-0.3.1.dist-info/METADATA,sha256=vigo-dozLuWv3dHeE7KKtIntwMltP-ipGzC-K78ul9c,8600
+hurdle_gate-0.3.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hurdle_gate-0.3.1.dist-info/entry_points.txt,sha256=1oTz-KQby1bASFUDQPLUGl2R4Wz4bzwXiCt1k_kicx8,43
+hurdle_gate-0.3.1.dist-info/top_level.txt,sha256=W__hcnaY6CM3gHRC8NyzOeEFu8xkQROLjifBSqq8Dms,7
+hurdle_gate-0.3.1.dist-info/RECORD,,

hurdle_gate-0.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hurdle_gate-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hurdle = hurdle.cli:main

hurdle_gate-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

hurdle_gate-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+hurdle