ripple-sql 0.1.5__tar.gz → 0.1.7__tar.gz

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/CHANGELOG.md

@@ -6,6 +6,16 @@ Notable changes to Ripple. The format follows
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-09-10
+
+### Fixed
+- A plain-SQL repo's `udf.sql` is the function its folder names. Mozilla's bigquery-etl keeps 155 of them at `udf_js/<function>/udf.sql`; named by file every one was "udf", the collision handler mangled them into path names, and the home page listed 118 one-file folders. The folder is the function now, `udf_js.<function>` is its alias, and those files sit in their dataset's row.
+
+## [0.1.6] - 2026-09-10
+
+### Fixed
+- Thirty-six findings from three rounds of a two-model review of the 0.1.3 to 0.1.5 work: the engine and map fixes each pinned by a test, the page fixes checked with headless browser probes (the page has no automated tests). Rounds two and three also settled INLINE over NULL and non-struct elements, name-matched fields, `AS (xx, yy)` alias lists, maps behind parentheses and casts, a cap before `as_native` parses, kind-prefixed group identities, the loader's own say on which folders are tables, and a cycle twin that stays visible while its other copy is folded. Engine: the generator names (`INLINE`, `EXPLODE`, `POSEXPLODE`) survive schema qualification, which reparsed the original SQL and threw them away; each `INLINE` output now takes lineage from its own struct field, not every field; `EXPLODE` over a map yields `key` and `value`; `as_number` keeps floats and `as_native` reads Python literals as dbt documents. Page: hovering a group heading threw instead of tinting (the group adjacency was walked as arrays); a group or model named `constructor` or `__proto__` crashed the page; a model's badge and a group's reader count included dashboard numbers while the key said models; a column suggestion showed its model's reader count instead of its own; two folders ending in the same name, or a schema and a folder of one name, merged into one row; a monorepo model named `models__marts__a` lost its folder; the filter went stale across focus and home and fought the fold; a late answer could overwrite newer navigation; Escape did not leave focus from the question box; a cycle drew a model on both sides; the typeahead left a stale `aria-activedescendant`.
+
 ## [0.1.5] - 2026-09-09
 
 ### Added
@@ -254,7 +264,9 @@ First public release.
 ### Removed
 - The dark whole-graph canvas that `ripple serve` used to open (`static/index.html`). Every surface now draws one answer.
 
-[Unreleased]: https://github.com/bteh/ripple/compare/v0.1.5...HEAD
+[Unreleased]: https://github.com/bteh/ripple/compare/v0.1.7...HEAD
+[0.1.7]: https://github.com/bteh/ripple/releases/tag/v0.1.7
+[0.1.6]: https://github.com/bteh/ripple/releases/tag/v0.1.6
 [0.1.5]: https://github.com/bteh/ripple/releases/tag/v0.1.5
 [0.1.4]: https://github.com/bteh/ripple/releases/tag/v0.1.4
 [0.1.3]: https://github.com/bteh/ripple/releases/tag/v0.1.3

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ripple-sql
-Version: 0.1.5
+Version: 0.1.7
 Summary: Offline column-level SQL lineage. See what breaks before you merge.
 Project-URL: Homepage, https://github.com/bteh/ripple
 Project-URL: Repository, https://github.com/bteh/ripple

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ripple-sql"
-version = "0.1.5"
+version = "0.1.7"
 description = "Offline column-level SQL lineage. See what breaks before you merge."
 readme = "README.md"
 requires-python = ">=3.10"

ripple_sql-0.1.7/src/ripple/engine/generators.py

