coradoc-adoc 2.0.23 → 2.0.25

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,8 +300,11 @@ module Coradoc
           end
 
           def transform_image(image)
-            target_class = image.inline ? Coradoc::AsciiDoc::Model::Image::InlineImage
-                                        : Coradoc::AsciiDoc::Model::Image::BlockImage
+            target_class = if image.inline
+                             Coradoc::AsciiDoc::Model::Image::InlineImage
+                           else
+                             Coradoc::AsciiDoc::Model::Image::BlockImage
+                           end
             target_class.new(**image_attributes(image))
           end
 

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

@@ -35,21 +35,44 @@ 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
 
+        # Two adjacent TextElements in the content array indicate the
+        # parser split a paragraph across source lines. Join them with a
+        # space (soft break) unless the second one carries a hard-break
+        # marker — the model owns that predicate, so this method does
+        # not reach into parser-specific line_break string values.
+        def soft_break_before?(previous, current)
+          previous.is_a?(Model::TextElement) &&
+            current.is_a?(Model::TextElement) &&
+            !current.hard_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

@@ -34,7 +34,10 @@ module Coradoc
 
             # Example
             rule(example: sequence(:example)) do
-              Model::Block::Example.new(title: '', lines: example)
+              Model::Block::Example.new(
+                title: '',
+                lines: example
+              )
             end
 
             # Admonition. Canonicalise the type to uppercase so round-trips
@@ -45,7 +48,10 @@ 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
+              )
             end
 
             # Block image

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

@@ -16,23 +16,23 @@ module Coradoc
         # returning a Model::Block::* instance. `max_length` nil means
         # unbounded.
         DELIMITER_CLASSIFICATIONS = [
-          ['*', 4, nil, ->(opts, attrs) {
+          ['*', 4, nil, lambda { |opts, attrs|
             if attrs && attrs.positional == [] && attrs.named.first&.name == 'reviewer'
-              Model::Block::ReviewerComment.new(**opts.merge(attributes: attrs))
+              Model::Block::ReviewerComment.new(**opts, attributes: attrs)
             else
-              Model::Block::Side.new(**opts.merge(attributes: attrs))
+              Model::Block::Side.new(**opts, attributes: attrs)
             end
           }],
-          ['=', 4, nil, ->(opts, attrs) { Model::Block::Example.new(**opts.merge(attributes: attrs)) }],
-          ['+', 4, nil, ->(opts, attrs) { Model::Block::Pass.new(**opts.merge(attributes: attrs)) }],
-          ['.', 4, nil, ->(opts, attrs) { Model::Block::Literal.new(**opts.merge(attributes: attrs)) }],
-          ['_', 4, nil, ->(opts, attrs) { Model::Block::Quote.new(**opts.merge(attributes: attrs)) }],
-          ['-', 4, nil, ->(opts, attrs) { Model::Block::SourceCode.new(**opts.merge(attributes: attrs)) }],
-          ['-', 2, 2,  ->(opts, attrs) { Model::Block::Open.new(**opts.merge(attributes: attrs)) }],
+          ['=', 4, nil, ->(opts, attrs) { Model::Block::Example.new(**opts, attributes: attrs) }],
+          ['+', 4, nil, ->(opts, attrs) { Model::Block::Pass.new(**opts, attributes: attrs) }],
+          ['.', 4, nil, ->(opts, attrs) { Model::Block::Literal.new(**opts, attributes: attrs) }],
+          ['_', 4, nil, ->(opts, attrs) { Model::Block::Quote.new(**opts, attributes: attrs) }],
+          ['-', 4, nil, ->(opts, attrs) { Model::Block::SourceCode.new(**opts, attributes: attrs) }],
+          ['-', 2, 2, ->(opts, attrs) { Model::Block::Open.new(**opts, attributes: attrs) }],
           # Markdown-style triple-backtick fence: behaves as a SourceCode
           # block. The language tag parsed from the opening fence is passed
           # through opts[:lang]; extract_block_language prefers block.lang.
-          ['`', 3, nil, ->(opts, attrs) {
+          ['`', 3, nil, lambda { |opts, attrs|
             model_opts = opts.merge(attributes: attrs, delimiter_char: '`')
             model_opts[:lang] = opts[:lang] if opts.key?(:lang)
             Model::Block::SourceCode.new(**model_opts)

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

@@ -21,7 +21,9 @@ 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:
+              )
             end
 
             rule(header: simple(:header)) do
@@ -34,7 +36,9 @@ 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
+              )
             end
 
             # Revision
@@ -43,7 +47,9 @@ module Coradoc
               date: simple(:date),
               remark: simple(:remark)
             ) do
-              Model::Revision.new(number:, date:, remark:)
+              Model::Revision.new(
+                number:, date:, remark:
+              )
             end
           end
         end

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

@@ -10,8 +10,8 @@ module Coradoc
         # `span` is excluded because it carries `text:` + `attributes:`
         # rather than `content:`, so it gets its own pair of rules.
         FORMATTING_VARIANTS = [
-          %i[bold      Bold],
-          %i[italic    Italic],
+          %i[bold Bold],
+          %i[italic Italic],
           %i[highlight Highlight],
           %i[monospace Monospace]
         ].freeze
@@ -31,7 +31,9 @@ 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:
+              )
             end
 
             # Inline image
@@ -60,7 +62,9 @@ module Coradoc
 
             # Attribute reference
             rule(attribute_reference: simple(:name)) do
-              Model::Inline::AttributeReference.new(name:)
+              Model::Inline::AttributeReference.new(
+                name:
+              )
             end
 
             # Hard line break (` +\n` or `\\n`). Emitted as a dedicated
@@ -68,7 +72,7 @@ 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
+            rule(hard_line_break: simple(:hard_line_break)) do
               Model::Inline::HardLineBreak.new
             end
 
@@ -77,30 +81,40 @@ 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
+              )
             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
+              )
             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
+              )
             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
