mosaic-headless 1.2.1 → 1.3.0

package/tools/build_page.py

@@ -140,6 +140,10 @@ class Surface:
 # string to them is accepted and then silently produces `transform:none`, `box-shadow:none`
 # or no rule at all - so these shorthands exist to make the correct shape unavoidable.
 # Each was confirmed against the compiled CSS; see references/styling.md.
+
+# A fixed namespace, so a design token's row ID is a function of its name alone and
+# a rebuild rebinds the same row instead of adding a second one.
+VAR_NAMESPACE = uuid.UUID("6d6f7361-6963-4865-6164-6c657373ff01")
 VAR_IDS = {}
 
 
@@ -245,8 +249,27 @@ def theme_records(spec, doc, surface):
         if not (collection and mode and skin):
             sys.exit("theme.variables needs a healed collection/mode/skin")
         recs = []
+        # The ID is DERIVED from the token name, not minted.
+        #
+        # It used to be a fresh `uuid4()` per run, and `_varIDs` starts empty every
+        # time, so each build wrote a NEW collectionVariable row and left the old one
+        # in place. The rows are parented to the theme's collection, which survives
+        # `build_site.py` making a fresh master, so they accumulate - and both end up
+        # in `:root`, where the later one wins. Measured: after changing `--mk-faint`
+        # from rgb(160,162,168) to rgb(107,109,113), the delivered stylesheet carried
+        #
+        #     --mk-faint: rgb(107, 109, 113)
+        #     --mk-faint: rgb(160, 162, 168)
+        #
+        # and the page kept rendering the old grey. Every server-side check passed:
+        # the commit succeeded, the new variable existed, its value was correct. Only
+        # `verify_browser.py`, reading the computed colour off the element, saw it.
+        #
+        # A UUIDv5 over the custom property is stable across runs and across machines
+        # with no state to carry, so a rebuild REBINDS the row instead of adding one.
         for custom_property, value in variables.items():
-            vid = spec.setdefault("_varIDs", {}).setdefault(custom_property, str(uuid.uuid4()))
+            vid = str(uuid.uuid5(VAR_NAMESPACE, custom_property))
+            spec.setdefault("_varIDs", {})[custom_property] = vid
             recs.append({"newRevisionRecord": {
                 "ID": vid, "parentType": "collection", "parentID": collection,
                 "ordering": "a0", "status": "publish", "revision": "", "version": "",
@@ -255,6 +278,16 @@ def theme_records(spec, doc, surface):
                          "customProperty": custom_property,
                          "skinsData": {skin: {mode: {"value": value["value"]}}}}},
                 "originalRevisionRecord": None})
+        # Reap strays from before the ID became derivable. Anything on this
+        # collection that claims a custom property we manage, under an ID we did not
+        # derive, is a leftover that can still win the cascade.
+        managed = {v["ID"] for v in (r["newRevisionRecord"] for r in recs)}
+        for row in (doc.get("collectionVariable") or []):
+            cp = (row.get("data") or {}).get("customProperty")
+            if cp in variables and row["ID"] not in managed:
+                print("  reaping stale variable %s (%s)" % (cp, row["ID"][:8]))
+                recs.append({"newRevisionRecord": dict(row, status="delete"),
+                             "originalRevisionRecord": row})
         out["collectionVariable"] = recs
         # register the IDs before element-class styles are expanded - those cite
         # tokens too, and expand_shorthands resolves {"token": ...} from this map

package/tools/extract_node_types.py

@@ -78,10 +78,21 @@ def extract(plugin_root, out_dir):
         relpath = rel(path, plugin_root)
         # the data class declaring this type's own properties sits beside the factory;
         # node-properties.csv is keyed by that class name, so record it to make the join
-        data_class = ""
+        #
+        # Its OWN parent has to be recorded here too. A data class that declares no
+        # properties of its own writes no row into node-properties.csv, so the
+        # `extends` column there cannot tell you what it inherits - and 64 of the 122
+        # types are exactly that case. Without this column a lookup for
+        # `accordion-content` reports zero properties, when in fact it has the nine
+        # every element has. An empty answer that looks like a real one is the
+        # failure this whole skill argues against, so read the parent off the class.
+        data_class, data_extends = "", ""
         for sibling in sorted(os.listdir(os.path.dirname(path))):
             if sibling.endswith("MResourceData.php"):
                 data_class = sibling[:-4]
+                dcls = RE_CLASS.search(read(os.path.join(os.path.dirname(path),
+                                                         sibling)))
+                data_extends = dcls.group(3) if dcls else ""
                 break
         bools = dict(RE_METHOD_BOOL.findall(src))
         alias = RE_ALIAS.search(src)
@@ -100,15 +111,26 @@ def extract(plugin_root, out_dir):
                 "can_be_parent": bools.get("canBeParentFor", ""),
                 "default_element_class": (dflt.group(1).strip() if dflt else ""),
                 "data_class": data_class,
+                "data_extends": data_extends,
                 "file": relpath,
             }
         )
 
+    # Every data class, whether or not it declares a property of its own. An abstract
+    # that adds nothing still sits in the chain - `ElementMResourceLoopDataAbstract`
+    # is one, and five node types inherit through it - so a hierarchy built only from
+    # classes that happen to own properties has holes exactly where the plain ones
+    # are. This file makes the walk total.
+    hierarchy = []
     props = []
     for path in sorted(walk(node_root, ("MResourceData.php", "MResourceDataAbstract.php"))):
         src = read(path)
         cls = RE_CLASS.search(src)
         owner = cls.group(2) if cls else os.path.basename(path)[:-4]
+        hierarchy.append({"class": owner,
+                          "extends": cls.group(3) if cls else "",
+                          "abstract": "yes" if (cls and cls.group(1)) else "no",
+                          "file": rel(path, plugin_root)})
         relpath = rel(path, plugin_root)
         reserved = RE_RESERVED.search(src)
         reserved_attrs = re.findall(r"'([^']+)'", reserved.group(1)) if reserved else []
@@ -146,6 +168,9 @@ def extract(plugin_root, out_dir):
     os.makedirs(out_dir, exist_ok=True)
     write_csv(os.path.join(out_dir, "node-types.csv"), types)
     write_csv(os.path.join(out_dir, "node-properties.csv"), props)
+    write_csv(os.path.join(out_dir, "data-class-hierarchy.csv"),
+              sorted(hierarchy, key=lambda r: r["class"]))
+    print("data classes:    %d" % len(hierarchy))
     print("node types:      %d (%d pro)" % (len(types), sum(t["edition"] == "pro" for t in types)))
     print("node properties: %d across %d classes" % (len(props), len({p["owner_class"] for p in props})))