@@ -0,0 +1,149 @@
+"""Bare table-generating functions name their own output columns.
+
+Spark's `SELECT INLINE(ARRAY(STRUCT('a' AS platform)))` has no alias and
+no column reference; its output columns are the struct's fields. A bare
+`EXPLODE(x)` is a column called `col`, `POSEXPLODE(x)` is `pos` and `col`,
+and over a map they are `key` and `value`. sqlglot leaves such items
+nameless, and the projection walks named them by their SQL text or dropped
+them, so a lookup table built this way reported no columns at all
+(Wikimedia dbt-jobs, platforms_ephemeral).
+
+The rewrite gives each output its default name as an alias over the
+expression that feeds it, before any projection walk runs: a struct field
+feeds its own output only, so a change to one field does not ripple to
+every column of the table.
+"""
+
+from __future__ import annotations
+
+from sqlglot import exp
+
+Output = tuple[str, exp.Expression]
+
+
+def generator_outputs(item: exp.Expression) -> list[Output] | None:
+    """(name, expression) per output column of a bare generator, None for
+    anything else. `INLINE(...) AS (xx, yy)` is the same generator with its
+    outputs named by position."""
+    if isinstance(item, exp.Aliases):
+        inner = generator_outputs(item.this)
+        names = [alias.name for alias in item.expressions]
+        if inner is None or len(names) != len(inner):
+            return None
+        return [(name, expr) for name, (_, expr) in zip(names, inner, strict=True)]
+    if isinstance(item, exp.Inline):
+        return _inline_outputs(item)
+    if isinstance(item, (exp.Explode, exp.Posexplode)):
+        return _explode_outputs(item)
+    return None
+
+
+def _struct_fields(element: exp.Expression) -> list[Output] | None:
+    if not isinstance(element, exp.Struct):
+        return None
+    fields: list[Output] = []
+    for field in element.expressions:
+        if isinstance(field, exp.PropertyEQ):
+            fields.append((field.this.name, field.expression))
+        elif isinstance(field, exp.Alias):
+            fields.append((field.alias, field.this))
+        elif isinstance(field, exp.Column):
+            fields.append((field.name, field))
+        else:
+            return None
+    return fields or None
+
+
+def _inline_outputs(item: exp.Inline) -> list[Output] | None:
+    """INLINE over a literal array: the first struct names the outputs and
+    field i of every struct feeds output i. That is Spark's own rule: the
+    array has one element type, and a later struct must carry the same
+    field names at the same positions, case-insensitively, or the query
+    fails analysis (TypeCoercion.findTypeForComplex). A struct whose names
+    are a permutation of the first's would not run in Spark; it is read by
+    name, as written. A NULL element adds nothing, and an element that is
+    not a struct literal (a struct column, a CASE) feeds every output, since
+    its fields cannot be told apart."""
+    array = item.this
+    if not (isinstance(array, exp.Array) and array.expressions):
+        return None
+    elements = [e for e in array.expressions if not isinstance(e, exp.Null)]
+    structs = [(e, _struct_fields(e)) for e in elements]
+    first = next((fields for _, fields in structs if fields), None)
+    if first is None:
+        return None
+    names = [name for name, _ in first]
+    feeds: list[list[exp.Expression]] = [[] for _ in names]
+    for element, fields in structs:
+        if fields is None:
+            for fed_by in feeds:
+                fed_by.append(element.copy())
+            continue
+        matched = _match_fields(first, fields)
+        if matched is None:
+            return None
+        for fed_by, expr in zip(feeds, matched, strict=True):
+            fed_by.append(expr.copy())
+    return [
+        (name, fed_by[0] if len(fed_by) == 1 else exp.Array(expressions=fed_by))
+        for name, fed_by in zip(names, feeds, strict=True)
+    ]
+
+
+def _match_fields(first: list[Output], fields: list[Output]) -> list[exp.Expression] | None:
+    """The expression of `fields` feeding each output of `first`, in order:
+    by position when the names line up (the only shape Spark accepts, and
+    the only reading when two unnamed fields share a name, `a.id, b.id`);
+    by name when they are a permutation; None when the shapes disagree."""
+    if len(fields) != len(first):
+        return None
+    want = [name.lower() for name, _ in first]
+    have = [name.lower() for name, _ in fields]
+    if want == have or len(set(have)) != len(have) or set(want) != set(have):
+        return [expr for _, expr in fields]
+    by_name = {name.lower(): expr for name, expr in fields}
+    return [by_name[name] for name in want]
+
+
+def _is_map(source: exp.Expression) -> bool:
+    if isinstance(source, (exp.Map, exp.VarMap)):
+        return True
+    to = source.args.get("to") if isinstance(source, exp.Cast) else None
+    return isinstance(to, exp.DataType) and to.this == exp.DataType.Type.MAP
+
+
+def _explode_outputs(item: exp.Expression) -> list[Output]:
+    """EXPLODE and POSEXPLODE: `col` fed by the whole call over an array;
+    `key` and `value` fed by the map's keys and values when the input is
+    visibly a map, or both by the whole map when only its type is visible
+    (a CAST to MAP). `pos` comes from the whole call either way."""
+    source = item.this
+    while isinstance(source, exp.Paren):
+        source = source.this
+    if isinstance(source, (exp.Map, exp.VarMap)):
+        outputs: list[Output] = [("key", source.args["keys"]), ("value", source.args["values"])]
+    elif _is_map(source):
+        outputs = [("key", source), ("value", source)]
+    else:
+        outputs = [("col", item)]
+    if isinstance(item, exp.Posexplode):
+        outputs = [("pos", item)] + outputs
+    return [(name, expr.copy()) for name, expr in outputs]
+
+
+def name_generator_outputs(tree: exp.Expression) -> exp.Expression:
+    """Alias every bare generator in every select list with its default
+    output names, in place, and return the tree."""
+    for select in list(tree.find_all(exp.Select)):
+        items = select.expressions
+        if not any(generator_outputs(item) for item in items):
+            continue
+        renamed: list[exp.Expression] = []
+        for item in items:
+            outputs = generator_outputs(item)
+            if not outputs:
+                renamed.append(item)
+                continue
+            renamed.extend(exp.alias_(expr, name) for name, expr in outputs)
+        select.set("expressions", renamed)
+    return tree

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/src/ripple/engine/schema_qualification.py

