coradoc-adoc 2.0.20 → 2.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fad1b11f8028b7157066b7a2d4474b2d20e3cab1e526e0347ca36015cdf3ad90
-  data.tar.gz: d143bb70ec7ab2e3a1656a5e9ed72d52bb0b2f1341b3566efa02ef44343a2044
+  metadata.gz: 42db73896b69e9e5344105625afe528bd2b7b8f57a11822f61881e782be8b974
+  data.tar.gz: bc3e5e3073992f0d2b71e12ab62fa07d11cdf6ded25299d673f863522cd6291d
 SHA512:
-  metadata.gz: 7848b8f80f104e960265ed5dbd295d4dfc7ad4cecb401b81765ae21ba6d16a31e02024ebfd7c65c1c86e0fd433512788a92ab4600b348293d895980bf2b5b446
-  data.tar.gz: c6a55d7b4abecd086fcbde8015fd54b217eb3a442f86699bd1ab110affc1f1dc20f9ff54ef24668dcc77fdcb1cf609b09651308bc4122ea47a05535e18585879
+  metadata.gz: 334c5ae5f1860ccde94bb518e8bc7f91be7dcce338d863d93ec137acbfedce8f742be44336fde3e4cec7ea6709b3f309c484c716ceb8c485da2830312515d59e
+  data.tar.gz: 3f387aab6c8b6d8862319593b9c2b8c2304758c4c66f15aed0e5ac57209f2f35b4930d1d95a57b2cf4d940834599db35395546c81b8d7760384062d0a7a48d49

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

@@ -4,13 +4,22 @@ module Coradoc
   module AsciiDoc
     module Parser
       module Admonition
+        # Match a single style name case-insensitively. Each character
+        # class `[Xx]` lets the same alternation accept +note+, +Note+,
+        # and +NOTE+ without three separate str() branches per style.
+        def case_insensitive_str(s)
+          s.chars.reduce(nil) do |acc, ch|
+            node = match("[#{ch.upcase}#{ch.downcase}]")
+            acc.nil? ? node : (acc >> node)
+          end
+        end
+
         def admonition_type
-          str('NOTE') | str('TIP') | str('EDITOR') |
-            str('IMPORTANT') | str('WARNING') | str('CAUTION') |
-            str('TODO')
-          # requires atypical syntax for access?
-          # | str('DANGER')
-          # | str('SAFETY PRECAUTION')
+          styles = Coradoc::AsciiDoc::Transform::ElementTransformers::AdmonitionStyles.all_styles
+          styles.reduce(nil) do |acc, style|
+            matcher = case_insensitive_str(style)
+            acc.nil? ? matcher : (acc | matcher)
+          end
         end
 
         def admonition_line

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

@@ -120,20 +120,38 @@ module Coradoc
           (str('image:').present? >> str('image:') >>
             str(':').absent? >>
             match('[A-Za-z0-9_.\\-:/&?=+,%#~;]+').repeat(1).as(:path) >>
-            (str('[') >> match('[^\\]]').repeat(1).as(:text) >> str(']')).maybe
+            attribute_list(:attribute_list).maybe
           ).as(:inline_image)
         end
 
         # Triple-plus inline passthrough: `+++raw content+++`. The content
         # passes through all substitutions verbatim. Common use is to embed
         # raw HTML in AsciiDoc documents.
-        def inline_passthrough
+        def inline_passthrough_triple_plus
           (str('+++') >>
             (str('+++').absent? >> match('[^\n]')).repeat(1).as(:raw) >>
             str('+++')
           ).as(:inline_passthrough)
         end
 
+        # `pass:[raw]` macro form. Equivalent semantic to triple-plus:
+        # the bracket payload survives all substitutions verbatim. Common
+        # use is inside monospace spans to keep characters like `<` from
+        # being re-interpreted as xref markers. The optional `subs` segment
+        # (`pass:quotes[...]`) is consumed but currently ignored — the
+        # payload is always passed through raw.
+        def inline_passthrough_macro
+          (str('pass:').present? >> str('pass:') >>
+            match('[a-zA-Z,+]').repeat(0) >>
+            str('[') >> (str(']]').absent? >> match('[^\]\n]')).repeat(1).as(:raw) >>
+            str(']')
+          ).as(:inline_passthrough)
+        end
+
+        def inline_passthrough
+          inline_passthrough_triple_plus | inline_passthrough_macro
+        end
+
         def underline
           (attribute_list >> match('\\[.underline\\]').as(:role) >>
             str('#') >>
@@ -157,10 +175,26 @@ module Coradoc
             str('link:').present? |
             str('image:').present? |
             str('+++').present? |
+            str('pass:').present? |
             term_type.present? |
             str('footnote').present? |
             stem_type.present? |
-            str('\\<<').present?
+            str('\\<<').present? |
+            hard_line_break_marker?
+        end
+
+        # AsciiDoc hard line break: a space followed by `+` at end of line,
+        # or a backslash at end of line. Both forms render as `<br>` inside
+        # the enclosing paragraph/verse. Recognised ahead of `text_unformatted`
+        # so the marker isn't swallowed as plain text.
+        def hard_line_break_marker?
+          (str(' +') >> str("\n")).present? |
+            (str('\\') >> str("\n")).present?
+        end
+
+        def hard_line_break
+          ((str(' +') >> str("\n")) |
+             (str('\\') >> str("\n"))).as(:hard_line_break)
         end
 
         def inline
@@ -187,7 +221,8 @@ module Coradoc
             inline_image |
             inline_passthrough |
             underline |
-            small
+            small |
+            hard_line_break
         end
 
         def text_unformatted

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

@@ -149,8 +149,13 @@ module Coradoc
         end
 
         def dlist_definition
-          text
-            .as(:definition) >> line_ending >> empty_line.repeat(0)
+          # AsciiDoc convention: the definition body is indented relative
+          # to the term. That leading whitespace is structural (marks
+          # 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)
         end
 
         def dlist_item(_delimiter = nil)

data/lib/coradoc/asciidoc/serializer/element_registry.rb

@@ -4,9 +4,12 @@ module Coradoc
   module AsciiDoc
     module Serializer
       # Registry for mapping Coradoc model classes to their AsciiDoc serializers.
-      # This is the authoritative source for model→serializer mappings.
       #
-      # Pattern mirrors Input::Html::Converters registry for symmetry.
+      # Thin layer over `Coradoc::Dispatch.strict`: each public method
+      # delegates to a single Dispatch instance so the dispatch mechanism
+      # (storage, miss-handling, override semantics) lives in one place.
+      # Adoc-specific concerns (the ArgumentError wording on miss, the
+      # `registered_models` name) stay here.
       #
       # @example Registering a custom serializer
       #   ElementRegistry.override(Model::Paragraph, CustomParagraphSerializer)
@@ -15,78 +18,45 @@ module Coradoc
       #   original = ElementRegistry.get(Model::Paragraph)
       #   ElementRegistry.override(Model::Paragraph, WrapperSerializer.new(original))
       class ElementRegistry
+        DISPATCH = Coradoc::Dispatch.strict
+
         class << self
-          # Register a serializer for a model class
-          # @param model_class [Class] The Coradoc model class
-          # @param serializer_class [Class] The serializer class
           def register(model_class, serializer_class)
-            registry[model_class] = serializer_class
+            DISPATCH.register(model_class, serializer_class)
           end
 
-          # Override a serializer for a model class
-          # This is an alias for register that makes the intent explicit
-          # @param model_class [Class] The Coradoc model class
-          # @param serializer_class [Class] The new serializer class
-          # @return [Class, nil] The previous serializer class, or nil if none
           def override(model_class, serializer_class)
-            previous = registry[model_class]
-            registry[model_class] = serializer_class
-            previous
+            DISPATCH.override(model_class, serializer_class)
           end
 
-          # Unregister a serializer for a model class
-          # @param model_class [Class] The model class to unregister
-          # @return [Class, nil] The removed serializer class, or nil if none
           def unregister(model_class)
-            registry.delete(model_class)
+            DISPATCH.unregister(model_class)
           end
 
-          # Get the serializer for a model class without raising
-          # @param model_class [Class] The model class
-          # @return [Class, nil] The serializer class, or nil if not registered
           def get(model_class)
-            registry[model_class]
+            DISPATCH.lookup(model_class)
           end
 
-          # Lookup serializer for a model class
-          # @param model_class [Class] The model class
-          # @return [Class] The serializer class
-          # @raise [ArgumentError] If no serializer is registered
           def lookup(model_class)
-            serializer_class = registry[model_class]
-
-            unless serializer_class
-              raise ArgumentError,
-                    "No serializer registered for #{model_class.name}. " \
-                    'Please register a serializer in ElementRegistry, or the serializer ' \
-                    'may not have been loaded yet (check Registrations.load_all!)'
-            end
+            serializer_class = DISPATCH.lookup(model_class)
+            return serializer_class if serializer_class
 
-            serializer_class
+            raise ArgumentError,
+                  "No serializer registered for #{model_class.name}. " \
+                  'Please register a serializer in ElementRegistry, or the serializer ' \
+                  'may not have been loaded yet (check Registrations.load_all!)'
           end
 
-          # Get all registered model classes
-          # @return [Array<Class>] Array of registered model classes
           def registered_models
-            registry.keys
+            DISPATCH.registered_keys
           end
 
-          # Check if a model class has a registered serializer
-          # @param model_class [Class] The model class
-          # @return [Boolean] True if registered
           def registered?(model_class)
-            registry.key?(model_class)
+            DISPATCH.registered?(model_class)
           end
 
-          # Clear all registrations (mainly for testing)
           def clear!
-            registry.clear
-          end
-
-          # Get the registry hash
-          # @return [Hash] Model class => Serializer class mapping
-          def registry
-            @@registry ||= {}
+            DISPATCH.clear!
           end
         end
       end

data/lib/coradoc/asciidoc/serializer/registrations.rb

@@ -3,104 +3,21 @@
 module Coradoc
   module AsciiDoc
     module Serializer
-      # Trigger loading of all serializer registrations
+      # Trigger loading of all serializer registrations.
       #
-      # Each serializer file self-registers when loaded via autoload.
-      # This module triggers the autoload of all serializers by accessing
-      # their constants, which causes the registration code in each file to execute.
+      # Each serializer file self-registers when loaded via
+      # `ElementRegistry.register(...)` at file bottom. Walking the
+      # serializers directory is the single source of truth for "which
+      # serializers exist" — adding a file is the only step required for
+      # it to register.
       module Registrations
         class << self
-          # Load all serializers to trigger their registration
-          # rubocop:disable Lint/Void - Constants are referenced to trigger autoload
           def load_all!
-            # Top-level serializers
-            Serializers::Base
-            Serializers::Admonition
-            Serializers::Attribute
-            Serializers::AttributeList
-            Serializers::AttributeListAttribute
-            Serializers::Audio
-            Serializers::Author
-            Serializers::Bibliography
-            Serializers::BibliographyEntry
-            Serializers::Break
-            Serializers::CommentBlock
-            Serializers::CommentLine
-            Serializers::Document
-            Serializers::DocumentAttributes
-            Serializers::Header
-            Serializers::Highlight
-            Serializers::Include
-            Serializers::LineBreak
-            Serializers::List
-            Serializers::NamedAttribute
-            Serializers::Paragraph
-            Serializers::ReviewerNote
-            Serializers::Revision
-            Serializers::Section
-            Serializers::Tag
-            Serializers::TableCell
-            Serializers::TableRow
-            Serializers::Table
-            Serializers::Term
-            Serializers::TextElement
-            Serializers::Title
-            Serializers::Video
-
-            # Block serializers
-            Serializers::Block
-            Serializers::Block::Core
-            Serializers::Block::Example
-            Serializers::Block::Listing
-            Serializers::Block::Literal
-            Serializers::Block::Open
-            Serializers::Block::Pass
-            Serializers::Block::Quote
-            Serializers::Block::ReviewerComment
-            Serializers::Block::Side
-            Serializers::Block::SourceCode
-
-            # Image serializers
-            Serializers::Image
-            Serializers::Image::Core
-
-            # Inline serializers
-            Serializers::Inline
-            Serializers::Inline::Anchor
-            Serializers::Inline::AttributeReference
-            Serializers::Inline::Bold
-            Serializers::Inline::CrossReference
-            Serializers::Inline::CrossReferenceArg
-            Serializers::Inline::Footnote
-            Serializers::Inline::HardLineBreak
-            Serializers::Inline::Highlight
-            Serializers::Inline::Italic
-            Serializers::Inline::Link
-            Serializers::Inline::Monospace
-            Serializers::Inline::Quotation
-            Serializers::Inline::Small
-            Serializers::Inline::Span
-            Serializers::Inline::Stem
-            Serializers::Inline::Strikethrough
-            Serializers::Inline::Subscript
-            Serializers::Inline::Superscript
-            Serializers::Inline::Underline
-
-            # List serializers
-            Serializers::List
-            Serializers::List::Core
-            Serializers::List::Definition
-            Serializers::List::DefinitionItem
-            Serializers::List::Item
-            Serializers::List::Ordered
-            Serializers::List::Unordered
-
+            Dir["#{__dir__}/serializers/**/*.rb"].sort.each { |path| require path }
             true
           end
-          # rubocop:enable Lint/Void
         end
 
-        # Auto-load all on module inclusion
         load_all!
       end
     end

data/lib/coradoc/asciidoc/serializer/serializers/inline/passthrough.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          # Serializer for the inline passthrough (`+++raw content+++`).
+          # Wraps the raw payload in triple-plus delimiters so downstream
+          # consumers know to skip inline substitution.
+          class Passthrough < Base
+            def to_adoc(model, _options = {})
+              content = serialize_content(model.content)
+              return '' if content.empty?
+
+              "+++#{content}+++"
+            end
+          end
+        end
+
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Passthrough, Inline::Passthrough)
+      end
+    end
+  end
+end

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

@@ -17,6 +17,7 @@ module Coradoc
           autoload :Italic, 'coradoc/asciidoc/serializer/serializers/inline/italic'
           autoload :Link, 'coradoc/asciidoc/serializer/serializers/inline/link'
           autoload :Monospace, 'coradoc/asciidoc/serializer/serializers/inline/monospace'
+          autoload :Passthrough, 'coradoc/asciidoc/serializer/serializers/inline/passthrough'
           autoload :Quotation, 'coradoc/asciidoc/serializer/serializers/inline/quotation'
           autoload :Small, 'coradoc/asciidoc/serializer/serializers/inline/small'
           autoload :Span, 'coradoc/asciidoc/serializer/serializers/inline/span'

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

@@ -26,6 +26,21 @@ module Coradoc
               BUILTIN.include?(name) || custom.include?(name)
             end
 
+            # Canonical uppercase form for +style+, or nil if unknown.
+            # Single source of truth for the canonical casing used in
+            # CoreModel::AnnotationBlock#annotation_type and AsciiDoc
+            # round-trip output.
+            def canonicalize(style)
+              return nil unless admonition?(style)
+
+              style.to_s.upcase
+            end
+
+            # All registered style names (BUILTIN + custom), lowercased.
+            def all_styles
+              (BUILTIN + custom).freeze
+            end
+
             # Register an additional admonition style. Open for extension.
             def register(style)
               name = style.to_s.downcase

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

@@ -71,16 +71,26 @@ module Coradoc
 
             # Dispatch entry point for any block whose AsciiDoc model carries
             # an attribute list (delimited blocks + open blocks). Per the
-            # AsciiDoc spec, every delimited block accepts admonition styles
-            # in its attribute line. Admonition style wins for example,
-            # sidebar, quote, and open blocks; verbatim blocks (source,
-            # listing) intentionally ignore it because their verbatim
-            # semantics are stronger than the annotation label.
+            # AsciiDoc spec, every delimited block accepts both admonition
+            # labels and verbatim/stem casts in its attribute line. The cast
+            # is resolved by +block_cast_semantic+ in MECE order:
+            # admonition > stem > verbatim > fallback.
             def transform_with_admonition_check(block, native_class)
-              style = first_positional_attr(block)
-              return transform_admonition_block(block, style) if AdmonitionStyles.admonition?(style)
-
-              transform_typed_block(block, native_class)
+              semantic = block_cast_semantic(block)
+              case semantic
+              when :admonition
+                transform_admonition_block(block, first_positional_attr(block))
+              when :stem
+                transform_stem_block(block, first_positional_attr(block))
+              when :source
+                transform_source_block(block)
+              when :listing
+                transform_listing_from_open(block)
+              when :literal
+                transform_literal_from_open(block)
+              else
+                transform_typed_block(block, native_class)
+              end
             end
 
             def transform_example_block(block)
@@ -98,36 +108,32 @@ module Coradoc
             # Open blocks (`--`) are generic containers. AsciiDoc allows
             # casting them to a different block type via positional
             # attributes: verbatim types (`[source]`, `[listing]`,
-            # `[literal]`) and admonition labels (`[NOTE]`, `[TIP]`,
+            # `[literal]`), STEM types (`[stem]`, `[latexmath]`,
+            # `[asciimath]`), and admonition labels (`[NOTE]`, `[TIP]`,
             # `[WARNING]`, `[CAUTION]`, `[IMPORTANT]`). When such a cast
             # is present, the block behaves like the corresponding
             # delimited block. Anything else stays an OpenBlock.
             def transform_open_block(block)
-              semantic = open_block_semantic(block)
-              case semantic
-              when :source
-                transform_source_block(block)
-              when :listing
-                transform_listing_from_open(block)
-              when :literal
-                transform_literal_from_open(block)
-              when :admonition
-                transform_admonition_block(block, first_positional_attr(block))
-              else
-                transform_typed_block(block, Coradoc::CoreModel::OpenBlock)
-              end
+              transform_with_admonition_check(block, Coradoc::CoreModel::OpenBlock)
             end
 
             VERBATILE_CAST_STYLES = %w[source listing literal].freeze
 
-            def open_block_semantic(block)
+            # Resolve a delimited block's cast from its first positional
+            # attribute. Single source of truth for the cast ladder used
+            # by every block-form transformer (example/sidebar/quote/open).
+            # Returns one of: :admonition, :stem, :source, :listing,
+            # :literal, or nil (no cast — use the block's native class).
+            def block_cast_semantic(block)
               style = first_positional_attr(block)
               return nil unless style
 
-              case style.to_s.downcase
-              when *VERBATILE_CAST_STYLES then :"#{style.downcase}"
-              else :admonition if AdmonitionStyles.admonition?(style)
-              end
+              style_str = style.to_s.downcase
+              return :admonition if AdmonitionStyles.admonition?(style)
+              return :stem if STEM_STYLES.key?(style_str)
+              return style_str.to_sym if VERBATILE_CAST_STYLES.include?(style_str)
+
+              nil
             end
 
             # Returns the first positional attribute on the block's
@@ -148,10 +154,14 @@ module Coradoc
             # (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.
             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: type.to_s.downcase,
+                annotation_type: canonical,
                 content: content_lines,
                 title: ToCoreModel.extract_title_text(block.title)
               )

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

@@ -13,6 +13,7 @@ module Coradoc
               children = CalloutMerger.call(children)
               children = prepend_frontmatter(children, doc.frontmatter)
               children = insert_title_heading_after_frontmatter(children, title_text)
+              children = resolve_attribute_references(children, attributes)
 
               Coradoc::CoreModel::DocumentElement.new(
                 id: doc.id,
@@ -58,6 +59,16 @@ module Coradoc
               children.insert(frontmatter_count, title_heading)
             end
 
+            # Resolve `{name}` attribute references in the body against the
+            # document's own declared attributes. Single source of truth:
+            # the resolver lives in core so other format gems can reuse it
+            # when they have equivalent reference macros.
+            def resolve_attribute_references(children, attributes)
+              return children if attributes.nil? || attributes.keys.empty?
+
+              Coradoc::CoreModel::AttributeReferenceResolver.call(children, attributes)
+            end
+
             def transform_section(section, parent_id: nil)
               title_text = ToCoreModel.extract_title_text(section.title)
               section_id = section.id || Coradoc::CoreModel::IdGenerator.generate_from_title(

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

@@ -67,20 +67,28 @@ module Coradoc
               )
               li.children = children
 
-              if item.nested.is_a?(Coradoc::AsciiDoc::Model::List::Core)
-                nested_core = transform_list(item.nested, list_marker_type(item.nested))
-                li.children << nested_core
-              elsif item.nested.is_a?(Array)
-                item.nested.each do |n|
-                  next unless n.is_a?(Coradoc::AsciiDoc::Model::List::Core)
-
-                  li.children << transform_list(n, list_marker_type(n))
-                end
-              end
-
+              nested_lists = extract_nested_lists(item)
+              li.nested_list = nested_lists.first if nested_lists.size == 1
               li
             end
 
+            # Pull every nested List::Core off the AsciiDoc model item and
+            # transform each into a CoreModel::ListBlock. Returns [] when
+            # the item has no nested lists. Single source of truth for the
+            # nested-list shape so transform_list_item and any future caller
+            # share the same extraction logic.
+            def extract_nested_lists(item)
+              nested = item.nested
+              return [] if nested.nil?
+
+              candidates = nested.is_a?(Array) ? nested : [nested]
+              candidates.filter_map do |n|
+                next unless n.is_a?(Coradoc::AsciiDoc::Model::List::Core)
+
+                transform_list(n, list_marker_type(n))
+              end
+            end
+
             def list_marker_type(list)
               case list
               when Coradoc::AsciiDoc::Model::List::Ordered then 'ordered'

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

@@ -15,9 +15,10 @@ module Coradoc
             end
 
             def transform_admonition(admonition)
+              canonical = Coradoc::AsciiDoc::Transform::ElementTransformers::AdmonitionStyles.canonicalize(admonition.type) || admonition.type.to_s
               children = ToCoreModel.transform_inline_content(admonition.content)
               block = Coradoc::CoreModel::AnnotationBlock.new(
-                annotation_type: admonition.type,
+                annotation_type: canonical,
                 content: ToCoreModel.extract_text_content(admonition.content)
               )
               block.children = children

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

@@ -5,8 +5,6 @@ module Coradoc
     module Transform
       # Transforms CoreModel to AsciiDoc models
       class FromCoreModel
-        include Coradoc::Transform::Base
-
         @registered = false
 
         class << self
@@ -319,6 +317,10 @@ module Coradoc
                 type: inline.stem_type || 'latexmath',
                 content: inline.content
               )
+            when 'raw_inline'
+              Coradoc::AsciiDoc::Model::Inline::Passthrough.new(content: inline.content)
+            when 'hard_line_break'
+              Coradoc::AsciiDoc::Model::Inline::HardLineBreak.new
             else
               Coradoc::AsciiDoc::Model::TextElement.new(content: inline.content)
             end
@@ -567,6 +569,8 @@ module Coradoc
             end
           end
         end
+
+        def transform(model) = self.class.transform(model)
       end
     end
   end

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

@@ -4,8 +4,6 @@ module Coradoc
   module AsciiDoc
     module Transform
       class ToCoreModel
-        include Coradoc::Transform::Base
-
         @registered = false
 
         class << self
@@ -133,6 +131,8 @@ module Coradoc
             text
           end
         end
+
+        def transform(model) = self.class.transform(model)
       end
     end
   end

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

@@ -172,9 +172,11 @@ module Coradoc
             Registry.register(
               Coradoc::AsciiDoc::Model::Inline::AttributeReference,
               lambda { |model|
+                name = model.name.to_s
                 Coradoc::CoreModel::InlineElement.new(
                   format_type: 'attribute_reference',
-                  content: "{#{model.name}}"
+                  target: name,
+                  content: "{#{name}}"
                 )
               }
             )
@@ -246,6 +248,16 @@ module Coradoc
               ->(model) { Inc.transform_include(model) }
             )
 
+            # Inline hard line break — distinct from the structural
+            # Model::LineBreak (which represents paragraph-separator blank
+            # lines and is dropped at the CoreModel boundary). Hard breaks
+            # are semantic and round-trip as CoreModel::HardLineBreakElement
+            # so HTML/Markdown renderers can map them to <br>.
+            Registry.register(
+              Coradoc::AsciiDoc::Model::Inline::HardLineBreak,
+              ->(_model) { Coradoc::CoreModel::HardLineBreakElement.new(content: '') }
+            )
+
             [
               Coradoc::AsciiDoc::Model::Audio,
               Coradoc::AsciiDoc::Model::Video,

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

@@ -37,12 +37,15 @@ module Coradoc
               Model::Block::Example.new(title: '', lines: example)
             end
 
-            # Admonition
+            # Admonition. Canonicalise the type to uppercase so round-trips
+            # through HTML/Markdown/DocBook all see the same key used by
+            # icon and CSS-class lookups.
             rule(
               admonition_type: simple(:admonition_type),
               content: sequence(:content)
             ) do
-              Model::Admonition.new(content: content, type: admonition_type.to_s)
+              canonical = Coradoc::AsciiDoc::Transform::ElementTransformers::AdmonitionStyles.canonicalize(admonition_type.to_s)
+              Model::Admonition.new(content: content, type: canonical)
             end
 
             # Block image

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

@@ -36,14 +36,17 @@ module Coradoc
 
             # Inline image
             rule(inline_image: subtree(:inline_image)) do
+              attrs = AttributeListNormalizer.coerce(inline_image[:attribute_list])
               Model::Image::InlineImage.new(
-                title: inline_image[:text],
                 src: inline_image[:path],
-                attributes: inline_image[:attribute_list]
+                attributes: attrs
               )
             end
 
-            # Inline passthrough (`+++raw content+++`)
+            # Inline passthrough (`+++raw content+++` or `pass:[raw]`).
+            # Both forms carry an opaque payload that survives all
+            # substitutions verbatim; `form` records which syntax was
+            # used so the AsciiDoc serializer can round-trip faithfully.
             rule(inline_passthrough: subtree(:passthrough)) do
               Model::Inline::Passthrough.new(
                 content: passthrough[:raw].to_s,
@@ -56,6 +59,15 @@ module Coradoc
               Model::Inline::AttributeReference.new(name:)
             end
 
+            # Hard line break (` +\n` or `\\n`). Emitted as a dedicated
+            # AsciiDoc model (Inline::HardLineBreak) distinct from
+            # Model::LineBreak, which only represents paragraph-separator
+            # blank lines. Hard breaks carry semantic meaning: HTML/Markdown
+            # renderers map them to <br>.
+            rule(hard_line_break: simple(:_)) do
+              Model::Inline::HardLineBreak.new
+            end
+
             # Term
             rule(
               term_type: simple(:term_type),

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

@@ -20,12 +20,24 @@ module Coradoc
           cell_opts = {}
           style = parse_format(format, cell_opts)
 
-          unescaped_content = content.to_s.gsub(/\\([|!,:;])/, '\1')
+          unescaped_content = cell_content_to_string(content).gsub(/\\([|!,:;])/, '\1')
           cell_opts[:content] = parse_inline_content(unescaped_content, style)
 
           Model::TableCell.new(**cell_opts)
         end
 
+        # Coerce the parser-supplied cell content into a plain String.
+        # The cell parser emits `text:` as either a single Parslet::Slice
+        # or an Array of slices (from `.repeat(0)`). An empty Array must
+        # map to "" — Ruby's `[].to_s` returns "[]", which previously
+        # leaked into TableCell content as a phantom "[]" cell.
+        def cell_content_to_string(content)
+          return '' if content.nil?
+          return content.map(&:to_s).join if content.is_a?(Array)
+
+          content.to_s
+        end
+
         # Coerce a raw parser cell value into a TableCell.
         # Used by TableLayout.group_cells_into_rows when it encounters
         # cells that the parser emitted as Hashes or plain strings.

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.20'
+    VERSION = '2.0.22'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.20
+  version: 2.0.22
 platform: ruby
 authors:
 - Ribose Inc.
@@ -283,6 +283,7 @@ files:
 - lib/coradoc/asciidoc/serializer/serializers/inline/italic.rb
 - lib/coradoc/asciidoc/serializer/serializers/inline/link.rb
 - lib/coradoc/asciidoc/serializer/serializers/inline/monospace.rb
+- lib/coradoc/asciidoc/serializer/serializers/inline/passthrough.rb
 - lib/coradoc/asciidoc/serializer/serializers/inline/quotation.rb
 - lib/coradoc/asciidoc/serializer/serializers/inline/small.rb
 - lib/coradoc/asciidoc/serializer/serializers/inline/span.rb