coradoc-adoc 2.0.29 → 2.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05d6ea3852e5fb5c4bae0176556b9dd3b7a572b09ab1fc8c9d3752ebe0833548
-  data.tar.gz: c9d4a61637e3e04a3fb0ad4b8394b8577236dbf0a9853375f01d750d8ff30f64
+  metadata.gz: 22eb5a515f97c8954148e99ef280dd4bb8ac3bed03d59d745291dc3d7ac302c2
+  data.tar.gz: 0435ded18a2f7895426d1de9aba45c5c3ccaeea442c287fb1f5cd6d14581b117
 SHA512:
-  metadata.gz: 2927618c321c352e622dfd8dc69dbeb5658715e76d4062b05793641dc8c35a829c168a8d1e446b7f382bfb86c7f09a0919b4c05409e0a262e41aa8f327a82755
-  data.tar.gz: 1fd71a5b04f52748ef48b0529b7d6d8dcbb46987002c6ec442d511fa5902b31761eff9c83d1f3bbb1c0992b7e9d34a544443b55ef5f4580247d93591bbc3f98d
+  metadata.gz: cc35eb17f93b7c78fc2f935cf71ef18d76af08eb36a52ab7040d90e735c72a4d1f990339fc414803ccbf767d0b57bf636be79d76940fa8a091e52bcd37091544
+  data.tar.gz: 8c93968c63d400dfb86d0855c6bb1a2ebc6bbe200a85b07da5d2861771baeacf2beb11cd811c136e912fae302d0003c8aa822f12c73ef2ae5d127ced9caea829

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