diffimpactscout 0.1.0__py3-none-any.whl

diffimpactscout/impact/diff_parser.py

@@ -0,0 +1,181 @@
+"""Parse git diffs into file changes and extract Python definitions and usages from source content.
+
+Example: a renamed module shows up with both its new and old path so
+references to the old name can still be found.
+"""
+
+import ast
+import os
+import re
+
+import diffimpactscout.gitrun as gitrun
+
+
+class Entity(object):
+    def __init__(self, name, kind, line, qualname):
+        self.name = name
+        self.kind = kind
+        self.line = line
+        self.qualname = qualname
+
+
+class FileChange(object):
+    def __init__(self, path, status, old_path=None, ext=None):
+        self.path = path
+        self.status = status
+        self.old_path = old_path
+        self.ext = ext
+
+
+_STATUS_RE = re.compile(r"^[AMDCTR]\d*$")
+_FUNCS = (ast.FunctionDef, ast.AsyncFunctionDef)
+
+
+def get_file_changes(root, anchor=None, staged=False, from_ref=None, to_ref=None):
+    if staged:
+        return _diff_changes(root, ["--cached"])
+    if anchor:
+        return _diff_changes(root, [anchor, "HEAD"])
+    if from_ref and to_ref:
+        return _diff_changes(root, [from_ref, to_ref])
+    changes = {}
+    for tail in (["--cached"], ["HEAD"], []):
+        for change in _diff_changes(root, tail):
+            if change.path not in changes:
+                changes[change.path] = change
+    return list(changes.values())
+
+
+def _diff_changes(root, tail):
+    args = ["diff", "--name-status", "-z", "--diff-filter=ACMRTD", "--find-renames"]
+    args.extend(tail)
+    changes = _parse_name_status(gitrun.git_nul(args, root), root)
+    for change in changes:
+        if change.status[0] == "D" and change.old_path is None:
+            change.old_path = change.path
+    return changes
+
+
+def _parse_name_status(data, root):
+    changes = []
+    i = 0
+    n = len(data)
+    while i < n:
+        field = data[i]
+        if not _STATUS_RE.match(field):
+            i += 1
+            continue
+        status = field
+        i += 1
+        if status[0] in "RC":
+            if i + 1 >= n:
+                break
+            old_path = _relpath(root, data[i])
+            new_path = _relpath(root, data[i + 1])
+            i += 2
+            changes.append(
+                FileChange(new_path, status, old_path, _ext(new_path))
+            )
+        else:
+            if i >= n:
+                break
+            path = _relpath(root, data[i])
+            i += 1
+            changes.append(FileChange(path, status, None, _ext(path)))
+    return changes
+
+
+def _relpath(root, path):
+    if path is None:
+        return None
+    if os.path.isabs(path) and root:
+        return os.path.relpath(path, root)
+    return path
+
+
+def _ext(path):
+    return os.path.splitext(path)[1].lstrip(".").lower()
+
+
+def read_path_at_ref(root, path, ref):
+    result = gitrun.git(["show", "%s:%s" % (ref, path)], root)
+    if not result.ok():
+        return ""
+    return result.out_
+
+
+def extract_entities(source):
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+    entities = []
+    _walk(tree, [], entities)
+    return entities
+
+
+def _walk(node, scope, entities):
+    for child in ast.iter_child_nodes(node):
+        if isinstance(child, ast.ClassDef):
+            entities.append(
+                Entity(
+                    child.name,
+                    "class",
+                    getattr(child, "lineno", 0),
+                    _qualname(scope, child.name),
+                )
+            )
+            _walk(child, scope + [("class", child.name)], entities)
+        elif isinstance(child, _FUNCS):
+            kind = None
+            if not scope:
+                kind = "function"
+            elif scope[-1][0] == "class":
+                kind = "method"
+            if kind is not None:
+                entities.append(
+                    Entity(
+                        child.name,
+                        kind,
+                        getattr(child, "lineno", 0),
+                        _qualname(scope, child.name),
+                    )
+                )
+            _walk(child, scope + [("function", child.name)], entities)
+        elif isinstance(child, (ast.Assign, ast.AnnAssign)):
+            for target in _assign_targets(child):
+                if not scope:
+                    entities.append(
+                        Entity(target, "module_field", getattr(child, "lineno", 0), target)
+                    )
+                elif scope[-1][0] == "class":
+                    entities.append(
+                        Entity(
+                            target,
+                            "class_field",
+                            getattr(child, "lineno", 0),
+                            _qualname(scope, target),
+                        )
+                    )
+            _walk(child, scope, entities)
+        else:
+            _walk(child, scope, entities)
+
+
+def _assign_targets(node):
+    if isinstance(node, ast.AnnAssign):
+        target = node.target
+        if isinstance(target, ast.Name):
+            return [target.id]
+        return []
+    targets = []
+    for target in node.targets:
+        if isinstance(target, ast.Name):
+            targets.append(target.id)
+    return targets
+
+
+def _qualname(scope, name):
+    parts = [n for _kind, n in scope]
+    parts.append(name)
+    return ".".join(parts)

