coradoc-adoc 2.0.29 → 2.0.31

data/lib/coradoc/asciidoc/transform/element_transformers/block_transformer.rb

@@ -169,19 +169,22 @@ module Coradoc
 
             # Single admonition dispatch used by every block-form path
             # (example / sidebar / quote / pass / open). Builds an
-            # AnnotationBlock with annotation_type set from the style and
-            # the block's body lines joined into a single content string.
-            # Type is canonicalised via AdmonitionStyles so every code path
-            # (line admonition, block admonition, attribute-cast admonition)
-            # produces the same uppercase key.
+            # AnnotationBlock by delegating to +transform_typed_block+
+            # with +annotation_type+ injected via +extra_attrs+. This
+            # preserves inline formatting (links, monospace, bold), list
+            # structure, and paragraph breaks — the typed-block pipeline
+            # already groups lines into ParagraphBlock children and
+            # dispatches block-level lines (lists, tables) through
+            # ToCoreModel.transform. Type is canonicalised via
+            # AdmonitionStyles so every code path (line admonition, block
+            # admonition, attribute-cast admonition) produces the same
+            # uppercase key.
             def transform_admonition_block(block, type)
               canonical = AdmonitionStyles.canonicalize(type) || type.to_s
-              content_lines = Array(block.lines).map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
-              Coradoc::CoreModel::AnnotationBlock.new(
-                annotation_type: canonical,
-                content: content_lines,
-                title: ToCoreModel.extract_title_text(block.title),
-                source_line: block.source_line
+              transform_typed_block(
+                block,
+                Coradoc::CoreModel::AnnotationBlock,
+                annotation_type: canonical
               )
             end
 
@@ -214,76 +217,85 @@ module Coradoc
             end
 
             def transform_typed_block(block, klass, extra_attrs = {})
-              raw_lines = Array(block.lines)
-              has_nested_blocks = raw_lines.any? { |line| block_level_child?(line) }
-
-              if has_nested_blocks
-                children = raw_lines.reject do |line|
-                  line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
-                    line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
-                end.filter_map do |line|
-                  result = ToCoreModel.transform(line)
-                  next nil if result.nil?
-                  next result if result.is_a?(Coradoc::CoreModel::Base)
-
-                  text = ToCoreModel.extract_text_content(result)
-                  next nil if text.nil? || text.strip.empty?
-
-                  Coradoc::CoreModel::TextContent.new(text: text)
-                end
-                klass.new(
-                  id: block.id,
-                  title: ToCoreModel.extract_title_text(block.title),
-                  children: children,
-                  language: ToCoreModel.extract_block_language(block),
-                  source_line: block.source_line,
-                  **extra_attrs
-                )
-              else
-                paragraph_groups = group_block_lines_into_paragraphs(raw_lines)
-
-                content_lines = paragraph_groups.map do |group|
-                  ToCoreModel.extract_text_content(group)
-                end.join("\n\n")
-
-                children = paragraph_groups.map do |group|
-                  inline = ToCoreModel.transform_inline_content(group)
-                  inline = [Coradoc::CoreModel::TextContent.new(text: '')] if inline.empty?
-                  Coradoc::CoreModel::ParagraphBlock.new(
-                    content: ToCoreModel.extract_text_content(group),
-                    children: Array(inline),
-                    source_line: ToCoreModel.extract_source_line(group)
-                  )
-                end
+              children, content = build_typed_block_children(block.lines)
 
-                klass.new(
-                  id: block.id,
-                  title: ToCoreModel.extract_title_text(block.title),
-                  content: content_lines,
-                  children: children,
-                  language: ToCoreModel.extract_block_language(block),
-                  source_line: block.source_line,
-                  **extra_attrs
-                )
-              end
+              klass.new(
+                id: block.id,
+                title: ToCoreModel.extract_title_text(block.title),
+                content: content,
+                children: children,
+                language: ToCoreModel.extract_block_language(block),
+                source_line: block.source_line,
+                **extra_attrs
+              )
             end
 
-            # AsciiDoc joins consecutive non-blank lines into one paragraph;
-            # blank lines (parsed as Model::LineBreak) separate paragraphs.
-            def group_block_lines_into_paragraphs(lines)
-              groups = []
-              current = []
-              lines.each do |line|
+            # Walks block.lines in document order and emits the typed
+            # block's children alongside the prose-string view of its
+            # paragraphs.
+            #
+            # Consecutive inline lines coalesce into one ParagraphBlock
+            # (preserving AsciiDoc paragraph semantics: soft-wrapped
+            # source lines are one paragraph, blank lines split them).
+            # Block-level lines (lists, tables, nested blocks — anything
+            # whose AsciiDoc model returns true from +block_level?+)
+            # dispatch through +ToCoreModel.transform+ and slot in at
+            # their original document-order position. LineBreak /
+            # PageBreak lines flush the pending inline paragraph.
+            #
+            # Returns [+children+, +content+] where +content+ is the
+            # paragraph text joined with blank-line separators (nil when
+            # the block has no paragraphs, e.g. contains only nested
+            # blocks).
+            #
+            # Single source of truth for typed-block body construction.
+            # Used by every typed-block transformer (example, sidebar,
+            # quote, open, typed-cast, admonition) so they all preserve
+            # inline formatting, list structure, and paragraph breaks
+            # identically.
+            def build_typed_block_children(lines)
+              children = []
+              paragraph_texts = []
+              pending_inline = []
+
+              Array(lines).each do |line|
                 if line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
                    line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
-                  groups << current if current.any?
-                  current = []
+                  flush_inline_paragraph(pending_inline, children, paragraph_texts)
+                  pending_inline.clear
+                elsif block_level_child?(line)
+                  flush_inline_paragraph(pending_inline, children, paragraph_texts)
+                  pending_inline.clear
+                  dispatched = ToCoreModel.transform(line)
+                  children << dispatched if dispatched
                 else
-                  current << line
+                  pending_inline << line
                 end
               end
-              groups << current if current.any?
-              groups
+              flush_inline_paragraph(pending_inline, children, paragraph_texts)
+
+              content = paragraph_texts.any? ? paragraph_texts.join("\n\n") : nil
+              [children, content]
+            end
+
+            # Materialises +pending_inline+ into a ParagraphBlock and
+            # appends it to +children+, recording its flat text in
+            # +paragraph_texts+ for later content-string joining. No-op
+            # when +pending_inline+ is empty so callers can flush
+            # unconditionally at every boundary (blank line, block-level
+            # child, end-of-input) without producing empty paragraphs.
+            def flush_inline_paragraph(pending_inline, children, paragraph_texts)
+              return if pending_inline.empty?
+
+              inline = ToCoreModel.transform_inline_content(pending_inline)
+              inline = [Coradoc::CoreModel::TextContent.new(text: '')] if inline.empty?
+              text = ToCoreModel.extract_text_content(pending_inline)
+              paragraph_texts << text
+              children << Coradoc::CoreModel::ParagraphBlock.new(
+                content: text,
+                children: Array(inline),
+                source_line: ToCoreModel.extract_source_line(pending_inline)
+              )
             end
 
             # A line that should be emitted as a direct child of the

data/lib/coradoc/asciidoc/transform/element_transformers/document_transformer.rb

@@ -51,7 +51,7 @@ module Coradoc
               return children if children.any? { |c| title_heading?(c) }
 
               title_id = doc_id || Coradoc::CoreModel::IdGenerator
-                                    .generate_from_title(title_text)
+                         .generate_from_title(title_text)
               title_heading = Coradoc::CoreModel::HeaderElement.new(
                 level: 0,
                 title: title_text,

data/lib/coradoc/asciidoc/transform/element_transformers/inline_transformer.rb

@@ -4,6 +4,24 @@ module Coradoc
   module AsciiDoc
     module Transform
       module ElementTransformers
+        # Owns the recursive re-parse that recognises nested inline marks
+        # (Bug 16B). The re-parse re-enters the full inline pipeline:
+        #
+        #   transform_inline → parse_nested_inline_children
+        #     → ToCoreModel.parse_and_transform_inline
+        #       → InlineTransformVisitor.visit
+        #         → ToCoreModel.transform
+        #           → transform_inline (cycle)
+        #
+        # The cycle terminates when the mark's content has no further
+        # inline-mark characters — the parser produces only flat text,
+        # `parse_nested_inline_children` returns `[]`, and the mark
+        # keeps its flat content shape.
+        #
+        # Realistic nesting is 2–3 levels. Pathological input
+        # (`*****…*****` with hundreds of levels) raises
+        # `SystemStackError` naturally — that's Ruby's contract, not a
+        # bespoke guard.
         class InlineTransformer
           class << self
             def transform_inline(inline, format_type)
@@ -11,36 +29,23 @@ module Coradoc
               raw_content = ToCoreModel.extract_text_content(inline.content)
 
               # Recursively parse the mark's content to recognise nested
-              # inline marks (Bug 16B). For `**Per-repo \`file.yml\`**`,
-              # the outer Bold's content "Per-repo `file.yml`" is fed
-              # back through the inline parser so the inner constrained
-              # monospace is recognised. The parsed children are stored
-              # on the BoldElement; the Mirror handler walks them to
-              # produce ProseMirror's flat text-node-with-marks shape.
+              # inline marks (Bug 16B). Only populate `children` when the
+              # parser found real nested marks — flat marks keep children
+              # empty, and the Mirror handler's `build_simple_mark` falls
+              # back to the `content` string. Saves one TextContent
+              # allocation per flat mark (the common case).
               children = parse_nested_inline_children(raw_content)
 
-              if children.any?
-                klass.new(
-                  content: raw_content,
-                  children: children,
-                  source_line: inline.source_line
-                )
-              else
-                klass.new(
-                  content: raw_content,
-                  source_line: inline.source_line
-                )
-              end
+              kwargs = { content: raw_content, source_line: inline.source_line }
+              kwargs[:children] = children if children.any?
+              klass.new(**kwargs)
             end
 
             # Re-parse a mark's raw content string through the inline
             # parser. Returns the list of CoreModel children when the
             # content contains nested inline marks; returns [] when
             # the content is plain text (no nested marks to preserve).
-            # The empty return is the recursion terminator — once a
-            # mark's content has no further mark characters, the
-            # parser produces only TextContent nodes, which we drop
-            # in favour of the mark's flat content string.
+            # The empty return is the recursion terminator.
             def parse_nested_inline_children(text)
               return [] if text.nil? || text.to_s.empty?
 

data/lib/coradoc/asciidoc/transform/element_transformers/list_transformer.rb

@@ -32,24 +32,74 @@ module Coradoc
             private
 
             def transform_definition_item(item)
-              term_content = item.terms
+              term_parts = Array(item.terms)
               def_content = item.contents
 
-              term_parts = term_content.is_a?(Array) ? term_content : [term_content]
-              parsed_terms = term_parts.flat_map do |part|
-                ToCoreModel.parse_inline_text(part)
+              # Process each term independently so multi-term `<dt>`'s
+              # (e.g. AsciiDoc `term1::\nterm2::\ndef`) preserve their
+              # distinct identities in CoreModel#terms. Each entry in
+              # `term_strings` is one term's plain text; `term_children`
+              # is the parallel array of typed inline children. The
+              # singular `term` accessor is set to the first term for
+              # backward compatibility with consumers that haven't
+              # migrated to the `terms` collection.
+              term_strings = term_parts.map do |part|
+                parsed = ToCoreModel.parse_inline_text(part)
+                ToCoreModel.extract_text_content(ToCoreModel.transform_inline_content(parsed))
               end
 
-              parsed_defs = ToCoreModel.parse_inline_text(def_content)
-
-              term_children = ToCoreModel.transform_inline_content(parsed_terms)
-              def_children = ToCoreModel.transform_inline_content(parsed_defs)
+              # Inline children for the FIRST term only. The CoreModel
+              # `term_children` accessor is singular; carrying per-term
+              # children for multi-term `<dt>`'s would require a
+              # collection of arrays. The common case (single-term dt
+              # with inline markup) is fully supported; multi-term dt
+              # with inline markup on later terms degrades to text-only
+              # for those later terms (acceptable per asciidoctor's
+              # observed behaviour — multi-term inline markup is rare).
+              primary_term_children = if term_parts.any?
+                                        parsed = ToCoreModel.parse_inline_text(term_parts.first)
+                                        ToCoreModel.transform_inline_content(parsed)
+                                      else
+                                        []
+                                      end
+
+              # contents is typed on DefinitionItem as Array<TextElement>
+              # (see model/list/definition_item.rb). Each TextElement's
+              # `to_s` handles the polymorphic content shape (String,
+              # Array, or nested Serializable). Join the per-line text
+              # elements into a single paragraph string so the inline
+              # parser sees the full multi-line dd content as one
+              # soft-wrapped paragraph.
+              #
+              # When dd has no inline definition (term-only item where
+              # the dd is populated entirely by `+`-continuation blocks),
+              # def_content is empty and we skip populating definitions
+              # entirely — avoids emitting an empty <text></text> node
+              # ahead of the attached blocks.
+              def_text = def_content.map(&:to_s).reject(&:empty?).join(' ')
+              has_definition = !def_text.empty?
+
+              parsed_defs = has_definition ? ToCoreModel.parse_inline_text(def_text) : []
+              def_children = has_definition ? ToCoreModel.transform_inline_content(parsed_defs) : []
+
+              # Transform `+`-continuation blocks (paragraphs, admonitions,
+              # delimited blocks) into their CoreModel equivalents. Each
+              # becomes a child of the dd, rendered after the definition
+              # paragraph. Passes through ToCoreModel.transform so any
+              # registered block transformer applies (paragraph, source,
+              # admonition, etc.).
+              attached_children = Array(item.attached).filter_map do |block|
+                ToCoreModel.transform(block)
+              end
 
+              primary_term = term_strings.first.to_s
               di = Coradoc::CoreModel::DefinitionItem.new(
-                term: ToCoreModel.extract_text_content(term_children),
-                definitions: [ToCoreModel.extract_text_content(def_children)],
-                term_children: term_children,
+                term: primary_term,
+                terms: term_strings,
+                definitions: has_definition ? [ToCoreModel.extract_text_content(def_children)] : [],
+                term_children: primary_term_children,
                 definition_children: def_children,
+                attached_children: attached_children,
                 source_line: item.source_line
               )
               di.id = item.id if item.id

data/lib/coradoc/asciidoc/transform/from_core_model.rb

@@ -31,15 +31,15 @@ module Coradoc
               without_title_heading, title_text = extract_title_heading(without_frontmatter, element.title)
 
               header = if title_text
-                          Coradoc::AsciiDoc::Model::Header.new(
-                            title: Coradoc::AsciiDoc::Model::Title.new(
-                              content: title_text,
-                              level_int: 0
-                            )
-                          )
-                        else
-                          Coradoc::AsciiDoc::Model::Header.new(title: '')
-                        end
+                         Coradoc::AsciiDoc::Model::Header.new(
+                           title: Coradoc::AsciiDoc::Model::Title.new(
+                             content: title_text,
+                             level_int: 0
+                           )
+                         )
+                       else
+                         Coradoc::AsciiDoc::Model::Header.new(title: '')
+                       end
 
               Coradoc::AsciiDoc::Model::Document.new(
                 id: element.id,
@@ -369,12 +369,18 @@ module Coradoc
 
           def transform_definition_item(item, depth = 1)
             delimiter = ':' * (depth + 1)
-            term = Coradoc::AsciiDoc::Model::Term.new(term: item.term.to_s)
+            # Multi-term `<dt>`: one Term per entry in `item.terms`.
+            # Falls back to `[item.term]` for items populated via
+            # legacy paths that only set the singular accessor.
+            term_strings = terms_for(item)
+            terms = term_strings.map do |text|
+              Coradoc::AsciiDoc::Model::Term.new(term: text.to_s)
+            end
             contents = Array(item.definitions).map do |defn|
               Coradoc::AsciiDoc::Model::TextElement.new(content: defn.to_s)
             end
             di = Coradoc::AsciiDoc::Model::List::DefinitionItem.new(
-              terms: [term],
+              terms: terms,
               contents: contents,
               delimiter: delimiter
             )
@@ -382,6 +388,16 @@ module Coradoc
             di
           end
 
+          # Source of truth for "the terms on this <dt>": the `terms`
+          # collection when populated, else `[term]` for legacy callers.
+          def terms_for(item)
+            collection = item.terms if item.is_a?(Coradoc::CoreModel::DefinitionItem)
+            return Array(collection) unless collection.nil? || collection.empty?
+
+            primary = item.term
+            primary.to_s.empty? ? [] : [primary.to_s]
+          end
+
           def transform_toc(_toc)
             Coradoc::AsciiDoc::Model::TextElement.new(
               content: 'toc::[]'

data/lib/coradoc/asciidoc/transformer/inline_rules.rb

@@ -71,13 +71,13 @@ module Coradoc
             # Each 2-char pattern collapses to a single Unicode character
             # at parse time so downstream consumers (HTML, Markdown) see
             # the literal typographic char without any post-processing.
-            # The mapping is the single source of truth declared on the
-            # parser side (Parser::Inline::TYPOGRAPHIC_QUOTE_PATTERNS).
+            # The mapping lives in the shared TypographicQuotes module
+            # (not on Parser or Transformer) so both layers reference
+            # the same source of truth.
             rule(typographic_quote: simple(:pattern)) do
-              char = Coradoc::AsciiDoc::Parser::Inline::TYPOGRAPHIC_QUOTE_PATTERNS.fetch(
-                pattern.to_s, pattern.to_s
+              Model::TextElement.new(
+                content: Coradoc::AsciiDoc::TypographicQuotes.char_for(pattern)
               )
-              Model::TextElement.new(content: char)
             end
 
             # Hard line break (` +\n` or `\\n`). Emitted as a dedicated

data/lib/coradoc/asciidoc/transformer/list_rules.rb

@@ -6,6 +6,19 @@ module Coradoc
       # Module containing list transformation rules
       module ListRules
         class << self
+          # Build a nested DefinitionList tree from a flat list of items.
+          #
+          # AsciiDoc's dlist syntax uses delimiter length to express
+          # nesting depth (`::` = 1, `:::` = 2, `::::` = 3). Consecutive
+          # term-only items at the SAME depth are merged into a single
+          # multi-term `<dt>` sharing the next item's `<dd>`:
+          #
+          #   term1::            →   <dt>term1</dt>
+          #   term2::                <dt>term2</dt>
+          #   def                    <dd>def</dd>
+          #
+          # Stack-based walk in source order. Each item carries its own
+          # `delimiter`; depth is derived via {#dlist_depth}.
           def build_dlist_tree(items)
             root = Model::List::Definition.new(items: [])
             stack = [[root, 0]]
@@ -14,16 +27,80 @@ module Coradoc
               depth = dlist_depth(item.delimiter)
               stack.pop while stack.last[1] >= depth
 
-              stack.last[0].items << item
-              nested_list = Model::List::Definition.new(items: [])
-              item.nested << nested_list
-              stack.push([nested_list, depth])
+              parent_list = stack.last[0]
+              last = parent_list.items.last
+
+              if merge_with_predecessor?(last, item)
+                merge_term_only_item(last, item)
+                # Stack stays — deeper items still nest under `last`.
+                # Replace the stack top so deeper items land in `last`'s
+                # current nested list (already on the stack from when
+                # `last` was first added).
+              else
+                parent_list.items << item
+                item.nested << Model::List::Definition.new(items: [])
+                stack.push([item.nested.last, depth])
+              end
             end
 
             prune_empty_nested(root)
             root
           end
 
+          # Two consecutive items at the same depth become a multi-term
+          # `<dt>` sharing one `<dd>` when the PREVIOUS item is term-only
+          # (no def, no attached blocks). The previous item is the
+          # accumulating dt; the current item contributes either another
+          # term (if it's also term-only) or the terminal dt + the
+          # shared dd (if it has a def).
+          #
+          # Once an item has its own def/attached, it's the terminal dt
+          # of any in-progress multi-term group; the next same-depth
+          # item starts a fresh entry.
+          def merge_with_predecessor?(last, current)
+            return false unless last
+            return false unless last.delimiter == current.delimiter
+            return false unless term_only?(last)
+
+            true
+          end
+
+          # "Term-only" means the item carries no dd content of its own
+          # (no inline def, no `+`-attached blocks, no nested child
+          # items). Such items are eligible to merge with a following
+          # same-depth item to form a multi-term `<dt>` sharing one dd.
+          # Items with nested children have already "claimed" their dd
+          # slot for the nested content and can't merge.
+          def term_only?(item)
+            return false if contents_present?(item)
+            return false if attached_present?(item)
+            return false if nested_has_items?(item)
+
+            true
+          end
+
+          def contents_present?(item)
+            !item.contents.nil? && !item.contents.empty?
+          end
+
+          def attached_present?(item)
+            !item.attached.nil? && item.attached.any?
+          end
+
+          # `item.nested` is an Array<Definition>; each Definition has
+          # its own `items` Array. An item with populated nested items
+          # (deeper dlist children) is not term-only.
+          def nested_has_items?(item)
+            Array(item.nested).any? { |list| list.is_a?(Model::List::Definition) && list.items.any? }
+          end
+
+          def merge_term_only_item(last, current)
+            last.terms.concat(current.terms)
+            # contents and attached are arrays; concat is safe (no-op for empty)
+            last.contents.concat(current.contents.to_a)
+            last.attached.concat(current.attached.to_a)
+          end
+
           def dlist_depth(delimiter)
             delim = delimiter.to_s
             return 1 if delim == ';;' || delim.empty?
@@ -134,38 +211,30 @@ module Coradoc
               end
             end
 
-            # Definition list item
-            rule(
-              definition_list_item: {
-                terms: sequence(:terms),
-                definition: simple(:contents)
-              }
-            ) do
-              term_strings = terms.map do |t|
-                t.is_a?(Hash) ? t[:text].to_s : t.to_s
-              end
-              item_id = nil
-              item_delim = '::'
-              terms.each do |t|
-                next unless t.is_a?(Hash)
-
-                item_id = t[:id].to_s if t[:id]
-                item_delim = t[:delimiter].to_s if t[:delimiter]
-              end
-              Model::List::DefinitionItem.new(terms: term_strings, contents: contents,
-                                              id: item_id, delimiter: item_delim)
-            end
-
-            # Definition list item with hash terms (single term case)
+            # Definition list item. The parser's dlist_definition rule
+            # always emits :lines (one entry per source line of the dd,
+            # including the single-line case as a one-element array).
+            # Join via the shared lines_to_text_elements helper used by
+            # ulist/olist — single source of truth for line joining.
+            # `attached:` carries any `+`-continuation blocks captured by
+            # the parser; pass through to the model so downstream stages
+            # can render them as additional dd children.
             rule(
               definition_list_item: subtree(:item_data)
             ) do
-              data = item_data.is_a?(Hash) ? item_data : { terms: Array(item_data), definition: '' }
+              data = item_data.is_a?(Hash) ? item_data : { terms: Array(item_data), lines: [] }
 
               item_id = nil
               item_delim = '::'
               terms_data = data[:terms]
-              definition = data[:definition].to_s
+              # Split lines on hard_line_break so each source line is one
+              # entry. Without this, text_any greedy-matches across
+              # newlines via hard_line_break, joining what should be
+              # separate source lines into one entry (and swallowing the
+              # `+` line-continuation marker).
+              split_lines = Transformer.split_lines_on_hard_break(data[:lines] || [])
+              definition = Transformer.lines_to_text_elements(split_lines)
+              attached = Array(data[:attached])
 
               terms = Array(terms_data).map do |t|
                 case t
@@ -179,7 +248,8 @@ module Coradoc
               end
 
               Model::List::DefinitionItem.new(terms: terms, contents: definition,
-                                              id: item_id, delimiter: item_delim)
+                                              id: item_id, delimiter: item_delim,
+                                              attached: attached)
             end
 
             rule(definition_list: sequence(:list_items)) do

data/lib/coradoc/asciidoc/transformer/table_layout.rb

@@ -114,7 +114,9 @@ module Coradoc
 
           col_count = parse_cols_attribute(attrs)
           if col_count.nil? && rows.first.is_a?(Model::TableRow) && rows.first.columns.any?
-            col_count = rows.first.columns.sum { |c| (c.colspan || 1).to_i }
+            col_count = rows.first.columns.sum do |c|
+              (c.colspan || 1).to_i
+            end
           end
 
           all_cells = rows.flat_map do |r|