asciidoctor-rhrev 1.5.0 → 1.5.2

package/antora-extension/antora-rhrev-asciidoc.js

@@ -182,29 +182,134 @@ function rollupTableCellRevisionEntries(catalog, doc, prefix) {
   })
 }
 
-// The cell's own <td>/<th> never carries the rhrev-changed role: that
-// needs a converter-level override, the same way the Ruby gem's HTML5
-// converter is overridden. Built and verified working standalone (a real
-// Opal subclass of Html5Converter, registered via ConverterFactory,
-// delegating to super for everything but a marked table), but it broke
-// real Antora builds: this exact demo site has three separate,
-// non-deduped @asciidoctor/core installs (rhrev, the site itself, and
-// baiyibai-extensions, whose cite-it extension wraps Antora's own document
-// loading), one of them (2.2.8 vs 2.2.9 elsewhere) a different version.
-// Antora's own converter/html5.js reads whatever is currently registered
-// as the 'html5' converter and builds a real Opal subclass on top of it;
-// with three non-identical copies of the Opal runtime involved, that
-// crashed (Object.setPrototypeOf called on null or undefined), confirmed
-// against a real local build, not assumed. That is a dependency-hygiene
-// problem in a sibling package, out of scope here.
+// The cell's own <td>/<th> DOES carry the rhrev-changed role, via a
+// converter-level override, patched directly onto the SAME live converter
+// class object Antora's own pipeline is already using for this document
+// (doc.getConverter().$$class, reached through Asciidoctor's own public
+// API), never a separately-required or separately-registered class.
 //
