coradoc-adoc 2.0.30 → 2.0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79a252c883acda46234ba968656577308075f2c1694ee2cdff96aa78006d3fe4
-  data.tar.gz: 20186d4848bfe7a63a16a11a43ce3b6ae861bb1bf60be7a71af4d96e7e31ea2b
+  metadata.gz: 451e2ccdd5dbbd4771079ee9bdc1041c3ee0d3ff74847237d7f3d4aea5064031
+  data.tar.gz: 9f161020aca1c07565f9f20c510114b562925cbfb55d4666db14f1d61a68ed81
 SHA512:
-  metadata.gz: dbb9841fe7829f87693c9d31bea1303d2f00c1762810e0f948112e01a6958210700bf90e5df15b3685fb49868dba22cf77f169e8842e420c15fa43e1160ec266
-  data.tar.gz: eb765458ac486a19fca72b69fcb15dea61eb09bb4c0f7ab1bc48793997653ae64dc24dbcd070fa526f3f9b8f467a6a7e157e353719a08d6ed2f795e5e2a1de7d
+  metadata.gz: 20150d6a118ae76db46737ca68c47b87a1195cd716ee88700de2afdb06094dd3edee9c66a5b224702e20c6333d28c4082d9840e24b590210154abe46643aad7a
+  data.tar.gz: a881fc61dd3bce4e276f3db93fd250d3cf0cd0ab18a2e93a296887a416070b43b0da61972818e79ff0d7c00bd9f4af6320bb8cae8976402fff8519943ce05299

data/lib/coradoc/asciidoc/reference_materializers/navigation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module ReferenceMaterializers
+      # Render a navigation edge as a first-class CrossReferenceElement
+      # — the model-driven xref node the AsciiDoc serializer already
+      # knows how to emit (never a raw macro string). Materializing for
+      # AsciiDoc fills in the visible text from the authored label or
+      # the resolved target's title.
+      class Navigation < Coradoc::Reference::Materializer::Base
+        class << self
+          def kind
+            :navigation
+          end
+
+          def presentation
+            :any
+          end
+
+          def format
+            :asciidoc
+          end
+        end
+
+        def materialize(edge:, result:, **)
+          text = display_text(edge, result)
+          Coradoc::CoreModel::CrossReferenceElement.new(
+            target: xref_target(edge.address),
+            content: text,
+            children: [
+              Coradoc::CoreModel::TextElement.new(content: text)
+            ]
+          )
+        end
+
+        private
+
+        def xref_target(address)
+          [address.target, address.fragment].compact.join('#')
+        end
+
+        def display_text(edge, result)
+          return edge.label if edge.label && !edge.label.empty?
+          return result.target.title if result.is_a?(Coradoc::Reference::Result::Resolved) && result.target&.title
+
+          edge.address.to_s
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/reference_materializers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    # Materializers rendering resolved reference Edges into
+    # AsciiDoc-shaped CoreModel nodes. They live in the format gem
+    # (not coradoc core) so format knowledge stays at the spoke of the
+    # hub-and-spoke architecture; registration is a load-time side
+    # effect via the Materializer registry's global extension point.
+    module ReferenceMaterializers
+      autoload :Navigation, "#{__dir__}/reference_materializers/navigation"
+    end
+  end
+end
+
+Coradoc::Reference::Materializer::Registry.register_global(
+  Coradoc::AsciiDoc::ReferenceMaterializers::Navigation
+)

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/version.rb

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

data/lib/coradoc/asciidoc.rb

@@ -94,6 +94,12 @@ module Coradoc
           document.to_adoc
         end
       end
+
+      # AsciiDoc round-trips include:: directives natively — graph-mode
+      # documents serialize losslessly, no hydration required.
+      def preserves_unresolved_includes?
+        true
+      end
     end
 
     # Backward-compatible aliases for model classes
@@ -152,3 +158,7 @@ Coradoc.register_format(:asciidoc, Coradoc::AsciiDoc,
 # Backward-compatibility: Coradoc::Model is now Coradoc::AsciiDoc::Model
 # This alias is provided for legacy code that hasn't been updated
 Coradoc::Model = Coradoc::AsciiDoc::Model unless defined?(Coradoc::Model)
+
+# Reference materializers for format: :asciidoc. Required (not autoloaded)
+# because registration is a load-time side effect, like register_format.
+require 'coradoc/asciidoc/reference_materializers'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.30
+  version: 2.0.32
 platform: ruby
 authors:
 - Ribose Inc.
@@ -235,6 +235,8 @@ files:
 - lib/coradoc/asciidoc/parser/table.rb
 - lib/coradoc/asciidoc/parser/term.rb
 - lib/coradoc/asciidoc/parser/text.rb
+- lib/coradoc/asciidoc/reference_materializers.rb
+- lib/coradoc/asciidoc/reference_materializers/navigation.rb
 - lib/coradoc/asciidoc/serializer.rb
 - lib/coradoc/asciidoc/serializer/adoc_serializer.rb
 - lib/coradoc/asciidoc/serializer/element_registry.rb