coradoc-adoc 2.0.22 → 2.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42db73896b69e9e5344105625afe528bd2b7b8f57a11822f61881e782be8b974
-  data.tar.gz: bc3e5e3073992f0d2b71e12ab62fa07d11cdf6ded25299d673f863522cd6291d
+  metadata.gz: d135f788f7205a03a242f7d1e9242b84fdc76994f6eff372579db29c9c420d51
+  data.tar.gz: 6eafdb8eb6a101650e48e6a29d5e719f729d8c7888c506a5e67a33511640db2f
 SHA512:
-  metadata.gz: 334c5ae5f1860ccde94bb518e8bc7f91be7dcce338d863d93ec137acbfedce8f742be44336fde3e4cec7ea6709b3f309c484c716ceb8c485da2830312515d59e
-  data.tar.gz: 3f387aab6c8b6d8862319593b9c2b8c2304758c4c66f15aed0e5ac57209f2f35b4930d1d95a57b2cf4d940834599db35395546c81b8d7760384062d0a7a48d49
+  metadata.gz: cfe57d959c7d69cf47aadb30526cd826ac85720d1f3f4426c4f6fc4d769c2618ad2c31cd713e3b86b4480f79fdf41d473457623c145746eb7fc25155c47b2dfc
+  data.tar.gz: 07dcf6099269006d16c34a21f5ca9457227fe9e7fcd597607716511ddecf7a3a1b7d794d5f32a29c6542a4b4f93ced0f61b37ae7e06553d775a0068ad4f7f363

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

@@ -87,6 +87,20 @@ module Coradoc
           )
         end
 
+        # Remove the first named attribute matching `name` and return its
+        # scalar value (or nil if absent). Used by promoters that lift a
+        # named attr out of the residual bag into a typed field.
+        # @param name [String, Symbol]
+        # @return [String, nil]
+        def delete_named(name)
+          name_str = name.to_s
+          idx = named.index { |n| n.name.to_s == name_str }
+          return nil unless idx
+
+          removed = @named.delete_at(idx)
+          removed.value.first&.to_s
+        end
+
         # Validate named attributes against validators
         #
         # @param validators [Hash] Hash of name => matcher pairs
@@ -209,12 +223,24 @@ module Coradoc
           positional.empty? && named.empty?
         end
 
-        # Get a named attribute value by name
+        # Get the scalar value of the first named attribute matching `name`.
+        # Returns the first element of the underlying multi-value array, or
+        # nil if the name is absent. Use {#fetch_all} to retrieve the full
+        # multi-value array.
         # @param name [String, Symbol] The attribute name
-        # @return [Object, nil] The attribute value or nil if not found
+        # @return [String, nil]
         def [](name)
           name_str = name.to_s
-          named.find { |n| n.name.to_s == name_str }&.value
+          named.find { |n| n.name.to_s == name_str }&.value&.first&.to_s
+        end
+
+        # Get the full multi-value array for a named attribute.
+        # @param name [String, Symbol]
+        # @return [Array<String>] (empty when absent)
+        def fetch_all(name)
+          name_str = name.to_s
+          found = named.find { |n| n.name.to_s == name_str }
+          found ? found.value : []
         end
 
         # Get a named attribute value with default
@@ -222,7 +248,8 @@ module Coradoc
         # @param default [Object] The default value if not found
         # @return [Object] The attribute value or default
         def fetch(name, default = nil)
-          self[name] || default
+          value = self[name]
+          value.nil? ? default : value
         end
       end
     end

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

@@ -35,6 +35,13 @@ module Coradoc
 
         attribute :id, :string
 
+        # 1-indexed source line where this element begins, when known.
+        # Populated by the Parslet transformer from the matched Slice's
+        # line_and_column. nil for programmatically constructed models.
+        # Single source of truth for source-position propagation through
+        # AsciiDoc::Model → CoreModel (Issue 1, STATUS-2026-06-28).
+        attribute :source_line, :integer
+
         # Element classification for spacing and serialization decisions.
         # Subclasses override these to declare their level.
         def block_level?

