mosaic-headless 1.26.1 → 1.28.0

package/tools/build_page.py

@@ -95,7 +95,7 @@ class Surface:
         self.default_children = {r["type"]: r["default_children"].split("|")
                                  for r in load_csv("default-children.csv")}
 
-    def check(self, parent_type, node, force):
+    def check(self, parent_type, node, force, ancestors=()):
         t = node["type"]
         problems = []
         if t not in self.types:
@@ -157,12 +157,23 @@ class Surface:
         # registered types - slider/slider-slides, accordion/accordion-item,
         # form/form-input - and which actually carries one of them is not the thing
         # that was measured, and the verdict does not apply to it.
+        rule_for_t = self.rules.get(t, {})
         family = [x for x in self.types if x.startswith(t + "-")]
         kids = [c.get("type") for c in (node.get("children") or []) if isinstance(c, dict)]
         nested_as_family = bool(family) and any(k in family for k in kids)
 
+        # `nested_under` is what `canBeNestedChildFor()` walks the parent chain
+        # looking for: `radio-input` needs a `choice` above it, `label` needs a
+        # `field`, `loop-pagination` needs a `loop`. The names often share no
+        # prefix, so this is the only way to tell a correct placement from the
+        # bare one that was measured.
+        needs = (rule_for_t.get("nested_under") or "").split("|") if rule_for_t else []
+        nested_ok = bool(needs and needs != [""] and
+                         any(x in needs for x in (ancestors + ((parent_type,)
+                                                               if parent_type else ()))))
+
         outcome = self.outcome.get(t)
