coradoc-adoc 2.0.29 → 2.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05d6ea3852e5fb5c4bae0176556b9dd3b7a572b09ab1fc8c9d3752ebe0833548
-  data.tar.gz: c9d4a61637e3e04a3fb0ad4b8394b8577236dbf0a9853375f01d750d8ff30f64
+  metadata.gz: 79a252c883acda46234ba968656577308075f2c1694ee2cdff96aa78006d3fe4
+  data.tar.gz: 20186d4848bfe7a63a16a11a43ce3b6ae861bb1bf60be7a71af4d96e7e31ea2b
 SHA512:
-  metadata.gz: 2927618c321c352e622dfd8dc69dbeb5658715e76d4062b05793641dc8c35a829c168a8d1e446b7f382bfb86c7f09a0919b4c05409e0a262e41aa8f327a82755
-  data.tar.gz: 1fd71a5b04f52748ef48b0529b7d6d8dcbb46987002c6ec442d511fa5902b31761eff9c83d1f3bbb1c0992b7e9d34a544443b55ef5f4580247d93591bbc3f98d
+  metadata.gz: dbb9841fe7829f87693c9d31bea1303d2f00c1762810e0f948112e01a6958210700bf90e5df15b3685fb49868dba22cf77f169e8842e420c15fa43e1160ec266
+  data.tar.gz: eb765458ac486a19fca72b69fcb15dea61eb09bb4c0f7ab1bc48793997653ae64dc24dbcd070fa526f3f9b8f467a6a7e157e353719a08d6ed2f795e5e2a1de7d

data/lib/coradoc/asciidoc/model/list/definition_item.rb

@@ -33,6 +33,19 @@ module Coradoc
           attribute :terms, Coradoc::AsciiDoc::Model::Term, collection: true
           attribute :contents, Coradoc::AsciiDoc::Model::TextElement, collection: true
           attribute :delimiter, :string, default: -> { '::' }
+          # `+`-continuation blocks attached to this dd (paragraphs,
+          # admonitions, delimited blocks). Same shape as Model::List::Item's
+          # attached collection — populated by the parser when an AsciiDoc
+          # `+` line follows the dd.
+          attribute :attached,
+                    Coradoc::AsciiDoc::Model::Attached,
+                    polymorphic: [
+                      Coradoc::AsciiDoc::Model::Admonition,
+                      Coradoc::AsciiDoc::Model::Paragraph,
+                      Coradoc::AsciiDoc::Model::Block::Core
+                    ],
+                    collection: true,
+                    initialize_empty: true
           attribute :nested,
                     Coradoc::AsciiDoc::Model::Base,
                     polymorphic: [Coradoc::AsciiDoc::Model::List::Definition],

data/lib/coradoc/asciidoc/model/text_element.rb

@@ -50,16 +50,21 @@ module Coradoc
           end
         end
 
-        # Get text content as string
+        # Get text content as a string. Handles the polymorphic shape of
+        # `content` (String, Array of mixed String/Model elements, nested
+        # Serializable). When the content is an Array, each element is
+        # rendered via its canonical source representation — Model::Base
+        # elements go through `to_adoc`, Strings pass through unchanged —
+        # so a downstream re-parse (e.g. by `ToCoreModel.parse_inline_text`)
+        # sees the original inline-mark syntax rather than `#<…>` dumps.
         #
         # @return [String] The text content
-        #
         def to_s
           case content
           when String
             content
           when Array
-            content.map(&:to_s).join
+            content.map { |element| element_to_s(element) }.join
           when Coradoc::AsciiDoc::Model::Base
             content.to_adoc
           when Lutaml::Model::Serializable
@@ -82,6 +87,17 @@ module Coradoc
         def text
           to_s
         end
+
+        private
+
+        def element_to_s(element)
+          case element
+          when Coradoc::AsciiDoc::Model::Base then element.to_adoc
+          when String then element
+          when nil then ''
+          else element.to_s
+          end
+        end
       end
     end
   end

data/lib/coradoc/asciidoc/parser/base.rb

@@ -88,6 +88,14 @@ module Coradoc
         def rule_dispatch(rule_name, *, **)
           RuleDispatcher.dispatch(self, rule_name, *, **)
         end