data/lib/coradoc/asciidoc/model/image/attribute_extractor.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Model
+      module Image
+        # Pure-function promoter: lifts semantically meaningful slots out of
+        # a generic {Model::AttributeList} into the typed fields declared on
+        # an image class, and the inverse — composes a serialisable
+        # AttributeList from typed fields + residual.
+        #
+        # The promotion map is owned by the target class itself, via
+        # +promoted_positional+ and +promoted_named+. This module is the
+        # single place that consumes those declarations, so adding a new
+        # promoted field is a one-line class-level change (OCP).
+        #
+        # Positional slots are consumed by index; named slots are removed
+        # from the residual list so they don't appear twice. The residual
+        # list preserves order and identity for everything that wasn't
+        # promoted (e.g. +scaledwidth+, +pdfwidth+, +opts+).
+        #
+        # @example Extract for an inline image
+        #   list = Model::AttributeList.new
+        #   list.add_positional('Alt', 'Thumb')
+        #   list.add_named('width', '640')
+        #   extracted, residual = AttributeExtractor.call(list, InlineImage)
+        #   extracted  # => { alt: 'Alt', role: 'Thumb', width: '640' }
+        #   residual.positional   # => []
+        #   residual.named         # => []
+        #
+        # @example Compose for serialisation
+        #   AttributeExtractor.compose(image)
+        #   # => Model::AttributeList with positional [alt, role] + named
+        #   #    [width, height, link] + residual attrs, in declaration order
+        #
+        module AttributeExtractor
+          module_function
+
+          # @param attribute_list [Model::AttributeList, nil]
+          # @param target_class [Class] an Image::Core subclass
+          # @return [Array<(Hash{Symbol=>String}, Model::AttributeList)>]
+          #   a tuple of promoted typed values and the residual list
+          def call(attribute_list, target_class)
+            source = attribute_list || Model::AttributeList.new
+            residual = Model::AttributeList.new
+            extracted = {}
+
+            promote_positional(extracted, residual, source, target_class)
+            promote_named(extracted, residual, source, target_class)
+
+            [extracted, residual]
+          end
+
+          # Inverse of {call}: rebuild a serialisable AttributeList from a
+          # model's typed fields plus its residual list. Used by the AsciiDoc
+          # image serializer so round-trips reproduce the original syntax.
+          #
+          # A field that's declared in both +promoted_positional+ and
+          # +promoted_named+ (e.g. inline image +role+) is emitted only
+          # once — via its positional slot when filled, otherwise via named.
+          # @param model [Coradoc::AsciiDoc::Model::Image::Core]
+          # @return [Model::AttributeList]
+          def compose(model)
+            composed = Model::AttributeList.new
+            filled = compose_positional(composed, model)
+            compose_named(composed, model, filled)
+            append_residual(composed, model.attributes)
+            composed
+          end
+
+          def compose_positional(composed, model)
+            filled = []
+            model.class.promoted_positional.each do |attr_name|
+              value = model.public_send(attr_name)
+              next if value.nil? || value.to_s.empty?
+
+              composed.add_positional(value.to_s)
+              filled << attr_name
+            end
+            filled
+          end
+
+          def compose_named(composed, model, filled)
+            model.class.promoted_named.each do |attr_name|
+              next if filled.include?(attr_name)
+
+              value = model.public_send(attr_name)
+              next if value.nil? || value.to_s.empty?
+
+              composed.add_named(attr_name.to_s, value.to_s)
+            end
+          end
+
+          def promote_positional(extracted, residual, source, target_class)
+            promoted = target_class.promoted_positional
+            source.positional.each_with_index do |positional_attr, index|
+              attr_name = promoted[index]
+              value = positional_attr.value
+              if attr_name && !value.to_s.empty?
+                extracted[attr_name] = value.to_s
+              else
+                residual.add_positional(value)
+              end
+            end
+          end
+
+          def promote_named(extracted, residual, source, target_class)
+            promoted_names = target_class.promoted_named.to_set(&:to_s)
+            source.named.each do |named_attr|
+              promote_one_named(extracted, residual, named_attr, promoted_names)
+            end
+          end
+
+          def promote_one_named(extracted, residual, named_attr, promoted_names)
+            name_str = named_attr.name.to_s
+            unless promoted_names.include?(name_str)
+              residual.add_named(named_attr.name, named_attr.value)
+              return
+            end
+            # Positional promotion wins: a slot already filled positionally
+            # is not overwritten by a same-named entry (rare, but possible
+            # when both `[alt, role, role=X]` are supplied).
+            key = name_str.to_sym
+            return if extracted.key?(key)
+
+            value = named_attr.value.first&.to_s
+            return if value.nil? || value.empty?
+
+            extracted[key] = value
+          end
+
+          def append_residual(composed, residual)
+            return unless residual.is_a?(Model::AttributeList)
+
+            residual.positional.each { |p| composed.add_positional(p.value) }
+            residual.named.each { |n| composed.add_named(n.name, n.value) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/model/image/block_image.rb

@@ -18,6 +18,14 @@ module Coradoc
                     default: lambda {
                       ::Coradoc::AsciiDoc::Model::AttributeList.new
                     }
+
+          # Block images support the legacy positional form
+          # `image::target[alt, caption, role, ...]`, so the 2nd positional
+          # is promoted to `caption` (Asciidoctor image block macro shorthand).
+          # @return [Array<Symbol>]
+          def self.promoted_positional
+            %i[alt caption]
+          end
         end
       end
     end

data/lib/coradoc/asciidoc/model/image/core.rb

@@ -9,30 +9,21 @@ module Coradoc
         # Images can be block-level (standalone paragraphs) or inline (within text).
         # This base class provides common functionality for both types.
         #
-        # @!attribute [r] id
-        #   @return [String, nil] Optional identifier for the image
+        # Typed promotion of attribute-list slots
+        # ---------------------------------------
         #
-        # @!attribute [r] title
-        #   @return [String, nil] Optional image title/alt text
-        #
-        # @!attribute [r] src
-        #   @return [String] The image source URL or path
-        #
-        # @!attribute [r] attributes
-        #   @return [Coradoc::AsciiDoc::Model::Image::Core::AttributeList] Image-specific attributes
-        #
-        # @!attribute [r] annotate_missing
-        #   @return [String, nil] Annotation text for missing images
-        #
-        # @!attribute [r] line_break
-        #   @return [String] Line break character (default: "")
-        #
-        # @!attribute [r] colons
-        #   @return [String, nil] Colon positioning for attributes
-        #
-        # @see Coradoc::AsciiDoc::Model::Image::BlockImage Block-level images
-        # @see Coradoc::AsciiDoc::Model::Image::InlineImage Inline images
+        # Semantically meaningful image attributes (`alt`, `role`, `width`,
+        # `height`, `link`) are declared as typed lutaml-model fields on
+        # `Core` itself — not as validators on a generic bag. The class-level
+        # {promoted_positional} and {promoted_named} methods are the single
+        # source of truth for which slots get lifted into typed fields and in
+        # what order; subclasses override them to reflect syntax differences
+        # (e.g. inline images treat the 2nd positional as `role`, block images
+        # do not).
         #
+        # The lift itself is performed by {AttributeExtractor}, a pure function
+        # over (AttributeList, target_class) → (extracted_hash, residual_list).
+        # Anything not promoted stays in `attributes` for round-trip fidelity.
         class Core < Coradoc::AsciiDoc::Model::Base
           # Autoload nested AttributeList class
           autoload :AttributeList, 'coradoc/asciidoc/model/image/core/attribute_list'
@@ -42,6 +33,12 @@ module Coradoc
           attribute :id, :string
           attribute :title, :string
           attribute :src, :string
+          attribute :alt, :string
+          attribute :caption, :string
+          attribute :role, :string
+          attribute :width, :string
+          attribute :height, :string
+          attribute :link, :string
           attribute :attributes,
                     Coradoc::AsciiDoc::Model::Image::Core::AttributeList,
                     default: lambda {
@@ -51,17 +48,29 @@ module Coradoc
           attribute :line_break, :string, default: -> { '' }
           attribute :colons, :string
 
-          # Aliases for common attribute accessors
           alias path src
-          alias alt title
+
+          # Positional attribute-list slots that this image class promotes to
+          # typed fields, in order. Subclasses override to reflect their
+          # syntax. Index 0 → alt for all image kinds; index 1 → role for
+          # inline images only.
+          # @return [Array<Symbol>]
+          def self.promoted_positional
+            %i[alt]
+          end
+
+          # Named attribute-list keys that this image class promotes to typed
+          # fields. The same set applies to both inline and block images.
+          # @return [Array<Symbol>]
+          def self.promoted_named
+            %i[width height link role]
+          end
 
           # Custom to_adoc implementation that uses ElementRegistry directly
           # to avoid recursion issues with image serialization.
           #
           # @return [String] AsciiDoc representation of this image
           def to_adoc
-            # Use the registered serializer rather than Coradoc::AsciiDoc::Serializer.serialize
-            # to avoid recursion
             serializer_class = Coradoc::AsciiDoc::Serializer::ElementRegistry.lookup(self.class)
             serializer_class.new.to_adoc(self)
           end

data/lib/coradoc/asciidoc/model/image/inline_image.rb

@@ -10,6 +10,13 @@ module Coradoc
           end
 
           attribute :colons, :string, default: -> { ':' }
+
+          # Inline images use the 2nd positional slot for the role, per
+          # Asciidoctor: `image:target[alt, role, width=N, ...]`.
+          # @return [Array<Symbol>]
+          def self.promoted_positional
+            %i[alt role]
+          end
         end
       end
     end

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

@@ -8,6 +8,7 @@ module Coradoc
         autoload :Core, 'coradoc/asciidoc/model/image/core'
         autoload :InlineImage, 'coradoc/asciidoc/model/image/inline_image'
         autoload :BlockImage, 'coradoc/asciidoc/model/image/block_image'
+        autoload :AttributeExtractor, 'coradoc/asciidoc/model/image/attribute_extractor'
       end
     end
   end

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

@@ -44,7 +44,10 @@ module Coradoc
         end
 
         def positional_value_unquoted
-          match('[^\],]').repeat(1)
+          # Exclude `=` so that `key=value` is matched by `named_attribute`
+          # rather than swallowed as a single positional token. A positional
+          # value that legitimately contains `=` must be quoted.
+          match('[^\],=]').repeat(1)
         end
 
         def positional_value_single_quote

data/lib/coradoc/asciidoc/serializer/serializers/image/core.rb

@@ -14,7 +14,8 @@ module Coradoc
                         end
               _anchor = model.anchor.nil? ? '' : "#{serialize_child(model.anchor)}\n"
               _title = model.title.to_s.empty? ? '' : ".#{model.title}\n"
-              attrs = serialize_child(model.attributes, options)
+              composed = Model::Image::AttributeExtractor.compose(model)
+              attrs = serialize_child(composed, options)
               [missing, _anchor, _title, 'image', model.colons, model.src, attrs,
                model.line_break].join
             end
@@ -24,6 +25,7 @@ module Coradoc
         # Self-register this serializer
         ElementRegistry.register(Coradoc::AsciiDoc::Model::Image::Core, Image::Core)
         ElementRegistry.register(Coradoc::AsciiDoc::Model::Image::BlockImage, Image::Core)
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Image::InlineImage, Image::Core)
       end
     end
   end

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

@@ -13,7 +13,12 @@ module Coradoc
         # 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
+          # Generic `[admonition]` (capitalized as ADMONITION by
+          # +canonicalize+) is the spec-defined generic admonition style.
+          # It is rarely used directly but exists in the AsciiDoc spec;
+          # treating it as a real admonition prevents it from collapsing
+          # to an ExampleBlock when applied to a delimited block.
+          BUILTIN = %w[note tip warning caution important editor todo admonition].freeze
 
           @custom = []
 

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

@@ -8,10 +8,13 @@ module Coradoc
           class << self
             def transform_paragraph(para)
               children = ToCoreModel.transform_inline_content(para.content)
+              source_lines = ToCoreModel.extract_source_lines(para.content)
 
               Coradoc::CoreModel::ParagraphBlock.new(
                 id: para.id,
                 content: ToCoreModel.extract_text_content(para.content),
+                lines: source_lines,
+                source_line: para.source_line,
                 children: children
               )
             end
@@ -22,19 +25,15 @@ module Coradoc
             # 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, 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)
-              end
-              content_lines = non_break_lines.map do |line|
-                ToCoreModel.extract_text_content(line)
-              end.join("\n")
+              source_lines = ToCoreModel.extract_source_lines(block.lines)
 
               klass.new(
                 id: block.id,
                 title: ToCoreModel.extract_title_text(block.title),
-                content: content_lines,
-                language: language_override || ToCoreModel.extract_block_language(block)
+                content: source_lines.join("\n"),
+                lines: source_lines,
+                language: language_override || ToCoreModel.extract_block_language(block),
+                source_line: block.source_line
               )
             end
 
@@ -74,7 +73,7 @@ module Coradoc
             # 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.
+            # admonition > stem > verbatim > typed-cast > fallback.
             def transform_with_admonition_check(block, native_class)
               semantic = block_cast_semantic(block)
               case semantic
@@ -88,6 +87,9 @@ module Coradoc
                 transform_listing_from_open(block)
               when :literal
                 transform_literal_from_open(block)
+              when :typed_cast
+                style = first_positional_attr(block).to_s.downcase
+                transform_typed_block(block, TYPED_BLOCK_CAST_STYLES.fetch(style))
               else
                 transform_typed_block(block, native_class)
               end
@@ -119,11 +121,25 @@ module Coradoc
 
             VERBATILE_CAST_STYLES = %w[source listing literal].freeze
 
+            # Positional style → typed CoreModel class for blocks whose
+            # attribute line casts an open block into a richer semantic
+            # type (e.g. `[sidebar]\n--\n...\n--`). Single source of
+            # truth: adding a new style cast is one line here, no edits
+            # to dispatch (OCP).
+            TYPED_BLOCK_CAST_STYLES = {
+              'sidebar' => Coradoc::CoreModel::SidebarBlock,
+              'example' => Coradoc::CoreModel::ExampleBlock,
+              'quote' => Coradoc::CoreModel::QuoteBlock,
+              'abstract' => Coradoc::CoreModel::AbstractBlock,
+              'partintro' => Coradoc::CoreModel::PartintroBlock
+            }.freeze
+
             # 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).
+            # :literal, :typed_cast, or nil (no cast — use the block's
+            # native class).
             def block_cast_semantic(block)
               style = first_positional_attr(block)
               return nil unless style
@@ -131,6 +147,7 @@ module Coradoc
               style_str = style.to_s.downcase
               return :admonition if AdmonitionStyles.admonition?(style)
               return :stem if STEM_STYLES.key?(style_str)
+              return :typed_cast if TYPED_BLOCK_CAST_STYLES.key?(style_str)
               return style_str.to_sym if VERBATILE_CAST_STYLES.include?(style_str)
 
               nil
@@ -163,7 +180,8 @@ module Coradoc
               Coradoc::CoreModel::AnnotationBlock.new(
                 annotation_type: canonical,
                 content: content_lines,
-                title: ToCoreModel.extract_title_text(block.title)
+                title: ToCoreModel.extract_title_text(block.title),
+                source_line: block.source_line
               )
             end
 
@@ -176,7 +194,7 @@ module Coradoc
             end
 
             def transform_block(block, semantic_type_or_delimiter)
-              content_lines = ToCoreModel.extract_block_lines(block)
+              source_lines = ToCoreModel.extract_source_lines(block.lines)
               semantic_type = if semantic_type_or_delimiter.is_a?(Symbol)
                                 semantic_type_or_delimiter
                               else
@@ -188,8 +206,10 @@ module Coradoc
                 delimiter_type: semantic_type_or_delimiter.is_a?(String) ? semantic_type_or_delimiter : nil,
                 id: block.id,
                 title: ToCoreModel.extract_title_text(block.title),
-                content: content_lines,
-                language: ToCoreModel.extract_block_language(block)
+                content: source_lines.join("\n"),
+                lines: source_lines,
+                language: ToCoreModel.extract_block_language(block),
+                source_line: block.source_line
               )
             end
 
@@ -216,6 +236,7 @@ module Coradoc
                   title: ToCoreModel.extract_title_text(block.title),
                   children: children,
                   language: ToCoreModel.extract_block_language(block),
+                  source_line: block.source_line,
                   **extra_attrs
                 )
               else
@@ -230,7 +251,8 @@ module Coradoc
                   inline = [Coradoc::CoreModel::TextContent.new(text: '')] if inline.empty?
                   Coradoc::CoreModel::ParagraphBlock.new(
                     content: ToCoreModel.extract_text_content(group),
-                    children: Array(inline)
+                    children: Array(inline),
+                    source_line: ToCoreModel.extract_source_line(group)
                   )
                 end
 
@@ -240,6 +262,7 @@ module Coradoc
                   content: content_lines,
                   children: children,
                   language: ToCoreModel.extract_block_language(block),
+                  source_line: block.source_line,
                   **extra_attrs
                 )
               end

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

@@ -12,7 +12,6 @@ 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)
               children = resolve_attribute_references(children, attributes)
 
               Coradoc::CoreModel::DocumentElement.new(
@@ -34,31 +33,6 @@ 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
-
             # 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
@@ -86,7 +60,8 @@ module Coradoc
                 level: section.level,
                 title: title_text,
                 children: content_children + nested_sections,
-                attributes: section_metadata_from(section)
+                attributes: section_metadata_from(section),
+                source_line: section.source_line
               )
             end
 

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

@@ -21,7 +21,8 @@ module Coradoc
                 target: model.path.to_s,
                 options: options,
                 raw_options: raw,
-                line_break: model.line_break.to_s
+                line_break: model.line_break.to_s,
+                source_line: model.source_line
               )
             end
 

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

@@ -9,14 +9,16 @@ module Coradoc
             def transform_inline(inline, format_type)
               klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
               klass.new(
-                content: ToCoreModel.extract_text_content(inline.content)
+                content: ToCoreModel.extract_text_content(inline.content),
+                source_line: inline.source_line
               )
             end
 
             def transform_inline_text(inline, format_type)
               klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
               klass.new(
-                content: inline.text.to_s
+                content: inline.text.to_s,
+                source_line: inline.source_line
               )
             end
 
@@ -24,28 +26,32 @@ module Coradoc
               parsed_content = ToCoreModel.parse_and_transform_inline(footnote.text.to_s)
               Coradoc::CoreModel::FootnoteElement.new(
                 target: footnote.id,
-                content: parsed_content
+                content: parsed_content,
+                source_line: footnote.source_line
               )
             end
 
             def transform_link(link)
               Coradoc::CoreModel::LinkElement.new(
                 target: link.path,
-                content: link.name || link.path
+                content: link.name || link.path,
+                source_line: link.source_line
               )
             end
 
             def transform_cross_reference(xref)
               Coradoc::CoreModel::CrossReferenceElement.new(
                 target: xref.href,
-                content: xref.args&.first || xref.href
+                content: xref.args&.first || xref.href,
+                source_line: xref.source_line
               )
             end
 
             def transform_stem(stem)
               Coradoc::CoreModel::StemElement.new(
                 content: stem.content,
-                stem_type: stem.type || 'stem'
+                stem_type: stem.type || 'stem',
+                source_line: stem.source_line
               )
             end
           end