coradoc-adoc 2.0.16 → 2.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b72474cf0652bc8f5702011009cab0caeb9dd5180a6f17510a2e081286951d
-  data.tar.gz: 8218895ed5672fe9932747a025c54621ba02870daea6f964b1cc28d506968a1d
+  metadata.gz: 99b9b654a8eebde5418dfbee6f7b184e65bbbcd830b24f0211963d61ed6c1201
+  data.tar.gz: 93e69befaf29a65358e5b6655b7b6cf63d0fb9baab9a828848d7468290c87e3b
 SHA512:
-  metadata.gz: 46c11254ea13b32498f66d11eb0ead0d13df136f7a0cca65e701373cf48f1edf9d9e1beb447553ddc1a14e4459052d559038aa1b6edb580731a6f91d27969616
-  data.tar.gz: 3d6b4701f38cfd0042bcd14d77d094c6c48626bc85ffab3557a274f2fd90041d1df95f37a156a18ef7a73e8d2d9d4900f8048c8c8d021425ddd8ec38a587db84
+  metadata.gz: 1480db996c2768544ae15657c7f394bcaed954c31c79bdf1bfd3f3493b608aad77dc078ed44058ac0964632626585f096a7c96d6047a256ed07f902291ac204a
+  data.tar.gz: b3d0d2044b40702ad13d2f500e06e4e5881e865eda9ac0bc3f01fba94c82175b9b1752e3076b05781d7fd03075af7d276b8af55ef18b4be08576ea5018ea07b0

data/lib/coradoc/asciidoc/builder/element_builder.rb

@@ -21,10 +21,21 @@ module Coradoc
             id: section_ast[:id],
             level: extract_level(section_ast),
             children: build_section_contents(section_ast[:contents]) +
-                      build_subsections(section_ast[:sections])
+                      build_subsections(section_ast[:sections]),
+            attributes: build_section_metadata(section_ast[:attribute_list])
           )
         end
 
+        # Coerces the AST attribute_list (hash / string / nil) through the
+        # normalizer, then delegates to Transform::AttributeListToMetadata
+        # for the typed Model::AttributeList -> CoreModel::Metadata step.
+        # Single source of truth lives in the transform layer (DRY/MECE).
+        def build_section_metadata(attribute_list)
+          list = Coradoc::AsciiDoc::Transformer::AttributeListNormalizer
+                 .coerce(attribute_list)
+          Coradoc::AsciiDoc::Transform::AttributeListToMetadata.call(list)
+        end
+
         def build_section_contents(contents_ast)
           return [] unless contents_ast
 

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

@@ -58,8 +58,21 @@ module Coradoc
                   Coradoc::AsciiDoc::Model::Section,
                   collection: true,
                   initialize_empty: true
+        # Block-header attribute list (e.g. `[appendix]`, `[bibliography]`).
+        # Single source of truth for the AsciiDoc `[style]` hint; downstream
+        # consumers (coradoc-mirror) read `style` from SectionElement#attributes
+        # to dispatch JS section types (annex, references, ...).
+        attribute :attribute_list, Coradoc::AsciiDoc::Model::AttributeList
         # attribute :anchor, Coradoc::AsciiDoc::Model::Inline::Anchor
 
+        # Style hint derived from the first positional in `attribute_list`.
+        # Returns nil when no list is attached. Kept here so callers don't
+        # need to know the AttributeList shape.
+        def style
+          first_positional = attribute_list&.positional&.first
+          first_positional&.value
+        end
+
         # Allow setting level directly during initialization
         def initialize(**attributes)
           level_value = attributes.delete(:level)

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

@@ -44,7 +44,7 @@ module Coradoc
         end
 
         def positional_value_unquoted
-          match['a-zA-Z0-9_\-%.'].repeat(1)
+          match('[^\]\s,]').repeat(1) >> space.absent?
         end
 
         def positional_value_single_quote

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

@@ -139,29 +139,57 @@ module Coradoc
             closing_delimiter >> newline
         end
 
-        # Block style parser with EXACT delimiter length (for open blocks)
-        # Open blocks use exactly 2 dashes and cannot nest within themselves
+        # Block style parser with EXACT delimiter length (for open blocks).
+        # Open blocks use exactly 2 dashes. A `[source]`/`[listing]`/`[literal]`
+        # positional attribute casts the body to verbatim — block macros like
+        # `image::` must survive byte-for-byte, same as delimited source blocks.
         def block_style_exact(n_deep = 3, delimiter = '-', exact_chars = 2)
           capture_key = :"delimit_#{delimiter}_exact_#{exact_chars}_#{n_deep}"
+          attr_capture_key = :"#{capture_key}_attrs"
           current_delimiter = str(delimiter).repeat(exact_chars, exact_chars).capture(capture_key)
           closing_delimiter = dynamic do |_s, c|
             str(c.captures[capture_key].to_s.strip)
           end
 
+          # Closure so the call bypasses Parslet's method_missing inside the
+          # dynamic block. capture() stashes the parsed AST (a nested Hash for
+          # a `[source,ruby]` header). Inspect the structure directly so we
+          # don't depend on Ruby's Hash#to_s format (it changed in 3.4).
+          verbatim_cast = lambda do |raw|
+            values = []
+            queue = [raw]
+            while (node = queue.shift)
+              case node
+              when Hash then queue.concat(node.values)
+              when Array then queue.concat(node)
+              else values << node
+              end
+            end
+            castable = %w[source listing literal]
+            values.any? { |v| castable.include?(v.to_s) }
+          end
+
           block_content_with_closing = dynamic do |_s, c|
             delim_str = c.captures[capture_key].to_s.strip
+            raw_header = c.captures[attr_capture_key]
             closing_pattern = str(delim_str) >> newline
 
-            content = block_image
-            content |= block(n_deep - 1) if n_deep.positive?
-            content |= list
-            content |= text_line(false, unguarded: true)
-            content |= empty_line.as(:line_break)
+            content = if verbatim_cast.call(raw_header)
+                        text_line(false, unguarded: true, verbatim: true) |
+                          empty_line.as(:line_break)
+                      else
+                        alt = block_image
+                        alt |= block(n_deep - 1) if n_deep.positive?
+                        alt |= list
+                        alt |= text_line(false, unguarded: true)
+                        alt |= empty_line.as(:line_break)
+                        alt
+                      end
 
             (closing_pattern.absent? >> content).repeat(1)
           end
 
-          block_header >>
+          block_header.capture(attr_capture_key) >>
             line_start? >>
             current_delimiter.as(:delimiter) >> newline >>
             block_content_with_closing.as(:lines) >>

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

@@ -14,6 +14,14 @@ module Coradoc
             str('>>')
           ).as(:cross_reference)
         end
+
+        # AsciiDoc escape: `\<<` produces the literal text `<<` without
+        # firing the cross-reference rule. Without this, documentation that
+        # shows AsciiDoc xref syntax as a literal example gets rewritten
+        # into a broken link to a non-existent anchor.
+        def escaped_xref
+          str('\\') >> str('<<').as(:text)
+        end
       end
     end
   end

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

@@ -158,7 +158,8 @@ module Coradoc
             str('+++').present? |
             term_type.present? |
             str('footnote').present? |
-            stem_type.present?
+            stem_type.present? |
+            str('\\<<').present?
         end
 
         def inline
@@ -175,6 +176,7 @@ module Coradoc
             superscript |
             subscript |
             attribute_reference |
+            escaped_xref |
             cross_reference |
             term_inline |
             term_inline2 |
@@ -188,8 +190,12 @@ module Coradoc
         end
 
         def text_unformatted
-          # line_not_text? >>
-          (inline.absent? >>
+          # `str('\\<<').absent?` stops text from consuming the backslash of
+          # an escaped xref (`\<<`). Without this guard, the `\` is taken as
+          # plain text, the `<<` re-enters cross_reference, and the literal
+          # escape is destroyed.
+          (str('\\<<').absent? >>
+            inline.absent? >>
             match("[^\n]")
           ).repeat(1)
         end

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

@@ -52,21 +52,19 @@ module Coradoc
 
         def olist_item(nesting_level = 1)
           item = olist_marker(nesting_level).as(:marker) >>
-                 match("\n").absent? >> space >> text_line(true, unguarded: true)
-          # >>
-          # (list_continuation.present? >> list_continuation >>
-          # paragraph #| example_block(n_deep: 1)
-          # ).repeat(0).as(:attached)
+                 match("\n").absent? >> space >>
+                 (text_line(true, unguarded: true) >>
+                  list_item_continuation_lines).as(:lines)
 
           att = (list_continuation.present? >>
                   list_continuation >>
-                  (admonition_line | paragraph | block) # (n_deep: 1))
+                  (admonition_line | paragraph | block)
                 ).repeat(0).as(:attached)
           item >>= att.maybe
 
           if nesting_level <= 4
             item >>= (list_marker(nesting_level + 1).present? >>
-                   list(nesting_level + 1)).repeat(0).as(:nested) # ).maybe
+                   list(nesting_level + 1)).repeat(0).as(:nested)
           end
           olist_marker(nesting_level).present? >> item.as(:list_item)
         end
@@ -82,21 +80,33 @@ module Coradoc
         def ulist_item(nesting_level = 1)
           item = ulist_marker(nesting_level).as(:marker) >>
                  str(' [[[').absent? >>
-                 match("\n").absent? >> space >> text_line(true, unguarded: true)
+                 match("\n").absent? >> space >>
+                 (text_line(true, unguarded: true) >>
+                  list_item_continuation_lines).as(:lines)
 
           att = (list_continuation.present? >>
                   list_continuation >>
-                  (admonition_line | paragraph | block) # (n_deep: 1))
+                  (admonition_line | paragraph | block)
                 ).repeat(0).as(:attached)
           item >>= att.maybe
 
           if nesting_level <= 4
             item >>= (list_marker(nesting_level + 1).present? >>
-                   list(nesting_level + 1)).repeat(0).as(:nested) # ).maybe
+                   list(nesting_level + 1)).repeat(0).as(:nested)
           end
           ulist_marker(nesting_level).present? >> item.as(:list_item)
         end
 
+        # Continuation lines of a list item's first paragraph. AsciiDoc
+        # joins consecutive non-blank lines into one paragraph within the
+        # item, but the lines must not start a sibling construct (another
+        # list marker, block delimiter, attribute list, section, element
+        # id, table boundary, list continuation, or list prefix).
+        # `line_not_text?` (from Paragraph) is that exact lookahead.
+        def list_item_continuation_lines
+          (line_not_text? >> text_line(true, unguarded: true)).repeat(0)
+        end
+
         def dlist_delimiter
           (
             (str(':::::') >> match(':').absent?) |
@@ -120,12 +130,18 @@ module Coradoc
         end
 
         def dlist_item(_delimiter = nil)
-          (((dlist_term.as(:terms).repeat(1) >> line_ending >>
-            empty_line.repeat(0)).repeat(1) >>
-            dlist_definition) |
-            (dlist_term.repeat(1, 1).as(:terms) >> space >>
-              dlist_definition)
-          ).as(:definition_list_item)
+          # Both forms below produce the same AST shape:
+          #   {terms: [<dlist_term>, ...], definition: <text>}
+          # so the transformer's definition_list_item rule matches uniformly.
+          #
+          # 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)
         end
       end
     end

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

@@ -13,7 +13,9 @@ module Coradoc
             list_prefix.absent? >>
             list_continuation.absent? >>
             element_id.absent? >>
-            section_prefix.absent?
+            section_prefix.absent? >>
+            comment_line.absent? >>
+            tag.absent?
         end
 
         # NOTE: many_breaks parameter has three states for different parsing contexts:

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      # Single source of truth for AsciiDoc Model::AttributeList ->
+      # CoreModel::Metadata conversion (DRY/MECE).
+      #
+      # Promotes the first positional attribute to `style` and the
+      # `role=` named attribute to `role`, matching the AsciiDoc
+      # block-header semantics that downstream consumers (coradoc-mirror)
+      # dispatch on to pick a JS section type (annex, abstract, ...).
+      #
+      # Returns nil for anything that isn't a typed AttributeList so
+      # callers can pass through optional/missing inputs without an
+      # extra guard.
+      module AttributeListToMetadata
+        module_function
+
+        def call(list)
+          return nil unless list.is_a?(Coradoc::AsciiDoc::Model::AttributeList)
+
+          metadata = Coradoc::CoreModel::Metadata.new
+          first_positional = list.positional.first
+          metadata['style'] = first_positional.value if first_positional
+          named_role = list.named.find { |n| n.name == 'role' }
+          metadata['role'] = named_role.value.first if named_role&.value&.any?
+          metadata
+        end
+      end
+    end
+  end
+end

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

@@ -16,7 +16,12 @@ module Coradoc
               )
             end
 
-            def transform_source_block(block)
+            # Verbatim blocks (source, listing, literal, pass) must round-trip
+            # their body byte-for-byte. Each source line becomes one content
+            # line; we join with "\n" so whitespace, indentation, and blank
+            # lines are preserved. Treating these as paragraphs would collapse
+            # whitespace and join consecutive lines into a single flowing text.
+            def transform_verbatim_block(block, klass)
               non_break_lines = Array(block.lines).reject do |line|
                 line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
                   line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
@@ -25,16 +30,26 @@ module Coradoc
                 ToCoreModel.extract_text_content(line)
               end.join("\n")
 
-              language = ToCoreModel.extract_block_language(block)
-
-              Coradoc::CoreModel::SourceBlock.new(
+              klass.new(
                 id: block.id,
                 title: ToCoreModel.extract_title_text(block.title),
                 content: content_lines,
-                language: language
+                language: ToCoreModel.extract_block_language(block)
               )
             end
 
+            def transform_source_block(block)
+              transform_verbatim_block(block, Coradoc::CoreModel::SourceBlock)
+            end
+
+            def transform_literal_block(block)
+              transform_verbatim_block(block, Coradoc::CoreModel::LiteralBlock)
+            end
+
+            def transform_pass_block(block)
+              transform_verbatim_block(block, Coradoc::CoreModel::PassBlock)
+            end
+
             # Open blocks (`--`) are generic containers. AsciiDoc allows
             # casting them to a different block type via positional
             # attributes: verbatim types (`[source]`, `[listing]`,
@@ -86,22 +101,11 @@ module Coradoc
             end
 
             def transform_listing_from_open(block)
-              content_lines = Array(block.lines).map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
-              Coradoc::CoreModel::ListingBlock.new(
-                id: block.id,
-                title: ToCoreModel.extract_title_text(block.title),
-                content: content_lines,
-                language: ToCoreModel.extract_block_language(block)
-              )
+              transform_verbatim_block(block, Coradoc::CoreModel::ListingBlock)
             end
 
             def transform_literal_from_open(block)
-              content_lines = Array(block.lines).map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
-              Coradoc::CoreModel::LiteralBlock.new(
-                id: block.id,
-                title: ToCoreModel.extract_title_text(block.title),
-                content: content_lines
-              )
+              transform_verbatim_block(block, Coradoc::CoreModel::LiteralBlock)
             end
 
             def transform_block(block, semantic_type_or_delimiter)
@@ -123,15 +127,14 @@ module Coradoc
             end
 
             def transform_typed_block(block, klass, extra_attrs = {})
-              lines = Array(block.lines).reject do |line|
-                line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
-                  line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
-              end
-
-              has_nested_blocks = lines.any?(Coradoc::AsciiDoc::Model::Block::Core)
+              raw_lines = Array(block.lines)
+              has_nested_blocks = raw_lines.any?(Coradoc::AsciiDoc::Model::Block::Core)
 
               if has_nested_blocks
-                children = lines.filter_map do |line|
+                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)
@@ -149,15 +152,21 @@ module Coradoc
                   **extra_attrs
                 )
               else
-                content_lines = lines.map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
-                children = lines.map do |line|
-                  inline = ToCoreModel.transform_inline_content(line)
-                  inline = [Coradoc::CoreModel::TextContent.new(text: "")] if inline.empty?
+                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(line),
+                    content: ToCoreModel.extract_text_content(group),
                     children: Array(inline)
                   )
                 end
+
                 klass.new(
                   id: block.id,
                   title: ToCoreModel.extract_title_text(block.title),
@@ -168,6 +177,24 @@ module Coradoc
                 )
               end
             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|
+                if line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                   line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+                  groups << current if current.any?
+                  current = []
+                else
+                  current << line
+                end
+              end
+              groups << current if current.any?
+              groups
+            end
           end
         end
       end

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

@@ -48,9 +48,19 @@ module Coradoc
                 id: section_id,
                 level: section.level,
                 title: title_text,
-                children: content_children + nested_sections
+                children: content_children + nested_sections,
+                attributes: section_metadata_from(section)
               )
             end
+
+            # Delegates to Transform::AttributeListToMetadata for the typed
+            # Model::AttributeList -> CoreModel::Metadata conversion. The
+            # helper handles the nil/non-AttributeList guard and is the
+            # single source of truth shared with Builder::ElementBuilder.
+            def section_metadata_from(section)
+              Coradoc::AsciiDoc::Transform::AttributeListToMetadata
+                .call(section.attribute_list)
+            end
           end
         end
       end

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

@@ -50,9 +50,7 @@ module Coradoc
             {
               Coradoc::AsciiDoc::Model::Block::Quote => Coradoc::CoreModel::QuoteBlock,
               Coradoc::AsciiDoc::Model::Block::Example => Coradoc::CoreModel::ExampleBlock,
-              Coradoc::AsciiDoc::Model::Block::Side => Coradoc::CoreModel::SidebarBlock,
-              Coradoc::AsciiDoc::Model::Block::Literal => Coradoc::CoreModel::LiteralBlock,
-              Coradoc::AsciiDoc::Model::Block::Pass => Coradoc::CoreModel::PassBlock
+              Coradoc::AsciiDoc::Model::Block::Side => Coradoc::CoreModel::SidebarBlock
             }.each do |block_class, core_model_class|
               Registry.register_with_priority(
                 block_class,
@@ -61,6 +59,22 @@ module Coradoc
               )
             end
 
+            # Verbatim typed blocks (literal, pass) preserve their body
+            # byte-for-byte — same line-joining strategy as source/listing.
+            # Routing them through `transform_typed_block` would collapse
+            # intra-block whitespace and join consecutive lines as paragraphs.
+            Registry.register_with_priority(
+              Coradoc::AsciiDoc::Model::Block::Literal,
+              ->(model) { Blk.transform_literal_block(model) },
+              priority: 10
+            )
+
+            Registry.register_with_priority(
+              Coradoc::AsciiDoc::Model::Block::Pass,
+              ->(model) { Blk.transform_pass_block(model) },
+              priority: 10
+            )
+
             Registry.register_with_priority(
               Coradoc::AsciiDoc::Model::Block::Open,
               ->(model) { Blk.transform_open_block(model) },

data/lib/coradoc/asciidoc/transform.rb

@@ -14,6 +14,7 @@ module Coradoc
       autoload :ElementTransformers, "#{__dir__}/transform/element_transformers"
       autoload :FrontmatterAttributeMap, "#{__dir__}/transform/frontmatter_attribute_map"
       autoload :CalloutMerger, "#{__dir__}/transform/callout_merger"
+      autoload :AttributeListToMetadata, "#{__dir__}/transform/attribute_list_to_metadata"
     end
   end
 end

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

@@ -47,8 +47,12 @@ module Coradoc
             rule(list_item: subtree(:list_item)) do
               marker = list_item[:marker]
               id = list_item[:id]
-              text = list_item[:text]
-              text = list_item[:text].to_s if list_item[:text].instance_of?(Parslet::Slice)
+              lines = list_item[:lines]
+              content = if lines
+                          Transformer.lines_to_text_elements(lines)
+                        else
+                          list_item[:text].to_s
+                        end
               attached = list_item[:attached]
               nested = list_item[:nested]
               line_break = list_item[:line_break]
@@ -70,7 +74,7 @@ module Coradoc
               end
 
               Model::List::Item.new(
-                content: text, id:, marker:, attached:, nested:, line_break:
+                content: content, id:, marker:, attached:, nested:, line_break:
               )
             end
 

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.16'
+    VERSION = '2.0.17'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.16
+  version: 2.0.17
 platform: ruby
 authors:
 - Ribose Inc.
@@ -314,6 +314,7 @@ files:
 - lib/coradoc/asciidoc/serializer/serializers/video.rb
 - lib/coradoc/asciidoc/serializer/spacing_strategy.rb
 - lib/coradoc/asciidoc/transform.rb
+- lib/coradoc/asciidoc/transform/attribute_list_to_metadata.rb
 - lib/coradoc/asciidoc/transform/callout_merger.rb
 - lib/coradoc/asciidoc/transform/element_transformers.rb
 - lib/coradoc/asciidoc/transform/element_transformers/block_transformer.rb