-        if (not declared_child and not nested_as_family
+        if (not declared_child and not nested_as_family and not nested_ok
                 and (outcome == "BROKE_PAGE" or (outcome or "").startswith("COMMIT_5"))):
             problems.append("%s is measured %s under a plain container, and %s is not its declared parent"
                             % (t, outcome, parent_type or "<root>"))
@@ -184,6 +195,19 @@ class Surface:
                 problems.append("%s is a leaf and accepts no children (tried %s)" % (parent_type, t))
             elif rule.get("rule") == "allow":
                 allowed = rule["allowed_children"].split("|") + self.default_children.get(parent_type, [])
+                # A loop container stands in for its parent's children: a
+                # `slider-loop-slides` sits inside `slider-slides` and repeats a
+                # `slider-slide`, so what it accepts is what `slider-slides`
+                # accepts. The plugin's own canBeParentFor says `slider-slides`
+                # here, which would nest the track inside its own loop - and the
+                # factory's default children say `slider-slide`, which is the
+                # structure the editor builds. Rather than hard-code the
+                # disagreement, take the rule from the grandparent, which is both
+                # types' actual authority.
+                # ancestors[-1] IS the parent; the grandparent is one further up
+                if t not in allowed and "-loop-" in parent_type and len(ancestors) > 1:
+                    gp = self.rules.get(ancestors[-2], {})
+                    allowed = allowed + (gp.get("allowed_children") or "").split("|")
                 if t not in allowed:
                     problems.append("%s accepts only %s, not %s" % (parent_type, "/".join(allowed), t))
         # customStyles is the pre-1.0.8 name of customDeclarations; expand_shorthands maps it
@@ -312,12 +336,13 @@ def refresh_node_ids(tree):
     return json.loads(blob)
 
 
-def flatten(node, parent_id, master_id, surface, force, ordering="a0", parent_type=None, out=None):
+def flatten(node, parent_id, master_id, surface, force, ordering="a0",
+            parent_type=None, out=None, ancestors=()):
     """Depth-first walk producing revision records, checking placement as it goes."""
     out = out if out is not None else []
     if node.get("component"):
         node = dict(node, type="div")     # placement is checked as a plain element
-    problems = surface.check(parent_type, node, force)
+    problems = surface.check(parent_type, node, force, ancestors)
     if problems:
         raise SystemExit("refusing to build:\n  " + "\n  ".join(problems))
 
@@ -360,7 +385,8 @@ def flatten(node, parent_id, master_id, surface, force, ordering="a0", parent_ty
     if node.get("text") is not None:
         children.insert(0, {"type": "wysiwyg-text", "data": {"text": node["text"]}})
     for i, child in enumerate(children):
-        flatten(child, nid, master_id, surface, force, ordering_for(i), node["type"], out)
+        flatten(child, nid, master_id, surface, force, ordering_for(i),
+                node["type"], out, ancestors + (node["type"],))
     return out
 
 

package/tools/extract_node_types.py

@@ -69,7 +69,13 @@ def extract(plugin_root, out_dir):
         sys.exit("no Mosaic/NodeTypes under %s" % plugin_root)
 
     types = []
-    for path in sorted(walk(node_root, ("TypeFactory.php",))):
+    # `*MResourceFactory.php` as well as `*TypeFactory.php`: two node types -
+    # `fieldset-legend` and `fieldset-content` - are declared only by the former,
+    # so a walk of TypeFactory alone leaves them out of the catalog entirely. A
+    # page that needs them is then refused by the placement guard as an "unknown
+    # node type", and a reader of this table is told the fieldset has no inner
+    # structure, which is how a form came back with its fields dropped.
+    for path in sorted(walk(node_root, ("TypeFactory.php", "MResourceFactory.php"))):
         src = read(path)
         cls = RE_CLASS.search(src)
         ctor = RE_CTOR.search(src)

package/tools/extract_placement.py

@@ -57,7 +57,8 @@ def read(path):
 def walk(root, suffix):
     for dirpath, _dirs, files in os.walk(root):
         for fn in sorted(files):
-            if fn.endswith(suffix):
+            if fn.endswith(suffix) if isinstance(suffix, str) else any(
+                    fn.endswith(x) for x in suffix):
                 yield os.path.join(dirpath, fn)
 
 
@@ -68,7 +69,7 @@ def extract(plugin_root, out_dir):
 
     # factory class name -> type slug, so instanceof targets can be named as types
     class_to_type, sources = {}, {}
-    for path in walk(node_root, "TypeFactory.php"):
+    for path in walk(node_root, ("TypeFactory.php", "MResourceFactory.php")):
         src = read(path)
         cls = RE_CLASS.search(src)
         if not cls:
@@ -95,6 +96,18 @@ def extract(plugin_root, out_dir):
         body, defined_in = resolve(cls_name)
         path, src, _parent = sources[cls_name]
         nested = "yes" if "function canBeNestedChildFor" in src else ""
+        # `yes` alone says a runtime ancestry rule exists and not what it wants.
+        # These methods walk the parent chain looking for one MResource class -
+        # `radio-input` wants a `ChoiceElementMResource` above it - and that is
+        # the one fact a caller needs to know whether a placement is legal.
+        nested_under = []
+        if nested:
+            mbody = re.search(
+                r"function\s+canBeNestedChildFor\s*\([^)]*\)\s*:\s*bool\s*\{(.*?)\n    \}",
+                src, re.S)
+            if mbody:
+                for cls in re.findall(r"instanceof\s+(\w+)ElementMResource\b", mbody.group(1)):
+                    nested_under.append(cls)
 
         if body is None:
             rule, allowed = "none", []          # inherited default on the abstract base
@@ -121,6 +134,12 @@ def extract(plugin_root, out_dir):
                 "allowed_children": "|".join(allowed),
                 "nested_rule": nested,
                 "takes_children": "yes" if RE_TAKES_CHILDREN.search(src) else "",
+                # `class_to_type` is keyed by the FACTORY class, and what the
+                # method names is the MResource - `ChoiceElementMResource` is
+                # declared by `ChoiceElementTypeFactory`.
+                "nested_under": "|".join(sorted(set(
+                    class_to_type.get(c + "ElementTypeFactory", "")
+                    for c in nested_under) - {""})),
                 "declared_in": os.path.relpath(defined_in or path, plugin_root).replace(os.sep, "/"),
             }
         )
@@ -128,7 +147,8 @@ def extract(plugin_root, out_dir):
     os.makedirs(out_dir, exist_ok=True)
     with open(os.path.join(out_dir, "placement-rules.csv"), "w", newline="", encoding="utf-8") as fh:
         w = csv.DictWriter(fh, fieldnames=["type", "rule", "allowed_children", "nested_rule",
-                                           "takes_children", "declared_in"])
+                                           "takes_children", "nested_under",
+                                           "declared_in"])
         w.writeheader()
         w.writerows(rows)
 

package/tools/verify_components.py

@@ -46,6 +46,13 @@ def main():
     ap.add_argument("--faq", default="cp-faq-q-%d/cp-faq-a-%d:4")
     ap.add_argument("--form", default="cp-form")
     ap.add_argument("--map", default="cp-map")
+    ap.add_argument("--loop-slider", default="ct-slider",
+                    help="a slider whose slides come from a loop")
+    ap.add_argument("--loop-tabs", default="ct-tabs-menu")
+    ap.add_argument("--pagination", default="ct-arch-nums",
+                    help="a loop-pagination-numbers whose children are page links")
+    ap.add_argument("--paged-item", default="ct-arch-title",
+                    help="the repeated attrID whose text should change per page")
     a = ap.parse_args()
 
     rows, fails = [], []
@@ -56,6 +63,18 @@ def main():
         if not ok:
             fails.append(name)
 
+    def skip(name, why):
+        """A page that does not carry a component is not a page that broke it.
+
+        The same tool runs against every showcase page, so "absent" has to be a
+        third outcome - otherwise either the form page fails on tabs it never
+        had, or the checks get a flag per component and nobody runs them."""
+        rows.append([name, "SKIPPED", why])
+        print("  %-28s %-5s %s" % (name, "SKIP", why))
+
+    def present(el_id):
+        return p.evaluate("(id) => !!document.getElementById(id)", el_id)
+
     def split(spec):
         pat, n = spec.rsplit(":", 1)
         tab, pane = pat.split("/")
@@ -71,64 +90,148 @@ def main():
         p.wait_for_timeout(2200)
 
         # ---- tabs
-        shown = [i for i in range(n_tabs) if p.evaluate(VISIBLE, pane_pat % i)]
-        check("TABS/one_pane_at_rest", shown == [0],
-              "visible panes at rest: %s" % shown)
-        last = n_tabs - 1
-        p.click("#" + tab_pat % last)
-        p.wait_for_timeout(600)
-        shown = [i for i in range(n_tabs) if p.evaluate(VISIBLE, pane_pat % i)]
-        check("TABS/click_switches", shown == [last],
-              "clicked tab %d -> panes %s" % (last, shown))
-        active = p.evaluate("""() => {
-          const t = document.querySelector('.m-tab--active');
-          if (!t) return null;
-          const ps = [...t.querySelectorAll('p')].map(e => getComputedStyle(e).color);
-          return {bg: getComputedStyle(t).backgroundColor, labels: ps};
-        }""")
-        # the active tab is darkened by the plugin; if the label was not restyled
-        # with ___tab--active___descendants it is ink on ink and unreadable
-        readable = bool(active) and active["bg"] != (active["labels"] or [""])[0]
-        check("TABS/active_label_readable", readable, str(active))
+        if not present(tab_pat % 0):
+            skip("TABS", "not on this page")
+        else:
+            shown = [i for i in range(n_tabs) if p.evaluate(VISIBLE, pane_pat % i)]
+            check("TABS/one_pane_at_rest", shown == [0],
+                  "visible panes at rest: %s" % shown)
+            last = n_tabs - 1
+            p.click("#" + tab_pat % last)
+            p.wait_for_timeout(600)
+            shown = [i for i in range(n_tabs) if p.evaluate(VISIBLE, pane_pat % i)]
+            check("TABS/click_switches", shown == [last],
+                  "clicked tab %d -> panes %s" % (last, shown))
+            active = p.evaluate("""() => {
+              const t = document.querySelector('.m-tab--active');
+              if (!t) return null;
+              const ps = [...t.querySelectorAll('p')].map(e => getComputedStyle(e).color);
+              return {bg: getComputedStyle(t).backgroundColor, labels: ps};
+            }""")
+            # the plugin darkens the active tab; a label that was not restyled
+            # with ___tab--active___descendants is then ink on ink
+            readable = bool(active) and active["bg"] != (active["labels"] or [""])[0]
+            check("TABS/active_label_readable", readable, str(active))
 
         # ---- accordion
-        open_now = [i for i in range(n_faq) if p.evaluate(VISIBLE, ans_pat % i)]
-        check("ACCORDION/shut_at_rest", open_now == [], "open: %s" % open_now)
-        p.click("#" + q_pat % 1)
-        p.wait_for_timeout(700)
-        open_now = [i for i in range(n_faq) if p.evaluate(VISIBLE, ans_pat % i)]
-        check("ACCORDION/click_opens_one", open_now == [1],
-              "clicked 1 -> open %s" % open_now)
-        tabindex = p.evaluate("(id) => document.getElementById(id).getAttribute('tabindex')",
-                              q_pat % 1)
-        check("ACCORDION/keyboard_reachable", tabindex == "0",
-              "title tabindex=%r - the plugin puts it in the tab order" % tabindex)
+        if not present(q_pat % 0):
+            skip("ACCORDION", "not on this page")
+        else:
+            open_now = [i for i in range(n_faq) if p.evaluate(VISIBLE, ans_pat % i)]
+            check("ACCORDION/shut_at_rest", open_now == [], "open: %s" % open_now)
+            p.click("#" + q_pat % 1)
+            p.wait_for_timeout(700)
+            open_now = [i for i in range(n_faq) if p.evaluate(VISIBLE, ans_pat % i)]
+            check("ACCORDION/click_opens_one", open_now == [1],
+                  "clicked 1 -> open %s" % open_now)
+            ti = p.evaluate("(id) => document.getElementById(id).getAttribute('tabindex')",
+                            q_pat % 1)
+            check("ACCORDION/keyboard_reachable", ti == "0",
+                  "title tabindex=%r - the plugin puts it in the tab order" % ti)
 
         # ---- form
-        fields = p.evaluate("""(id) => [...document.querySelectorAll(
-            '#' + id + ' input, #' + id + ' textarea')].map(
-            e => ({name: e.getAttribute('name'), req: e.required,
-                   tag: e.tagName.toLowerCase()}))""", a.form)
-        named = [f["name"] for f in fields if f["name"]]
-        honeypot = [n for n in named if n.startswith("mosaic_hp")]
-        real = [n for n in named if not n.startswith("mosaic_hp")]
-        check("FORM/fields", len(real) >= 3, "named fields: %s" % real)
-        check("FORM/required", all(f["req"] for f in fields
-                                   if f["name"] in real),
-              "every author field is required")
-        check("FORM/honeypot", bool(honeypot),
-              "Mosaic adds its own spam trap: %s" % honeypot)
+        if not present(a.form):
+            skip("FORM", "not on this page")
+        else:
+            fields = p.evaluate("""(id) => [...document.querySelectorAll(
+                '#' + id + ' input, #' + id + ' select, #' + id + ' textarea')].map(
+                e => ({name: e.getAttribute('name'), req: e.required,
+                       tag: e.tagName.toLowerCase(), type: e.type}))""", a.form)
+            named = [f["name"] for f in fields if f["name"]]
+            honeypot = [n for n in named if n.startswith("mosaic_hp")]
+            real = [f for f in fields if f["name"] and not f["name"].startswith("mosaic_hp")]
+            kinds = sorted({f["type"] for f in real})
+            check("FORM/fields", len(real) >= 3,
+                  "%d controls, types: %s" % (len(real), ", ".join(kinds)))
+            check("FORM/required", any(f["req"] for f in real),
+                  "required is set on %d of them" % sum(1 for f in real if f["req"]))
+            check("FORM/honeypot", bool(honeypot),
+                  "Mosaic adds its own spam trap: %s" % honeypot)
+            # a <select> whose options have no text renders as a blank dropdown:
+            # `select-option` is a LEAF and its label is the `text` PROPERTY
+            opts = p.evaluate("""(id) => [...document.querySelectorAll('#' + id + ' option')]
+                .map(o => o.textContent.trim())""", a.form)
+            if opts:
+                check("FORM/option_labels", all(opts),
+                      "%d options, all labelled" % len(opts) if all(opts)
+                      else "blank labels - `text` is a property, not a child")
+            else:
+                skip("FORM/option_labels", "no select on this form")
+            # the browser's own validation has to stop an empty required form
+            p.evaluate("(id) => document.getElementById(id).reset()", a.form)
+            invalid = p.evaluate("""(id) => [...document.getElementById(id)
+                .querySelectorAll(':invalid')].filter(e => e.name).map(e => e.name)""",
+                                 a.form)
+            check("FORM/required_blocks", bool(invalid),
+                  "empty form reports invalid: %s" % invalid[:4])
+
+        # ---- components whose children come from a loop
+        #
+        # One authored template, repeated per row. The assertion is COUNT: a
+        # template that failed to loop renders exactly once and looks fine.
+        if not present(a.loop_slider):
+            skip("LOOP/slider", "not on this page")
+        else:
+            n = p.evaluate("""(id) => document.querySelectorAll(
+                '#' + id + ' mosaic-slider-slide').length""", a.loop_slider)
+            check("LOOP/slider", n > 1,
+                  "%d slides from one authored slider-slide" % n)
+        if not present(a.loop_tabs):
+            skip("LOOP/tabs", "not on this page")
+        else:
+            n = p.evaluate("""(id) => document.querySelectorAll(
+                '#' + id + ' .m-tab').length""", a.loop_tabs)
+            labels = p.evaluate("""(id) => [...document.querySelectorAll(
+                '#' + id + ' .m-tab')].map(e => e.textContent.trim())""", a.loop_tabs)
+            check("LOOP/tabs", n > 1, "%d tabs from one authored tabs-tab" % n)
+            # @substr counts BYTES; a cut through a multi-byte character leaves
+            # U+FFFD, which is invisible in a count and obvious to a reader
+            check("LOOP/tab_labels_intact",
+                  all("�" not in x for x in labels),
+                  "no replacement characters - @substr counts bytes, so a length "
+                  "that is not a multiple of the encoding cuts a glyph in half")
+
+        # ---- pagination actually pages
+        if not present(a.pagination):
+            skip("LOOP/pagination", "not on this page")
+        else:
+            def titles():
+                return p.evaluate("""(id) => [...document.querySelectorAll(
+                    '[id=' + id + ']')].map(e => e.textContent.trim())""",
+                                  a.paged_item)
+            links = p.evaluate("""(id) => [...document.getElementById(id).children]
+                .map(e => e.getAttribute('href'))""", a.pagination)
+            check("LOOP/pagination_links", len(links) > 1 and all(links),
+                  "%d page links: %s" % (len(links),
+                                         [l.split("?")[-1] for l in links if l][:3]))
+            # `p` is one of WordPress's own query vars - ?p=2 is a 301 to post 2 -
+            # so a paginationKey of "p" takes the visitor off the page entirely
+            bad_key = [l for l in links if l and ("?p=" in l or "&p=" in l)]
+            check("LOOP/pagination_key_is_safe", not bad_key,
+                  "paginationKey does not collide with a WordPress query var"
+                  if not bad_key else "uses ?p=, which WordPress reads as a post ID")
+            before = titles()
+            p.click("#%s > *:nth-child(2)" % a.pagination)
+            p.wait_for_timeout(2000)
+            after = titles()
+            check("LOOP/pagination_changes_rows",
+                  bool(after) and set(after) != set(before),
+                  "page 1 %s -> page 2 %s" % (len(before), len(after)))
 
         # ---- map