@@ -92,9 +92,14 @@ def qualify_sql_with_schema(
     sql: str,
     dialect: str,
     warehouse_columns: WarehouseColumns,
+    expression: "exp.Expression | None" = None,
 ) -> tuple["exp.Expression | None", bool]:
     """Qualify unqualified columns in SQL using warehouse schema.
 
+    Pass `expression` when the caller has already normalized the tree (bare
+    generators named, for one): re-parsing the text here would throw that
+    work away, and the caller's names would come back as _col_0.
+
     Uses SQLGlot's optimizer.qualify to add table qualifiers to columns.
     This resolves ambiguous column references like SELECT col FROM a, b
     into SELECT a.col FROM a, b when 'col' only exists in table 'a'.
@@ -120,8 +125,13 @@ def qualify_sql_with_schema(
         return None, False
 
     schema_dict = build_sqlglot_schema(warehouse_columns)
+
+    def fresh() -> "exp.Expression":
+        # qualify() mutates, so each attempt starts from its own copy
+        return expression.copy() if expression is not None else sqlglot.parse_one(sql, read=dialect)
+
     try:
-        parsed = sqlglot.parse_one(sql, read=dialect)
+        parsed = fresh()
         qualified = qualify(parsed, schema=schema_dict, dialect=dialect)
         return qualified, True
     except Exception as e:
@@ -130,7 +140,7 @@ def qualify_sql_with_schema(
     # what the schema resolves, leave the rest as written instead of throwing
     # away every resolved column with it.
     try:
-        parsed = sqlglot.parse_one(sql, read=dialect)
+        parsed = fresh()
         qualified = qualify(
             parsed,
             schema=schema_dict,

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/src/ripple/engine/statement.py

@@ -247,7 +247,7 @@ def extract_column_lineage_fast(
         # return the AST directly to avoid double-parsing
         if warehouse_columns:
             qualified_ast, was_qualified = qualify_sql_with_schema(
-                cleaned_sql, dialect, warehouse_columns
+                cleaned_sql, dialect, warehouse_columns, expression=parsed
             )
             if was_qualified and qualified_ast is not None:
                 parsed = qualified_ast

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/src/ripple/home.py

@@ -115,6 +115,9 @@ def model_map(nodes: list[dict], edges) -> dict:
     it, a dashboard number past a dashboard prefix, and a model otherwise.
     Star and placeholder columns are links, never columns."""
     members: dict[str, dict] = {}