+              )
             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
+              )
             end
 
             # Inline formatting rules generated from a single registry.
@@ -114,11 +128,15 @@ 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
+                )
               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
+                )
               end
             end
 
@@ -143,18 +161,24 @@ module Coradoc
             # Superscript
             rule(superscript: subtree(:superscript)) do
               content = Transformer.extract_simple_inline_content(superscript)
-              Model::Inline::Superscript.new(content:)
+              Model::Inline::Superscript.new(
+                content:
+              )
             end
 
             # Subscript
             rule(subscript: subtree(:subscript)) do
               content = Transformer.extract_simple_inline_content(subscript)
-              Model::Inline::Subscript.new(content:)
+              Model::Inline::Subscript.new(
+                content:
+              )
             end
 
             # Highlight (simple)
             rule(highlight: simple(:text)) do
-              Model::Highlight.new(content: text)
+              Model::Highlight.new(
+                content: text
+              )
             end
             # Stem
             rule(stem: subtree(:stem)) do

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

@@ -85,26 +85,36 @@ module Coradoc
 
             # Unordered list
             rule(unordered: sequence(:list_items)) do
-              Model::List::Unordered.new(items: list_items)
+              Model::List::Unordered.new(
+                items: 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
+              )
             end
 
             # Ordered list
             rule(ordered: sequence(:list_items)) do
-              Model::List::Ordered.new(items: list_items)
+              Model::List::Ordered.new(
+                items: 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
+              )
             end
 
             # Definition list term (with optional anchor)

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

@@ -12,11 +12,16 @@ module Coradoc
                    comment_text: simple(:comment_text),
                    line_break: simple(:line_break)
                  }) do
-              Model::CommentLine.new(text: comment_text, line_break: line_break)
+              Model::CommentLine.new(
+                text: comment_text,
+                line_break: line_break
+              )
             end
 
             rule(comment_block: { comment_text: simple(:comment_text) }) do
-              Model::CommentBlock.new(text: comment_text)
+              Model::CommentBlock.new(
+                text: comment_text
+              )
             end
 
             # Page break
@@ -45,7 +50,7 @@ module Coradoc
             end
 
             rule(positional: simple(:positional)) do
-              positional.to_s
+              positional
             end
 
             rule(attribute_array: nil) do
@@ -54,10 +59,14 @@ module Coradoc
 
             rule(attribute_array: sequence(:attributes)) do
               attr_list = Model::AttributeList.new
+
               attributes.each do |a|
-                if a.is_a?(String)
+                case a
+                when Parslet::Slice
+                  attr_list.add_positional(a.to_s)
+                when String
                   attr_list.add_positional(a)
-                elsif a.is_a?(Model::Attribute)
+                when Model::Attribute
                   attr_list.add_named(a.key, a.value)
                 end
               end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+module Coradoc
+  module AsciiDoc
+    class Transformer < Parslet::Transform
+      # Walks a Parslet AST subtree (Hash/Array/Slice/String/Model) and
+      # returns the 1-indexed source line of the first +Parslet::Slice+
+      # or Model::Base#source_line it finds.
+      #
+      # Parslet preserves byte offsets on every matched slice
+      # (+slice.line_and_column+ returns +[line, column]+); the
+      # transformer receives these slices in the AST but most rules
+      # discard the position when building Model objects. This helper
+      # recovers the start line of any subtree so transformer rules
+      # can populate +Model::Base#source_line+ without changing the
+      # parser.
+      #
+      # Handles two distinct shapes:
+      #   * Pre-transform AST (Hash/Array of Parslet::Slice) — used by
+      #     rules that bind raw slices via +simple(:x)+.
+      #   * Post-transform Model tree (Model::Base instances whose
+      #     +source_line+ was populated by an earlier rule) — used by
+      #     rules that bind via +subtree(:x)+ and receive already-
+      #     transformed content.
+      #
+      # Returns nil when no position is found (programmatic input,
+      # already-stripped ASTs, etc.) — callers should treat nil as
+      # "source position unavailable".
+      module SourceLineExtractor
+        module_function
+
+        def extract(node)
+          case node
+          when Parslet::Slice then line_of(node)
+          when Coradoc::AsciiDoc::Model::Base then node.source_line
+          when Hash then extract_from_hash(node)
+          when Array then extract_from_array(node)
+          end
+        end
+
+        def line_of(slice)
+          line, _column = slice.line_and_column
+          line
+        end
+
+        def extract_from_hash(hash)
+          hash.each_value do |value|
+            line = extract(value)
+            return line if line
+          end
+          nil
+        end
+
+        def extract_from_array(array)
+          array.each do |value|
+            line = extract(value)
+            return line if line
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -46,9 +46,7 @@ module Coradoc
           normalized_cells = cells.map { |cell| TableCellBuilder.normalize_cell(cell) }
 
           col_count = explicit_col_count
-          if col_count.nil? || col_count.zero?
-            col_count = infer_column_count(normalized_cells)
-          end
+          col_count = infer_column_count(normalized_cells) if col_count.nil? || col_count.zero?
           col_count = normalized_cells.size if col_count.nil? || col_count.zero?
 
           rows = []

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

@@ -9,7 +9,9 @@ module Coradoc
           transformer_class.class_eval do
             # Text Model
             rule(text: simple(:text)) do
-              Model::TextElement.new(content: text.to_s)
+              Model::TextElement.new(
+                content: text.to_s
+              )
             end
 
             rule(text_string: subtree(:text_string)) do
@@ -17,19 +19,30 @@ module Coradoc
             end
 
             rule(text: simple(:text), line_break: simple(:line_break)) do
-              Model::TextElement.new(content: text.to_s, line_break: line_break)
+              Model::TextElement.new(
+                content: text.to_s,
+                line_break: line_break
+              )
             end
 
             rule(text: sequence(:text), line_break: simple(:line_break)) do
-              Model::TextElement.new(content: text, line_break: line_break)
+              Model::TextElement.new(
+                content: text,
+                line_break: line_break
+              )
             end
 
             rule(id: simple(:id), text: simple(:text)) do
-              Model::TextElement.new(content: text.to_s, id: id.to_s)
+              Model::TextElement.new(
+                content: text.to_s,
+                id: id.to_s
+              )
             end
 
             rule(text: sequence(:text)) do
-              Model::TextElement.new(content: text)
+              Model::TextElement.new(
+                content: text
+              )
             end
 
             rule(
@@ -58,7 +71,9 @@ module Coradoc
 
             # Line break
             rule(line_break: simple(:line_break)) do
-              Model::LineBreak.new(line_break:)
+              Model::LineBreak.new(
+                line_break:
+              )
             end
 
             # Unparsed text