coradoc-adoc 2.0.22 → 2.0.24

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

@@ -16,11 +16,15 @@ module Coradoc
               end
 
               if marker_type == 'definition'
-                Coradoc::CoreModel::DefinitionList.new(items: items)
+                Coradoc::CoreModel::DefinitionList.new(
+                  items: items,
+                  source_line: list.source_line
+                )
               else
                 Coradoc::CoreModel::ListBlock.new(
                   marker_type: marker_type,
-                  items: items
+                  items: items,
+                  source_line: list.source_line
                 )
               end
             end
@@ -45,7 +49,8 @@ module Coradoc
                 term: ToCoreModel.extract_text_content(term_children),
                 definitions: [ToCoreModel.extract_text_content(def_children)],
                 term_children: term_children,
-                definition_children: def_children
+                definition_children: def_children,
+                source_line: item.source_line
               )
               di.id = item.id if item.id
 
@@ -63,7 +68,8 @@ module Coradoc
 
               li = Coradoc::CoreModel::ListItem.new(
                 content: ToCoreModel.extract_text_content(content_val),
-                marker: item.marker
+                marker: item.marker,
+                source_line: item.source_line
               )
               li.children = children
 

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

@@ -10,7 +10,8 @@ module Coradoc
               Coradoc::CoreModel::Term.new(
                 text: term.term.to_s,
                 type: term.type&.to_s || 'preferred',
-                lang: term.lang&.to_s || 'en'
+                lang: term.lang&.to_s || 'en',
+                source_line: term.source_line
               )
             end
 
@@ -19,31 +20,31 @@ module Coradoc
               children = ToCoreModel.transform_inline_content(admonition.content)
               block = Coradoc::CoreModel::AnnotationBlock.new(
                 annotation_type: canonical,
-                content: ToCoreModel.extract_text_content(admonition.content)
+                content: ToCoreModel.extract_text_content(admonition.content),
+                source_line: admonition.source_line
               )
               block.children = children
               block
             end
 
             def transform_image(image)
-              src = image.src.to_s
-              src = src[1..] if src.start_with?(':')
-              positional = image.attributes&.positional || []
-              positional_alt = positional.first&.value&.to_s || ''
-              caption = positional[1]&.value&.to_s
-              title = image.title&.to_s
-              # AsciiDoc block-title (`.Caption`) is semantically a caption,
-              # but for compatibility with the existing pipeline that treated
-              # it as alt when no positional alt was supplied, fall back to it.
-              alt = positional_alt.empty? ? title : positional_alt
-              Coradoc::CoreModel::Image.new(
-                src: src,
-                alt: alt,
-                caption: caption,
-                title: title,
-                width: image.attributes&.[]('width'),
-                height: image.attributes&.[]('height')
-              )
+              Coradoc::CoreModel::Image.new(**image_attributes(image))
+            end
+
+            def image_attributes(image)
+              {
+                src: normalize_image_src(image.src),
+                alt: image.alt, title: image.title, caption: image.caption,
+                width: image.width, height: image.height,
+                link: image.link, role: image.role,
+                inline: image.is_a?(Coradoc::AsciiDoc::Model::Image::InlineImage),
+                source_line: image.source_line
+              }
+            end
+
+            def normalize_image_src(src)
+              s = src.to_s
+              s.start_with?(':') ? s[1..] : s
             end
 
             def transform_bibliography(bib)
@@ -55,7 +56,8 @@ module Coradoc
                 id: bib.id,
                 title: bib.title.to_s,
                 level: nil,
-                entries: entries
+                entries: entries,
+                source_line: bib.source_line
               )
             end
 
@@ -63,7 +65,8 @@ module Coradoc
               Coradoc::CoreModel::BibliographyEntry.new(
                 anchor_name: entry.anchor_name,
                 document_id: entry.document_id,
-                ref_text: entry.ref_text.to_s
+                ref_text: entry.ref_text.to_s,
+                source_line: entry.source_line
               )
             end
           end

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

@@ -14,7 +14,8 @@ module Coradoc
               Coradoc::CoreModel::Table.new(
                 id: table.id,
                 title: table.title&.to_s,
-                rows: rows
+                rows: rows,
+                source_line: table.source_line
               )
             end
 
@@ -24,7 +25,8 @@ module Coradoc
               end
               Coradoc::CoreModel::TableRow.new(
                 cells: cells,
-                header: row.header
+                header: row.header,
+                source_line: row.source_line
               )
             end
 
@@ -38,7 +40,8 @@ module Coradoc
                 colspan: cell.colspan,
                 rowspan: cell.rowspan,
                 style: cell.style_name,
-                children: children
+                children: children,
+                source_line: cell.source_line
               )
             end
           end

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

@@ -38,18 +38,12 @@ module Coradoc
                          Coradoc::AsciiDoc::Model::Header.new(title: '')
                        end
 
-              # 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(without_title),
+                sections: flatten_children(without_frontmatter),
                 frontmatter: frontmatter
               )
             when CoreModel::SectionElement
@@ -68,27 +62,6 @@ 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
@@ -327,11 +300,17 @@ module Coradoc
           end
 
           def transform_image(image)
-            Coradoc::AsciiDoc::Model::Image::BlockImage.new(
-              src: image.src,
-              title: image.alt,
-              attributes: build_image_attributes(image)
-            )
+            target_class = image.inline ? Coradoc::AsciiDoc::Model::Image::InlineImage
+                                        : Coradoc::AsciiDoc::Model::Image::BlockImage
+            target_class.new(**image_attributes(image))
+          end
+
+          def image_attributes(image)
+            {
+              src: image.src, alt: image.alt, title: image.title,
+              caption: image.caption, width: image.width, height: image.height,
+              link: image.link, role: image.role
+            }
           end
 
           def transform_bibliography(bib)
@@ -530,6 +509,10 @@ module Coradoc
               content.map { |item| create_text_elements(item) }
             when Coradoc::CoreModel::InlineElement
               transform_inline(content)
+            when Coradoc::CoreModel::TextContent
+              Coradoc::AsciiDoc::Model::TextElement.new(content: content.text.to_s)
+            when Coradoc::CoreModel::Base
+              transform(content)
             when Coradoc::AsciiDoc::Model::Base
               content
             when Lutaml::Model::Serializable
@@ -555,13 +538,6 @@ module Coradoc
             attrs
           end
 
-          def build_image_attributes(image)
-            attrs = {}
-            attrs['width'] = image.width if image.width
-            attrs['height'] = image.height if image.height
-            attrs
-          end
-
           def default_marker(marker_type)
             case marker_type
             when 'ordered' then '.'

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

@@ -35,21 +35,39 @@ module Coradoc
           end
         end
 
+        # Folds soft source line breaks into a single text run: when two
+        # +Model::TextElement+s sit adjacent in the content array (the parser
+        # emits one per source line of a paragraph), a space is inserted
+        # between them so wrapped text renders as flowing prose rather than
+        # concatenated words.
+        #
+        # The previous item must ALSO be a TextElement — if a non-text
+        # inline (HardLineBreak, Passthrough, Image, etc.) sits between two
+        # TextElements, the source did not have a soft break there and no
+        # space should be synthesised. Without this guard, `foo +\nbar`
+        # would emit `["foo", hard_break, " ", "bar"]` (stray space) and
+        # `Before +pass:[RAW]+ after` would emit a double space around the
+        # passthrough.
         def visit_array(items)
           result = []
-          items.each_with_index do |item, idx|
+          previous = nil
+          items.each do |item|
             transformed = visit_content(item)
             next if transformed.empty?
 
-            needs_space = idx.positive? &&
-                          item.is_a?(Model::TextElement) &&
-                          item.line_break != '+'
-            result << CoreModel::TextContent.new(text: ' ') if needs_space
+            result << CoreModel::TextContent.new(text: ' ') if soft_break_before?(previous, item)
             result.concat(transformed)
+            previous = item
           end
           result
         end
 
+        def soft_break_before?(previous, current)
+          previous.is_a?(Model::TextElement) &&
+            current.is_a?(Model::TextElement) &&
+            current.line_break != '+'
+        end
+
         def visit_model(model)
           @to_core_model.transform(model)
         end

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

@@ -23,14 +23,38 @@ module Coradoc
             transformer ? transformer.call(model) : model
           end
 
+          # Returns the source-line view of an AsciiDoc content array as
+          # an Array<String>. Single source of truth for source-line
+          # extraction — every transformer that needs to populate
+          # CoreModel::Block#lines goes through here so the filtering
+          # rules (skip Model::LineBreak and Model::Break::PageBreak,
+          # which carry no renderable text) apply consistently.
+          def extract_source_lines(content)
+            Array(content).filter_map do |item|
+              next if item.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                      item.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+
+              extract_text_content(item).to_s
+            end
+          end
+
           def extract_block_lines(block)
-            non_break_lines = Array(block.lines).reject do |line|
-              line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
-                line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+            extract_source_lines(block.lines).join("\n")
+          end
+
+          # Extracts the source_line of the first AsciiDoc::Model::Base in
+          # +content+. Single source of truth for source-line propagation
+          # from AsciiDoc::Model trees into CoreModel objects built from
+          # grouped content (e.g., paragraphs inside typed blocks).
+          # Returns nil when no model carries a source_line.
+          def extract_source_line(content)
+            Array(content).each do |item|
+              next unless item.is_a?(Coradoc::AsciiDoc::Model::Base)
+
+              line = item.source_line
+              return line if line
             end
-            non_break_lines.map do |line|
-              extract_text_content(line)
-            end.join("\n")
+            nil
           end
 
           def extract_title_text(title)

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

@@ -23,7 +23,8 @@ module Coradoc
                 title: title,
                 delimiter_len: delimiter.size,
                 lines: lines,
-                ordering: ordering
+                ordering: ordering,
+                source_line: SourceLineExtractor.extract(block)
               }
               # Markdown fences carry the language tag inline (```ruby);
               # pass it through so the SourceCode classifier entry can set
@@ -34,7 +35,11 @@ module Coradoc
 
             # Example
             rule(example: sequence(:example)) do
-              Model::Block::Example.new(title: '', lines: example)
+              Model::Block::Example.new(
+                title: '',
+                lines: example,
+                source_line: SourceLineExtractor.extract(example)
+              )
             end
 
             # Admonition. Canonicalise the type to uppercase so round-trips
@@ -45,7 +50,11 @@ module Coradoc
               content: sequence(:content)
             ) do
               canonical = Coradoc::AsciiDoc::Transform::ElementTransformers::AdmonitionStyles.canonicalize(admonition_type.to_s)
-              Model::Admonition.new(content: content, type: canonical)
+              Model::Admonition.new(
+                content: content,
+                type: canonical,
+                source_line: SourceLineExtractor.extract(admonition_type)
+              )
             end
 
             # Block image
@@ -54,12 +63,17 @@ module Coradoc
               title = block_image[:title]
               path = block_image[:path]
               attrs = AttributeListNormalizer.coerce(block_image[:attribute_list_macro])
+              promoted, residual = Model::Image::AttributeExtractor.call(
+                attrs, Model::Image::BlockImage
+              )
               Model::Image::BlockImage.new(
                 title: title,
                 id: id,
                 src: path,
-                attributes: attrs,
-                line_break: "\n"
+                attributes: residual,
+                line_break: "\n",
+                source_line: SourceLineExtractor.extract(block_image),
+                **promoted
               )
             end
           end

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

@@ -21,7 +21,10 @@ module Coradoc
               id = id.to_s unless id.nil?
               id = nil if id && id.empty?
 
-              Model::Header.new(id:, title:, author:, revision:)
+              Model::Header.new(
+                id:, title:, author:, revision:,
+                source_line: SourceLineExtractor.extract(header)
+              )
             end
 
             rule(header: simple(:header)) do
@@ -34,7 +37,10 @@ module Coradoc
               last_name: simple(:last_name),
               email: simple(:email)
             ) do
-              Model::Author.new(first_name:, last_name:, email:, middle_name: nil)
+              Model::Author.new(
+                first_name:, last_name:, email:, middle_name: nil,
+                source_line: SourceLineExtractor.extract(first_name)
+              )
             end
 
             # Revision
@@ -43,7 +49,10 @@ module Coradoc
               date: simple(:date),
               remark: simple(:remark)
             ) do
-              Model::Revision.new(number:, date:, remark:)
+              Model::Revision.new(
+                number:, date:, remark:,
+                source_line: SourceLineExtractor.extract(number)
+              )
             end
           end
         end

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

@@ -22,7 +22,8 @@ module Coradoc
             rule(link: subtree(:link)) do
               Model::Inline::Link.new(
                 path: link[:path].to_s,
-                name: link[:text]&.to_s
+                name: link[:text]&.to_s,
+                source_line: SourceLineExtractor.extract(link)
               )
             end
 
@@ -31,15 +32,23 @@ module Coradoc
               href = xref[:href].to_s
               text = xref[:text]
               args = text ? [text.to_s] : []
-              Model::Inline::CrossReference.new(href:, args:)
+              Model::Inline::CrossReference.new(
+                href:, args:,
+                source_line: SourceLineExtractor.extract(xref)
+              )
             end
 
             # Inline image
             rule(inline_image: subtree(:inline_image)) do
               attrs = AttributeListNormalizer.coerce(inline_image[:attribute_list])
+              promoted, residual = Model::Image::AttributeExtractor.call(
+                attrs, Model::Image::InlineImage
+              )
               Model::Image::InlineImage.new(
                 src: inline_image[:path],
-                attributes: attrs
+                attributes: residual,
+                source_line: SourceLineExtractor.extract(inline_image),
+                **promoted
               )
             end
 
@@ -50,13 +59,17 @@ module Coradoc
             rule(inline_passthrough: subtree(:passthrough)) do
               Model::Inline::Passthrough.new(
                 content: passthrough[:raw].to_s,
-                form: 'triple'
+                form: 'triple',
+                source_line: SourceLineExtractor.extract(passthrough)
               )
             end
 
             # Attribute reference
             rule(attribute_reference: simple(:name)) do
-              Model::Inline::AttributeReference.new(name:)
+              Model::Inline::AttributeReference.new(
+                name:,
+                source_line: SourceLineExtractor.extract(name)
+              )
             end
 
             # Hard line break (` +\n` or `\\n`). Emitted as a dedicated
@@ -64,8 +77,10 @@ module Coradoc
             # 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
+            rule(hard_line_break: simple(:hard_line_break)) do
+              Model::Inline::HardLineBreak.new(
+                source_line: SourceLineExtractor.extract(hard_line_break)
+              )
             end
 
             # Term
@@ -73,30 +88,45 @@ module Coradoc
               term_type: simple(:term_type),
               term: simple(:term)
             ) do
-              Coradoc::AsciiDoc::Model::Term.new(term:, type: term_type, lang: :en)
+              Coradoc::AsciiDoc::Model::Term.new(
+                term:, type: term_type, lang: :en,
+                source_line: SourceLineExtractor.extract(term_type)
+              )
             end
 
             # Footnote
             rule(footnote: simple(:footnote)) do
               text_str = footnote.to_s
-              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str)
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(
+                text: text_str,
+                source_line: SourceLineExtractor.extract(footnote)
+              )
             end
 
             rule(footnote: simple(:footnote), id: simple(:id)) do
               text_str = footnote.to_s
-              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str, id: id.to_s)
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(
+                text: text_str, id: id.to_s,
+                source_line: SourceLineExtractor.extract(footnote)
+              )
             end
 
             # Footnote with empty content (reference to named footnote)
             rule(footnote: sequence(:footnote), id: simple(:id)) do
               text_str = footnote.map(&:to_s).join
-              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str, id: id.to_s)
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(
+                text: text_str, id: id.to_s,
+                source_line: SourceLineExtractor.extract(footnote)
+              )
             end
 
             # Footnote with empty content and no id
             rule(footnote: sequence(:footnote)) do
               text_str = footnote.map(&:to_s).join
-              Coradoc::AsciiDoc::Model::Inline::Footnote.new(text: text_str)
+              Coradoc::AsciiDoc::Model::Inline::Footnote.new(
+                text: text_str,
+                source_line: SourceLineExtractor.extract(footnote)
+              )
             end
 
             # Inline formatting rules generated from a single registry.
@@ -110,11 +140,17 @@ module Coradoc
 
               rule(constrained_key => subtree(:subtree)) do
                 content = Transformer.extract_inline_content(subtree)
-                klass.new(content: content, unconstrained: false)
+                klass.new(
+                  content: content, unconstrained: false,
+                  source_line: SourceLineExtractor.extract(subtree)
+                )
               end
               rule(unconstrained_key => subtree(:subtree)) do
                 content = Transformer.extract_inline_content(subtree)
-                klass.new(content: content, unconstrained: true)
+                klass.new(
+                  content: content, unconstrained: true,
+                  source_line: SourceLineExtractor.extract(subtree)
+                )
               end
             end
 
@@ -123,7 +159,8 @@ module Coradoc
               Model::Inline::Span.new(
                 text: span_constrained[:text],
                 unconstrained: false,
-                attributes: span_constrained[:attribute_list]
+                attributes: span_constrained[:attribute_list],
+                source_line: SourceLineExtractor.extract(span_constrained)
               )
             end
 
@@ -132,31 +169,42 @@ module Coradoc
               Model::Inline::Span.new(
                 text: span_unconstrained[:text],
                 unconstrained: true,
-                attributes: span_unconstrained[:attribute_list]
+                attributes: span_unconstrained[:attribute_list],
+                source_line: SourceLineExtractor.extract(span_unconstrained)
               )
             end
 
             # Superscript
             rule(superscript: subtree(:superscript)) do
               content = Transformer.extract_simple_inline_content(superscript)
-              Model::Inline::Superscript.new(content:)
+              Model::Inline::Superscript.new(
+                content:,
+                source_line: SourceLineExtractor.extract(superscript)
+              )
             end
 
             # Subscript
             rule(subscript: subtree(:subscript)) do
               content = Transformer.extract_simple_inline_content(subscript)
-              Model::Inline::Subscript.new(content:)
+              Model::Inline::Subscript.new(
+                content:,
+                source_line: SourceLineExtractor.extract(subscript)
+              )
             end
 
             # Highlight (simple)
             rule(highlight: simple(:text)) do
-              Model::Highlight.new(content: text)
+              Model::Highlight.new(
+                content: text,
+                source_line: SourceLineExtractor.extract(text)
+              )
             end
             # Stem
             rule(stem: subtree(:stem)) do
               Coradoc::AsciiDoc::Model::Inline::Stem.new(
                 type: stem[:stem_type],
-                content: stem[:content]
+                content: stem[:content],
+                source_line: SourceLineExtractor.extract(stem)
               )
             end
           end

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

@@ -74,7 +74,8 @@ module Coradoc
               end
 
               Model::List::Item.new(
-                content: content, id:, marker:, attached:, nested:, line_break:
+                content: content, id:, marker:, attached:, nested:, line_break:,
+                source_line: SourceLineExtractor.extract(list_item)
               )
             end
 
@@ -85,26 +86,40 @@ module Coradoc
 
             # Unordered list
             rule(unordered: sequence(:list_items)) do
-              Model::List::Unordered.new(items: list_items)
+              Model::List::Unordered.new(
+                items: list_items,
+                source_line: SourceLineExtractor.extract(list_items)
+              )
             end
 
             rule(
               attribute_list: simple(:attribute_list),
               unordered: sequence(:list_items)
             ) do
-              Model::List::Unordered.new(items: list_items, attrs: attribute_list)
+              Model::List::Unordered.new(
+                items: list_items,
+                attrs: attribute_list,
+                source_line: SourceLineExtractor.extract(attribute_list)
+              )
             end
 
             # Ordered list
             rule(ordered: sequence(:list_items)) do
-              Model::List::Ordered.new(items: list_items)
+              Model::List::Ordered.new(
+                items: list_items,
+                source_line: SourceLineExtractor.extract(list_items)
+              )
             end
 
             rule(
               attribute_list: simple(:attribute_list),
               ordered: sequence(:list_items)
             ) do
-              Model::List::Ordered.new(items: list_items, attrs: attribute_list)
+              Model::List::Ordered.new(
+                items: list_items,
+                attrs: attribute_list,
+                source_line: SourceLineExtractor.extract(attribute_list)
+              )
             end
 
             # Definition list term (with optional anchor)