diffimpactscout/impact/impact.py

@@ -0,0 +1,345 @@
+"""Blast-radius orchestration: link changed symbols to template and frontend references and emit a report.
+
+Example: deleting an endpoint class raises a High row for every place still
+referencing its old name.
+"""
+
+import ast
+import json
+import os
+import sys
+
+import diffimpactscout.env as env
+import diffimpactscout.gitrun as gitrun
+import diffimpactscout.scope as scope
+from diffimpactscout.config import is_excluded
+from diffimpactscout.impact import reporter
+from diffimpactscout.impact import route_linker
+from diffimpactscout.impact import python_analyzer as pa
+from diffimpactscout.impact.cache import SymbolCache
+from diffimpactscout.impact.diff_parser import extract_entities, get_file_changes, read_path_at_ref
+
+_ENTITY_KINDS = {
+    "class_field": ("attr",),
+    "function": ("name", "attr", "import"),
+    "module_field": ("name", "attr", "import"),
+    "method": ("name", "attr"),
+    "class": ("name", "attr", "import"),
+}
+
+_DEFAULT_KINDS = ("name",)
+
+
+def run_impact(root, cfg, staged=False, fast=False, json_out=False):
+    if _skip_requested():
+        return 0
+    impact_cfg = cfg.get("impact") or {}
+    profile = impact_cfg.get("profile") or "plain"
+    from_ref, to_ref = env.pre_commit_refs()
+    anchor = None
+    if not staged:
+        anchor = scope.DevScope(root).scope_base(from_ref, to_ref)
+    changes = get_file_changes(root, anchor, staged, from_ref, to_ref)
+    changed_paths = [c.path for c in changes]
+    if staged:
+        old_ref = "HEAD"
+    elif anchor:
+        old_ref = anchor
+    else:
+        old_ref = from_ref
+    entities = _changed_entities(changes, root, old_ref)
+    cache_file = impact_cfg.get("cache_file") or ".impact_analysis_cache.json"
+    if root and not os.path.isabs(cache_file):
+        cache_file = os.path.join(root, cache_file)
+    cache = SymbolCache(cache_file)
+    py_files = _python_files(root, cfg)
+    if fast:
+        sys.stderr.write(
+            "diffimpactscout: fast mode; template/frontend scanning skipped, "
+            "python scans limited to import-linked files\n"
+        )
+        scan = _fast_subset(root, py_files, cache.load(), entities, changes)
+    else:
+        scan = py_files
+    for path in scan:
+        pa.analyze_path(path, root, cache)
+    cache.prune(py_files)
+    cache.save(cache.load())
+    analyses = cache.load()
+    rows, unresolved = _compose_rows(
+        root, impact_cfg, profile, entities, analyses, changed_paths, fast
+    )
+    changed_count = len(changes)
+    if json_out:
+        sys.stdout.write(
+            json.dumps(
+                {
+                    "changed_count": changed_count,
+                    "rows": rows,
+                    "unresolved": unresolved,
+                }
+            )
+            + "\n"
+        )
+    else:
+        sys.stdout.write(reporter.render_report(rows, unresolved, changed_count))
+    strict_env = os.environ.get("IMPACT_CHECK_STRICT")
+    tty = reporter.interactive_tty()
+    block, reason = reporter.should_block(strict_env, tty)
+    if block:
+        if tty:
+            block = not reporter.confirm("Proceed with push? (Y/n)")
+        else:
+            sys.stderr.write("diffimpactscout: %s\n" % reason)
+    return 1 if block else 0
+
+
+def _skip_requested():
+    return env.skip_requested()
+
+
+def _changed_entities(changes, root, old_ref):
+    entities = {}
+    for change in changes:
+        if change.ext != "py":
+            continue
+        old_path = change.old_path
+        if old_path is None or change.status[0] != "R":
+            old_path = change.path
+        old_src = read_path_at_ref(root, old_path, old_ref) if old_ref else ""
+        new_src = _read_disk(root, change.path)
+        old_map = _entity_map(old_src)
+        new_map = _entity_map(new_src)
+        for name, kind in new_map.items():
+            if name not in entities:
+                entities[name] = {"kind": kind, "deleted": False}
+            elif entities[name].get("deleted"):
+                entities[name] = {"kind": kind, "deleted": False}
+        for name, kind in old_map.items():
+            if name not in new_map:
+                entities[name] = {"kind": kind, "deleted": True}
+    return entities
+
+
+def _entity_map(source):
+    return {e.name: e.kind for e in extract_entities(source)}
+
+
+def _compose_rows(root, impact_cfg, profile, entities, analyses, changed_paths, fast):
+    rows = []
+    layers = {}
+    for name, ent in entities.items():
+        kinds = _ENTITY_KINDS.get(ent["kind"], _DEFAULT_KINDS)
+        hits = pa.find_references(analyses, [name], kinds=kinds)
+        layers.setdefault(name, set())
+        for hit in hits:
+            layers[name].add("python")
+            rows.append(_python_row(hit, name, ent))
+    routes = _routes(root, impact_cfg, profile)
+    if fast:
+        template_refs = []
+        frontend_refs = []
+    else:
+        template_refs = route_linker.extract_template_refs(
+            root, impact_cfg.get("template_globs")
+        )
+        frontend_refs = route_linker.extract_frontend_refs(
+            root, impact_cfg.get("frontend_globs")
+        )
+    template_matched, template_unresolved = route_linker.match_template_refs(
+        template_refs, routes
+    )
+    frontend_matched, frontend_unresolved = route_linker.match_endpoints(
+        frontend_refs, routes
+    )
+    unresolved = list(template_unresolved)
+    unresolved.extend(frontend_unresolved)
+    for hit in template_matched:
+        name = _handler_entity(hit.get("route"), entities)
+        if name is None:
+            continue
+        layers.setdefault(name, set()).add("template")
+        rows.append(_template_row(hit, name, entities[name]))
+    for hit in frontend_matched:
+        name = _handler_entity(hit.get("route"), entities)
+        if name is None:
+            continue
+        layers.setdefault(name, set()).add("frontend")
+        rows.append(_frontend_row(hit, name, entities[name]))
+    rows = _dedup_rows(rows)
+    rows.sort(key=_row_key)
+    for row in rows:
+        name = row.pop("_entity")
+        deleted = row.pop("_deleted")
+        row["severity"] = reporter.classify_severity(
+            layers.get(name) or (), deleted, changed_paths, row.get("path")
+        )
+        row["action"] = _action(row["severity"], deleted)
+    return rows, unresolved
+
+
+def _dedup_rows(rows):
+    out = []
+    seen = set()
+    for row in rows:
+        key = (row.get("path") or "", row.get("category") or "", row.get("ref") or "")
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(row)
+    return out
+
+
+def _row_key(row):
+    return (row.get("path") or "", row.get("category") or "", row.get("ref") or "")
+
+
+def _python_row(hit, name, ent):
+    path = hit.get("path") or ""
+    ctx = hit.get("ctx_qname") or ""
+    return {
+        "path": path,
+        "module": ctx if ctx else _dir_of(path),
+        "category": "python",
+        "ref": "%s (%s at %s:%d)" % (hit.get("name"), hit.get("how"), path, hit.get("line", 0)),
+        "_entity": name,
+        "_deleted": bool(ent.get("deleted")),
+    }
+
+
+def _template_row(hit, name, ent):
+    path = hit.get("file") or ""
+    return {
+        "path": path,
+        "module": _dir_of(path),
+        "category": "template",
+        "ref": "{%% url '%s' %%} at %s" % (hit.get("ref"), path),
+        "_entity": name,
+        "_deleted": bool(ent.get("deleted")),
+    }
+
+
+def _frontend_row(hit, name, ent):
+    path = hit.get("file") or ""
+    method = hit.get("method") or "get"
+    line = hit.get("line") or 0
+    return {
+        "path": path,
+        "module": _dir_of(path),
+        "category": "frontend",
+        "ref": 'http.%s("%s") at %s:%d' % (method, hit.get("ref"), path, line),
+        "_entity": name,
+        "_deleted": bool(ent.get("deleted")),
+    }
+
+
+def _handler_entity(route, entities):
+    if route is None or not route.handler:
+        return None
+    handler = route.handler
+    if handler.endswith("()"):
+        handler = handler[:-2]
+    if handler.endswith(".as_view"):
+        handler = handler[:-len(".as_view")]
+    base = handler.rsplit(".", 1)[-1]
+    if base in entities:
+        return base
+    return None
+
+
+def _routes(root, impact_cfg, profile):
+    if profile == "django":
+        return route_linker.extract_django_routes(root, impact_cfg.get("urls_globs"))
+    if profile == "fastapi":
+        return route_linker.extract_fastapi_routes(root, impact_cfg.get("urls_globs"))
+    return []
+
+
+def _action(severity, deleted):
+    if deleted:
+        return "verify dangling references"
+    if severity == "High":
+        return "review/verify"
+    if severity == "Medium":
+        return "verify"
+    return "ok"
+
+
+def _python_files(root, cfg):
+    files = []
+    for path in gitrun.git_nul(["ls-files", "-z", "*.py"], root):
+        if not is_excluded(path, cfg, root):
+            files.append(path)
+    return files
+
+
+def _fast_subset(root, py_files, cache_data, entities, changes):
+    seed = set(entities.keys())
+    for change in changes:
+        if change.ext == "py":
+            seed.add(change.path[:-3].rsplit("/", 1)[-1])
+    index = {}
+    for path in py_files:
+        analysis = _peel(cache_data.get(path))
+        if isinstance(analysis, dict):
+            index[path] = _analysis_imports(analysis)
+        else:
+            index[path] = _import_names(_read_disk(root, path))
+    subset = set()
+    for change in changes:
+        if change.ext == "py":
+            subset.add(change.path)
+    for path in py_files:
+        if index.get(path) and (index[path] & seed):
+            subset.add(path)
+    return sorted(subset)
+
+
+def _peel(entry):
+    if isinstance(entry, dict):
+        analysis = entry.get("analysis")
+        if isinstance(analysis, dict):
+            return analysis
+    return entry
+
+
+def _analysis_imports(analysis):
+    names = set()
+    if not isinstance(analysis, dict):
+        return names
+    for usage in analysis.get("usages") or []:
+        if usage.get("kind") == "import" and usage.get("name"):
+            names.add(usage["name"])
+    return names
+
+
+def _import_names(source):
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError, TypeError):
+        return set()
+    names = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                names.add(alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                names.add(alias.name)
+    return names
+
+
+def _read_disk(root, path):
+    if not path:
+        return ""
+    full = os.path.join(root, path) if root else path
+    try:
+        with open(full, "rb") as fh:
+            data = fh.read()
+    except (OSError, ValueError):
+        return ""
+    return data.decode("utf-8", "replace")
+
+
+def _dir_of(path):
+    return os.path.dirname(path or "") or ""