-// Instead, propagateCellContentMarks above tags the cell's marked nested
-// block directly (a normal rollup-context node, so it needs no converter
-// override at all, the same unmodified converter already supports a role
-// there), rather than the cell itself. The visible result is a border
-// around the changed paragraph inside the cell rather than around the
-// whole cell box; confirmed against the real, unmodified converter output,
-// not assumed to work the same as the PDF gem's margin bar.
+// EARLIER ATTEMPT, SUPERSEDED (kept here since the next engineer will
+// otherwise reach for the same idea first): a real Opal subclass of
+// Html5Converter, registered via ConverterFactory, the same way the Ruby
+// gem's PDF converter is overridden. Built and verified working
+// standalone, but broke real Antora builds: this exact demo site had
+// three separate, non-deduped @asciidoctor/core installs (rhrev, the site
+// itself, and baiyibai-extensions, whose cite-it extension wraps Antora's
+// own document loading), one of them a different version. Antora's own
+// converter/html5.js reads whatever is currently registered as the
+// 'html5' converter and builds a real Opal subclass on top of that; with
+// non-identical copies of the Opal runtime involved, defining a SECOND,
+// independent subclass crashed (Object.setPrototypeOf called on null or
+// undefined), confirmed against a real local build, not assumed. A
+// require('@antora/asciidoc-loader') from inside this file cannot avoid
+// that risk either, even now that baiyibai-extensions' own version drift
+// is fixed (1.15.1): this package ships its own @asciidoctor/core copy
+// for its own test suite, so a plain require() here resolves against
+// THIS package's node_modules first, not necessarily the consuming
+// site's, and remains a live, standing risk of resolving a different
+// copy regardless of what any sibling package currently pins.
+//
+// doc.getConverter() sidesteps the whole class of problem: it returns
+// whichever converter object is ACTUALLY resolved for THIS document, in
+// THIS process, by Antora's own pipeline, guaranteed correct by
+// construction rather than by keeping multiple packages' pins in sync.
+// Confirmed directly: asciidoctor.load(text).getConverter() already
+// returns a real, usable converter instance, with a real $$class, before
+// convert() is ever called, meaning it is available in time from inside a
+// treeprocessor (treeprocessors run during load(), before conversion).
+const PATCHED_CONVERT_TABLE = Symbol.for('rhrev.patchedConvertTable')
+
+// Idempotency is keyed on the converter CLASS, not the document: a single
+// Antora build converts many documents against the same resolved
+// converter class object, and redefining $convert_table would otherwise
+// re-wrap the previous wrapper on every single page, nesting deeper each
+// time (and, worse, the second pass would capture the FIRST WRAPPER as
+// its own "original", not the real one, once the reference below is
+// overwritten).
+//
+// Captures the real, original $convert_table function reference directly
+// off the class's own prototype before replacing it, and calls that
+// reference directly, rather than Opal.find_super_dispatcher (Antora's
+// own html5.js pattern, copied from initially, then found wrong for this
+// case, confirmed against a real crash: find_super_dispatcher climbs an
+// inheritance chain, correct when Opal.klass creates a genuine SUBCLASS
+// the way Antora's own converter/html5.js does, but this patches the
+// SAME class object in place, no subclass involved, so there is no
+// superclass boundary to dispatch across; the original implementation
+// lives directly on classDef.$$prototype itself, confirmed directly, and
+// Opal.defn below overwrites that exact slot).
+function patchConvertTableForCellTagging (doc) {
+  const Opal = global.Opal
+  if (!Opal) return
+  const converter = doc.getConverter && doc.getConverter()
+  const classDef = converter && converter.$$class
+  if (!classDef || classDef[PATCHED_CONVERT_TABLE]) return
+  const originalConvertTable = classDef.$$prototype['$convert_table']
+  if (typeof originalConvertTable !== 'function') return
+  classDef[PATCHED_CONVERT_TABLE] = true
+
+  Opal.defn(classDef, '$convert_table', function convertTableWithCellTags (node) {
+    const html = originalConvertTable.call(this, node)
+    return typeof html === 'string' ? liftRhrevChangedToCells(html) : html
+  })
+}
+
+// Moves the rhrev-changed marker from a marked cell's own nested content
+// (propagateCellContentMarks above) onto its enclosing <td>/<th>, so the
+// site stylesheet highlights the whole cell box, matching the PDF
+// backend's own margin bar spanning the cell's full row height, rather
+// than only the changed paragraph inside it. Operates on the already-
+// rendered HTML string, not the AST: Asciidoctor's real convert_table has
+// no per-cell hook to override cleanly (table rendering is one self-
+// contained method, the same reason the PDF gem needed a Prawn-level
+// patch rather than an ordinary converter override, confirmed against
+// Asciidoctor's own source), so this calls the real, unmodified super()
+// implementation first and only adjusts its output afterward.
+//
+// Finds the nearest PRECEDING <td/<th opening tag before each marker,
+// confirmed against real rendered output (a plain cell's own <p
+// class="tableblock"> vs an a| cell's <div class="content">, both
+// verified). A table nested inside a cell, itself containing its own
+// <td>/<th> tags between the marker and its true enclosing cell, would
+// defeat that heuristic: a known, accepted limitation, not handled.
+function liftRhrevChangedToCells (html) {
+  const cellTagRx = /<(td|th)\b[^>]*>/g
+  const cellTags = []
+  let m
+  while ((m = cellTagRx.exec(html))) {
+    cellTags.push({ start: m.index, end: m.index + m[0].length, text: m[0] })
+  }
+  if (cellTags.length === 0) return html
+
+  const markerRx = /class="[^"]*\brhrev-changed\b[^"]*"/g
+  const toPatch = new Set()
+  while ((m = markerRx.exec(html))) {
+    let owner
+    for (const tag of cellTags) {
+      if (tag.start <= m.index) owner = tag
+      else break
+    }
+    if (owner) toPatch.add(owner)
+  }
+  if (toPatch.size === 0) return html
+
+  let out = ''
+  let cursor = 0
+  for (const tag of cellTags) {
+    if (!toPatch.has(tag)) continue
+    out += html.slice(cursor, tag.start)
+    out += addRoleClass(tag.text, 'rhrev-changed')
+    cursor = tag.end
+  }
+  out += html.slice(cursor)
+  return out
+}
+
+function addRoleClass (tagText, role) {
+  if (new RegExp(`\\bclass="[^"]*\\b${role}\\b[^"]*"`).test(tagText)) return tagText
+  if (/\bclass="/.test(tagText)) return tagText.replace(/\bclass="/, `class="${role} `)
+  return tagText.replace(/^<(td|th)\b/, `<$1 class="${role}"`)
+}
 
 // Catalog for storing revision entries
 class RevisionCatalog {
@@ -729,6 +834,17 @@ module.exports.register = function (registry, context = {}) {
       const changeAttr = prefix + String(revnumber).replace(/\./g, '-')
       const contexts = ROW_LEVEL_CONTEXTS.concat(ROLLUP_CONTEXTS)
 
+      // A marked table cell was already tagged on its own nested content by
+      // propagateCellContentMarks, in the earlier treeprocessor: that walk
+      // is scoped to each cell's own, structurally separate inner document,
+      // invisible to this treeprocessor's own outer-document findBy below,
+      // so `tagged` (which only reflects THIS loop) is never a reliable
+      // signal for whether a cell needs patching. Runs unconditionally once
+      // change bars are known enabled, before the tagged/return-early check,
+      // so a document whose only marked content is a table cell (no other
+      // block matched below) still gets its converter patched.
+      patchConvertTableForCellTagging(doc)
+
       let tagged = false
       doc.findBy((b) => contexts.includes(b.getContext())).forEach((block) => {
         const attrs = block.getAttributes()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asciidoctor-rhrev",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "Revision history block macro extension for Asciidoctor.js and Antora (HTML5 backend)",
   "main": "antora-extension/antora-rhrev-asciidoc.js",
   "scripts": {