+    # the loader's identity says whether a folder is the table; kept aside so
+    # the page payload does not carry it
+    uids = {n["name"]: n.get("id") or "" for n in nodes}
     for n in nodes:
         source = n["type"] == "source"
         columns = [c for c in n.get("columns") or [] if _is_column(c)]
@@ -171,19 +174,22 @@ def model_map(nodes: list[dict], edges) -> dict:
     links = _links(edges)
     layers = _layers(members, links)
     models = [{**m, "layer": layers[m["id"]]} for m in members.values()]
-    _name_groups(models)
+    labels = _name_groups(models, uids)
     ordered = _ordered(models, links)
-    return {"models": ordered, "links": links, "groups": _groups(ordered, links)}
+    return {"models": ordered, "links": links, "groups": _groups(ordered, links, labels)}
 
 
-def group_of(member: dict) -> str:
-    """Where a model lives, as a person would say it: the folder of a model,
-    the schema of a source table, "dashboards" for a dashboard number.
+def group_of(member: dict, uid: str = "", table_folders: frozenset[str] = frozenset()) -> str:
+    """Where a model lives, unshortened: the folder of a model, the schema of
+    a source table, "dashboards" for a dashboard number.
 
-    A file named after its model sits in its folder (`models/marts/orders.sql`
-    is in `models/marts`). A file with a generic name names its folder as the
-    table (`telemetry_derived/clients_v1/query.sql`), so the group is the
-    folder above. A model with no path is in "models"."""
+    A model file sits in its folder (`models/marts/orders.sql` is in
+    `models/marts`), whatever the model is called: a monorepo may name it
+    `models__marts__orders`, and a dbt model may be called query. When the
+    loader itself took a folder as the table (`telemetry_derived/clients_v1/
+    query.sql`, a schema.yaml sidecar) the group is the folder above, for
+    that model and for every other file in the table's folder (a script.sql
+    beside the query). A model with no path is in "models"."""
     if member["kind"] == "dashboard":
         return "dashboards"
     if member["kind"] == "source":
@@ -192,55 +198,95 @@ def group_of(member: dict) -> str:
     path = member.get("path")
     if not path:
         return "models"
-    parts = path.replace("\\", "/").split("/")
-    stem = parts[-1].rsplit(".", 1)[0]
-    folders = parts[:-1]
-    if folders and stem != member["id"]:
+    folders = path.replace("\\", "/").split("/")[:-1]
+    if table_folder(member, uid) or "/".join(folders).lower() in table_folders:
         folders = folders[:-1]
     return "/".join(folders) or "models"
 
 
+def table_folder(member: dict, uid: str = "") -> str | None:
+    """The folder a model's loader took as the table, lowercased, or None.
+
+    That happened when the model's name, or the relation in its uid
+    (path::relation, possibly dataset.table), is the last folder and the
+    file is called something else (query.sql, schema.yaml). A file that is
+    the folder's namesake, or any file in a dbt project, keeps its folder."""
+    path = member.get("path")
+    if not path or member["kind"] != "model":
+        return None
+    parts = path.replace("\\", "/").split("/")
+    folders, stem = parts[:-1], parts[-1].rsplit(".", 1)[0]
+    if not folders:
+        return None
+    folder = folders[-1].lower()
+    relation = uid.rpartition("::")[-1].rpartition(".")[-1].lower()
+    name = member["id"].lower()
+    named_after_folder = folder in (name, relation) or name.endswith("__" + folder)
+    if named_after_folder and stem.lower() != folder:
+        return "/".join(folders).lower()
+    return None
+
+
 def _shorten(names: set[str], sep: str) -> dict[str, str]:
-    """Drop the leading segments every name shares, so `models/staging` and
-    `models/marts` read as `staging` and `marts`. A lone name keeps itself."""
+    """Labels: drop the leading segments every deep name shares, so
+    `models/staging` and `models/marts` read as `staging` and `marts`. A lone
+    name keeps itself, and `models/core` next to `models/staging/core` keeps
+    enough to tell them apart."""
     parts = {n: n.split(sep) for n in names}
     while True:
         deep = [p for p in parts.values() if len(p) > 1]
         if len(deep) < 2 or len({p[0] for p in deep}) != 1:
             break
-        parts = {n: p[1:] if len(p) > 1 else p for n, p in parts.items()}
+        nxt = {n: p[1:] if len(p) > 1 else p for n, p in parts.items()}
+        # a strip that makes two names read the same stops here
+        if len({sep.join(p) for p in nxt.values()}) < len(nxt):
+            break
+        parts = nxt
     return {n: sep.join(p) for n, p in parts.items()}
 
 
 SOURCE_SCHEMAS = 6
 
 
-def _name_groups(models: list[dict]) -> None:
-    """Set each model's group, shortened per kind, in place. A project that
-    reads from more than a handful of schemas gets one "sources" group: a
-    row per schema would be a page of one-table rows, and the chip already
-    carries the schema in its name."""
-    raw = {m["id"]: group_of(m) for m in models}
-    short: dict[str, str] = {}
-    for kind, sep in (("model", "/"), ("source", ".")):
+def _name_groups(models: list[dict], uids: dict[str, str]) -> dict[str, str]:
+    """Set each model's group in place and return the label of every group.
+
+    The group is an identity, never shown: the kind and the unshortened
+    folder or schema (`model:models/marts`, `source:raw`), so a schema and a
+    folder of one name, or a folder called dashboards, stay separate rows.
+    The label is what the page prints. A project that reads
+    from more than a handful of schemas gets one "sources" group: a row per
+    schema would be a page of one-table rows, and the chip already carries
+    the schema in its name."""
+    tables = frozenset(t for m in models if (t := table_folder(m, uids.get(m["id"], ""))))
+    raw = {m["id"]: group_of(m, uids.get(m["id"], ""), tables) for m in models}
+    labels: dict[str, str] = {}
+    for kind, sep in (("model", "/"), ("source", "."), ("dashboard", "/")):
+        prefix = kind + ":"
         names = {raw[m["id"]] for m in models if m["kind"] == kind}
         if kind == "source" and len(names) > SOURCE_SCHEMAS:
-            short.update({n: "sources" for n in names})
-            continue
-        short.update(_shorten(names, sep))
+            for m in models:
+                if m["kind"] == kind:
+                    raw[m["id"]] = "sources"
+            names = {"sources"}
+        for name, label in _shorten(names, sep).items():
+            labels[prefix + name] = label
     for m in models:
-        m["group"] = short.get(raw[m["id"]], raw[m["id"]])
+        m["group"] = m["kind"] + ":" + raw[m["id"]]
+    return labels
 
 
 GROUP_RANK = {"source": 0, "model": 1, "dashboard": 2}
 
 