+
+        # Per-instance dispatch cache used by RuleDispatcher. Encapsulated
+        # accessor — the dispatcher reads this instead of poking
+        # instance_variable_get/set. Lazy-initialized; returns the same
+        # Hash across calls on the same instance.
+        def _rule_dispatch_cache
+          @_rule_dispatch_cache ||= {}
+        end
       end
 
       # Wrap every parser rule for Parslet memoization. Must run after all

data/lib/coradoc/asciidoc/parser/inline.rb

@@ -4,25 +4,18 @@ module Coradoc
   module AsciiDoc
     module Parser
       module Inline
-        # AsciiDoc typographic quote syntax: a 2-char pattern that
-        # Asciidoctor substitutes with the corresponding Unicode curly
-        # quote. Single source of truth for the pattern → Unicode char
-        # mapping; the transformer reads this table.
-        #
-        # The patterns MUST be recognised before +monospace_constrained+
-        # in the +inline+ alternation, otherwise the lone backtick in
-        # +`"`+ or +`"``+ fires monospace and the surrounding quote
-        # collapses to straight ASCII quotes wrapped around a spurious
-        # code span.
-        TYPOGRAPHIC_QUOTE_PATTERNS = {
-          '"`' => "“",  # U+201C left double
-          '`"' => "”",  # U+201D right double
-          "'`" => "‘",  # U+2018 left single
-          "`'" => "’"   # U+2019 right single
-        }.freeze
+        # Typographic quote patterns are owned by the shared
+        # {Coradoc::AsciiDoc::TypographicQuotes} module so both the
+        # parser and the transformer reference the same source of
+        # truth without one layer reaching across the other.
 
         def typographic_quote
-          (str('"`') | str('`"') | str("'`") | str("`'")).as(:typographic_quote)
+          patterns = AsciiDoc::TypographicQuotes::PATTERNS
+          combined = patterns.reduce(nil) do |acc, pat|
+            atom = str(pat)
+            acc ? (acc | atom) : atom
+          end
+          combined.as(:typographic_quote)
         end
 
         def attribute_reference
@@ -31,19 +24,54 @@ module Coradoc
             str('}')
         end
 
+        # ── Constrained / unconstrained mark builders ──
+        #
+        # Single source of truth for the four constrained + four
+        # unconstrained inline mark rules. Before this extraction each
+        # rule hand-rolled the same open → content → close → lookahead
+        # shape with subtly different guards (presence checks, newline
+        # exclusions, inner-marker allowances). Now each rule is a
+        # 1-line wrapper over one of two parameterised builders.
+        #
+        # The constrained builder adds a `marker.absent?` guard on both
+        # ends so single-marker constrained never matches when a
+        # double-marker unconstrained is intended (e.g. `*` defers to
+        # `**`). The alternation order in `inline` handles this too,
+        # but the guard is belt-and-suspenders — it keeps each rule
+        # self-contained for unit testing.
+        #
+        # The unconstrained builder allows newlines in the content
+        # (Asciidoctor's behaviour for `__`, `**`, `##`, ``` `` ``` — a
+        # mark can span line breaks). This was Bug 15B's fix scope;
+        # highlight_unconstrained was previously inconsistent (excluded
+        # newlines). All four are now uniform.
+
+        def constrained_mark(marker, reject_paragraph_break: false, content: nil)
+          open_guard = str(marker) >> str(marker).absent?
+          content_rule = content || default_constrained_content(marker)
+          close_guard = str(marker) >> str(marker).absent?
+          sequence = open_guard >> content_rule >> close_guard
+          sequence >>= str("\n\n").absent? if reject_paragraph_break
+          sequence
+        end
+
+        def default_constrained_content(marker)
+          match("[^#{marker}\n]").repeat(1).as(:text).repeat(1, 1)
+        end
+
+        def unconstrained_mark(marker)
+          double = marker * 2
+          str(double) >>
+            match("[^#{marker}]").repeat(1).as(:text).repeat(1, 1) >>
+            str(double)
+        end
+
         def bold_constrained
