coradoc-adoc 2.0.19 → 2.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 817eba65c55a5dea765ab8e80ee5542a1353741659c8a32ef4eb80e39f052dcb
-  data.tar.gz: 25a07bc63696b7ba27933c9724c0a5ada466dc7cd0f37350ae4c9a4a475afbec
+  metadata.gz: 1c4b5749f4fd1a691eb76fe9f7848b1d4bc2cd2e43cd2ee0a5f1afdcb697459c
+  data.tar.gz: 90e6bf66da9a7c4dba7c7eafbdabf378259e4b9792a93d4c88209d52bd991876
 SHA512:
-  metadata.gz: c3d26bcc8f91f799f455f051109933875545219b14e9556cc4d5774dcda16e9abdcb1f0e6a090f1d9aea35c49d4d7f5ed8c6bae2b1e47a76cc75a86270e47cd7
-  data.tar.gz: 50a575b3666d1d6df0a8813a9761345ced5d895b2c73bf80347d8fb24e36c396389d4901fa22a6f34e1adcea6cb4d5b697bdab121dc495603da88740753e821d
+  metadata.gz: e421d05a3a2c43387471224818a5261229478c1539ddade33a30957be8d7fb0775c9b0bb95b59afa32cb4e84f0adab07b62164113a521635fd5e70cdbe66ecec
+  data.tar.gz: dd6c2ea15fcb4c3e521a929006ba2e7ebbff5f6548902a2d7947cdac04a9005a792a9ae4fb07d68f53e30c844de9cbd00bd62a0fa034fa9f9c298209fe50ec7e

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

@@ -105,12 +105,24 @@ module Coradoc
         end
 
         def block_content(n_deep = 3)
-          c = block_image
+          block_container_content(n_deep).repeat(1)
+        end
+
+        # Single source of truth for "what can appear inside a non-verbatim
+        # block container". Used by block_content, block_style (non-verbatim
+        # branch), and block_style_exact (non-verbatim branch).
+        #
+        # `table` is listed before `text_line` so a leading `|===` is parsed
+        # as a table rather than mis-bracketed as text. The recursive `block`
+        # alternative handles every other delimited block.
+        def block_container_content(n_deep)
+          c = table.as(:table)
+          c |= block_image
           c |= block(n_deep - 1) if n_deep.positive?
           c |= list
           c |= text_line(false, unguarded: true)
           c |= empty_line.as(:line_break)
-          c.repeat(1)
+          c
         end
 
         # Block delimiter: 4+ identical characters, or 2 dashes for open
@@ -155,12 +167,7 @@ module Coradoc
                         text_line(false, unguarded: true, verbatim: true) |
                           empty_line.as(:line_break)
                       else
-                        c = block_image
-                        c |= block(n_deep - 1) if n_deep.positive?
-                        c |= list
-                        c |= text_line(false, unguarded: true)
-                        c |= empty_line.as(:line_break)
-                        c
+                        block_container_content(n_deep)
                       end
 
             (closing_pattern.absent? >> content).repeat(1)
@@ -213,12 +220,7 @@ module Coradoc
                         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
+                        block_container_content(n_deep)
                       end
 
             (closing_pattern.absent? >> content).repeat(1)

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        # Admonition style registry. Single source of truth for "which
+        # positional attribute names map to an admonition block."
+        #
+        # Built-in AsciiDoc admonition styles are always recognized. Callers
+        # can register additional styles (e.g. +DANGER+, +SAFETY+) without
+        # modifying dispatch code — the registry is consulted by every
+        # block-form transformer that needs to decide between an admonition
+        # and the block's native type.
+        module AdmonitionStyles
+          BUILTIN = %w[note tip warning caution important editor todo].freeze
+
+          @custom = []
+
+          class << self
+            # True if +style+ (case-insensitive) is a known admonition style.
+            def admonition?(style)
+              return false if style.nil?
+
+              name = style.to_s.downcase
+              BUILTIN.include?(name) || custom.include?(name)
+            end
+
+            # Register an additional admonition style. Open for extension.
+            def register(style)
+              name = style.to_s.downcase
+              @custom << name unless @custom.include?(name) || BUILTIN.include?(name)
+              self
+            end
+
+            # Reset custom registrations. Intended for specs.
+            def reset!
+              @custom = []
+              self
+            end
+
+            def custom
+              @custom.dup
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module Coradoc
             # 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)
+            def transform_verbatim_block(block, klass, language_override: nil)
               non_break_lines = Array(block.lines).reject do |line|
                 line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
                   line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
@@ -34,7 +34,7 @@ module Coradoc
                 id: block.id,
                 title: ToCoreModel.extract_title_text(block.title),
                 content: content_lines,
-                language: ToCoreModel.extract_block_language(block)
+                language: language_override || ToCoreModel.extract_block_language(block)
               )
             end
 
@@ -47,9 +47,54 @@ module Coradoc
             end
 
             def transform_pass_block(block)
+              style = first_positional_attr(block)
+              return transform_stem_block(block, style) if STEM_STYLES.key?(style.to_s.downcase)
+
               transform_verbatim_block(block, Coradoc::CoreModel::PassBlock)
             end
 
+            # AsciiDoc recognizes three STEM block styles. The default
+            # `[stem]` resolves to LaTeX; the other two name their
+            # interpreter explicitly. Single source of truth for the
+            # style→language mapping.
+            STEM_STYLES = {
+              'stem' => 'latex',
+              'latexmath' => 'latex',
+              'asciimath' => 'asciimath'
+            }.freeze
+
+            def transform_stem_block(block, style)
+              language = STEM_STYLES.fetch(style.to_s.downcase, 'latex')
+              transform_verbatim_block(block, Coradoc::CoreModel::StemBlock,
+                                       language_override: language)
+            end
+
+            # 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.
+            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)
+            end
+
+            def transform_example_block(block)
+              transform_with_admonition_check(block, Coradoc::CoreModel::ExampleBlock)
+            end
+
+            def transform_sidebar_block(block)
+              transform_with_admonition_check(block, Coradoc::CoreModel::SidebarBlock)
+            end
+
+            def transform_quote_block(block)
+              transform_with_admonition_check(block, Coradoc::CoreModel::QuoteBlock)
+            end
+
             # Open blocks (`--`) are generic containers. AsciiDoc allows
             # casting them to a different block type via positional
             # attributes: verbatim types (`[source]`, `[listing]`,
@@ -60,41 +105,53 @@ module Coradoc
             def transform_open_block(block)
               semantic = open_block_semantic(block)
               case semantic
-              when :source_code
+              when :source
                 transform_source_block(block)
               when :listing
                 transform_listing_from_open(block)
               when :literal
                 transform_literal_from_open(block)
               when :admonition
-                transform_admonition_from_open(block)
+                transform_admonition_block(block, first_positional_attr(block))
               else
                 transform_typed_block(block, Coradoc::CoreModel::OpenBlock)
               end
             end
 
-            ADMONITION_TYPES = %w[note tip warning caution important].freeze
+            VERBATILE_CAST_STYLES = %w[source listing literal].freeze
 
             def open_block_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
+            end
+
+            # Returns the first positional attribute on the block's
+            # attribute list as a String, or nil if absent. Centralizes the
+            # shape-walking that was previously inlined in
+            # `transform_admonition_from_open` and `open_block_semantic`.
+            def first_positional_attr(block)
               attrs = block.attributes
               return nil unless attrs.is_a?(Coradoc::AsciiDoc::Model::AttributeList)
 
               first = attrs.positional&.first
               return nil unless first.is_a?(Coradoc::AsciiDoc::Model::AttributeListAttribute)
 
-              case first.value.to_s.downcase
-              when 'source' then :source_code
-              when 'listing' then :listing
-              when 'literal' then :literal
-              when *ADMONITION_TYPES then :admonition
-              end
+              first.value.to_s
             end
 
-            def transform_admonition_from_open(block)
-              type = block.attributes.positional.first.value.to_s.downcase
+            # 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.
+            def transform_admonition_block(block, type)
               content_lines = Array(block.lines).map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
               Coradoc::CoreModel::AnnotationBlock.new(
-                annotation_type: type,
+                annotation_type: type.to_s.downcase,
                 content: content_lines,
                 title: ToCoreModel.extract_title_text(block.title)
               )

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

@@ -12,6 +12,7 @@ module Coradoc
               children = ToCoreModel.transform(doc.sections || doc.contents || [])
               children = CalloutMerger.call(children)
               children = prepend_frontmatter(children, doc.frontmatter)
+              children = insert_title_heading_after_frontmatter(children, title_text)
 
               Coradoc::CoreModel::DocumentElement.new(
                 id: doc.id,
@@ -32,6 +33,31 @@ module Coradoc
               [block, *children]
             end
 
+            # Per the AsciiDoc spec, the document title (`= Title`) is the
+            # document's level-0 heading. Asciidoctor renders it as an
+            # <h1> at the top of the body by default. Emit a HeaderElement
+            # at level 0 so consumers that walk the body's children see the
+            # title (the standard ProseMirror/HTML rendering pattern)
+            # instead of having to read Document.title separately.
+            #
+            # The title attribute on DocumentElement is preserved for
+            # consumers that read it directly. The title heading is placed
+            # after any FrontmatterBlock (frontmatter is metadata that
+            # precedes the body).
+            def insert_title_heading_after_frontmatter(children, title_text)
+              return children if title_text.nil? || title_text.strip.empty?
+
+              title_heading = Coradoc::CoreModel::HeaderElement.new(
+                level: 0,
+                title: title_text,
+                content: title_text
+              )
+              frontmatter_count = children.count do |child|
+                child.is_a?(Coradoc::CoreModel::FrontmatterBlock)
+              end
+              children.insert(frontmatter_count, title_heading)
+            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.rb

@@ -11,6 +11,7 @@ module Coradoc
         autoload :TableTransformer, "#{__dir__}/element_transformers/table_transformer"
         autoload :OtherTransformer, "#{__dir__}/element_transformers/other_transformer"
         autoload :IncludeTransformer, "#{__dir__}/element_transformers/include_transformer"
+        autoload :AdmonitionStyles, "#{__dir__}/element_transformers/admonition_styles"
       end
     end
   end

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
@@ -40,12 +38,18 @@ module Coradoc
                          Coradoc::AsciiDoc::Model::Header.new(title: '')
                        end
 
-              sections, frontmatter = extract_frontmatter(Array(element.children))
+              # Pull FrontmatterBlock out first so strip_title_heading sees
+              # the body children in their natural order (frontmatter →
+              # title heading → body). The reverse-direction strip then
+              # matches on a level-0 HeaderElement wherever it sits among
+              # the remaining children.
+              without_frontmatter, frontmatter = extract_frontmatter(Array(element.children))
+              without_title = strip_title_heading(without_frontmatter, element.title)
 
               Coradoc::AsciiDoc::Model::Document.new(
                 id: element.id,
                 header: header,
-                sections: flatten_children(sections),
+                sections: flatten_children(without_title),
                 frontmatter: frontmatter
               )
             when CoreModel::SectionElement
@@ -64,6 +68,27 @@ module Coradoc
             end
           end
 
+          # The forward direction (DocumentTransformer#insert_title_heading_after_frontmatter)
+          # emits a level-0 HeaderElement after any FrontmatterBlock so
+          # consumers that walk the children see the title. On the reverse
+          # path, that HeaderElement would round-trip back as a separate
+          # body element and the title would be emitted twice (once via
+          # the document header, once via the heading child). Drop it
+          # before serialization when it carries the same text as the
+          # document title.
+          def strip_title_heading(children, document_title)
+            return children unless document_title && !document_title.strip.empty?
+
+            index = children.find_index do |child|
+              child.is_a?(CoreModel::HeaderElement) &&
+                child.level.to_i.zero? &&
+                child.title.to_s == document_title.to_s
+            end
+            return children unless index
+
+            children.reject.with_index { |_, i| i == index }
+          end
+
           # Transforms each CoreModel child and flattens one level so a
           # transform that returns multiple siblings (e.g. a source block
           # followed by its re-expanded callout paragraphs) stays in
@@ -292,6 +317,8 @@ module Coradoc
                 type: inline.stem_type || 'latexmath',
                 content: inline.content
               )
+            when 'raw_inline'
+              Coradoc::AsciiDoc::Model::Inline::Passthrough.new(content: inline.content)
             else
               Coradoc::AsciiDoc::Model::TextElement.new(content: inline.content)
             end
@@ -540,6 +567,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

@@ -48,14 +48,19 @@ module Coradoc
               priority: 10
             )
 
+            # Quote / Example / Sidebar blocks all share the same dispatch:
+            # check the attribute style for an admonition label first
+            # (`[NOTE]\n====` → AnnotationBlock), fall back to the block's
+            # native CoreModel type. Single source of truth lives in
+            # BlockTransformer#transform_with_admonition_check.
             {
-              Coradoc::AsciiDoc::Model::Block::Quote => Coradoc::CoreModel::QuoteBlock,
-              Coradoc::AsciiDoc::Model::Block::Example => Coradoc::CoreModel::ExampleBlock,
-              Coradoc::AsciiDoc::Model::Block::Side => Coradoc::CoreModel::SidebarBlock
-            }.each do |block_class, core_model_class|
+              Coradoc::AsciiDoc::Model::Block::Quote => :transform_quote_block,
+              Coradoc::AsciiDoc::Model::Block::Example => :transform_example_block,
+              Coradoc::AsciiDoc::Model::Block::Side => :transform_sidebar_block
+            }.each do |block_class, method|
               Registry.register_with_priority(
                 block_class,
-                ->(model) { Blk.transform_typed_block(model, core_model_class) },
+                ->(model) { Blk.public_send(method, model) },
                 priority: 10
               )
             end

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.19'
+    VERSION = '2.0.21'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.19
+  version: 2.0.21
 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
@@ -317,6 +318,7 @@ files:
 - 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/admonition_styles.rb
 - lib/coradoc/asciidoc/transform/element_transformers/block_transformer.rb
 - lib/coradoc/asciidoc/transform/element_transformers/document_transformer.rb
 - lib/coradoc/asciidoc/transform/element_transformers/include_transformer.rb