asciidoctor-rhrev 1.8.2 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 155f025dbf45d15c912cbb3f624bc9214344472bd3d33e21c8cfb8dcca21f54a
-  data.tar.gz: b6ceffec703149d7b45f2c3007ff32099421532cf9e73f9cff763200706f6b00
+  metadata.gz: e018143599f73eace12e5f22c99a54119721a6358e61abb67d5040b81118712b
+  data.tar.gz: 194a1c032bd7602dfffe37c6bf87e069ff64d19e172244e3f05fab5effdf7947
 SHA512:
-  metadata.gz: eb676e02167dad226f2ef494bf8de843df79497d8f6fd419d44d815c727e635ea6d62ca9767283540630a515ae27c201695d67875b57d6684158cb1dc15f26e2
-  data.tar.gz: 4369e143e5614067d6f0f28039788e5004a5f772bc5383beacfd56c6f20c3dd7970808515bbcf9b459337d4d7b726e79f3b1d20bbdaa46a689cc26bb639fa6f4
+  metadata.gz: f1f9463fa7dc56dbb4f0d521ff547806724927ffb4b4f87289a30262bf2f7aba2812b6c99eb5eb58927d30e346b80740591f16fe0458559e1e1c2341765b2c64
+  data.tar.gz: 69433c330dca726113054335cff0ac2856882f6f18d07eaf31866ecec4f9543f6276a871f9c8409f942e1e2ee784a69b0ae06943c68b222c054c8c57d73677f9

data/CHANGELOG.adoc

@@ -1,5 +1,16 @@
 = Changelog
 
+== 1.9.0 (2026-10-27)
+
+* Third-level revisions such as `1.3.2`. The `rhrev-third-level` attribute selects `collapse` or `expand`, and `rhrev-third-level-kind` selects `draft`, the default, or `amendment`. With either mode, every mark of the current `x.y` release up to the current third level draws a change bar. `collapse` groups the revision history table by `x.y`, merging change texts and `all` and `cover` entries, with the group header reading `x-y-prevrev` and falling back to the lowest third-level `prevrev`. `expand` keeps one group per revision. `draft` orders `x.y` after its drafts, and a bare `x.y` mark beside its own drafts logs a warning and is ignored everywhere, `all` and `cover` entries included; `amendment` orders `x.y` before its amendments. New `third_level.rb` and `antora-extension/third-level.js`; the Antora extensions parse every page first so a release ignored on one page is ignored on all. Unset, output is unchanged (gem and npm)
+* Change bar style `table`, set with `rhrev-change-bars-style` or the theme key `rhrev_change_bars_style` (PDF backend). In expand mode every changed block gets a box in the margin with one column per revision, its own revisions' columns filled, and each page labels the columns at the top of its body. The `table` theme keys set `column-width`, `max-columns`, `border-color`, `border-width`, `grid-color`, `grid-width`, and the label font family, style, size, and color. Beyond `max-columns`, the first column accumulates the oldest revisions and carries the newest one's label; labels wider than a column turn 90 degrees. The default style `bar` and collapse mode draw the single bar (gem)
+* New regression files `tests/regression/third-level.rb` and `tests/regression/js-third-level.js`
+
+== 1.8.3 (2026-10-22)
+
+* Fix per-item list change bars landing on another revision's items when marks for several revisions stack one per attribute line (PDF backend). Asciidoctor numbers positional entries per attribute line and merges the lines into one hash, so a later line's targets overwrote an earlier line's: `[rhrev1-2="...",2]` followed by `[rhrev1-3="..."]` barred item 2 for revision 1.3 instead of the whole list, and a current mark on the first line took the targets of the line below it. The new `mark_targets.rb` hooks `AttributeList#parse_into`, reads each block attribute line's own memoized parse result, and records which positional entries follow which mark on that line; `Converter#list_item_change_bar_targets` reads the current mark's own record and falls back to every positional entry only for a list built without one. Reported against a real document. Stacked-line checks in `tests/regression/list-item-target-change-bars.rb` cover a current mark with no targets, a current mark on the first line, a later line with fewer targets, a custom `revhistoryprefix`, and a style before the mark, plus a render spy that fails (bars on the wrong items) without the fix
+* Note: gem-only; the Antora extension has no per-item list targets, npm still bumps concurrently per the standing 1.5.1 policy
+
 == 1.8.2 (2026-10-06)
 
 * Change the initial-release table's default text from `Initial Release` to `Initial release` and render it bold (PDF backend), matching the bold `Page` cell beside it; `rhrev-customization-initial-release-text` still overrides the text and is rendered bold too

data/lib/asciidoctor/rhrev/catalog.rb

@@ -1,3 +1,5 @@
+require_relative 'third_level'
+
 module Asciidoctor
   module Rhrev
     class Catalog
@@ -5,11 +7,21 @@ module Asciidoctor
         attr_accessor :all_entries
         attr_accessor :cover_entries
         
-        def initialize
+        # third_level is the rhrev-third-level mode; in collapse mode every
+        # revision is stored under its x-y group (ThirdLevel.group_key).
+        # kind is the rhrev-third-level-kind, which orders an x-y revision
+        # relative to its x-y-z revisions (ThirdLevel.sort_key).
+        def initialize third_level: nil, kind: nil
           @entries = {}  # Hash of revision => [entries]
           @all_entries = {}  # Hash of revision => text for 'all' entries
           @cover_entries = {}  # Hash of revision => text for 'cover' entries
           @sequence_counter = 0  # Counter to track document order
+          @third_level = third_level
+          @kind = kind
+        end
+
+        def revision_key revision
+          ::Asciidoctor::Rhrev::ThirdLevel.group_key revision, @third_level
         end
         
         def self.default_labels
@@ -24,15 +36,26 @@ module Asciidoctor
         end
         
         def add_entry revision, anchor, change_text, reftext: nil, title: nil, sectnum: nil, context: nil, is_chapter: false, sectname: nil, caption_number: nil, source_line: nil
-          @entries[revision] ||= []
-          
-          # Prevent duplicates (e.g. if collected multiple times)
-          return if @entries[revision].any? { |e| e[:anchor] == anchor }
+          key = revision_key revision
+          @entries[key] ||= []
+
+          # Prevent duplicates (e.g. if collected multiple times). In collapse
+          # mode, one anchor marked in several revisions of the same group
+          # merges into one entry, its change texts joined as bullets.
+          if (existing = @entries[key].find { |e| e[:anchor] == anchor })
+            return if existing[:revisions].include? revision
+            existing[:revisions] << revision
+            unless change_text.to_s.empty?
+              existing[:change] = existing[:change].to_s.empty? ? change_text : "#{existing[:change]} * #{change_text}"
+            end
+            return
+          end
           
           @sequence_counter += 1
           # Use source_line if available, otherwise fall back to sequence counter
           sequence = source_line || @sequence_counter