-          (str('*').present? >> str('*') >>
-            match('[^*\n]').repeat(1).as(:text).repeat(1, 1) >>
-             str('*') >> str('*').absent? >>
-             str("\n\n").absent?
-          ).as(:bold_constrained)
+          constrained_mark('*', reject_paragraph_break: true).as(:bold_constrained)
         end
 
         def bold_unconstrained
-          (str('**').present? >> str('**') >>
-            match('[^*]').repeat(1).as(:text).repeat(1, 1) >>
-             str('**')
-          ).as(:bold_unconstrained)
+          unconstrained_mark('*').as(:bold_unconstrained)
         end
 
         def span_constrained
@@ -63,45 +91,28 @@ module Coradoc
         end
 
         def italic_constrained
-          (str('_') >> str('_').absent? >>
-            match('[^_\n]').repeat(1).as(:text).repeat(1, 1) >>
-             str('_') >> str('_').absent?
-          ).as(:italic_constrained)
+          constrained_mark('_').as(:italic_constrained)
         end
 
         def italic_unconstrained
-          (str('__') >>
-            match('[^_]').repeat(1).as(:text).repeat(1, 1) >>
-             str('__')
-          ).as(:italic_unconstrained)
+          unconstrained_mark('_').as(:italic_unconstrained)
         end
 
         def highlight_constrained
-          (str('#') >>
-            match('[^#\n]').repeat(1).as(:text).repeat(1, 1) >>
-             str('#') >> str('#').absent?
-          ).as(:highlight_constrained)
+          constrained_mark('#').as(:highlight_constrained)
         end
 
         def highlight_unconstrained
-          (str('##') >>
-            match('[^#\n]').repeat(1).as(:text).repeat(1, 1) >>
-             str('##')
-          ).as(:highlight_unconstrained)
+          unconstrained_mark('#').as(:highlight_unconstrained)
         end
 
         def monospace_constrained
-          (str('`') >>
-            constrained_span_content('`').as(:text).repeat(1, 1) >>
-             str('`') >> str('`').absent?
-          ).as(:monospace_constrained)
+          content = constrained_span_content('`').as(:text).repeat(1, 1)
+          constrained_mark('`', content: content).as(:monospace_constrained)
         end
 
         def monospace_unconstrained
-          (str('``') >>
-            match('[^\`]').repeat(1).as(:text).repeat(1, 1) >>
-             str('``')
-          ).as(:monospace_unconstrained)
+          unconstrained_mark('`').as(:monospace_unconstrained)
         end
 
         def superscript
@@ -219,33 +230,31 @@ module Coradoc
              (str('\\') >> str("\n"))).as(:hard_line_break)
         end
 
+        # Priority-ordered registry of inline rules. The ORDER IS LOAD-BEARING:
+        # typographic_quote MUST come before monospace_constrained (Bug 14);
+        # each unconstrained rule MUST come before its constrained sibling
+        # (`` `` `` before `` ` ``, `**` before `*`, `__` before `_`).
+        # Adding a new inline rule = appending one symbol here (OCP).
+        INLINE_RULE_ORDER = %i[
+          typographic_quote
+          bold_unconstrained bold_constrained
+          span_unconstrained span_constrained
+          italic_unconstrained italic_constrained
+          highlight_unconstrained highlight_constrained
+          monospace_unconstrained monospace_constrained
+          superscript subscript
+          attribute_reference
+          escaped_xref cross_reference
+          term_inline term_inline2
+          footnote stem
+          link inline_image
+          inline_passthrough
+          underline small
+          hard_line_break
+        ].freeze
+
         def inline
-          typographic_quote |
-            bold_unconstrained |
-            bold_constrained |
-            span_unconstrained |
-            span_constrained |
-            italic_unconstrained |
-            italic_constrained |
-            highlight_unconstrained |
-            highlight_constrained |
-            monospace_unconstrained |
-            monospace_constrained |
-            superscript |
-            subscript |
-            attribute_reference |
-            escaped_xref |
-            cross_reference |
-            term_inline |
-            term_inline2 |
-            footnote |
-            stem |
-            link |
-            inline_image |
-            inline_passthrough |
-            underline |
-            small |
-            hard_line_break
+          INLINE_RULE_ORDER.map { |name| public_send(name) }.reduce(:|)
         end
 
         def text_unformatted