-        src = p.evaluate("""(id) => { const f = document.querySelector('#' + id + ' iframe');
-            return f ? f.getAttribute('src') : null; }""", a.map)
-        m = re.search(r"marker=([-\d.]+),([-\d.]+)", src or "")
-        times_square = bool(m) and m.group(1).startswith("40.75")
-        check("MAP/frame", bool(src), "renders an openstreetmap iframe")
-        check("MAP/coordinates_applied", bool(m) and not times_square,
-              ("marker=%s,%s" % m.groups()) if m else "no marker in %r" % (src or "")[:60]
-              + (" - this is the default, so the property name was wrong"
-                 if times_square else ""))
+        if not present(a.map):
+            skip("MAP", "not on this page")
+        else:
+            src = p.evaluate("""(id) => { const f = document.querySelector('#' + id + ' iframe');
+                return f ? f.getAttribute('src') : null; }""", a.map)
+            m = re.search(r"marker=([-\d.]+),([-\d.]+)", src or "")
+            default_centre = bool(m) and m.group(1).startswith("40.75")
+            check("MAP/frame", bool(src), "renders an openstreetmap iframe")
+            check("MAP/coordinates_applied", bool(m) and not default_centre,
+                  ("marker=%s,%s" % m.groups()) if m and not default_centre
+                  else "Times Square - the property name was wrong "
+                       "(it is latitude/longitude, not lat/lon)")
+
         b.close()
 
     print("\n%d checks, %d FAIL" % (len(rows), len(fails)))