asciidoctor-rhrev 1.8.3 → 1.9.0

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

@@ -17,7 +17,23 @@
 // of their own. A marked one rolls up as a bullet into its nearest
 // enclosing section's entry instead (or the document-level -all entry, if
 // it has no enclosing section, or its enclosing section has no id).
-const { liftCellTextMarks } = require('./cell-text-marks.js')
+const { liftCellTextMarks, cellTextMarks } = require('./cell-text-marks.js')
+const {
+  thirdLevelMode,
+  thirdLevelKind,
+  revisionOf,
+  groupAttr,
+  groupKey,
+  sortMarkKeys,
+  revisionComparator,
+  mixedDraftGroups,
+  mixedDraftMessage,
+  markedRevisionOf,
+  markedRevisions,
+  dropReleaseMarks,
+  Matcher,
+  REVISION_RX
+} = require('./third-level.js')
 
 const ROLLUP_CONTEXTS = ['paragraph', 'ulist', 'olist', 'dlist', 'admonition', 'open', 'quote', 'verse', 'sidebar']
 
@@ -40,7 +56,8 @@ function enclosingSection(node) {
 // appends another bullet onto its change text, or creates the entry if
 // anchorNode has none yet. Same shape as Converter#append_child_change_to_entry.
 function appendChildChangeToEntry(catalog, revision, anchorNode, changeText) {
-  const entries = catalog.entries[revision] || (catalog.entries[revision] = [])
+  const key = catalog.revisionKey(revision)
+  const entries = catalog.entries[key] || (catalog.entries[key] = [])
   const anchorId = anchorNode.getId()
   const entry = entries.find((e) => e.anchor === anchorId)
   if (entry) {
@@ -56,9 +73,7 @@ function appendChildChangeToEntry(catalog, revision, anchorNode, changeText) {
 // Appends onto catalog's existing -all change text for this revision, or
 // sets it fresh if none exists yet. Same shape as Converter#append_child_change_to_all.
 function appendChildChangeToAll(catalog, revision, changeText) {
-  const existing = catalog.allEntries[revision]
-  const combined = (existing && String(existing).length) ? `${existing} * ${changeText}` : changeText
-  catalog.addAllEntry(revision, combined)
+  catalog.appendAllEntry(revision, changeText)
 }
 
 // Gathers every marked rollup-context node in one unified, document-order
@@ -74,7 +89,7 @@ function rollupChildRevisionEntries(catalog, doc, prefix) {
     if (!attrs) return
     const section = enclosingSection(node)
     const hasSection = !!(section && section.getId())
-    Object.keys(attrs).forEach((key) => {
+    sortMarkKeys(Object.keys(attrs), prefix, catalog.kind).forEach((key) => {
       if (!key.startsWith(prefix)) return
       if (key.includes('-all') || key.endsWith('-cover')) return
       const revision = key.substring(prefix.length)
@@ -122,7 +137,8 @@ function rollupChildRevisionEntries(catalog, doc, prefix) {
 function propagateCellContentMarks(doc, prefix) {
   const changeBarsEnabled = doc.hasAttribute('rhrev-change-bars')
   const revnumber = doc.getAttribute('revnumber')
-  const changeAttr = (changeBarsEnabled && revnumber) ? prefix + String(revnumber).replace(/\./g, '-') : null
+  const matcher = (changeBarsEnabled && revnumber) ? new Matcher(prefix, revnumber, docThirdLevelMode(doc), docThirdLevelKind(doc), docIgnoredReleases(doc, prefix)) : null
+  const isChangeMark = matcher ? (key) => matcher.isMark(key) : null
 
   // First the raw-text rule (cell-text-marks.js): an rhrev attribute list
   // alone on the first line of any cell's content, any style, any row
@@ -131,7 +147,7 @@ function propagateCellContentMarks(doc, prefix) {
   // content as blocks. The role span it wraps a marked plain cell's text in
   // is what patchConvertTableForCellTagging's HTML lift finds for such a
   // cell, the same way a marked nested node's role serves an a| cell.
-  liftCellTextMarks(doc, prefix, { changeAttr, wrapForTag: !!changeAttr })
+  liftCellTextMarks(doc, prefix, { isChangeMark, wrapForTag: !!matcher })
 
   doc.findBy((n) => n.getContext() === 'table').forEach((table) => {
     const rows = table.getRows()
@@ -146,7 +162,7 @@ function propagateCellContentMarks(doc, prefix) {
         Object.keys(attrs).forEach((key) => {
           if (!key.startsWith(prefix)) return
           cell.setAttribute(key, attrs[key])
-          if (key === changeAttr) {
+          if (matcher && matcher.isMark(key)) {
             const roles = attrs.role
             node.setAttribute('role', roles ? `${roles} rhrev-changed` : 'rhrev-changed')
           }
@@ -322,20 +338,99 @@ function addRoleClass (tagText, role) {
   return tagText.replace(/^<(td|th)\b/, `<$1 class="${role}"`)
 }
 
-// Catalog for storing revision entries
+// The document's rhrev-third-level mode, warning once per document on an
+// unrecognized value.
+function docThirdLevelMode(doc) {
+  return thirdLevelMode(doc.getAttribute('rhrev-third-level'), (message) => {
+    if (doc.$$rhrevThirdLevelWarned) return
+    doc.$$rhrevThirdLevelWarned = true
+    doc.getLogger().warn(message)
+  })
+}
+
+// The document's rhrev-third-level-kind, or null without a mode, warning
+// once per document on an unrecognized value.
+function docThirdLevelKind(doc) {
+  return thirdLevelKind(doc.getAttribute('rhrev-third-level-kind'), docThirdLevelMode(doc), (message) => {
+    if (doc.$$rhrevThirdLevelKindWarned) return
+    doc.$$rhrevThirdLevelKindWarned = true
+    doc.getLogger().warn(message)
+  })
+}
+
+// The x-y releases a draft-kind document marks beside marks of their own
+// drafts, warning once per release, same as
+// ThirdLevel.drop_mixed_release_marks on the Ruby side. Reads the cell
+// text marks liftCellTextMarks has not lifted yet, so it gives the same
+// answer before and after propagateCellContentMarks. Memoized on the
+// document.
+function docMixedReleases(doc, prefix) {
+  if (doc.$$rhrevMixedReleases) return doc.$$rhrevMixedReleases
+  let releases = []
+  if (docThirdLevelKind(doc) === 'draft') {
+    const revisions = markedRevisions(doc, prefix)
+    doc.findBy((n) => n.getContext() === 'table').forEach((table) => {
+      const rows = table.getRows()
+      ;[].concat(rows.head.flat(), rows.foot.flat(), rows.body.flat()).forEach((cell) => {
+        Object.keys(cellTextMarks(cell, prefix)).forEach((key) => {
+          const revision = markedRevisionOf(key, prefix)
+          if (revision) revisions.push(revision)
+        })
+      })
+    })
+    releases = mixedDraftGroups(revisions).map(([release, drafts]) => {
+      doc.getLogger().warn(mixedDraftMessage(prefix, release, drafts))
+      return release
+    })
+  }
+  doc.$$rhrevMixedReleases = releases
+  return releases
+}
+
+// The releases whose marks the document ignores: its own mixed releases,
+// plus those of its component catalog, which antora-rhrev-html.js finds
+// across every page of the component.
+function docIgnoredReleases(doc, prefix) {
+  const componentName = doc.getAttribute('page-component-name')
+  const component = componentName && global.antoraRhrevCatalog && global.antoraRhrevCatalog.byComponent &&
+    global.antoraRhrevCatalog.byComponent[componentName]
+  return [...new Set(docMixedReleases(doc, prefix).concat((component && component.ignored) || []))]
+}
+
+// Catalog for storing revision entries. In collapse mode (thirdLevel) every
+// revision is stored under its x-y group, and one anchor marked in several
+// revisions of a group merges into one entry. kind orders an x-y revision
+// relative to its x-y-z revisions.
 class RevisionCatalog {
-  constructor() {
+  constructor(thirdLevel = null, kind = null) {
     this.entries = {}       // Block-level entries: { '1-1': [...], '1-2': [...] }
     this.allEntries = {}    // Document-level -all entries: { '1-1': 'text', '1-2': 'text' }
     this.sequence = 0
+    this.thirdLevel = thirdLevel
+    this.kind = kind
+  }
+
+  revisionKey(revision) {
+    return groupKey(revision, this.thirdLevel)
   }
 
   addEntry(revision, anchor, change, metadata = {}) {
-    if (!this.entries[revision]) {
-      this.entries[revision] = []
+    const key = this.revisionKey(revision)
+    if (!this.entries[key]) {
+      this.entries[key] = []
     }
 
-    this.entries[revision].push({
+    if (this.thirdLevel === 'collapse') {
+      const existing = this.entries[key].find((e) => e.anchor === anchor)
+      if (existing) {
+        if (change && String(change).length) {
+          existing.change = (existing.change && String(existing.change).length) ? `${existing.change} * ${change}` : change
+        }
+        return
+      }
+    }
+
+    this.entries[key].push({
       anchor,
       change,
       title: metadata.title || null,
@@ -345,7 +440,12 @@ class RevisionCatalog {
   }
 
   addAllEntry(revision, change) {
-    this.allEntries[revision] = change
+    this.allEntries[this.revisionKey(revision)] = change
+  }
+
+  appendAllEntry(revision, change) {
+    const existing = this.allEntries[this.revisionKey(revision)]
+    this.addAllEntry(revision, (existing && String(existing).length) ? `${existing} * ${change}` : change)
   }
 
   sortedRevisions() {
@@ -353,20 +453,8 @@ class RevisionCatalog {
       ...Object.keys(this.entries),
       ...Object.keys(this.allEntries)
     ])
-    return Array.from(revisions).sort(compareRevisions)
-  }
-}
-
-function compareRevisions(a, b) {
-  const aParts = a.split('-').map(Number)
-  const bParts = b.split('-').map(Number)
-  const len = Math.max(aParts.length, bParts.length)
-  for (let i = 0; i < len; i++) {
-    const aVal = i < aParts.length ? aParts[i] : 0
-    const bVal = i < bParts.length ? bParts[i] : 0
-    if (aVal !== bVal) return bVal - aVal
+    return Array.from(revisions).sort(revisionComparator(this.kind))
   }
-  return 0
 }
 
 function isInitialRelease(revnumber) {
@@ -427,25 +515,31 @@ function formatChangeAsHtmlList(text) {
 }
 
 function collectAllEntries(doc) {
-  const catalog = new RevisionCatalog()
+  const thirdLevel = docThirdLevelMode(doc)
+  const catalog = new RevisionCatalog(thirdLevel, docThirdLevelKind(doc))
   const prefix = doc.getAttribute('revhistoryprefix') || 'rhrev'
 
-  // Collect document-level entries (-all)
-  for (let major = 0; major <= 9; major++) {
-    for (let minor = 0; minor <= 9; minor++) {
-      const revision = `${major}-${minor}`
-      const prevrevAttr = `${revision}-prevrev`
-
-      if (doc.getAttribute(prevrevAttr)) {
-        const allAttrName = `${prefix}${revision}-all`
-        const allValue = doc.getAttribute(allAttrName)
-
-        if (allValue) {
-          catalog.addAllEntry(revision, allValue)
-        }
-      }
+  // Collect document-level entries (-all). Discover revisions from
+  // *-prevrev attributes so any number of segments works, the same as the
+  // Ruby side; with rhrev-third-level set, a revision's -all attribute
+  // counts too. Ascending order keeps merged collapse-mode text in
+  // revision order.
+  const revisions = new Set()
+  Object.keys(doc.getAttributes()).forEach((key) => {
+    let revision = null
+    if (key.endsWith('-prevrev')) {
+      revision = key.slice(0, -'-prevrev'.length)
+    } else if (thirdLevel && key.endsWith('-all')) {
+      revision = revisionOf(key.slice(0, -'-all'.length), prefix)
     }
-  }
+    if (revision && REVISION_RX.test(revision)) revisions.add(revision)
+  })
+  Array.from(revisions).sort(revisionComparator(catalog.kind)).reverse().forEach((revision) => {
+    const allValue = doc.getAttribute(`${prefix}${revision}-all`)
+    if (allValue) {
+      catalog.appendAllEntry(revision, allValue)
+    }
+  })
 
   // Collect block-level entries by scanning document
   function scanBlocks(blocks) {
@@ -461,7 +555,7 @@ function collectAllEntries(doc) {
 
         // Also check if attributes are exposed differently
         // Some Asciidoctor.js versions expose them via getAttribute(name) only
-        Object.keys(attrs).forEach(key => {
+        sortMarkKeys(Object.keys(attrs), prefix, catalog.kind).forEach(key => {
           const value = attrs[key]
 
           if (key.startsWith(prefix) && !key.includes('-all') && !key.endsWith('-cover')) {
@@ -654,11 +748,11 @@ function generateHtmlTable(doc, catalog, currentPage = '') {
   const allText = doc.getAttribute('rhrev-localization-all') || 'All'
 
   catalog.sortedRevisions().forEach(revision => {
-    const prevrevAttr = `${revision}-prevrev`
-    const prevrevdateAttr = `${revision}-prevrevdate`
+    const thirdLevel = docThirdLevelMode(doc)
+    const docAttrs = doc.getAttributes()
     const revisionLabel = String(doc.getAttribute('version-label') || 'Revision')
-    const prevTitle = String(doc.getAttribute(prevrevAttr) || revision.replaceAll('-', '.'))
-    const prevDate = String(doc.getAttribute(prevrevdateAttr) || '')
+    const prevTitle = String(groupAttr(docAttrs, revision, 'prevrev', thirdLevel) || revision.replaceAll('-', '.'))
+    const prevDate = String(groupAttr(docAttrs, revision, 'prevrevdate', thirdLevel) || '')
     const prevRevText = formatPrevRev(prevTitle, prevDate, doc)
 
     // Build header text
@@ -820,7 +914,13 @@ module.exports.register = function (registry, context = {}) {
 
     self.process(function (doc) {
       const prefix = doc.getAttribute('revhistoryprefix') || 'rhrev'
+      // Dropping the ignored releases' marks before and after propagation
+      // removes them from blocks and nested cell content first, then from
+      // the cell text marks propagation lifts onto their cells.
+      const ignored = docIgnoredReleases(doc, prefix)
+      dropReleaseMarks(doc, prefix, ignored)
       propagateCellContentMarks(doc, prefix)
+      dropReleaseMarks(doc, prefix, ignored)
       return doc
     })
   })
@@ -842,7 +942,7 @@ module.exports.register = function (registry, context = {}) {
       const revnumber = doc.getAttribute('revnumber')
       if (!revnumber) return doc
       const prefix = doc.getAttribute('revhistoryprefix') || 'rhrev'
-      const changeAttr = prefix + String(revnumber).replace(/\./g, '-')
+      const matcher = new Matcher(prefix, revnumber, docThirdLevelMode(doc), docThirdLevelKind(doc), docIgnoredReleases(doc, prefix))
       const contexts = ROW_LEVEL_CONTEXTS.concat(ROLLUP_CONTEXTS)
 
       // A marked table cell was already tagged on its own nested content by
@@ -859,7 +959,7 @@ module.exports.register = function (registry, context = {}) {
       let tagged = false
       doc.findBy((b) => contexts.includes(b.getContext())).forEach((block) => {
         const attrs = block.getAttributes()
-        if (!attrs || attrs[changeAttr] === undefined) return
+        if (!matcher.match(attrs)) return
         const role = attrs.role ? attrs.role + ' rhrev-changed' : 'rhrev-changed'
         block.setAttribute('role', role)
         tagged = true

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

@@ -1,6 +1,20 @@
 'use strict'
 
 const { liftCellTextMarks } = require('./cell-text-marks.js')
+const {
+  thirdLevelMode,
+  thirdLevelKind,
+  revisionOf,
+  groupKey,
+  sortMarkKeys,
+  revisionComparator,
+  mixedDraftGroups,
+  mixedDraftMessage,
+  markedRevisionOf,
+  markedRevisions,
+  dropReleaseMarks,
+  REVISION_RX
+} = require('./third-level.js')
 
 /**
  * Antora pipeline extension for revision history (rhrev).
@@ -43,7 +57,7 @@ noIncludeRegistry.includeProcessor(function () {
 // sibling file: the two files are independent Antora extension entry
 // points, loaded and registered separately, matching the existing
 // duplication between this file and antora-rhrev-asciidoc.js (each has
-// its own copy of, for example, compareRevisions and formatChangeAsHtmlList).
+// its own copy of, for example, formatChangeAsHtmlList).
 const ROLLUP_CONTEXTS = ['paragraph', 'ulist', 'olist', 'dlist', 'admonition', 'open', 'quote', 'verse', 'sidebar']
 
 // Row-level: gets its own revision-history row when marked, requires an id.
@@ -151,9 +165,10 @@ function mergeCatalogs(catalogs) {
     allEntries: {},
     sortedRevisions() {
       const all = [...Object.keys(this.entries), ...Object.keys(this.allEntries)]
-      return [...new Set(all)].sort(compareRevisions)
+      return [...new Set(all)].sort(revisionComparator(this.kind))
     }
   }
+  merged.kind = (catalogs.find((catalog) => catalog.kind) || {}).kind || null
   for (const catalog of catalogs) {
     for (const [revision, entries] of Object.entries(catalog.entries)) {
       if (!merged.entries[revision]) merged.entries[revision] = []
@@ -174,7 +189,8 @@ function mergeCatalogs(catalogs) {
 // the anchor node's own for a row-level entry (anchorNode is the marked
 // node itself, so meta === the anchor's own position).
 function appendChildChangeToEntry(catalog, revision, anchorNode, changeText, pageMeta, meta) {
-  const entries = catalog.entries[revision] || (catalog.entries[revision] = [])
+  const key = groupKey(revision, catalog.thirdLevel)
+  const entries = catalog.entries[key] || (catalog.entries[key] = [])
   const anchorId = anchorNode.getId()
   const entry = entries.find((e) => e.anchor === anchorId)
   if (entry) {
@@ -194,9 +210,10 @@ function appendChildChangeToEntry(catalog, revision, anchorNode, changeText, pag
 // Appends onto catalog's existing -all change text for this revision, or
 // sets it fresh if none exists yet.
 function appendChildChangeToAll(catalog, revision, changeText) {
-  const existing = catalog.allEntries[revision]
+  const key = groupKey(revision, catalog.thirdLevel)
+  const existing = catalog.allEntries[key]
   const combined = (existing && String(existing).length) ? `${existing} * ${changeText}` : changeText
-  catalog.allEntries[revision] = combined
+  catalog.allEntries[key] = combined
 }
 
 function buildComponentCatalog(pageFiles, logger, quiet) {
@@ -213,7 +230,7 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
         ...Object.keys(this.allEntries)
       ]
       const uniqueRevisions = [...new Set(allRevisions)]
-      return uniqueRevisions.sort(compareRevisions)
+      return uniqueRevisions.sort(revisionComparator(this.kind))
     }
   }
 
@@ -224,20 +241,63 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
   // Component attributes are in src.origin.descriptor.asciidoc.attributes
   const componentAttrs = firstFile.src?.origin?.descriptor?.asciidoc?.attributes || {}
   const prefix = componentAttrs.revhistoryprefix || 'rhrev'
+  catalog.thirdLevel = thirdLevelMode(componentAttrs['rhrev-third-level'], (message) => logger.warn(message))
+  catalog.kind = thirdLevelKind(componentAttrs['rhrev-third-level-kind'], catalog.thirdLevel, (message) => logger.warn(message))
 
   if (!quiet) {
     logger.debug(`rhrev-extension: Using prefix '${prefix}'`)
   }
 
-  // Collect document-level entries by scanning for *-prevrev attributes (supports N-part versions)
+  // Parse every page before collecting anything (the parse itself is
+  // described where the block-level entries are collected): a draft-kind
+  // component ignores a release
+  // marked beside its own drafts on any page, which is only known once
+  // every page has been read. catalog.ignored lists those releases for
+  // antora-rhrev-asciidoc.js, so page tagging ignores them too.
+  const parsedPages = []
+  pageFiles.forEach((file) => {
+    if (!file.contents) return
+    const content = file.contents.toString()
+    let doc
+    try {
+      doc = asciidoctor.load(content, { safe: 'safe', sourcemap: true, extension_registry: noIncludeRegistry, attributes: componentAttrs })
+    } catch (e) {
+      if (!quiet) logger.debug(`rhrev-extension: failed to parse ${file.src?.relative}, skipped: ${e.message}`)
+      return
+    }
+    liftCellTextMarks(doc, prefix)
+    parsedPages.push({ file, content, doc })
+  })
+  catalog.ignored = []
+  if (catalog.kind === 'draft') {
+    const marked = Object.keys(componentAttrs).map((key) => markedRevisionOf(key, prefix)).filter(Boolean)
+    parsedPages.forEach(({ doc }) => marked.push(...markedRevisions(doc, prefix)))
+    catalog.ignored = mixedDraftGroups(marked).map(([release, drafts]) => {
+      logger.warn(mixedDraftMessage(prefix, release, drafts))
+      return release
+    })
+    parsedPages.forEach(({ doc }) => dropReleaseMarks(doc, prefix, catalog.ignored))
+  }
+
+  // Collect document-level entries by scanning for *-prevrev attributes
+  // (supports N-part versions); with rhrev-third-level set, a revision's
+  // -all attribute counts too. Ascending order keeps merged collapse-mode
+  // text in revision order.
   const prevrevRx = /^([0-9]+(?:-[0-9]+)+)-prevrev$/
+  const revisions = new Set()
   for (const attrName of Object.keys(componentAttrs)) {
     const m = attrName.match(prevrevRx)
-    if (!m) continue
-    const revision = m[1]
+    if (m) {
+      revisions.add(m[1])
+    } else if (catalog.thirdLevel && attrName.endsWith('-all')) {
+      const revision = revisionOf(attrName.slice(0, -'-all'.length), prefix)
+      if (revision && REVISION_RX.test(revision)) revisions.add(revision)
+    }
+  }
+  for (const revision of Array.from(revisions).sort(revisionComparator(catalog.kind)).reverse()) {
     const allValue = componentAttrs[`${prefix}${revision}-all`]
-    if (allValue) {
-      catalog.allEntries[revision] = allValue
+    if (allValue && !catalog.ignored.includes(revision)) {
+      appendChildChangeToAll(catalog, revision, allValue)
       if (!quiet) {
         logger.debug(`rhrev-extension: Found -all entry for ${revision}`)
       }
@@ -253,11 +313,7 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
   // by [#anchor], .Title, or a heading line, so it had no way to reach
   // paragraphs, lists, admonitions, or any of the other rollup contexts,
   // or table cells, at all. Real parsing has no such limit.
-  pageFiles.forEach(file => {
-    if (!file.contents) return
-
-    const content = file.contents.toString()
-
+  parsedPages.forEach(({ file, content, doc }) => {
     if (!quiet && content.includes(prefix)) {
       logger.debug(`rhrev-extension: Scanning ${file.src?.relative} for block attributes`)
     }
@@ -274,14 +330,6 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
     })
     catalog.fileMeta[file.src?.relative || file.path] = fileTagBoundaries
 
-    let doc
-    try {
-      doc = asciidoctor.load(content, { safe: 'safe', sourcemap: true, extension_registry: noIncludeRegistry, attributes: componentAttrs })
-    } catch (e) {
-      if (!quiet) logger.debug(`rhrev-extension: failed to parse ${file.src?.relative}, skipped: ${e.message}`)
-      return
-    }
-
     const pageMeta = {
       page: file.src?.relative || file.path,
       component: file.src?.component,
@@ -310,12 +358,20 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
       if (!blockId) return
       const attrs = block.getAttributes()
       if (!attrs) return
-      Object.keys(attrs).forEach((key) => {
+      sortMarkKeys(Object.keys(attrs), prefix, catalog.kind).forEach((key) => {
         if (!key.startsWith(prefix)) return
         if (key.includes('-all') || key.endsWith('-cover')) return
         const revision = key.substring(prefix.length)
-        catalog.entries[revision] = catalog.entries[revision] || []
-        catalog.entries[revision].push({
+        if (catalog.thirdLevel === 'collapse') {
+          const grouped = catalog.entries[groupKey(revision, 'collapse')] || []
+          if (grouped.some((e) => e.anchor === blockId && e.page === pageMeta.page)) {
+            appendChildChangeToEntry(catalog, revision, block, String(attrs[key]), pageMeta, metaFor(block))
+            return
+          }
+        }
+        const rowKey = groupKey(revision, catalog.thirdLevel)
+        catalog.entries[rowKey] = catalog.entries[rowKey] || []
+        catalog.entries[rowKey].push({
           anchor: blockId,
           change: String(attrs[key]),
           title: block.getTitle(),
@@ -378,7 +434,7 @@ function buildComponentCatalog(pageFiles, logger, quiet) {
       if (!attrs) return
       const section = enclosingSection(node)
       const hasSection = !!(section && section.getId())
-      Object.keys(attrs).forEach((key) => {
+      sortMarkKeys(Object.keys(attrs), prefix, catalog.kind).forEach((key) => {
         if (!key.startsWith(prefix)) return
         if (key.includes('-all') || key.endsWith('-cover')) return
         const revision = key.substring(prefix.length)
@@ -501,7 +557,7 @@ function generateRevisionHistoryHtml(file, catalog, logger, quiet) {
   ]
   const uniqueRevisions = [...new Set(allRevisions)]
   
-  const sortedRevisions = uniqueRevisions.sort(compareRevisions)
+  const sortedRevisions = uniqueRevisions.sort(revisionComparator(catalog.kind))
 
   // Generate revision rows
   sortedRevisions.forEach(revision => {
@@ -582,18 +638,6 @@ function stripVerbatimBlocks(content) {
   return out.join('\n')
 }
 
-function compareRevisions(a, b) {
-  const aParts = a.split('-').map(Number)
-  const bParts = b.split('-').map(Number)
-  const len = Math.max(aParts.length, bParts.length)
-  for (let i = 0; i < len; i++) {
-    const aVal = i < aParts.length ? aParts[i] : 0
-    const bVal = i < bParts.length ? bParts[i] : 0
-    if (aVal !== bVal) return bVal - aVal
-  }
-  return 0
-}
-
 function formatChangeAsHtmlList(text) {
   if (!text) return ''
   

package/antora-extension/cell-text-marks.js

@@ -21,8 +21,9 @@
 // (global.Opal), so the accepted syntax matches the Ruby side exactly. When
 // no Opal runtime is present the cell is left untouched.
 //
-// wrapForTag: when set, and the lifted attributes include changeAttr (the
-// current revision's own attribute, change bars enabled), the remaining
+// wrapForTag: when set, and isChangeMark accepts one of the lifted
+// attributes (a mark of the current revision, change bars enabled,
+// third-level.js Matcher#isMark), the remaining
 // cell text is wrapped in an unconstrained role span carrying the
 // rhrev-changed role. Antora's HTML pipeline cannot tag a cell's own
 // <td>/<th> from a treeprocessor; antora-rhrev-asciidoc.js's converter
@@ -49,8 +50,18 @@ function parseAttributeList (list) {
   return attrs
 }
 
+// The rhrev marks a cell's raw text carries on its first line, as a plain
+// object, without lifting them. Empty when there are none.
+function cellTextMarks (cell, prefix) {
+  const raw = cell.text
+  const m = typeof raw === 'string' && LEADING_ATTRIBUTE_LIST_RX.exec(raw)
+  const attrs = m && parseAttributeList(m[1])
+  if (!attrs) return {}
+  return Object.fromEntries(Object.entries(attrs).filter(([key]) => key.startsWith(prefix)))
+}
+
 // Lifts a mark from one cell. Returns true when the cell changed.
-function liftCellTextMark (cell, prefix, { changeAttr = null, wrapForTag = false } = {}) {
+function liftCellTextMark (cell, prefix, { isChangeMark = null, wrapForTag = false } = {}) {
   const raw = cell.text
   if (typeof raw !== 'string') return false
   const m = LEADING_ATTRIBUTE_LIST_RX.exec(raw)
@@ -62,7 +73,7 @@ function liftCellTextMark (cell, prefix, { changeAttr = null, wrapForTag = false
   markKeys.forEach((key) => cell.setAttribute(key, attrs[key]))
   let rest = raw.slice(m[0].length)
   const style = cell.getStyle()
-  if (wrapForTag && changeAttr && markKeys.includes(changeAttr) && style !== 'asciidoc' && style !== 'literal') {
+  if (wrapForTag && isChangeMark && markKeys.some(isChangeMark) && style !== 'asciidoc' && style !== 'literal') {
     rest = `[.rhrev-changed]##${rest}##`
   }
   cell.text = rest
@@ -81,4 +92,4 @@ function liftCellTextMarks (doc, prefix, options = {}) {
   return lifted
 }
 
-module.exports = { liftCellTextMarks, liftCellTextMark, LEADING_ATTRIBUTE_LIST_RX }
+module.exports = { liftCellTextMarks, liftCellTextMark, cellTextMarks, LEADING_ATTRIBUTE_LIST_RX }

package/antora-extension/third-level.js

@@ -0,0 +1,228 @@
+'use strict'
+
+// Support for x.y.z revision numbers, selected by the rhrev-third-level
+// attribute. Mirrors lib/asciidoctor/rhrev/third_level.rb on the Ruby side:
+//
+// collapse: the revision history table groups every revision by its first
+//   two levels, and the change bar covers every mark of the current x.y
+//   release.
+// expand: the table lists every revision on its own, and the change bar
+//   covers every mark of the current x.y release. The third-level lanes
+//   are PDF-only; HTML draws one bar per element.
+//
+// Without the attribute, only a mark for exactly the current revnumber
+// draws a bar, and every revision gets its own table group.
+//
+// The rhrev-third-level-kind attribute says what an x.y.z revision is:
+//
+// draft: the default; x.y.1, x.y.2, ... are drafts leading up to the
+//   release x.y, so x.y sorts after its drafts, an x.y mark draws no bar
+//   while the revnumber names a draft, and an x.y mark beside marks of its
+//   own drafts is dropped with a warning (mixedDraftGroups,
+//   dropReleaseMarks).
+// amendment: x.y.1, x.y.2, ... amend the released x.y, so x.y sorts
+//   before them and its marks draw a bar for every amendment.
+
+const MODES = ['expand', 'collapse']
+const KINDS = ['draft', 'amendment']
+const DEFAULT_KIND = 'draft'
+const REVISION_RX = /^\d+(?:-\d+)*$/
+
+// The mode for an attribute value, 'expand' or 'collapse', or null when
+// the attribute is unset. An unrecognized value calls warn and yields null.
+function thirdLevelMode (value, warn) {
+  if (value === undefined || value === null || value === false) return null
+  value = String(value)
+  if (MODES.includes(value)) return value
+  if (warn) warn(`rhrev-third-level must be expand or collapse, got '${value}'; ignoring it`)
+  return null
+}
+
+// The kind, 'draft' or 'amendment', for an attribute value, or null when
+// mode is null. An unrecognized value calls warn and yields the default.
+function thirdLevelKind (value, mode, warn) {
+  if (!mode) return null
+  if (value === undefined || value === null || value === false) return DEFAULT_KIND
+  value = String(value)
+  if (KINDS.includes(value)) return value
+  if (warn) warn(`rhrev-third-level-kind must be draft or amendment, got '${value}'; using ${DEFAULT_KIND}`)
+  return DEFAULT_KIND
+}
+
+// The revision a mark names, "1-3-2" for rhrev1-3-2, or null for any other
+// attribute, including -all, -cover, and configuration keys sharing the
+// prefix.
+function revisionOf (key, prefix) {
+  if (!key.startsWith(prefix)) return null
+  const revision = key.substring(prefix.length)
+  return REVISION_RX.test(revision) ? revision : null
+}
+
+function revisionParts (revision) {
+  return revision.split('-').map(Number)
+}
+
+// The comparable form of a revision. In draft kind an x-y revision is the
+// release its x-y-z drafts lead up to, so it sorts after them; otherwise
+// x-y sorts as x-y-0, before x-y-1.
+function sortKey (revision, kind) {
+  const parts = revisionParts(revision)
+  return kind === 'draft' && parts.length === 2 ? parts.concat(Infinity) : parts
+}
+
+function compareAscending (a, b) {
+  const len = Math.max(a.length, b.length)
+  for (let i = 0; i < len; i++) {
+    const x = i < a.length ? a[i] : 0
+    const y = i < b.length ? b[i] : 0
+    if (x !== y) return x < y ? -1 : 1
+  }
+  return 0
+}
+
+// A comparator ordering revisions newest first for the given kind.
+function revisionComparator (kind) {
+  return (a, b) => compareAscending(sortKey(b, kind), sortKey(a, kind))
+}
+
+// The x-y groups whose release mark appears beside marks of its own
+// drafts, each as [release, drafts], from the revisions a document marks.
+function mixedDraftGroups (revisions) {
+  const unique = [...new Set(revisions)]
+  return unique
+    .filter((revision) => revision.split('-').length === 2)
+    .map((release) => [release, unique
+      .filter((revision) => revision.startsWith(`${release}-`) && revision.split('-').length === 3)
+      .sort((a, b) => compareAscending(revisionParts(a), revisionParts(b)))])
+    .filter(([, drafts]) => drafts.length > 0)
+}
+
+// The warning for one mixed group (mixedDraftGroups).
+function mixedDraftMessage (prefix, release, drafts) {
+  return `${prefix}${release} marks the release that its drafts ${drafts.map((d) => prefix + d).join(', ')} lead up to; ignoring the ${prefix}${release} marks, mark each change with the draft that made it`
+}
+
+// The revision an attribute names as a mark, or as an -all or -cover
+// entry, or null.
+function markedRevisionOf (key, prefix) {
+  return revisionOf(key.replace(/-(?:all|cover)$/, ''), prefix)
+}
+
+// Calls fn(node, attributes) for every node that carries marks: the
+// document, every block in it and in nested documents, and every table
+// cell.
+function eachMarkedNode (doc, fn) {
+  doc.findBy({ traverse_documents: true }, () => true).forEach((node) => {
+    fn(node, node.getAttributes() || {})
+    if (node.getContext() !== 'table') return
+    const rows = node.getRows()
+    ;[].concat(rows.head.flat(), rows.foot.flat(), rows.body.flat()).forEach((cell) => fn(cell, cell.getAttributes() || {}))
+  })
+}
+
+// Every revision doc marks, through marks, -all, and -cover entries.
+function markedRevisions (doc, prefix) {
+  const revisions = []
+  eachMarkedNode(doc, (node, attrs) => Object.keys(attrs).forEach((key) => {
+    const revision = markedRevisionOf(key, prefix)
+    if (revision) revisions.push(revision)
+  }))
+  return revisions
+}
+
+// Removes every mark, -all, and -cover entry of the given releases from
+// doc, same as ThirdLevel.drop_mixed_release_marks on the Ruby side.
+function dropReleaseMarks (doc, prefix, releases) {
+  if (!releases.length) return
+  eachMarkedNode(doc, (node, attrs) => Object.keys(attrs).forEach((key) => {
+    if (releases.includes(markedRevisionOf(key, prefix))) node.removeAttribute(key)
+  }))
+}
+
+// The table group a revision belongs to: its first two levels in collapse
+// mode, the revision itself otherwise.
+function groupKey (revision, mode) {
+  if (mode !== 'collapse') return revision
+  const parts = revision.split('-')
+  return parts.length > 2 ? parts.slice(0, 2).join('-') : revision
+}
+
+// A table group's prevrev or prevrevdate value from a plain attribute
+// object: the group's own attribute, or in collapse mode, the lowest
+// third-level revision's attribute that is set.
+function groupAttr (attrs, revision, suffix, mode) {
+  const own = attrs[`${revision}-${suffix}`]
+  if (own !== undefined && own !== null && own !== '') return own
+  if (mode !== 'collapse' || revision.split('-').length !== 2) return null
+  const rx = new RegExp(`^${revision}-(\\d+)-${suffix}$`)
+  let lowest = null
+  for (const key of Object.keys(attrs)) {
+    const m = rx.exec(key)
+    if (m && (lowest === null || Number(m[1]) < lowest[0])) lowest = [Number(m[1]), key]
+  }
+  return lowest ? attrs[lowest[1]] : null
+}
+
+// Attribute keys with every mark first, in ascending revision order, so
+// change texts merged into one collapse-mode entry follow revision order,
+// not source order. Every other key keeps its place after them.
+function sortMarkKeys (keys, prefix, kind = null) {
+  return keys
+    .map((key, index) => ({ key, index, revision: revisionOf(key, prefix) }))
+    .sort((a, b) => {
+      if (!a.revision !== !b.revision) return a.revision ? -1 : 1
+      const byRevision = a.revision ? compareAscending(sortKey(a.revision, kind), sortKey(b.revision, kind)) : 0
+      return byRevision || a.index - b.index
+    })
+    .map(({ key }) => key)
+}
+
+// Decides which marks draw a change bar for the current revnumber.
+class Matcher {
+  // ignored lists releases whose marks never match (mixedDraftGroups).
+  constructor (prefix, revnumber, mode, kind = DEFAULT_KIND, ignored = []) {
+    revnumber = String(revnumber)
+    this.prefix = prefix
+    this.kind = kind
+    this.ignored = ignored
+    this.exact = prefix + revnumber.replace(/\./g, '-')
+    this.mode = null
+    if (mode && /^\d+(?:\.\d+)+$/.test(revnumber)) {
+      const parts = revnumber.split('.').map(Number)
+      this.mode = mode
+      this.base = parts.slice(0, 2)
+      this.currentZ = parts[2]
+    }
+  }
+
+  isMark (key) {
+    if (!this.mode) return key === this.exact
+    const revision = revisionOf(key, this.prefix)
+    if (!revision || this.ignored.includes(revision)) return false
+    const parts = revisionParts(revision)
+    if (parts[0] !== this.base[0] || parts[1] !== this.base[1]) return false
+    if (this.currentZ === undefined) return true
+    return parts.length > 2 ? parts[2] <= this.currentZ : this.kind !== 'draft'
+  }
+
+  match (attrs) {
+    return !!attrs && Object.keys(attrs).some((key) => this.isMark(key))
+  }
+}
+
+module.exports = {
+  thirdLevelMode,
+  thirdLevelKind,
+  revisionOf,
+  groupKey,
+  groupAttr,
+  sortMarkKeys,
+  revisionComparator,
+  mixedDraftGroups,
+  mixedDraftMessage,
+  markedRevisionOf,
+  markedRevisions,
+  dropReleaseMarks,
+  Matcher,
+  REVISION_RX
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asciidoctor-rhrev",
-  "version": "1.8.3",
+  "version": "1.9.0",
   "description": "Revision history block macro extension for Asciidoctor.js and Antora (HTML5 backend)",
   "main": "antora-extension/antora-rhrev-asciidoc.js",
   "scripts": {
@@ -28,6 +28,7 @@
     "antora-extension/antora-rhrev-html.js",
     "antora-extension/antora-rhrev-placeholder.js",
     "antora-extension/cell-text-marks.js",
+    "antora-extension/third-level.js",
     "README.adoc",
     "LICENSE"
   ]