-def _groups(models: list[dict], links: list[dict]) -> list[dict]:
+def _groups(models: list[dict], links: list[dict], labels: dict[str, str]) -> list[dict]:
     """The groups in the order the data flows: source schemas, then model
     folders by the mean layer of their models, then dashboards. Each carries
-    how many models it holds and how many models outside it read one of its."""
+    its label, how many models it holds and how many models outside it read
+    one of its; a dashboard number is not a reader."""
     by: dict[str, dict] = {}
     of: dict[str, str] = {}
+    kind_of: dict[str, str] = {}
     for m in models:
         g = by.setdefault(
             m["group"],
@@ -248,19 +294,25 @@ def _groups(models: list[dict], links: list[dict]) -> list[dict]:
         )
         g["n"] += 1
         g["layers"].append(m["layer"])
-        if GROUP_RANK[m["kind"]] > GROUP_RANK[g["kind"]]:
-            g["kind"] = m["kind"]
         of[m["id"]] = m["group"]
+        kind_of[m["id"]] = m["kind"]
     for link in links:
         src, dst = of.get(link["src"]), of.get(link["dst"])
-        if src and dst and src != dst:
+        if src and dst and src != dst and kind_of[link["dst"]] != "dashboard":
             by[src]["readers"].add(link["dst"])
     out = sorted(
         by.values(),
         key=lambda g: (GROUP_RANK[g["kind"]], sum(g["layers"]) / len(g["layers"]), g["id"]),
     )
     return [
-        {"id": g["id"], "kind": g["kind"], "n": g["n"], "readers": len(g["readers"])} for g in out
+        {
+            "id": g["id"],
+            "label": labels.get(g["id"], g["id"]),
+            "kind": g["kind"],
+            "n": g["n"],
+            "readers": len(g["readers"]),
+        }
+        for g in out
     ]
 
 

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/src/ripple/loaders/identity.py

@@ -301,7 +301,7 @@ def _merge_self_read_derivations(project: Project, group: list[Model]) -> list[M
     return kept
 
 
-ROLE_STEMS = frozenset({"query", "view", "model", "table", "select", "main", "definition"})
+ROLE_STEMS = frozenset({"query", "view", "model", "table", "select", "main", "definition", "udf"})
 
 
 def directory_identity(rel: str) -> tuple[str, set[str]] | None:
@@ -313,8 +313,9 @@ def directory_identity(rel: str) -> tuple[str, set[str]] | None:
     collision handler mangled them into path names no reference could match,
     and a 2,096-model repo came out with 0 verified edges. The directory is
     the relation; its two nearest ancestors are the qualified spellings.
-    Returns None when the stem carries identity as usual. checks.sql and
-    script.sql are deliberately not roles: a check reads the relation, it
+    udf.sql is a role too: Mozilla keeps 155 of them at udf_js/<function>/,
+    and the directory is the function. Returns None when the stem carries
+    identity as usual. checks.sql and script.sql are deliberately not roles: a check reads the relation, it
     does not define it, and claiming the directory would collide with the
     real definition beside it.
     """

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/src/ripple/render.py

@@ -18,6 +18,7 @@ matters; unknown macros degrade to NULL (parseable, no fake lineage).
 
 from __future__ import annotations
 
+import ast as _ast
 import datetime as _datetime
 import itertools as _itertools
 import re
@@ -288,25 +289,35 @@ def _as_bool(value):
 
 
 def _as_number(value):
+    """dbt's as_number: a number stays what it is (1.5 is not 1), a string
+    becomes an int or a float, anything else comes back untouched."""
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return value
+    text = str(value).strip()
     try:
-        return int(value)
-    except (TypeError, ValueError):
+        return int(text)
+    except ValueError:
         pass
     try:
-        return float(value)
-    except (TypeError, ValueError):
+        return float(text)
+    except ValueError:
         return value
 
 
+# a literal past this length never reaches the parser: deep enough nesting
+# can overflow the C parser outright, past any except clause, and no dbt
+# var is a tenth of it
+_LITERAL_MAX = 10_000
+
+
 def _as_native(value):
-    """dbt's as_native: a string read back as YAML, anything else untouched."""
-    if not isinstance(value, str):
+    """dbt's as_native: a string read as a Python literal (a tuple, a dict
+    with None in it), the string itself when it is not one."""
+    if not isinstance(value, str) or len(value) > _LITERAL_MAX:
         return value
     try:
-        import yaml
-
-        return yaml.safe_load(value)
-    except Exception:
+        return _ast.literal_eval(value.strip())
+    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError):
         return value
 
 

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/src/ripple/static/answer.css