data/lib/coradoc/asciidoc/parser/list.rb

@@ -53,7 +53,7 @@ module Coradoc
         def olist_item(nesting_level = 1)
           item = olist_marker(nesting_level).as(:marker) >>
                  match("\n").absent? >> space >>
-                 (text_line(false, unguarded: true) >>
+                 (list_body_text_line >>
                   list_item_continuation_lines).as(:lines)
 
           att = (list_continuation.present? >>
@@ -105,7 +105,7 @@ module Coradoc
           item = ulist_marker(nesting_level).as(:marker) >>
                  str(' [[[').absent? >>
                  match("\n").absent? >> space >>
-                 (text_line(false, unguarded: true) >>
+                 (list_body_text_line >>
                   list_item_continuation_lines).as(:lines)
 
           att = (list_continuation.present? >>
@@ -128,14 +128,11 @@ module Coradoc
         # id, table boundary, list continuation, or list prefix).
         # `line_not_text?` (from Paragraph) is that exact lookahead.
         #
-        # Each iteration matches exactly one source line via
-        # `text_line(false, ...)` (single-newline termination). The
-        # `.repeat(0)` walks multiple continuation lines one at a time.
-        # Using `text_line(true, ...)` here would let `line_ending.repeat(1)`
-        # greedy-match across blank lines, silently absorbing the
-        # follow-up paragraph into the last list item's content.
+        # Uses `list_body_text_line` (not raw `text_line`) so a hard break
+        # at end of one source line doesn't greedy-pull the next line's
+        # content via text_any — same fix as dlist.
         def list_item_continuation_lines
-          (line_not_text? >> text_line(false, unguarded: true)).repeat(0)
+          (line_not_text? >> list_body_text_line).repeat(0)
         end
 
         def dlist_delimiter
@@ -161,23 +158,128 @@ module Coradoc
           # the line as a continuation of the dlist item), not content.
           # Consume it without capturing so downstream CoreModel text
           # doesn't carry the source indentation into HTML/Markdown.
-          (match('[ \t]').repeat(0) >> text.as(:definition)) >>
-            line_ending >> empty_line.repeat(0)
+          #
+          # Multi-line definitions: AsciiDoc joins consecutive non-blank
+          # lines into a single paragraph within the dd. We capture each
+          # source line so the transformer can join them.
+          #
+          # Two load-bearing guards:
+          #   1. `line_not_text?` — prevents matching a `+` (list
+          #      continuation marker) or `[example]` (block attribute)
+          #      as the dd's text content.
+          #   2. `dlist_definition_line` (custom text_line variant) —
+          #      text_line's text_any is greedy and matches across
+          #      newlines via hard_line_break, swallowing the next
+          #      source line's content (e.g. the `+` marker on the
+          #      line after a hard break). The custom matcher excludes
+          #      hard_line_break from the inline set so each `:lines`
+          #      entry corresponds to exactly one source line.
+          (line_not_text? >> match('[ \t]').repeat(0) >>
+            (list_body_text_line >> list_item_continuation_lines).as(:lines)
+          ) >> empty_line.repeat(0)
+        end
+
+        # Single source line of text for any list item body (dlist dd,
+        # ulist item, olist item). Like text_line(false, unguarded: true)
+        # but uses `LIST_BODY_INLINE_RULE_NAMES` (excludes hard_line_break)
+        # so hard_break's ` +\n` consumption doesn't greedy-pull the next
+        # source line's content (e.g. the `+` line-continuation marker).
+        #
+        # Shared across list types — single source of truth for the
+        # "text inside a list item" grammar.
+        def list_body_text_line
+          literal_space? >>
+            list_body_text_any.as(:text) >>
+            list_body_line_ending
+        end
+
+        def list_body_text_any
+          (list_body_inline_except_hard_break |
+            list_body_text_unformatted.as(:text)).repeat(1)
+        end
+
+        def list_body_inline_except_hard_break
+          LIST_BODY_INLINE_RULE_NAMES.map { |name| public_send(name) }.reduce(:|)
+        end
+
+        # Single source of truth for "inline rules usable inside a list
+        # item body line". Mirrors INLINE_RULE_ORDER minus hard_line_break.
+        # If INLINE_RULE_ORDER changes, update this list (the
+        # list_body_inline_rule_names spec catches drift).
+        LIST_BODY_INLINE_RULE_NAMES = %i[
+          typographic_quote
+          bold_unconstrained bold_constrained
+          span_unconstrained span_constrained
+          italic_unconstrained italic_constrained
+          highlight_unconstrained highlight_constrained
+          monospace_unconstrained monospace_constrained
+          superscript subscript
+          attribute_reference
+          escaped_xref cross_reference
+          term_inline term_inline2
+          footnote stem
+          link inline_image
+          inline_passthrough
+          underline small
+        ].freeze
+
+        def list_body_text_unformatted
+          (str('\\<<').absent? >>
+            list_body_inline_except_hard_break.absent? >>
+            list_body_hard_break_marker?.absent? >>
+            match("[^\n]")
+          ).repeat(1)
+        end
+
+        def list_body_hard_break_marker?
+          (str(' +') >> str("\n")).present? |
+            (str('\\') >> str("\n")).present?
+        end
+
+        # Recognizes line endings for a list body source line, including
+        # the ` +\n` hard-break form. The hard_break marker is preserved
+        # as a `:hard_line_break` capture so downstream can render it
+        # as `<br>`.
+        def list_body_line_ending
+          (str(' +').as(:hard_line_break) >> line_ending.as(:line_break)) |
+            line_ending.as(:line_break) |
+            eof?
         end
 
         def dlist_item(_delimiter = nil)
-          # Both forms below produce the same AST shape:
-          #   {terms: [<dlist_term>, ...], definition: <text>}
-          # so the transformer's definition_list_item rule matches uniformly.
+          # AST shape: { terms: [single dlist_term], delimiter: <delim>,
+          #              lines: <def or nil>, attached: [...] }
           #
-          # Multi-line form: one or more term-lines (`term::` + newline +
-          # optional blank lines), then the definition on its own line(s).
-          # Single-line form: one term + inline space + definition.
-          term_line = dlist_term >> line_ending >> empty_line.repeat(0)
-
-          ((term_line.repeat(1).as(:terms) >> dlist_definition) |
-           (dlist_term.repeat(1, 1).as(:terms) >> space >>
-             dlist_definition)).as(:definition_list_item)
+          # ONE term per dlist_item. Multi-term `<dt>`'s and multi-level
+          # nesting are both handled by the transformer's `build_dlist_tree`,
+          # which inspects each item's `delimiter` to infer depth and
+          # merges consecutive same-depth term-only items into multi-term
+          # items. Keeping the parser's term-emission at one-per-item lets
+          # `delimiter` carry the nesting signal unambiguously — a parser
+          # that greedily groups `parent::` and `child:::` into one item
+          # loses the depth change between them.
+          #
+          # `repeat(1, 1).as(:terms)` ensures `:terms` is captured as a
+          # single-element Array (matching the shape transformer's `Array()`
+          # wrap expects) rather than a bare Hash — bare Hashes confuse
+          # `Array(hash)` into nested-pair conversion.
+          #
+          # Two forms:
+          #   1. multi-line: term on its own line, optional def on next line(s)
+          #   2. inline:     term + def on same line
+          multi_line = dlist_term.repeat(1, 1).as(:terms) >> line_ending >>
+                       empty_line.repeat(0) >> dlist_definition.maybe
+          inline = dlist_term.repeat(1, 1).as(:terms) >> space >> dlist_definition
+
+          item = multi_line | inline
+
+          attached = (list_continuation.present? >>
+                       list_continuation >>
+                       (admonition_line | paragraph | block)
+                     ).repeat(0).as(:attached)
+          item >>= attached.maybe
+
+          item.as(:definition_list_item)
         end
       end
     end

data/lib/coradoc/asciidoc/parser/rule_dispatcher.rb

@@ -119,8 +119,10 @@ module Coradoc
           end
 
           def dispatch_cache(parser_instance)
-            parser_instance.instance_variable_get(:@_rule_dispatch_cache) ||
-              parser_instance.instance_variable_set(:@_rule_dispatch_cache, {})
+            # Per-instance memoization of dispatch rules. Exposed via
+            # the public `_rule_dispatch_cache` method on Parser::Base
+            # so we don't bypass encapsulation with instance_variable_*.
+            parser_instance._rule_dispatch_cache
           end
 
           def dispatch?

data/lib/coradoc/asciidoc/parser.rb

@@ -6,6 +6,7 @@ module Coradoc
       autoload :Base, "#{__dir__}/parser/base"
       autoload :Cache, "#{__dir__}/parser/cache"
       autoload :FrontmatterParser, "#{__dir__}/parser/frontmatter_parser"
+      autoload :Inline, "#{__dir__}/parser/inline"
     end
   end
 end

data/lib/coradoc/asciidoc/serializer/serializers/document.rb

@@ -24,9 +24,7 @@ module Coradoc
             # Frontmatter prefix, if present. The raw YAML text is
             # already canonical (single source of truth is Codec), so we
             # only wrap it with `---` delimiters.
-            if @model.frontmatter && !@model.frontmatter.strip.empty?
-              parts << "---\n#{@model.frontmatter.chomp}\n---\n\n"
-            end
+            parts << "---\n#{@model.frontmatter.chomp}\n---\n\n" if @model.frontmatter && !@model.frontmatter.strip.empty?
 
             # Only add leading newline if we have sections but no header
             parts << "\n" if @model.sections && !@model.sections.empty? && !@model.header

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|

data/lib/coradoc/asciidoc/transformer.rb

@@ -128,17 +128,31 @@ module Coradoc
       # Used by the paragraph and reviewer_note rules to share the same
       # line-shape handling (DRY).
       def self.lines_to_text_elements(lines)
-        Array(lines).map do |line|
+        # Parslet may deliver `lines` as a single Hash (one line captured)
+        # or an Array of Hashes (multiple lines). `Array(hash)` converts
+        # to nested pairs, which we don't want — normalize explicitly.
+        normalized = case lines
+                     when nil then []
+                     when Array then lines
+                     when Hash then [lines]
+                     else Array(lines)
+                     end
+        normalized.map do |line|
           next line unless line.is_a?(Hash) && line.key?(:text)
 
           text_content = line[:text]
-          transformed = if text_content.is_a?(Array)
-                          text_content.map do |item|
-                            item.is_a?(Hash) ? new.apply(item) : item
-                          end
-                        else
-                          text_content
-                        end
+          # `text_content` may be a single Hash (one inline), an Array
+          # of Hashes (multiple inlines), or a String. Normalize to an
+          # Array of Hashes for uniform processing.
+          text_array = case text_content
+                       when Array then text_content
+                       when Hash then [text_content]
+                       when String then [{ text: text_content }]
+                       else [{ text: text_content.to_s }]
+                       end
+          transformed = text_array.map do |item|
+            item.is_a?(Hash) ? new.apply(item) : item
+          end
 
           Model::TextElement.new(
             content: transformed,
@@ -147,6 +161,57 @@ module Coradoc
         end
       end
 
+      # Split `:lines` entries that span multiple source lines (via
+      # text_any greedy-matching across hard_line_break). Each call
+      # returns one entry per logical source line: when a line entry's
+      # `:text` array contains a `hard_line_break`, the entry is split
+      # at each hard_break, producing N+1 entries for N hard breaks.
+      # The hard_break is preserved as the `:line_break` of its segment.
+      #
+      # Without this, a dd source like:
+      #   `term::` First line. +
+      #   +
+      #   attached
+      # produces a single `:lines` entry whose text contains
+      # ["First line.", hard_line_break(" +\n"), "+", "attached..."],
+      # which the renderer joins into "First line. + attached" — the
+      # `+` continuation marker ends up inside the dd's text instead
+      # of triggering the attached-block path.
+      #
+      # Used by the dlist transformer before lines_to_text_elements.
+      def self.split_lines_on_hard_break(lines)
+        normalized = case lines
+                     when nil then []
+                     when Array then lines
+                     when Hash then [lines]
+                     else Array(lines)
+                     end
+        normalized.flat_map do |line|
+          next [line] unless line.is_a?(Hash) && line[:text].is_a?(Array)
+          next [line] unless line[:text].any? { |p| p.is_a?(Hash) && p.key?(:hard_line_break) }
+
+          segments = []
+          current_text = []
+          current_break = nil
+          line[:text].each do |part|
+            if part.is_a?(Hash) && part.key?(:hard_line_break)
+              segments << { text: current_text, line_break: part[:hard_line_break] }
+              current_text = []
+              current_break = :had_hard_break
+            else
+              current_text << part
+            end
+          end
+          # Final segment gets the original line's line_break (or empty
+          # if it ended with a hard break).
+          final_break = current_break == :had_hard_break ? "\n" : line[:line_break]
+          segments << { text: current_text, line_break: final_break }
+          # Drop leading empty segment if the line started with a hard break
+          # (shouldn't happen in practice but be defensive).
+          segments.reject { |s| s[:text].empty? && s != segments.last }
+        end
+      end
+
       # Legacy transform method (deprecated)
       # @deprecated Use {.transform} instead
       def self.legacy_transform(syntax_tree)

data/lib/coradoc/asciidoc/typographic_quotes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    # Single source of truth for AsciiDoc's typographic quote substitution.
+    #
+    # Asciidoctor replaces four 2-char patterns with the corresponding
+    # Unicode curly quotes. Both the parser (to recognise the patterns)
+    # and the transformer (to emit the Unicode chars) reference this
+    # module — the mapping lives here, not on either consumer, so the
+    # parser/transformer seam stays clean.
+    #
+    # The patterns MUST be recognised before +monospace_constrained+ in
+    # the +inline+ alternation, otherwise the lone backtick in +`"`+ or
+    # +`"``+ fires monospace and the surrounding quote collapses to
+    # straight ASCII quotes wrapped around a spurious code span.
+    module TypographicQuotes
+      PATTERN_TO_CHAR = {
+        '"`' => '“',  # U+201C left double
+        '`"' => '”',  # U+201D right double
+        "'`" => '‘',  # U+2018 left single
+        "`'" => '’'   # U+2019 right single
+      }.freeze
+
+      # All four 2-char patterns, suitable for building a Parslet alternation.
+      # @return [Array<String>]
+      PATTERNS = PATTERN_TO_CHAR.keys.freeze
+
+      # Look up the Unicode char for a matched pattern.
+      # @param pattern [String, Parslet::Slice] the matched 2-char pattern
+      # @return [String] the Unicode curly quote char
+      def self.char_for(pattern)
+        PATTERN_TO_CHAR.fetch(pattern.to_s, pattern.to_s)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.29'
+    VERSION = '2.0.30'
   end
 end

data/lib/coradoc/asciidoc.rb

@@ -28,6 +28,7 @@ end
 module Coradoc
   module AsciiDoc
     autoload :DelimiterMapping, "#{__dir__}/asciidoc/delimiter_mapping"
+    autoload :TypographicQuotes, "#{__dir__}/asciidoc/typographic_quotes"
     autoload :Model, "#{__dir__}/asciidoc/model"
     autoload :Parser, "#{__dir__}/asciidoc/parser"
     autoload :Transformer, "#{__dir__}/asciidoc/transformer"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.29
+  version: 2.0.30
 platform: ruby
 authors:
 - Ribose Inc.
@@ -348,6 +348,7 @@ files:
 - lib/coradoc/asciidoc/transformer/table_cell_builder.rb
 - lib/coradoc/asciidoc/transformer/table_layout.rb
 - lib/coradoc/asciidoc/transformer/text_rules.rb
+- lib/coradoc/asciidoc/typographic_quotes.rb
 - lib/coradoc/asciidoc/version.rb
 - lib/coradoc/util.rb
 - lib/coradoc/util/asciidoc.rb
@@ -357,6 +358,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/lutaml/coradoc
   source_code_uri: https://github.com/lutaml/coradoc
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib