coradoc 2.0.4 → 2.0.6

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

@@ -103,14 +103,15 @@ module Coradoc
           def transform_block(block)
             content = block.renderable_content
 
-            if block.element_type == 'paragraph'
+            semantic = resolve_semantic_type(block)
+
+            case semantic
+            when :paragraph
               return Coradoc::AsciiDoc::Model::Paragraph.new(
                 id: block.id,
                 content: create_text_elements(content)
               )
-            end
-
-            if block.element_type == 'comment'
+            when :comment
               return Coradoc::AsciiDoc::Model::CommentBlock.new(
                 text: safe_content_to_string(content)
               )
@@ -118,42 +119,67 @@ module Coradoc
 
             content_text = safe_content_to_string(content)
 
-            case block.delimiter_type
-            when 'source'
+            case semantic
+            when :source_code
               Coradoc::AsciiDoc::Model::Block::SourceCode.new(
                 id: block.id,
                 title: block.title,
                 lines: content_text.split("\n"),
                 attributes: build_attributes(block)
               )
-            when 'quote'
+            when :quote
               Coradoc::AsciiDoc::Model::Block::Quote.new(
                 id: block.id,
                 title: block.title,
                 lines: content_text.split("\n")
               )
-            when 'example'
+            when :example
               Coradoc::AsciiDoc::Model::Block::Example.new(
                 id: block.id,
                 title: block.title,
                 lines: content_text.split("\n")
               )
-            when 'sidebar'
+            when :sidebar
               Coradoc::AsciiDoc::Model::Block::Side.new(
                 id: block.id,
                 title: block.title,
                 lines: content_text.split("\n")
               )
-            when 'literal'
+            when :literal
               Coradoc::AsciiDoc::Model::Block::Literal.new(
                 id: block.id,
                 title: block.title,
                 lines: content_text.split("\n")
               )
-            when 'paragraph'
-              Coradoc::AsciiDoc::Model::Paragraph.new(
+            when :open
+              Coradoc::AsciiDoc::Model::Block::Open.new(
                 id: block.id,
-                content: create_text_elements(content)
+                title: block.title,
+                lines: content_text.split("\n")
+              )
+            when :pass
+              Coradoc::AsciiDoc::Model::Block::Pass.new(
+                id: block.id,
+                title: block.title,
+                lines: content_text.split("\n")
+              )
+            when :listing
+              Coradoc::AsciiDoc::Model::Block::Listing.new(
+                id: block.id,
+                title: block.title,
+                lines: content_text.split("\n")
+              )
+            when :verse
+              Coradoc::AsciiDoc::Model::Block::Quote.new(
+                id: block.id,
+                title: block.title,
+                lines: content_text.split("\n")
+              )
+            when :reviewer
+              Coradoc::AsciiDoc::Model::Block::ReviewerComment.new(
+                id: block.id,
+                title: block.title,
+                lines: content_text.split("\n")
               )
             else
               delim = block.delimiter_type.to_s
@@ -350,6 +376,51 @@ module Coradoc
 
           private
 
+          # Reverse mapping: semantic type → AsciiDoc delimiter generation
+          SEMANTIC_TO_ADOC_BLOCK = {
+            source_code: :source_code,
+            quote: :quote,
+            example: :example,
+            sidebar: :sidebar,
+            literal: :literal,
+            pass: :pass,
+            open: :open,
+            verse: :open,
+            paragraph: :paragraph,
+            comment: :comment
+          }.freeze
+
+          # Map raw delimiter_type string → semantic type (backward compat)
+          DELIMITER_CHAR_TO_SEMANTIC = {
+            '-' => :source_code,
+            '=' => :example,
+            '_' => :quote,
+            '*' => :sidebar,
+            '.' => :literal,
+            '+' => :pass
+          }.freeze
+
+          def resolve_semantic_type(block)
+            # Polymorphic dispatch: typed classes override semantic_type
+            semantic = block.resolve_semantic_type
+            return semantic if semantic
+
+            # Format-specific fallback from delimiter_type
+            delim = block.delimiter_type
+            return nil unless delim && !delim.empty?
+
+            case delim
+            when 'comment' then :comment
+            when 'paragraph' then :paragraph
+            when '[verse]' then :verse
+            when '>' then :quote
+            when "'''", '---', '___', '***' then :horizontal_rule
+            else
+              char = delim[0]
+              DELIMITER_CHAR_TO_SEMANTIC[char] || nil
+            end
+          end
+
           def safe_content_to_string(content)
             case content
             when String

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

@@ -13,7 +13,7 @@ module Coradoc
 
         class << self
           def transform(model)
-            return model.map { |item| transform(item) } if model.is_a?(Array)
+            return model.map { |item| transform(item) }.compact if model.is_a?(Array)
             return model unless model.is_a?(Coradoc::AsciiDoc::Model::Base)
 
             transformer = Registry.lookup(model.class)
@@ -31,21 +31,23 @@ module Coradoc
             when Coradoc::AsciiDoc::Model::Paragraph
               transform_paragraph(model)
             when Coradoc::AsciiDoc::Model::Block::SourceCode
-              transform_block(model, 'source')
+              transform_source_block(model)
             when Coradoc::AsciiDoc::Model::Block::Quote
-              transform_block(model, 'quote')
+              transform_typed_block(model, Coradoc::CoreModel::QuoteBlock)
             when Coradoc::AsciiDoc::Model::Block::Example
-              transform_block(model, 'example')
+              transform_typed_block(model, Coradoc::CoreModel::ExampleBlock)
             when Coradoc::AsciiDoc::Model::Block::Side
-              transform_block(model, 'sidebar')
+              transform_typed_block(model, Coradoc::CoreModel::SidebarBlock)
             when Coradoc::AsciiDoc::Model::Block::Literal
-              transform_block(model, 'literal')
+              transform_typed_block(model, Coradoc::CoreModel::LiteralBlock)
             when Coradoc::AsciiDoc::Model::Block::Open
-              transform_block(model, 'open')
+              transform_typed_block(model, Coradoc::CoreModel::OpenBlock)
             when Coradoc::AsciiDoc::Model::Block::Pass
-              transform_block(model, 'pass')
+              transform_typed_block(model, Coradoc::CoreModel::PassBlock)
+            when Coradoc::AsciiDoc::Model::Block::Listing
+              transform_typed_block(model, Coradoc::CoreModel::ListingBlock)
             when Coradoc::AsciiDoc::Model::Block::Core
-              transform_block(model, model.delimiter)
+              transform_block(model, model.delimiter.to_s)
             when Coradoc::AsciiDoc::Model::Table
               transform_table(model)
             when Coradoc::AsciiDoc::Model::TableRow
@@ -96,10 +98,12 @@ module Coradoc
 
           def transform_document(doc)
             title_text = extract_title_text(doc.header&.title)
+            attributes = extract_document_attributes(doc)
             Coradoc::CoreModel::StructuralElement.new(
               element_type: 'document',
               id: doc.id,
               title: title_text,
+              attributes: attributes,
               children: transform(doc.sections || doc.contents || [])
             )
           end
@@ -123,33 +127,25 @@ module Coradoc
 
             Coradoc::CoreModel::Block.new(
               element_type: 'paragraph',
+              block_semantic_type: :paragraph,
               id: para.id,
               content: extract_text_content(para.content),
               children: children
             )
           end
 
-          def transform_block(block, delimiter_type)
-            content_lines = Array(block.lines).map do |line|
-              case line
-              when Coradoc::AsciiDoc::Model::Base
-                transformed = transform(line)
-                if transformed.is_a?(Coradoc::CoreModel::Base)
-                  extract_core_model_text(transformed)
-                else
-                  transformed.to_s
-                end
-              else
-                line.to_s
-              end
+          def transform_source_block(block)
+            content_lines = Array(block.lines).reject do |line|
+              line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+            end.map do |line|
+              extract_text_content(line)
             end.join("\n")
 
-            language = block.lang || block.attributes&.[]('language') ||
-                       block.attributes&.positional&.first
+            language = extract_block_language(block)
 
-            Coradoc::CoreModel::Block.new(
+            Coradoc::CoreModel::SourceBlock.new(
               element_type: 'block',
-              delimiter_type: delimiter_type,
               id: block.id,
               title: extract_title_text(block.title),
               content: content_lines,
@@ -157,6 +153,47 @@ module Coradoc
             )
           end
 
+          def transform_block(block, semantic_type_or_delimiter)
+            content_lines = extract_block_lines(block)
+            semantic_type = if semantic_type_or_delimiter.is_a?(Symbol)
+                              semantic_type_or_delimiter
+                            else
+                              asciidoc_delimiter_to_semantic(semantic_type_or_delimiter)
+                            end
+
+            Coradoc::CoreModel::Block.new(
+              element_type: 'block',
+              block_semantic_type: semantic_type,
+              delimiter_type: semantic_type_or_delimiter.is_a?(String) ? semantic_type_or_delimiter : nil,
+              id: block.id,
+              title: extract_title_text(block.title),
+              content: content_lines,
+              language: extract_block_language(block)
+            )
+          end
+
+          def transform_typed_block(block, klass, extra_attrs = {})
+            content_lines = extract_block_lines(block)
+
+            klass.new(
+              element_type: 'block',
+              id: block.id,
+              title: extract_title_text(block.title),
+              content: content_lines,
+              language: extract_block_language(block),
+              **extra_attrs
+            )
+          end
+
+          def extract_block_lines(block)
+            Array(block.lines).reject do |line|
+              line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+            end.map do |line|
+              extract_text_content(line)
+            end.join("\n")
+          end
+
           def transform_table(table)
             rows = Array(table.rows).map do |row|
               transform_table_row(row)
@@ -173,7 +210,10 @@ module Coradoc
             cells = Array(row.columns).map do |cell|
               transform_table_cell(cell)
             end
-            Coradoc::CoreModel::TableRow.new(cells: cells)
+            Coradoc::CoreModel::TableRow.new(
+              cells: cells,
+              header: row.header
+            )
           end
 
           def transform_table_cell(cell)
@@ -317,6 +357,45 @@ module Coradoc
 
           private
 
+          # AsciiDoc delimiters are any length of the same character (4+ for most, 2+ for open).
+          # We map by the first character to handle all lengths correctly.
+          ADOC_DELIMITER_CHAR_TO_SEMANTIC = {
+            '-' => :source_code,
+            '=' => :example,
+            '_' => :quote,
+            '*' => :sidebar,
+            '.' => :literal,
+            '+' => :pass
+          }.freeze
+
+          def asciidoc_delimiter_to_semantic(delimiter)
+            return :open if delimiter && delimiter.length < 4
+
+            char = delimiter&.[](0)
+            ADOC_DELIMITER_CHAR_TO_SEMANTIC[char] || :open
+          end
+
+          def extract_document_attributes(doc)
+            return {} unless doc.document_attributes
+
+            doc.document_attributes.to_hash
+          end
+
+          def extract_block_language(block)
+            lang = block.lang
+            return lang if lang.is_a?(String) && !lang.empty?
+
+            attrs = block.attributes
+            return nil unless attrs.is_a?(Coradoc::AsciiDoc::Model::AttributeList)
+
+            named_lang = attrs['language']
+            return named_lang.to_s if named_lang
+
+            # For [source,yaml], the language is the second positional attribute
+            positional = attrs.positional
+            positional[1]&.value&.to_s if positional.length > 1
+          end
+
           def transform_inline_content(content)
             return [] if content.nil?
 

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

@@ -35,25 +35,30 @@ module Coradoc
           end
 
           def register_block_transformers!
-            [
-              [Coradoc::AsciiDoc::Model::Block::SourceCode, 'source'],
-              [Coradoc::AsciiDoc::Model::Block::Quote, 'quote'],
-              [Coradoc::AsciiDoc::Model::Block::Example, 'example'],
-              [Coradoc::AsciiDoc::Model::Block::Side, 'sidebar'],
-              [Coradoc::AsciiDoc::Model::Block::Literal, 'literal'],
-              [Coradoc::AsciiDoc::Model::Block::Open, 'open'],
-              [Coradoc::AsciiDoc::Model::Block::Pass, 'pass']
-            ].each do |block_class, delimiter_type|
+            Registry.register_with_priority(
+              Coradoc::AsciiDoc::Model::Block::SourceCode,
+              METHOD_DISPATCH[:transform_source_block],
+              priority: 10
+            )
+
+            {
+              Coradoc::AsciiDoc::Model::Block::Quote => Coradoc::CoreModel::QuoteBlock,
+              Coradoc::AsciiDoc::Model::Block::Example => Coradoc::CoreModel::ExampleBlock,
+              Coradoc::AsciiDoc::Model::Block::Side => Coradoc::CoreModel::SidebarBlock,
+              Coradoc::AsciiDoc::Model::Block::Literal => Coradoc::CoreModel::LiteralBlock,
+              Coradoc::AsciiDoc::Model::Block::Open => Coradoc::CoreModel::OpenBlock,
+              Coradoc::AsciiDoc::Model::Block::Pass => Coradoc::CoreModel::PassBlock
+            }.each do |block_class, core_model_class|
               Registry.register_with_priority(
                 block_class,
-                block_wrapper(delimiter_type),
+                typed_block_wrapper(core_model_class),
                 priority: 10
               )
             end
 
             Registry.register(
               Coradoc::AsciiDoc::Model::Block::Core,
-              block_wrapper(nil) # uses model.delimiter at call time
+              block_model_wrapper
             )
 
             Registry.register(
@@ -182,7 +187,6 @@ module Coradoc
             # Passthrough types (no CoreModel equivalent)
             [
               Coradoc::AsciiDoc::Model::TextElement,
-              Coradoc::AsciiDoc::Model::LineBreak,
               Coradoc::AsciiDoc::Model::Include,
               Coradoc::AsciiDoc::Model::Audio,
               Coradoc::AsciiDoc::Model::Video,
@@ -191,18 +195,45 @@ module Coradoc
             ].each do |klass|
               Registry.register(klass, ->(model) { model })
             end
+
+            # Filtered types (layout-only, no CoreModel representation)
+            [
+              Coradoc::AsciiDoc::Model::LineBreak,
+              Coradoc::AsciiDoc::Model::Break::PageBreak
+            ].each do |klass|
+              Registry.register(klass, ->(_model) { nil })
+            end
           end
 
+          METHOD_DISPATCH = {
+            transform_document: ->(model) { ToCoreModel.transform_document(model) },
+            transform_section: ->(model) { ToCoreModel.transform_section(model) },
+            transform_paragraph: ->(model) { ToCoreModel.transform_paragraph(model) },
+            transform_source_block: ->(model) { ToCoreModel.transform_source_block(model) },
+            transform_link: ->(model) { ToCoreModel.transform_link(model) },
+            transform_cross_reference: ->(model) { ToCoreModel.transform_cross_reference(model) },
+            transform_inline_footnote: ->(model) { ToCoreModel.transform_inline_footnote(model) },
+            transform_stem: ->(model) { ToCoreModel.transform_stem(model) },
+            transform_table: ->(model) { ToCoreModel.transform_table(model) },
+            transform_table_row: ->(model) { ToCoreModel.transform_table_row(model) },
+            transform_table_cell: ->(model) { ToCoreModel.transform_table_cell(model) },
+            transform_term: ->(model) { ToCoreModel.transform_term(model) },
+            transform_admonition: ->(model) { ToCoreModel.transform_admonition(model) },
+            transform_image: ->(model) { ToCoreModel.transform_image(model) },
+            transform_bibliography: ->(model) { ToCoreModel.transform_bibliography(model) },
+            transform_bibliography_entry: ->(model) { ToCoreModel.transform_bibliography_entry(model) }
+          }.freeze
+
           def method_wrapper(method_name)
-            ->(model) { ToCoreModel.public_send(method_name, model) }
+            METHOD_DISPATCH.fetch(method_name)
           end
 
-          def block_wrapper(delimiter_type)
-            if delimiter_type
-              ->(model) { ToCoreModel.transform_block(model, delimiter_type) }
-            else
-              ->(model) { ToCoreModel.transform_block(model, model.delimiter) }
-            end
+          def typed_block_wrapper(klass)
+            ->(model) { ToCoreModel.transform_typed_block(model, klass) }
+          end
+
+          def block_model_wrapper
+            ->(model) { ToCoreModel.transform_block(model, model.delimiter.to_s) }
           end
 
           def list_wrapper(marker_type)

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

@@ -19,6 +19,11 @@ module Coradoc
               Model::CommentBlock.new(text: comment_text)
             end
 
+            # Page break
+            rule(page_break: simple(:page_break)) do
+              Model::Break::PageBreak.new
+            end
+
             # Tag
             rule(tag: subtree(:tag)) do
               Model::Tag.new(

data/coradoc-adoc/lib/coradoc/asciidoc/transformer/structural_rules.rb

@@ -65,7 +65,7 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(rows: rows)
+              Model::Table.new(rows: Transformer.regroup_table_rows(rows))
             end
 
             # Table with rows and title
@@ -74,7 +74,7 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(title: title.to_s, rows: rows)
+              Model::Table.new(title: title.to_s, rows: Transformer.regroup_table_rows(rows))
             end
 
             # Table with rows and id
@@ -83,7 +83,7 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(id: id.to_s, rows: rows)
+              Model::Table.new(id: id.to_s, rows: Transformer.regroup_table_rows(rows))
             end
 
             # Table with rows, id, and attributes
@@ -93,7 +93,7 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(id: id.to_s, rows: rows, attrs: attrs)
+              Model::Table.new(id: id.to_s, rows: Transformer.regroup_table_rows(rows, attrs), attrs: attrs)
             end
 
             # Table with rows, title, and attributes
@@ -103,7 +103,7 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(title: title.to_s, rows: rows, attrs: attrs)
+              Model::Table.new(title: title.to_s, rows: Transformer.regroup_table_rows(rows, attrs), attrs: attrs)
             end
 
             # Table with rows and attributes only
@@ -112,7 +112,7 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(rows: rows, attrs: attrs)
+              Model::Table.new(rows: Transformer.regroup_table_rows(rows, attrs), attrs: attrs)
             end
 
             # Table with rows, id, title, and attributes (full set)
@@ -123,7 +123,8 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(id: id.to_s, title: title.to_s, rows: rows, attrs: attrs)
+              Model::Table.new(id: id.to_s, title: title.to_s, rows: Transformer.regroup_table_rows(rows, attrs),
+                               attrs: attrs)
             end
 
             # Table with id and title (no attributes)
@@ -133,7 +134,7 @@ module Coradoc
               delim_char: simple(:delim_char),
               rows: sequence(:rows)
             ) do
-              Model::Table.new(id: id.to_s, title: title.to_s, rows: rows)
+              Model::Table.new(id: id.to_s, title: title.to_s, rows: Transformer.regroup_table_rows(rows))
             end
 
             # Title

data/coradoc-adoc/lib/coradoc/asciidoc/transformer.rb

@@ -333,11 +333,9 @@ module Coradoc
 
       # Infer column count from cells
       # Look for patterns where rows have consistent cell counts
-      # Prefers LARGER valid column counts (more likely to be correct)
       def self.infer_column_count(cells)
         return nil if cells.nil? || cells.empty?
 
-        # Count column slots for each cell
         col_slots = cells.map do |cell|
           cell.is_a?(Model::TableCell) && cell.colspan ? cell.colspan : 1
         end
@@ -349,7 +347,6 @@ module Coradoc
           next false if candidate > total_cells
           next false if total_cells % candidate != 0
 
-          # Verify that the cells distribute evenly
           slots_used = 0
           valid = true
 
@@ -366,11 +363,31 @@ module Coradoc
           valid && slots_used.zero?
         end
 
-        # Return the largest valid column count
-        # (more likely to represent actual table structure)
         possible_cols.max || col_slots.first || 1
       end
 
+      # Regroup parser-level rows into proper AsciiDoc rows.
+      # The parser produces one "row" per line; this flattens all cells
+      # and regroups by the cols attribute, then marks the first row as header.
+      #
+      # @param rows [Array<Model::TableRow>] Parser-level rows
+      # @param attrs [Model::AttributeList, nil] Table attributes containing cols
+      # @return [Array<Model::TableRow>] Properly grouped rows with header flag
+      def self.regroup_table_rows(rows, attrs = nil)
+        return rows if rows.nil? || rows.empty?
+
+        col_count = parse_cols_attribute(attrs)
+        all_cells = rows.flat_map do |r|
+          r.is_a?(Model::TableRow) ? r.columns : []
+        end
+
+        return rows if all_cells.empty?
+
+        grouped = group_cells_into_rows(all_cells, col_count)
+        grouped.first.header = true unless grouped.empty?
+        grouped
+      end
+
       # Transform a syntax tree using this transformer's rules
       #
       # @param syntax_tree [Hash, Array] The AST from the parser

data/coradoc-adoc/lib/coradoc/asciidoc.rb

@@ -15,9 +15,14 @@ module Coradoc
   end
 end
 
-# Load version and parse_error (small files, needed immediately)
+# Autoload version and parse error
 require_relative 'asciidoc/version'
-require_relative 'asciidoc/parse_error'
+
+module Coradoc
+  module AsciiDoc
+    autoload :ParseError, "#{__dir__}/asciidoc/parse_error"
+  end
+end
 
 # Autoload main components (lazy loading)
 module Coradoc