@@ -144,8 +144,8 @@ pre{margin:0; padding:16px 22px 18px; overflow-x:auto; font:400 13px/1.65 var(--
 .gcell:hover{background:var(--well)}
 .grow.sel .gcell{background:var(--accent); color:#fff}
 .grow.sel .gcell small{color:rgba(255,255,255,.72)}
-.grow.up .gcell{background:#E4F1F4; box-shadow:inset 3px 0 0 var(--accent)}
-.grow.down .gcell{background:var(--well); box-shadow:inset 3px 0 0 var(--ink)}
+.grow.up .gcell{background:#E4F1F4; color:var(--accent-strong)}
+.grow.down .gcell{background:var(--well)}
 .index .chips{display:flex; flex-wrap:wrap; gap:6px 8px; align-items:center}
 .index .mdl{max-width:100%; overflow-wrap:anywhere; text-align:left; line-height:1.25}
 .index .gname{flex-basis:100%}

{ripple_sql-0.1.5 → ripple_sql-0.1.7}/src/ripple/static/answer.html

@@ -112,9 +112,11 @@
   function renderBoard(a){
     Array.prototype.slice.call(board.querySelectorAll('.lvl')).forEach(function(el){ el.remove(); });
     wires.innerHTML = '';
-    var via = {};
+    // model and column names are user data: a model called constructor
+    // must not meet an inherited property, so every lookup is a bare dict
+    var via = dict();
     a.edges.forEach(function(e){ if (!(e.dst in via)) via[e.dst] = e; });
-    var byDepth = {}, maxD = 0;
+    var byDepth = dict(), maxD = 0;
     a.nodes.forEach(function(n){ (byDepth[n.depth] = byDepth[n.depth] || []).push(n); if (n.depth > maxD) maxD = n.depth; });
     var depths = []; for (var d = 0; d <= maxD; d++) if (byDepth[d]) depths.push(d);
     if (a.kind === 'trace') depths.reverse();
@@ -124,7 +126,7 @@
       head.textContent = d === 0 ? (a.kind === 'trace' ? 'You asked about' : 'Your change')
                                  : plural(d, 'step') + (a.kind === 'trace' ? ' back' : '');
       lvl.appendChild(head);
-      var groups = {}, order = [];
+      var groups = dict(), order = [];
       byDepth[d].forEach(function(n){ if (!groups[n.model]){ groups[n.model] = []; order.push(n.model); } groups[n.model].push(n); });
       order.forEach(function(m){
         var g = document.createElement('div'); g.className = 'grp';
@@ -157,9 +159,9 @@
     if (window.innerWidth <= 680) return;
     var base = board.getBoundingClientRect();
     wires.setAttribute('width', board.scrollWidth); wires.setAttribute('height', board.scrollHeight);
-    var chips = {};
+    var chips = dict();
     Array.prototype.slice.call(board.querySelectorAll('.node')).forEach(function(el){ chips[el.dataset.id] = el; });
-    var byId = {}; a.nodes.forEach(function(n){ byId[n.id] = n; });
+    var byId = dict(); a.nodes.forEach(function(n){ byId[n.id] = n; });
     a.edges.forEach(function(e){
       var from = chips[e.src], to = chips[e.dst];
       if (!from || !to) return;
@@ -253,6 +255,7 @@
         onAsk: function(id){ document.getElementById('q').value = id; ask(id, document.getElementById('dir').value); },
         onFocus: function(id){ go(id, true); },
         onHome: function(){ goHome(true); },
+        onPin: function(){ invalidate(); },
         onFilter: function(n){ hiddenNote.hidden = !n; hiddenNote.textContent = n ? plural(n, 'model') + ' hidden by the filter' : ''; }});
       if (mapApi.compact){
         document.getElementById('key-feeds').hidden = true;
@@ -268,17 +271,23 @@
         if (found) return found;
         found = [];
         if (!L.map) return found;
-        var feeds = {};
-        L.map.links.forEach(function(l){ feeds[l.src] = (feeds[l.src] || 0) + 1; });
+        // rank: how many models read the model; readers: the number shown,
+        // a column's own count (a dashboard number is not a reader)
+        var kind = Object.create(null), feeds = Object.create(null);
+        L.map.models.forEach(function(m){ kind[m.id] = m.kind; });
+        L.map.links.forEach(function(l){ if (kind[l.dst] !== 'dashboard') feeds[l.src] = (feeds[l.src] || 0) + 1; });
         L.map.models.forEach(function(m){
-          found.push({id: m.id, kind: m.kind, feeds: feeds[m.id] || 0});
-          if (m.kind !== 'dashboard') m.columns.forEach(function(c){ found.push({id: m.id + '.' + c, kind: 'column', feeds: feeds[m.id] || 0}); });
+          var n = feeds[m.id] || 0;
+          found.push({id: m.id, kind: m.kind, rank: n, readers: n});
+          if (m.kind !== 'dashboard') m.columns.forEach(function(c, i){
+            found.push({id: m.id + '.' + c, kind: 'column', rank: n, readers: m.reads ? m.reads[i] : 0});
+          });
         });
         return found;
       },
       onPick: function(c){
         if (c.kind === 'column' || !mapApi){ ask(c.id, document.getElementById('dir').value); return; }
-        document.getElementById('q').value = '';
+        document.getElementById('q').value = ''; mapApi.filter('');
         go(c.id, true);
       }});
     var ladder = document.getElementById('ladder'); ladder.hidden = false;
@@ -298,19 +307,28 @@
       ev.preventDefault();
       var target = document.getElementById('q').value.trim();
       if (!target) return;
-      if (mapApi && !/\./.test(target) && mapApi.focus(target)){ document.getElementById('q').value = ''; go(target, true); return; }
+      if (mapApi && !/\./.test(target) && mapApi.focus(target)){ document.getElementById('q').value = ''; mapApi.filter(''); go(target, true); return; }
       ask(target, document.getElementById('dir').value);
     });
   }
   // one model's neighbourhood, the index of all models, or an answer: the
   // address bar says which, so Back and a shared link land on the same view
+  var asking = 0, ASKING = 'asking the local server…';
+  // any move on the page outdates the answer still on its way: the reply is
+  // dropped when it lands, and the line under the box stops saying "asking"
+  function invalidate(){
+    asking += 1;
+    if (fine.textContent === ASKING) fine.textContent = LIVE_FINE;
+  }
   function go(id, push){
+    invalidate();
     if (current || mapEl.hidden) home();
     if (!mapApi.focus(id)){ fine.textContent = 'No model called ' + id + ' in this project.'; return; }
     hint(mapApi.compact ? HINT_FOCUS : HINT_SMALL);
     if (push) history.pushState({m: id}, '', '?m=' + encodeURIComponent(id));
   }
   function goHome(push){
+    invalidate();
     if (current || mapEl.hidden) home();
     if (mapApi){ mapApi.home(); hint(mapApi.compact ? HINT_INDEX : HINT_SMALL); requestAnimationFrame(mapApi.draw); }
     if (push) history.pushState({}, '', location.pathname);
@@ -325,10 +343,12 @@
     else goHome(false);
   }
   function ask(target, dir, silent){
-    fine.textContent = 'asking the local server…';
+    var mine = ++asking;
+    fine.textContent = ASKING;
     fetch(L.api + '/' + dir + '?target=' + encodeURIComponent(target), {cache: 'no-store'}).then(function(r){
       return r.json().then(function(j){ return [r.ok, j]; });
     }).then(function(pair){
+      if (mine !== asking) return;
       var ok = pair[0], j = pair[1];
       if (!ok){
         var msg = j.error || 'no answer';
@@ -339,7 +359,7 @@
       fine.textContent = LIVE_FINE;
       show(j.answer, j.text);
       if (!silent) history.pushState({q: target}, '', '?q=' + encodeURIComponent(target) + '&dir=' + dir);
-    }).catch(function(){ fine.textContent = 'The local server did not answer. Is ripple serve still running?'; });
+    }).catch(function(){ if (mine === asking) fine.textContent = 'The local server did not answer. Is ripple serve still running?'; });
   }
   // SERVE END