-          @entries[revision] << {
+          @entries[key] << {
+            revisions: [revision],
             anchor: anchor,
             change: change_text,
             dest: nil,
@@ -48,11 +71,23 @@ module Asciidoctor
         end
         
         def add_all_entry revision, change_text
-          @all_entries[revision] = change_text
+          @all_entries[revision_key revision] = change_text
         end
         
         def add_cover_entry revision, change_text
-          @cover_entries[revision] = change_text
+          @cover_entries[revision_key revision] = change_text
+        end
+
+        # Adds change_text to the revision's 'all' or 'cover' text, joined as
+        # another bullet when the group already has one.
+        def append_all_entry revision, change_text
+          existing = @all_entries[revision_key revision]
+          add_all_entry revision, (existing.to_s.empty? ? change_text : "#{existing} * #{change_text}")
+        end
+
+        def append_cover_entry revision, change_text
+          existing = @cover_entries[revision_key revision]
+          add_cover_entry revision, (existing.to_s.empty? ? change_text : "#{existing} * #{change_text}")
         end
         
         def link_dest_to_page anchor, physical_page_number, start_page_number, y: nil
@@ -121,7 +156,7 @@ module Asciidoctor
         
         def parse_revision rev_string
           # Parse "1-1", "1-2", "1-10-2" into comparable array [1, 1], [1, 2], [1, 10, 2]
-          rev_string.split('-').map(&:to_i)
+          ::Asciidoctor::Rhrev::ThirdLevel.sort_key rev_string, @kind
         end
       end
   end

data/lib/asciidoctor/rhrev/change_bars.rb

@@ -8,16 +8,33 @@ module Asciidoctor
       # Enabled by the rhrev-change-bars document attribute.
       #
       # Styling comes from the PDF theme by default (rhrev_change_bars category:
-      # color, width, offset, side), overridable per document via the
-      # rhrev-change-bars-color/-width/-offset/-side attributes.
+      # style, color, width, offset, side, and the table_* keys), the first
+      # five overridable per document via the rhrev-change-bars-style/
+      # -color/-width/-offset/-side attributes.
+      #
+      # With rhrev-third-level set, every mark of the current x.y release
+      # draws the bar (ThirdLevel::Matcher). In expand mode a mark naming a
+      # revision belongs to a lane of its own, the lowest revision nearest
+      # the text (assign_change_bar_lanes), so every lane stands for exactly
+      # one revision. Style bar draws one bar whatever the lanes. Style
+      # table draws the lanes as a table: every changed block draws a thin
+      # box with one column per lane, the columns of its own revisions
+      # filled, and every page with a box labels each column at the top of
+      # its body, so an isolated change still shows which revision it is.
+      # Without lanes, as in collapse mode, table draws the bar too.
       module ChangeBars
+        CHANGE_BAR_STYLES = %w(bar table).freeze
+
         def init_change_bars doc
           @change_bar_attr = nil
+          @change_bar_matcher = nil
+          @change_bar_lane_index = nil
           @change_bar_settings = nil
           return unless doc.attr? 'rhrev-change-bars'
           # Without a revnumber there is no "current" revision to match
           return unless (revnumber = doc.attr 'revnumber')
-          @change_bar_attr = %(#{@revision_prefix}#{revnumber.to_s.tr '.', '-'})
+          @change_bar_matcher = ::Asciidoctor::Rhrev::ThirdLevel.matcher doc, @revision_prefix, revnumber
+          @change_bar_attr = @change_bar_matcher.exact
           # Capture attribute values only; holding the Document in an ivar here
           # would leak it into the scratch prototype, which must stay marshalable
           @change_bar_overrides = {
@@ -25,9 +42,11 @@ module Asciidoctor
             width: (doc.attr 'rhrev-change-bars-width'),
             offset: (doc.attr 'rhrev-change-bars-offset'),
             side: (doc.attr 'rhrev-change-bars-side'),
+            style: (doc.attr 'rhrev-change-bars-style'),
           }
           @change_bar_starts = {}
           @change_bar_section_stack = []
+          @change_bar_grid_labeled_pages = {}
         end
 
         # Resolved lazily on first ink: the theme (and @media/@folio_placement)
@@ -40,22 +59,76 @@ module Asciidoctor
             theme = @theme
             side = overrides[:side] || theme&.rhrev_change_bars_side ||
               (@media == 'prepress' ? 'outer' : 'right')
+            color = change_bar_color overrides[:color] || theme&.rhrev_change_bars_color || 'FF0000'
+            border_color = change_bar_color theme&.rhrev_change_bars_table_border_color || '999999'
+            border_width = (theme&.rhrev_change_bars_table_border_width || 0.25).to_f
             {
-              color: (overrides[:color] || theme&.rhrev_change_bars_color || 'FF0000').to_s.delete_prefix('#').upcase,
+              style: (change_bar_style overrides[:style] || theme&.rhrev_change_bars_style),
+              color: color,
               width: (overrides[:width] || theme&.rhrev_change_bars_width || 2).to_f,
               offset: (overrides[:offset] || theme&.rhrev_change_bars_offset || 16).to_f,
               side: side.to_s,
+              table_column_width: (theme&.rhrev_change_bars_table_column_width || 4).to_f,
+              table_max_columns: [(theme&.rhrev_change_bars_table_max_columns || 8).to_i, 1].max,
+              table_border_color: border_color,
+              table_border_width: border_width,
+              table_grid_color: (change_bar_color theme&.rhrev_change_bars_table_grid_color || border_color),
+              table_grid_width: (theme&.rhrev_change_bars_table_grid_width || border_width).to_f,
+              table_label_font_family: theme&.rhrev_change_bars_table_label_font_family,
+              table_label_font_style: (theme&.rhrev_change_bars_table_label_font_style || 'normal').to_sym,
+              table_label_font_size: (theme&.rhrev_change_bars_table_label_font_size || 5).to_f,
+              table_label_font_color: (change_bar_color theme&.rhrev_change_bars_table_label_font_color || '666666'),
             }
           end
         end
 
+        def change_bar_color value
+          value.to_s.delete_prefix('#').upcase
+        end
+
+        # bar or table, bar when unset. An unrecognized style warns once
+        # and draws the bar.
+        def change_bar_style value
+          return 'bar' if value.nil? || value.to_s.empty?
+          return value.to_s if CHANGE_BAR_STYLES.include? value.to_s
+          logger.warn %(rhrev-change-bars-style must be bar or table, got '#{value}'; using bar)
+          'bar'
+        end
+
+        # Numbers the lanes from the revisions of the current x.y release
+        # the document marks, so a revision keeps the same lane on every
+        # page: the x.y release itself first when the document marks it,
+        # nil standing for it, then each third level in ascending order.
+        def assign_change_bar_lanes third_levels
+          return unless @change_bar_matcher&.mode == 'expand'
+          levels = third_levels.uniq
+          ordered = ((levels.include? nil) ? [nil] : []) + levels.compact.sort
+          @change_bar_lane_index = ordered.each_with_index.to_h
+        end
+
+        # The lanes a node's own attributes fill, one per matching mark,
+        # sorted, or nil when none of its marks belongs to the current
+        # revision. Without lanes, as in collapse mode, every mark fills
+        # lane 0.
+        def change_bar_lanes attributes
+          return nil unless @change_bar_matcher
+          marks = @change_bar_matcher.marks attributes
+          return nil if marks.empty?
+          marks.values.map {|z| @change_bar_lane_index&.[](z) || 0 }.uniq.sort
+        end
+
+        # The lanes a node's own marks draw, or nil.
+        def node_change_bar_lanes node
+          return nil unless @change_bar_attr && node.respond_to?(:attributes) && node.attributes
+          change_bar_lanes node.attributes
+        end
+
         def change_bar? node
-          @change_bar_attr && node.respond_to?(:attributes) &&
-            node.attributes && (node.attributes.key? @change_bar_attr)
+          !(node_change_bar_lanes node).nil?
         end
 
         def record_change_bar_start node
-          @change_bar_starts[node] = { page: page_number, cursor: cursor }
+          @change_bar_starts[node] = { page: page_number, cursor: cursor, lanes: (node_change_bar_lanes node) }
         end
 
         def take_change_bar_start node
@@ -112,39 +185,133 @@ module Asciidoctor
         # number (honoring pdf-folio-placement inversion), matching prepress
         # physical folio placement.
         def change_bar_x pgnum, settings
+          (change_bar_on_right? pgnum, settings) ? bounds.right + settings[:offset] : bounds.left - settings[:offset] - settings[:width]
+        end
+
+        def change_bar_on_right? pgnum, settings
           case settings[:side]
           when 'right'
-            on_right = true
+            true
           when 'outer', 'inner'
             recto = (page_side pgnum, @folio_placement && @folio_placement[:inverted]) == :recto
-            on_right = settings[:side] == 'outer' ? recto : !recto
+            settings[:side] == 'outer' ? recto : !recto
+          else
+            false
+          end
+        end
+
+        # Fills a bar or a table column between top and bottom on the
+        # current page.
+        def ink_change_bar_fill x, top, bottom, width, color
+          bounding_box [x, top], width: width, height: top - bottom do
+            fill_bounds color
           end
-          on_right ? bounds.right + settings[:offset] : bounds.left - settings[:offset] - settings[:width]
         end
 
-        # Paints the bar page by page; from/to are { page:, cursor: }.
+        # Whether bars draw as a table: with style table, once the
+        # document's revisions have lanes, as in expand mode.
+        def change_bar_table? settings
+          settings[:style] == 'table' && !(@change_bar_lane_index.nil? || @change_bar_lane_index.empty?)
+        end
+
+        # The table's columns, at most max of them: an array mapping each
+        # lane to its column. Up to max lanes, each lane has a column of its
+        # own. Beyond max, the first column accumulates the oldest lanes and
+        # every newer lane keeps a column of its own, so each further
+        # revision shifts the others one column toward the text.
+        def change_bar_table_columns total, max
+          return (0...total).to_a if total <= max
+          merged = total - max + 1
+          (0...total).map {|lane| lane < merged ? 0 : lane - merged + 1 }
+        end
+
+        # Inks one page's share of a table box between top and bottom: the
+        # columns from change_bar_table_columns, the columns of lanes
+        # filled, the first column nearest the text.
+        def ink_change_bar_table pgnum, top, bottom, lanes, settings
+          width = settings[:table_column_width]
+          on_right = change_bar_on_right? pgnum, settings
+          column_of = change_bar_table_columns @change_bar_lane_index.size, settings[:table_max_columns]
+          count = column_of.last + 1
+          left = on_right ? bounds.right + settings[:offset] : bounds.left - settings[:offset] - count * width
+          column_x = ->(column) { on_right ? left + column * width : left + (count - 1 - column) * width }
+          lanes.map {|lane| column_of[lane] }.uniq.each do |column|
+            ink_change_bar_fill (column_x.call column), top, bottom, width, settings[:color]
+          end
+          save_graphics_state do
+            if settings[:table_grid_width] > 0
+              stroke_color settings[:table_grid_color]
+              line_width settings[:table_grid_width]
+              (1...count).each {|i| stroke_vertical_line top, bottom, at: left + i * width }
+            end
+            if settings[:table_border_width] > 0
+              stroke_color settings[:table_border_color]
+              line_width settings[:table_border_width]
+              stroke_rectangle [left, top], count * width, top - bottom
+            end
+          end
+          ink_change_bar_table_labels pgnum, column_of, column_x, settings unless @change_bar_grid_labeled_pages[pgnum]
+        end
+
+        # Labels each column at the top of the page body with the
+        # third-level number of the newest lane it holds, 0 for the x.y
+        # release itself. The labels sit above every box on the page,
+        # whichever box inks first. When any label is wider than a column,
+        # every label reads upward, turned 90 degrees and centered on its
+        # column. A label font size of 0 omits the labels.
+        def ink_change_bar_table_labels pgnum, column_of, column_x, settings
+          @change_bar_grid_labeled_pages[pgnum] = true
+          return unless (size = settings[:table_label_font_size]) > 0
+          revisions = @change_bar_lane_index.invert
+          newest = {}
+          column_of.each_with_index {|column, lane| newest[column] = lane }
+          save_graphics_state do
+            fill_color settings[:table_label_font_color]
+            font (settings[:table_label_font_family] || font.family), style: settings[:table_label_font_style] do
+              font_size size do
+                width = settings[:table_column_width]
+                labels = newest.map {|column, lane| [column, (revisions[lane] || 0).to_s] }
+                if labels.any? {|_, label| (width_of label) > width }
+                  # Turned text extends from its baseline toward lower x, so
+                  # the baseline sits half a digit height past the center.
+                  shift = (font.ascender - font.descender) * 0.35
+                  labels.each do |column, label|
+                    draw_text label, at: [(column_x.call column) + width / 2.0 + shift, bounds.top + 2], rotate: 90
+                  end
+                else
+                  labels.each do |column, label|
+                    draw_text label, at: [(column_x.call column) + (width - (width_of label)) / 2.0, bounds.top + 2], rotate: 0
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        # Paints the bar page by page; from/to are { page:, cursor: }, and
+        # from[:lanes] lists the table columns to fill, the first when absent.
         # Called immediately after the block is rendered, so all spanned pages exist.
         def ink_change_bar from, to
           return if scratch? || from.nil? || to.nil?
           return if to[:page] < from[:page]
           return if to[:page] == from[:page] && to[:cursor] >= from[:cursor]
           settings = change_bar_settings
+          lanes = from[:lanes] || [0]
           float do
             (from[:page]..to[:page]).each do |pgnum|
               go_to_page pgnum unless page_number == pgnum
               top = pgnum == from[:page] ? from[:cursor] : bounds.top
               bottom = pgnum == to[:page] ? to[:cursor] : 0
               next if (height = top - bottom) <= 0
-              bounding_box [(change_bar_x pgnum, settings), top], width: settings[:width], height: height do
-                fill_bounds settings[:color]
-              end
+              next ink_change_bar_table pgnum, top, bottom, lanes, settings if change_bar_table? settings
+              ink_change_bar_fill (change_bar_x pgnum, settings), top, bottom, settings[:width], settings[:color]
             end
           end
         end
 
-        def ink_change_bar_for_extent extent
+        def ink_change_bar_for_extent extent, lanes = nil
           return unless extent
-          ink_change_bar({ page: extent.from.page, cursor: extent.from.cursor },
+          ink_change_bar({ page: extent.from.page, cursor: extent.from.cursor, lanes: lanes },
             { page: extent.to.page, cursor: extent.to.cursor })
         end
 
@@ -164,7 +331,7 @@ module Asciidoctor
         # The extent yielded here is exact across page breaks.
         def arrange_block node, &block
           if @change_bar_attr && !scratch? &&
-              (ARRANGED_BLOCK_CONTEXTS.include? node.context) && (change_bar? node)
+              (ARRANGED_BLOCK_CONTEXTS.include? node.context) && (lanes = node_change_bar_lanes node)
             super node do |extent|
               if scratch?
                 # measurement pass: upstream instance_execs this wrapper on the scratch
@@ -172,7 +339,7 @@ module Asciidoctor
                 instance_exec(&block)
               else
                 block.call extent
-                ink_change_bar_for_extent extent
+                ink_change_bar_for_extent extent, lanes
               end
             end
           else
@@ -188,8 +355,8 @@ module Asciidoctor
         # out as a shared helper since none of the four need any special-
         # casing the others don't.
         def bracket_change_bar node
-          if @change_bar_attr && !scratch? && (change_bar? node)
-            bar_from = { page: page_number, cursor: cursor }
+          if @change_bar_attr && !scratch? && (lanes = node_change_bar_lanes node)
+            bar_from = { page: page_number, cursor: cursor, lanes: lanes }
           end
           result = yield
           ink_change_bar bar_from, { page: page_number, cursor: cursor } if bar_from

data/lib/asciidoctor/rhrev/converter.rb

@@ -37,7 +37,7 @@ module Asciidoctor
         end
 
         def revision_history
-          @catalog ||= Catalog.new
+          @catalog ||= Catalog.new third_level: @third_level_mode, kind: @third_level_kind
         end
 
         # The physical PDF page where the document's own body content starts
@@ -159,6 +159,12 @@ module Asciidoctor
 
         def convert_document node
           @revision_prefix = node.attr 'revhistoryprefix', 'rhrev'
+          @third_level_mode = ::Asciidoctor::Rhrev::ThirdLevel.mode node
+          @third_level_kind = ::Asciidoctor::Rhrev::ThirdLevel.kind node
+          # Lifting cell text marks first lets the mixed-release check see
+          # them; prescan_document lifts again, which finds nothing left.
+          ::Asciidoctor::Rhrev::CellTextMarks.lift node, @revision_prefix
+          ::Asciidoctor::Rhrev::ThirdLevel.drop_mixed_release_marks node, @revision_prefix
           init_change_bars node
 
           # Check if we're in manual mode (pagerhref support needed)
@@ -304,10 +310,10 @@ module Asciidoctor
             # Skip recording when the upstream table-container rewrap will trigger
             # (condition replicated from asciidoctor-pdf convert_table); the
             # re-entrant conversion of the attribute-preserving dup records instead
-            if @change_bar_attr && !scratch? && (change_bar? node) &&
+            if @change_bar_attr && !scratch? && (lanes = node_change_bar_lanes node) &&
                 !(!at_page_top? && ((node.option? 'unbreakable') ||
                   ((node.option? 'breakable') && (node.id || node.title?))))
-              bar_from = { page: page_number, cursor: cursor }
+              bar_from = { page: page_number, cursor: cursor, lanes: lanes }
             end
             result = super
             catalog_block_anchor node
@@ -323,16 +329,16 @@ module Asciidoctor
           collect_revision_entries node unless @prescan_complete
           update_revision_entry_metadata node
           # PDF targets import whole pages; there is no cursor flow to mark
-          if @change_bar_attr && !scratch? && (change_bar? node) &&
+          if @change_bar_attr && !scratch? && (lanes = node_change_bar_lanes node) &&
               !((node.attr 'target').to_s.downcase.end_with? '.pdf')
-            bar_from = { page: page_number, cursor: cursor }
+            bar_from = { page: page_number, cursor: cursor, lanes: lanes }
           end
           result = super
           catalog_block_anchor node
           if bar_from
             bar_to = { page: page_number, cursor: cursor }
             # Images never split; a page change means the image moved wholesale
-            bar_from = { page: bar_to[:page], cursor: bounds.top } if bar_to[:page] > bar_from[:page]
+            bar_from = { page: bar_to[:page], cursor: bounds.top, lanes: bar_from[:lanes] } if bar_to[:page] > bar_from[:page]
             ink_change_bar bar_from, bar_to
           end
           result
@@ -435,20 +441,19 @@ module Asciidoctor
 
         def convert_dlist node
           targets = list_item_change_bar_targets node
-          if (::Set === targets) && !(DLIST_STYLES_ROUTING_THROUGH_LIST_ITEM.include? node.style)
+          if targets && !targets[:items].empty? && !(DLIST_STYLES_ROUTING_THROUGH_LIST_ITEM.include? node.style)
             log :warn, %(rhrev per-item list marking is not supported for a dlist using the '#{node.style || 'default'}' style; marking the whole block instead)
-            targets = :all
+            targets = { whole: (targets[:items].values.flatten + targets[:whole]).uniq.sort, items: {} }
           end
           convert_targeted_list(node, targets) { super }
         end
 
         # Shared by convert_ulist/convert_olist/convert_dlist: computes the
-        # target set (unless the caller, convert_dlist, already resolved
-        # it), pushes it so convert_list_item can read the innermost
-        # enclosing list's own targets, and either brackets the whole list
-        # (targets == :all) or leaves bar-inking to convert_list_item
-        # entirely (targets is a real index Set, or nil, not marked at
-        # all). The stack, not a single ivar, matters for a list nested
+        # targets (unless the caller, convert_dlist, already resolved
+        # them), pushes them so convert_list_item can read the innermost
+        # enclosing list's own targets, brackets the whole list with the
+        # lanes of every mark that targets the whole list, and leaves each
+        # targeted item's lanes to convert_list_item. The stack, not a single ivar, matters for a list nested
         # inside a marked item's own content: the same shape
         # @change_bar_section_stack already uses for nested sections.
         #
@@ -464,8 +469,11 @@ module Asciidoctor
         def convert_targeted_list node, targets = (list_item_change_bar_targets node)
           @list_change_bar_target_stack ||= []
           @list_change_bar_target_stack.push targets
-          if targets == :all
-            bracket_change_bar(node) { yield }
+          if targets && !targets[:whole].empty? && !scratch?
+            bar_from = { page: page_number, cursor: cursor, lanes: targets[:whole] }
+            result = yield
+            ink_change_bar bar_from, { page: page_number, cursor: cursor }
+            result
           else
             yield
           end
@@ -473,29 +481,51 @@ module Asciidoctor
           @list_change_bar_target_stack.pop
         end
 
-        # The target set for the list currently being converted: :all
-        # (bar the whole list, the only behavior before this feature
-        # existed), nil (not marked for the current revision at all), or a
-        # Set of 1-based item positions parsed from one or more trailing
-        # positional attributes, expanding an N-M token into a range.
-        # Reuses change_bar? for the marked/not-marked check, the same
-        # predicate every other bar-inking decision in this file already
-        # uses, so this only ever answers for the current revnumber.
+        # The targets for the list currently being converted, or nil when
+        # no mark on it belongs to the current revision. Otherwise a Hash:
+        # :whole holds the lanes drawn over the whole list, :items maps a
+        # 1-based item position to the lanes drawn over that item alone.
+        # Each matching mark contributes its own lanes (change_bar_lanes) to
+        # the whole list when it names no item, or to each item its
+        # trailing positional attributes name, an N-M token naming a range.
+        #
+        # Only a mark's own positional attributes count. With stacked
+        # attribute lines the merged hash mixes every line's positional
+        # entries, so the per-line record MarkTargets keeps at parse time
+        # decides; a list built without one (through the extension API, for
+        # instance) falls back to every positional entry.
         def list_item_change_bar_targets node
           return nil unless change_bar? node
           raw = node.instance_variable_get(:@attributes)
-          positional_keys = raw.keys.select {|k| ::Integer === k }.sort
-          return :all if positional_keys.empty?
-          targets = ::Set.new
-          positional_keys.each do |key|
-            token = raw[key].to_s
-            if (m = /\A(\d+)-(\d+)\z/.match token)
-              (m[1].to_i..m[2].to_i).each {|i| targets << i }
-            elsif /\A\d+\z/.match? token
-              targets << token.to_i
+          by_mark = raw[::Asciidoctor::Rhrev::MarkTargets::KEY]
+          whole = []
+          items = {}
+          @change_bar_matcher.marks(raw).each_key do |mark|
+            lanes = change_bar_lanes({ mark => true })
+            tokens = if by_mark && (by_mark.key? mark)
+              by_mark[mark]
+            else
+              raw.keys.select {|k| ::Integer === k }.sort.map {|k| raw[k] }
+            end
+            positions = ::Set.new
+            tokens.each do |token|
+              token = token.to_s
+              if (m = /\A(\d+)-(\d+)\z/.match token)
+                (m[1].to_i..m[2].to_i).each {|i| positions << i }
+              elsif /\A\d+\z/.match? token
+                positions << token.to_i
+              end
+            end
+            if positions.empty?
+              whole |= lanes
+            else
+              positions.each {|i| items[i] = (items[i] || []) | lanes }
             end
           end
-          targets.empty? ? :all : targets
+          whole.sort!
+          items.transform_values! {|lanes| (lanes - whole).sort }
+          items.reject! {|_, lanes| lanes.empty? }
+          { whole: whole, items: items }
         end
 
         # A single item within a ulist/olist (and a dlist using the
@@ -527,15 +557,15 @@ module Asciidoctor
         # the "should this bar" question on its own.
         def convert_list_item node, list, opts = {}
           targets = @list_change_bar_target_stack&.last
-          if (::Set === targets) && (idx = list.items.index node) && (targets.include? idx + 1)
-            ink_targeted_list_item_change_bar { super }
+          if targets && (idx = list.items.index node) && (lanes = targets[:items][idx + 1])
+            ink_targeted_list_item_change_bar(lanes) { super }
           else
             super
           end
         end
 
-        def ink_targeted_list_item_change_bar
-          bar_from = { page: page_number, cursor: cursor } if @change_bar_attr && !scratch?
+        def ink_targeted_list_item_change_bar lanes
+          bar_from = { page: page_number, cursor: cursor, lanes: lanes } if @change_bar_attr && !scratch?
           result = yield
           ink_change_bar bar_from, { page: page_number, cursor: cursor } if bar_from
           result
@@ -620,7 +650,7 @@ module Asciidoctor
           
           debug_log "Found entry candidate on #{node.context} id=#{node.id}", @document
           
-          attr_entries.each do |key, value|
+          ::Asciidoctor::Rhrev::ThirdLevel.sort_marks(attr_entries, @revision_prefix, @third_level_kind).each do |key, value|
             key_str = key.to_s
             next unless key_str.start_with?(@revision_prefix)
             next if key_str.include?('-all') || key_str.end_with?('-cover')
@@ -720,7 +750,7 @@ module Asciidoctor
             section = enclosing_section node
             has_section = section && section.id
 
-            attr_entries.each do |key, value|
+            ::Asciidoctor::Rhrev::ThirdLevel.sort_marks(attr_entries, @revision_prefix, @third_level_kind).each do |key, value|
               key_str = key.to_s
               next unless key_str.start_with?(@revision_prefix)
               next if key_str.include?('-all') || key_str.end_with?('-cover')
@@ -753,7 +783,7 @@ module Asciidoctor
         # directly, so a synthesized table entry looks the same as one from
         # the normal collect_revision_entries path.
         def append_child_change_to_entry revision, anchor_node, change_text
-          entries = revision_history.entries[revision] ||= []
+          entries = revision_history.entries[revision_history.revision_key revision] ||= []
           entry = entries.find { |e| e[:anchor] == anchor_node.id }
           if entry
             entry[:change] = entry[:change].to_s.empty? ? change_text : "#{entry[:change]} * #{change_text}"
@@ -777,14 +807,9 @@ module Asciidoctor
         end
 
         # Appends onto the document's existing -all change text for this
-        # revision, or sets it fresh if none exists yet. Catalog#add_all_entry
-        # overwrites unconditionally, so the existing value has to be read
-        # and folded in here, unlike add_entry it has no anchor to guard
-        # against being called more than once.
+        # revision, or sets it fresh if none exists yet.
         def append_child_change_to_all revision, change_text
-          existing = revision_history.all_entries[revision]
-          combined = existing.to_s.empty? ? change_text : "#{existing} * #{change_text}"
-          revision_history.add_all_entry revision, combined
+          revision_history.append_all_entry revision, change_text
         end
 
         # A table cell marked with an rhrev attribute is not a rollup context
@@ -906,7 +931,7 @@ module Asciidoctor
               
               revision = key_str.sub("#{@revision_prefix}", '')
               
-              entries = revision_history.entries[revision]
+              entries = revision_history.entries[revision_history.revision_key revision]
               next unless entries
               
               entry = entries.find { |e| e[:anchor] == node.id }
@@ -1048,25 +1073,53 @@ module Asciidoctor
           @document_entries_collected = true
 
           # Discover revisions from *-prevrev attributes so any number of
-          # segments works (1-1, 1-2-0, ...), not just major-minor
+          # segments works (1-1, 1-2-0, ...), not just major-minor. With
+          # rhrev-third-level set, a third-level revision often declares no
+          # prevrev of its own, so its -all and -cover attributes count too.
+          # Ascending order keeps merged collapse-mode text in revision order.
+          revisions = []
           doc.attributes.each_key do |key|
             key_str = key.to_s
-            next unless key_str.end_with?('-prevrev')
-            revision = key_str.delete_suffix('-prevrev')
-            next unless revision.match?(/\A\d+(?:-\d+)*\z/)
+            if key_str.end_with?('-prevrev')
+              revision = key_str.delete_suffix('-prevrev')
+            elsif @third_level_mode && (m = /-(?:all|cover)\z/.match(key_str))
+              revision = ::Asciidoctor::Rhrev::ThirdLevel.revision_of key_str.delete_suffix(m[0]), @revision_prefix
+            else
+              next
+            end
+            revisions << revision if revision&.match?(/\A\d+(?:-\d+)*\z/)
+          end
 
+          revisions.uniq.sort_by { |revision| revision_history.parse_revision revision }.each do |revision|
             all_attr_name = "#{@revision_prefix}#{revision}-all"
             if (all_value = doc.attr(all_attr_name))
-              revision_history.add_all_entry revision, all_value
+              revision_history.append_all_entry revision, all_value
             end
 
             cover_attr_name = "#{@revision_prefix}#{revision}-cover"
             if (cover_value = doc.attr(cover_attr_name))
-              revision_history.add_cover_entry revision, cover_value
+              revision_history.append_cover_entry revision, cover_value
             end
           end
         end
 
+        # Every revision of the current x.y release the document marks
+        # anywhere, block, list, or table cell, as its third-level number,
+        # or nil for the x.y release itself, for the expand-mode lanes.
+        def discover_third_level_lanes doc
+          return unless @change_bar_matcher&.mode == 'expand'
+          found = []
+          collect = proc do |attributes|
+            @change_bar_matcher.marks(attributes).each_value { |z| found << z }
+          end
+          doc.find_by(traverse_documents: true) { true }.each do |node|
+            collect.call node.attributes if node.respond_to?(:attributes)
+            next unless node.context == :table
+            (node.rows[:head] + node.rows[:body] + node.rows[:foot]).flatten.each { |cell| collect.call cell.attributes }
+          end
+          assign_change_bar_lanes found
+        end
+
         def prescan_document doc
           debug_log "Starting prescan_document", doc
           
@@ -1094,6 +1147,7 @@ module Asciidoctor
             propagate_cell_content_marks doc
             rollup_child_revision_entries doc
             rollup_table_cell_revision_entries doc
+            discover_third_level_lanes doc
 
             @prescan_complete = true
             debug_log "Prescan complete. Catalog has #{revision_history.entries.values.flatten.size} entries.", doc

data/lib/asciidoctor/rhrev/exporter.rb

@@ -55,11 +55,9 @@ module Asciidoctor
           
           # Process each revision
           revision_history.sorted_revisions.each do |revision|
-            prevrev_attr = "#{revision}-prevrev"
-            prevrevdate_attr = "#{revision}-prevrevdate"
             revision_label = doc.attr('version-label', 'Revision')
-            prev_title = doc.attr(prevrev_attr) || revision.tr('-', '.')
-            prev_date = doc.attr(prevrevdate_attr) || ""
+            prev_title = ::Asciidoctor::Rhrev::ThirdLevel.group_attr(doc, revision, 'prevrev', @third_level_mode) || revision.tr('-', '.')
+            prev_date = ::Asciidoctor::Rhrev::ThirdLevel.group_attr(doc, revision, 'prevrevdate', @third_level_mode) || ""
             prev_rev_text = format_prev_rev(prev_title, prev_date, doc)
             
             # Build header text, avoiding "Revision Revision" repetition

data/lib/asciidoctor/rhrev/mark_targets.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module Rhrev
+    # Records which positional list-item targets belong to which rhrev mark,
+    # one block attribute line at a time.
+    #
+    # Stacked attribute lines merge into one attribute hash, and Asciidoctor
+    # numbers positional entries per line, so a later line's positional
+    # entries overwrite an earlier line's at the same index:
+    #
+    #   [rhrev1-2="old",2]
+    #   [rhrev1-3="new"]
+    #
+    # leaves {"rhrev1-2"=>"old", 2=>"2", "rhrev1-3"=>"new"}, and the merged
+    # hash no longer says whether target 2 belongs to rhrev1-2 or rhrev1-3.
+    # Each line is still parsed on its own, through AttributeList#parse_into,
+    # whose per-line result is memoized, so reading it here costs no second
+    # parse. Every positional entry on a line belongs to the nearest mark
+    # before it on that same line; a mark with no positional entry after it
+    # targets the whole list.
+    #
+    # The record is stored on the block's own attribute hash under KEY, as a
+    # Hash of mark name => Array of raw target tokens. KEY never starts with
+    # an attribute name character, so it collides with no AsciiDoc attribute
+    # and is never mistaken for an rhrev mark by any prefix scan.
+    module MarkTargets
+      KEY = '@rhrev-mark-targets'
+
+      def self.record attributes, line, prefix
+        by_mark = current = nil
+        line.each do |key, value|
+          if ::String === key
+            next unless key.start_with? prefix
+            (by_mark ||= (attributes[KEY] ||= {}))[current = key] = []
+          elsif current && ::Integer === key
+            by_mark[current] << value
+          end
+        end
+      end
+
+      # Only a block attribute line passes the document itself as the block
+      # (Parser.parse_block_metadata_line, sub_result: true); every other
+      # caller, such as a block macro's attribute list, passes none.
+      module AttributeListHook
+        def parse_into attributes, positional_attrs = []
+          if ::Asciidoctor::Document === @block
+            MarkTargets.record attributes, (parse positional_attrs), (@block.attr 'revhistoryprefix', 'rhrev')
+          end
+          super
+        end
+      end
+    end
+  end
+end
+
+::Asciidoctor::AttributeList.prepend ::Asciidoctor::Rhrev::MarkTargets::AttributeListHook

data/lib/asciidoctor/rhrev/renderer.rb

@@ -438,11 +438,9 @@ module Asciidoctor
           cover_text = doc.attr 'rhrev-localization-cover', 'Cover'
           
           revision_history.sorted_revisions.each do |revision|
-            prevrev_attr = "#{revision}-prevrev"
-            prevrevdate_attr = "#{revision}-prevrevdate"
             revision_label = doc.attr('version-label', 'Revision')
-            prev_title = doc.attr(prevrev_attr) || "#{revision.tr('-', '.')}"
-            prev_date = doc.attr(prevrevdate_attr) || ""
+            prev_title = ::Asciidoctor::Rhrev::ThirdLevel.group_attr(doc, revision, 'prevrev', @third_level_mode) || "#{revision.tr('-', '.')}"
+            prev_date = ::Asciidoctor::Rhrev::ThirdLevel.group_attr(doc, revision, 'prevrevdate', @third_level_mode) || ""
             prev_rev_text = format_prev_rev(prev_title, prev_date, doc)
             
             if prev_title.strip.downcase.start_with?(revision_label.downcase)

data/lib/asciidoctor/rhrev/rhrev_html.rb

@@ -42,6 +42,7 @@ module Asciidoctor
         prefix = document.attr 'revhistoryprefix', 'rhrev'
 
         ::Asciidoctor::Rhrev::CellTextMarks.lift document, prefix
+        ::Asciidoctor::Rhrev::ThirdLevel.drop_mixed_release_marks document, prefix
 
         document.find_by(context: :table).each do |table|
           cells = (table.rows[:head] + table.rows[:body] + table.rows[:foot]).flatten
@@ -91,11 +92,11 @@ module Asciidoctor
         return document unless document.attr? 'rhrev-change-bars'
         return document unless (revnumber = document.attr 'revnumber')
         prefix = document.attr 'revhistoryprefix', 'rhrev'
-        change_attr = %(#{prefix}#{revnumber.to_s.tr '.', '-'})
+        matcher = ThirdLevel.matcher document, prefix, revnumber
 
         tagged = false
         document.find_by { |b| TRACKED_CONTEXTS.include? b.context }.each do |block|
-          next unless block.attributes && (block.attributes.key? change_attr)
+          next unless block.attributes && (matcher.match? block.attributes)
           roles = (block.attr 'role')
           block.set_attr 'role', [roles, 'rhrev-changed'].compact.join(' ')
           tagged = true
@@ -173,7 +174,7 @@ module Asciidoctor
           return super
         end
         prefix = doc.attr 'revhistoryprefix', 'rhrev'
-        change_attr = %(#{prefix}#{revnumber.to_s.tr '.', '-'})
+        matcher = ThirdLevel.matcher doc, prefix, revnumber
 
         result = []
         id_attribute = node.id ? %( id="#{node.id}") : ''
@@ -231,7 +232,7 @@ module Asciidoctor
 
                 cell_tag_name = (tsec == :head || cell.style == :header ? 'th' : 'td')
                 cell_classes = ['tableblock', %(halign-#{cell.attr 'halign'}), %(valign-#{cell.attr 'valign'})]
-                cell_classes << 'rhrev-changed' if cell.attributes && (cell.attributes.key? change_attr)
+                cell_classes << 'rhrev-changed' if cell.attributes && (matcher.match? cell.attributes)
                 cell_class_attribute = %( class="#{cell_classes.join ' '}")
                 cell_colspan_attribute = cell.colspan ? %( colspan="#{cell.colspan}") : ''
                 cell_rowspan_attribute = cell.rowspan ? %( rowspan="#{cell.rowspan}") : ''
@@ -405,7 +406,7 @@ module Asciidoctor
       # take catalog as an argument since collect_all_entries builds a fresh
       # one locally rather than reading an instance-level revision_history.
       def append_child_change_to_entry catalog, revision, anchor_node, change_text
-        entries = catalog.entries[revision] ||= []
+        entries = catalog.entries[catalog.revision_key revision] ||= []
         entry = entries.find { |e| e[:anchor] == anchor_node.id }
         if entry
           entry[:change] = entry[:change].to_s.empty? ? change_text : "#{entry[:change]} * #{change_text}"
@@ -426,9 +427,7 @@ module Asciidoctor
       # or sets it fresh if none exists yet. Same shape as
       # Converter#append_child_change_to_all on the PDF side.
       def append_child_change_to_all catalog, revision, change_text
-        existing = catalog.all_entries[revision]
-        combined = existing.to_s.empty? ? change_text : "#{existing} * #{change_text}"
-        catalog.add_all_entry revision, combined
+        catalog.append_all_entry revision, change_text
       end
 
       # Gathers every marked rollup-context node in one unified, document-order
@@ -447,7 +446,7 @@ module Asciidoctor
           section = enclosing_section node
           has_section = section && section.id
 
-          attr_entries.each do |key, value|
+          ThirdLevel.sort_marks(attr_entries, prefix, (ThirdLevel.kind doc)).each do |key, value|
             key_str = key.to_s
             next unless key_str.start_with?(prefix)
             next if key_str.include?('-all') || key_str.end_with?('-cover')
@@ -500,21 +499,33 @@ module Asciidoctor
       end
 
       def collect_all_entries(doc)
-        catalog = Catalog.new
+        third_level = ThirdLevel.mode doc
+        kind = ThirdLevel.kind doc
+        catalog = Catalog.new third_level: third_level, kind: kind
         prefix = doc.attr 'revhistoryprefix', 'rhrev'
 
         # Collect document-level entries (-all)
         # Discover revisions from *-prevrev attributes so any number of
-        # segments works (1-1, 1-2-0, ...), not just major-minor
+        # segments works (1-1, 1-2-0, ...), not just major-minor. With
+        # rhrev-third-level set, a revision's -all attribute counts too,
+        # same as Converter#collect_document_level_entries on the PDF side.
+        revisions = []
         doc.attributes.each_key do |key|
           key_str = key.to_s
-          next unless key_str.end_with?('-prevrev')
-          revision = key_str.delete_suffix('-prevrev')
-          next unless revision.match?(/\A\d+(?:-\d+)*\z/)
+          if key_str.end_with?('-prevrev')
+            revision = key_str.delete_suffix('-prevrev')
+          elsif third_level && key_str.end_with?('-all')
+            revision = ThirdLevel.revision_of key_str.delete_suffix('-all'), prefix
+          else
+            next
+          end
+          revisions << revision if revision&.match?(/\A\d+(?:-\d+)*\z/)
+        end
 
+        revisions.uniq.sort_by { |revision| catalog.parse_revision revision }.each do |revision|
           all_attr_name = "#{prefix}#{revision}-all"
           if (all_value = doc.attr(all_attr_name))
-            catalog.add_all_entry revision, all_value
+            catalog.append_all_entry revision, all_value
           end
 
           # Skip -cover entries for HTML
@@ -526,7 +537,7 @@ module Asciidoctor
           next unless block.id
 
           if block.respond_to?(:attributes)
-            block.attributes.each do |key, value|
+            ThirdLevel.sort_marks(block.attributes, prefix, kind).each do |key, value|
               key_str = key.to_s
               next unless key_str.start_with?(prefix)
               next if key_str.include?('-all') || key_str.end_with?('-cover')
@@ -596,11 +607,10 @@ module Asciidoctor
         all_text = doc.attr 'rhrev-localization-all', 'All'
         
         catalog.sorted_revisions.each do |revision|
-          prevrev_attr = "#{revision}-prevrev"
-          prevrevdate_attr = "#{revision}-prevrevdate"
+          third_level = ThirdLevel.mode doc
           revision_label = doc.attr('version-label', 'Revision')
-          prev_title = doc.attr(prevrev_attr) || revision.tr('-', '.')
-          prev_date = doc.attr(prevrevdate_attr) || ""
+          prev_title = ThirdLevel.group_attr(doc, revision, 'prevrev', third_level) || revision.tr('-', '.')
+          prev_date = ThirdLevel.group_attr(doc, revision, 'prevrevdate', third_level) || ""
           prev_rev_text = format_prev_rev(prev_title, prev_date, doc)
           
           # Build header text

data/lib/asciidoctor/rhrev/table_cell_change_bar_patch.rb

@@ -48,13 +48,15 @@ if defined? ::Prawn::Table
     module PDF
       module Rhrev
         module TableCellChangeBarPatch
+          # The change-bar lanes the cell draws (ChangeBars#change_bar_lanes),
+          # or nil for an unmarked cell.
           attr_accessor :rhrev_marked
 
           def draw_background pt
             if @rhrev_marked && @pdf.respond_to?(:ink_change_bar)
               x, y = pt
               page = @pdf.page_number
-              @pdf.ink_change_bar({ page: page, cursor: y }, { page: page, cursor: y - height })
+              @pdf.ink_change_bar({ page: page, cursor: y, lanes: @rhrev_marked }, { page: page, cursor: y - height })
             end
             super
           end
@@ -76,12 +78,12 @@ if defined? ::Prawn::Table
               rows = node.rows
               (rows[:head] + rows[:body] + rows[:foot]).each_with_index do |row, r|
                 row.each_with_index do |cell, c|
-                  next unless cell.respond_to?(:attributes) && cell.attributes && (cell.attributes.key? change_attr)
+                  next unless cell.respond_to?(:attributes) && cell.attributes && (lanes = document.change_bar_lanes cell.attributes)
                   next unless (cell_data = data[r] && data[r][c]).is_a?(::Hash)
                   if (content = cell_data[:content]).is_a? ::Prawn::Table::Cell
-                    content.rhrev_marked = true
+                    content.rhrev_marked = lanes
                   else
-                    cell_data[:rhrev_marked] = true
+                    cell_data[:rhrev_marked] = lanes
                   end
                 end
               end

data/lib/asciidoctor/rhrev/third_level.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module Rhrev
+    # Support for x.y.z revision numbers, selected by the rhrev-third-level
+    # document attribute:
+    #
+    # collapse:: the revision history table groups every revision by its
+    #   first two levels, and one change bar covers every mark of the
+    #   current x.y release.
+    # expand:: the table lists every revision on its own, as without the
+    #   attribute; the PDF backend draws one lane for every mark of the
+    #   current x.y release plus one lane per third-level revision further
+    #   out in the margin.
+    #
+    # 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 (drop_mixed_release_marks).
+    # 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.
+    module ThirdLevel
+      MODES = %w(expand collapse).freeze
+      KINDS = %w(draft amendment).freeze
+      DEFAULT_KIND = 'draft'
+      RevisionRx = /\A\d+(?:-\d+)*\z/
+
+      # The document's mode, 'expand' or 'collapse', or nil when the
+      # attribute is unset. An unrecognized value warns once per document
+      # and falls back to nil.
+      def self.mode doc
+        return nil unless doc.attr? 'rhrev-third-level'
+        value = (doc.attr 'rhrev-third-level').to_s
+        return value if MODES.include? value
+        unless doc.instance_variable_get :@rhrev_third_level_warned
+          doc.instance_variable_set :@rhrev_third_level_warned, true
+          doc.logger.warn %(rhrev-third-level must be expand or collapse, got '#{value}'; ignoring it)
+        end
+        nil
+      end
+
+      # The document's kind, 'draft' or 'amendment', or nil when
+      # rhrev-third-level is unset. An unrecognized value warns once per
+      # document and falls back to the default.
+      def self.kind doc
+        return nil unless mode doc
+        return DEFAULT_KIND unless doc.attr? 'rhrev-third-level-kind'
+        value = (doc.attr 'rhrev-third-level-kind').to_s
+        return value if KINDS.include? value
+        unless doc.instance_variable_get :@rhrev_third_level_kind_warned
+          doc.instance_variable_set :@rhrev_third_level_kind_warned, true
+          doc.logger.warn %(rhrev-third-level-kind must be draft or amendment, got '#{value}'; using #{DEFAULT_KIND})
+        end
+        DEFAULT_KIND
+      end
+
+      # 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 before x-y-1.
+      def self.sort_key revision, kind
+        parts = revision.split('-').map(&:to_i)
+        kind == 'draft' && parts.size == 2 ? (parts << ::Float::INFINITY) : parts
+      end
+
+      # The x-y groups whose release mark appears beside marks of its own
+      # drafts, each with the draft revisions found, from a list of the
+      # revisions a draft-kind document marks.
+      def self.mixed_draft_groups revisions
+        revisions = revisions.uniq
+        revisions.select {|revision| revision.count('-') == 1 }.filter_map do |release|
+          drafts = revisions.select {|revision| revision.start_with?(%(#{release}-)) && revision.count('-') == 2 }
+          [release, drafts.sort_by {|revision| sort_key revision, nil }] unless drafts.empty?
+        end
+      end
+
+      # Calls the block with the attributes of every node that carries
+      # marks: the document, every block in it and in nested documents,
+      # and every table cell. Cell text marks count only once
+      # CellTextMarks.lift has run.
+      def self.each_marked_attributes doc
+        doc.find_by(traverse_documents: true) { true }.each do |node|
+          yield node.attributes
+          next unless node.context == :table
+          (node.rows[:head] + node.rows[:body] + node.rows[:foot]).flatten.each {|cell| yield cell.attributes }
+        end
+      end
+
+      # The revision an attribute names as a mark, or as an -all or -cover
+      # entry, or nil.
+      def self.marked_revision_of key, prefix
+        revision_of key.to_s.sub(/-(?:all|cover)\z/, ''), prefix
+      end
+
+      # In a draft-kind document, removes every mark, -all, and -cover
+      # entry of an x-y release that the document also marks drafts of,
+      # warning once per release, so no backend shows a release beside its
+      # own drafts. Runs once per document, after CellTextMarks.lift.
+      def self.drop_mixed_release_marks doc, prefix
+        return unless kind(doc) == 'draft'
+        return if doc.instance_variable_get :@rhrev_mixed_releases_dropped
+        doc.instance_variable_set :@rhrev_mixed_releases_dropped, true
+        revisions = []
+        each_marked_attributes(doc) do |attributes|
+          attributes.each_key {|key| (revision = marked_revision_of key, prefix) && (revisions << revision) }
+        end
+        releases = mixed_draft_groups(revisions).map do |release, drafts|
+          doc.logger.warn %(#{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)
+          release
+        end
+        return if releases.empty?
+        each_marked_attributes(doc) do |attributes|
+          attributes.delete_if {|key, _| releases.include? marked_revision_of(key, prefix) }
+        end
+      end
+
+      # The revision a mark names, "1-3-2" for rhrev1-3-2, or nil for any
+      # other attribute, including -all, -cover, and configuration keys
+      # sharing the prefix.
+      def self.revision_of key, prefix
+        key = key.to_s
+        return nil unless key.start_with? prefix
+        revision = key.delete_prefix prefix
+        (RevisionRx.match? revision) ? revision : nil
+      end
+
+      # The attribute pairs with every mark in ascending revision order and
+      # every other attribute after them, so change texts merged into one
+      # collapse-mode entry follow revision order, not source order.
+      def self.sort_marks attributes, prefix, kind = nil
+        attributes.sort_by.with_index do |(key, _), index|
+          revision = revision_of key, prefix
+          revision ? [0, (sort_key revision, kind), index] : [1, [], index]
+        end
+      end
+
+      # The table group a revision belongs to: its first two levels in
+      # collapse mode, the revision itself otherwise.
+      def self.group_key revision, mode
+        return revision unless mode == 'collapse'
+        parts = revision.split '-'
+        parts.size > 2 ? (parts.take 2).join('-') : revision
+      end
+
+      # A table group's prevrev or prevrevdate value: the group's own
+      # attribute, or in collapse mode, the lowest third-level revision's
+      # attribute that the document sets.
+      def self.group_attr doc, revision, suffix, mode
+        if (value = doc.attr %(#{revision}-#{suffix}))
+          return value
+        end
+        return nil unless mode == 'collapse' && revision.count('-') == 1
+        rx = /\A#{::Regexp.escape revision}-(\d+)-#{suffix}\z/
+        lowest = doc.attributes.keys.filter_map {|key| (m = rx.match key.to_s) && [m[1].to_i, key] }.min
+        lowest && (doc.attr lowest[1])
+      end
+
+      # The Matcher for a document's revnumber, mode, and kind.
+      def self.matcher doc, prefix, revnumber
+        Matcher.new prefix, revnumber, (mode doc), (kind doc)
+      end
+
+      # Decides which marks on a node draw a change bar for the current
+      # revnumber, and which third-level revision each belongs to.
+      class Matcher
+        attr_reader :mode, :kind, :exact
+
+        def initialize prefix, revnumber, mode, kind = DEFAULT_KIND
+          @prefix = prefix
+          @mode = mode
+          @kind = kind
+          revnumber = revnumber.to_s
+          @exact = %(#{prefix}#{revnumber.tr '.', '-'})
+          if mode && (/\A\d+(?:\.\d+)+\z/.match? revnumber)
+            parts = revnumber.split('.').map(&:to_i)
+            @base = parts.take 2
+            @current_z = parts[2]
+          else
+            @mode = nil
+          end
+        end
+
+        # A Hash of each matching mark name to its third-level number, or
+        # to nil for a mark without one. Empty when nothing matches.
+        def marks attributes
+          return {} unless attributes
+          return ((attributes.key? @exact) ? { @exact => nil } : {}) unless @mode
+          result = {}
+          attributes.each_key do |key|
+            next unless ::String === key && (revision = ThirdLevel.revision_of key, @prefix)
+            parts = revision.split('-').map(&:to_i)
+            next unless (parts.take 2) == @base
+            z = parts[2]
+            if @current_z
+              next if z ? z > @current_z : @kind == 'draft'
+            end
+            result[key] = z
+          end
+          result
+        end
+
+        def match? attributes
+          !(marks attributes).empty?
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/rhrev.rb

@@ -7,6 +7,8 @@ require 'asciidoctor' unless defined? Asciidoctor
 require_relative 'rhrev/processors'
 require_relative 'rhrev/helpers'
 require_relative 'rhrev/cell_text_marks'
+require_relative 'rhrev/mark_targets'
+require_relative 'rhrev/third_level'
 require_relative 'rhrev/catalog'
 
 # Try to load the PDF converter support if asciidoctor-pdf is available

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciidoctor-rhrev
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.9.0
 platform: ruby
 authors:
 - 白一百 baiyibai
@@ -43,12 +43,14 @@ files:
 - lib/asciidoctor/rhrev/converter.rb
 - lib/asciidoctor/rhrev/exporter.rb
 - lib/asciidoctor/rhrev/helpers.rb
+- lib/asciidoctor/rhrev/mark_targets.rb
 - lib/asciidoctor/rhrev/processors.rb
 - lib/asciidoctor/rhrev/renderer.rb
 - lib/asciidoctor/rhrev/rhrev_html.rb
 - lib/asciidoctor/rhrev/rhrev_pdf.rb
 - lib/asciidoctor/rhrev/table_cell_change_bar_patch.rb
 - lib/asciidoctor/rhrev/table_draw_patch.rb
+- lib/asciidoctor/rhrev/third_level.rb
 homepage: https://gitlab.com/baiyibai/rhrev-asciidoctor-automatic-revision-history
 licenses:
 - CC0-1.0