coradoc 2.0.4 → 2.0.6

data/coradoc-adoc/spec/coradoc/asciidoc/integration_pipeline_spec.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Integration pipeline fixes' do
+  def parse_to_core(adoc)
+    ast = Coradoc::AsciiDoc::Parser::Base.parse(adoc)
+    model = Coradoc::AsciiDoc::Transformer.transform(ast)
+    Coradoc::AsciiDoc::Transform::ToCoreModel.transform(model)
+  end
+
+  def parse_to_ast(adoc)
+    Coradoc::AsciiDoc::Parser::Base.parse(adoc)
+  end
+
+  describe 'Fix 01: Page break parsing' do
+    it 'parses <<< as page_break at document level' do
+      ast = parse_to_ast("= Title\n\n<<<\n")
+      doc_nodes = ast[:document]
+      page_breaks = doc_nodes.select { |n| n.is_a?(Hash) && n.key?(:page_break) }
+      expect(page_breaks.length).to eq(1)
+    end
+
+    it 'parses <<< as page_break inside sections' do
+      ast = parse_to_ast("== Section\n\n<<<\n\nSome text\n")
+      doc_nodes = ast[:document]
+      section = doc_nodes.find { |n| n.is_a?(Hash) && n.key?(:section) }
+      contents = section[:section][:contents]
+      page_breaks = contents.select { |n| n.is_a?(Hash) && n.key?(:page_break) }
+      expect(page_breaks.length).to eq(1)
+    end
+
+    it 'does not capture <<< as paragraph text' do
+      ast = parse_to_ast("= Title\n\n<<<\n")
+      doc_nodes = ast[:document]
+      paragraphs = doc_nodes.select { |n| n.is_a?(Hash) && n.key?(:paragraph) }
+      paragraph_texts = paragraphs.map { |p| p[:paragraph][:lines].map { |l| l[:text].to_s }.join }
+      expect(paragraph_texts).not_to include('<<<')
+    end
+
+    it 'transforms page_break through to CoreModel as nil (filtered out)' do
+      core = parse_to_core("= Title\n\nHello\n\n<<<\n\n== Section\n")
+      expect(core).to be_a(Coradoc::CoreModel::StructuralElement)
+      expect(core.children.length).to eq(2) # paragraph + section, no page break
+    end
+  end
+
+  describe 'Fix 02+03: Table row grouping and header detection' do
+    it 'groups cells into rows by column count' do
+      adoc = <<~ADOC
+        = Doc
+
+        [cols="2"]
+        |===
+        | A | B
+        | C | D
+        | E | F
+        |===
+      ADOC
+
+      core = parse_to_core(adoc)
+      table = find_first_table(core)
+      expect(table).not_to be_nil
+      expect(table.rows.length).to eq(3)
+      table.rows.each do |row|
+        expect(row.cells.length).to eq(2)
+      end
+    end
+
+    it 'marks the first row as header' do
+      adoc = <<~ADOC
+        = Doc
+
+        [cols="2"]
+        |===
+        | Header A | Header B
+        | Data 1 | Data 2
+        |===
+      ADOC
+
+      core = parse_to_core(adoc)
+      table = find_first_table(core)
+      expect(table.rows.first.header).to be true
+      expect(table.rows.last.header).to be false
+    end
+
+    it 'handles 3-column tables' do
+      adoc = <<~ADOC
+        = Doc
+
+        [cols="3"]
+        |===
+        | A | B | C
+        | D | E | F
+        |===
+      ADOC
+
+      core = parse_to_core(adoc)
+      table = find_first_table(core)
+      expect(table.rows.length).to eq(2)
+      table.rows.each { |row| expect(row.cells.length).to eq(3) }
+    end
+  end
+
+  describe 'Fix 04: LineBreak leak' do
+    it 'does not leak LineBreak elements into CoreModel children' do
+      adoc = <<~ADOC
+        = Title
+
+        First paragraph.
+
+        Second paragraph.
+      ADOC
+
+      core = parse_to_core(adoc)
+      core.children.each do |child|
+        next if child.is_a?(String) && child.strip.empty?
+
+        expect(child).not_to be_a(Coradoc::AsciiDoc::Model::LineBreak)
+      end
+    end
+
+    it 'does not leak PageBreak elements into CoreModel children' do
+      core = parse_to_core("= Title\n\n<<<\n\n== Section\n")
+      core.children.each do |child|
+        expect(child).not_to be_a(Coradoc::AsciiDoc::Model::Break::PageBreak)
+      end
+    end
+  end
+
+  describe 'Fix 05: Document attributes' do
+    it 'preserves document attributes in CoreModel' do
+      skip 'Parser does not yet propagate document attributes to CoreModel'
+      adoc = <<~ADOC
+        = My Document
+        :author: John
+        :revdate: 2024-01-01
+
+        Content here.
+      ADOC
+
+      core = parse_to_core(adoc)
+      expect(core.attributes).to include('author' => 'John', 'revdate' => '2024-01-01')
+    end
+
+    it 'handles multiple attributes' do
+      skip 'Parser does not yet propagate document attributes to CoreModel'
+      adoc = <<~ADOC
+        = Doc
+        :docnumber: 1
+        :edition: 2
+        :language: zh-Hant
+
+        Text.
+      ADOC
+
+      core = parse_to_core(adoc)
+      expect(core.attributes).to include(
+        'docnumber' => '1',
+        'edition' => '2',
+        'language' => 'zh-Hant'
+      )
+    end
+  end
+
+  describe 'Fix 07: Cross-references' do
+    it 'parses simple cross-reference <<id>>' do
+      skip 'Cross-reference parsing not yet implemented'
+      adoc = <<~ADOC
+        = Doc
+
+        See <<introduction>> for details.
+      ADOC
+
+      core = parse_to_core(adoc)
+      xrefs = find_all_xrefs(core)
+      expect(xrefs.length).to be >= 1
+      expect(xrefs.first.target).to eq('introduction')
+    end
+
+    it 'parses cross-reference with text <<id,text>>' do
+      skip 'Cross-reference parsing not yet implemented'
+      adoc = <<~ADOC
+        = Doc
+
+        See <<introduction,Introduction>> for details.
+      ADOC
+
+      core = parse_to_core(adoc)
+      xrefs = find_all_xrefs(core)
+      expect(xrefs.length).to be >= 1
+      expect(xrefs.first.target).to eq('introduction')
+      expect(xrefs.first.content).to eq('Introduction')
+    end
+
+    it 'parses multiple cross-references' do
+      skip 'Cross-reference parsing not yet implemented'
+      adoc = <<~ADOC
+        = Doc
+
+        See <<section-a>> and <<section-b,Section B>>.
+      ADOC
+
+      core = parse_to_core(adoc)
+      xrefs = find_all_xrefs(core)
+      expect(xrefs.length).to be >= 2
+      targets = xrefs.map(&:target)
+      expect(targets).to include('section-a', 'section-b')
+    end
+  end
+
+  describe 'Fix 06: Section hierarchy — bold in list items' do
+    it 'parses ordered list items starting with bold formatting' do
+      ast = parse_to_ast(". *First* text\n")
+      doc_nodes = ast[:document]
+      lists = doc_nodes.select { |n| n.is_a?(Hash) && n.key?(:list) }
+      expect(lists.length).to eq(1)
+    end
+
+    it 'parses ordered list items starting with bold inside a section' do
+      adoc = <<~ADOC
+        == Section
+
+        . *Bold item* — description
+        . Normal item
+      ADOC
+
+      ast = parse_to_ast(adoc)
+      section = ast[:document].find { |n| n.is_a?(Hash) && n.key?(:section) }
+      contents = section[:section][:contents]
+      lists = contents.select { |n| n.is_a?(Hash) && n.key?(:list) }
+      expect(lists.length).to eq(1)
+    end
+
+    it 'parses source blocks with YAML delimiters inside' do
+      adoc = <<~ADOC
+        = Doc
+
+        [source]
+        ----
+        ---
+        frontmatter
+        ---
+        ----
+      ADOC
+
+      core = parse_to_core(adoc)
+      expect(core).to be_a(Coradoc::CoreModel::StructuralElement)
+    end
+
+    it 'does not let highlight unconstrained match across lines' do
+      ast = parse_to_ast("## heading\nSome text\n")
+      doc_nodes = ast[:document]
+      paragraphs = doc_nodes.select { |n| n.is_a?(Hash) && n.key?(:paragraph) }
+      highlight_nodes = paragraphs.select do |p|
+        text = p[:paragraph]
+        text.to_s.include?('highlight')
+      end
+      expect(highlight_nodes).to be_empty
+    end
+  end
+
+  describe 'Fix 08: List marker_type' do
+    it 'sets marker_type to unordered for bullet lists' do
+      adoc = <<~ADOC
+        = Doc
+
+        * Item one
+        * Item two
+        * Item three
+      ADOC
+
+      core = parse_to_core(adoc)
+      lists = find_all_lists(core)
+      expect(lists).not_to be_empty
+      expect(lists.first.marker_type).to eq('unordered')
+    end
+
+    it 'sets marker_type to ordered for numbered lists' do
+      adoc = <<~ADOC
+        = Doc
+
+        . First item
+        . Second item
+        . Third item
+      ADOC
+
+      core = parse_to_core(adoc)
+      lists = find_all_lists(core)
+      expect(lists).not_to be_empty
+      expect(lists.first.marker_type).to eq('ordered')
+    end
+  end
+
+  private
+
+  def find_first_table(el)
+    return el if el.is_a?(Coradoc::CoreModel::Table)
+    return nil unless el.is_a?(Coradoc::CoreModel::Base)
+
+    if el.class.attributes.key?(:children) && el.children
+      el.children.each do |child|
+        result = find_first_table(child)
+        return result if result
+      end
+    end
+
+    nil
+  end
+
+  def find_all_xrefs(el)
+    xrefs = []
+    return xrefs unless el
+
+    xrefs << el if el.is_a?(Coradoc::CoreModel::InlineElement) && el.format_type == 'xref'
+
+    children = if el.respond_to?(:children) && el.children
+                 el.children
+               elsif el.is_a?(Coradoc::CoreModel::Base) && el.class.attributes.key?(:children)
+                 el.children
+               end
+
+    children&.each { |c| xrefs.concat(find_all_xrefs(c)) }
+
+    xrefs
+  end
+
+  def find_all_lists(el)
+    lists = []
+    return lists unless el
+
+    lists << el if el.is_a?(Coradoc::CoreModel::ListBlock)
+
+    if el.is_a?(Coradoc::CoreModel::ListBlock) && el.items
+      el.items.each { |c| lists.concat(find_all_lists(c)) }
+    elsif el.is_a?(Coradoc::CoreModel::Base) && el.class.attributes.key?(:children) && el.children
+      el.children.each { |c| lists.concat(find_all_lists(c)) }
+    end
+
+    lists
+  end
+end

data/coradoc-adoc/spec/coradoc/asciidoc/list_continuation_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe 'AsciiDoc List Continuation' do
       expect(result).to be_a(Coradoc::AsciiDoc::Model::Document)
 
       # Navigate to the list
-      contents = result.respond_to?(:contents) ? result.contents : result.sections
+      contents = result.is_a?(Coradoc::AsciiDoc::Model::Document) ? result.sections : result.contents
       list = contents.first
       expect(list).to be_a(Coradoc::AsciiDoc::Model::List::Unordered)
 

data/coradoc-adoc/spec/coradoc/asciidoc/round_trip_spec.rb

@@ -2,7 +2,6 @@
 
 require 'spec_helper'
 
-# rubocop:disable RSpec/DescribeClass
 RSpec.describe 'Round-Trip Conversion' do
   # Helper to parse, transform to CoreModel, transform back, and serialize
   def round_trip(adoc_text)
@@ -258,4 +257,3 @@ RSpec.describe 'Round-Trip Conversion' do
     end
   end
 end
-# rubocop:enable RSpec/DescribeClass

data/coradoc-adoc/spec/coradoc/asciidoc/transform/from_core_model_spec.rb

@@ -32,15 +32,16 @@ RSpec.describe Coradoc::AsciiDoc::Transform::FromCoreModel do
     end
 
     context 'with Block' do
-      it 'transforms a CoreModel Block to AsciiDoc Block' do
+      it 'transforms a CoreModel Block to AsciiDoc Example Block' do
         core_block = Coradoc::CoreModel::Block.new(
+          block_semantic_type: :example,
           delimiter_type: '====',
           content: 'Example content'
         )
 
         result = described_class.transform(core_block)
 
-        expect(result).to be_a(Coradoc::AsciiDoc::Model::Block::Core)
+        expect(result).to be_a(Coradoc::AsciiDoc::Model::Block::Example)
       end
     end
 

data/coradoc-adoc/spec/coradoc/developer_experience_spec.rb

@@ -2,7 +2,6 @@
 
 require 'spec_helper'
 
-# rubocop:disable RSpec/DescribeClass - This is a feature spec for the API facade
 RSpec.describe 'Developer Experience API' do
   # Load coradoc core and asciidoc
 
@@ -121,4 +120,3 @@ RSpec.describe 'Developer Experience API' do
     end
   end
 end
-# rubocop:enable RSpec/DescribeClass

data/coradoc-adoc/spec/transform/from_core_model_spec.rb

@@ -41,18 +41,18 @@ RSpec.describe Coradoc::AsciiDoc::Transform::FromCoreModel do
     end
 
     context 'when transforming a block' do
-      it 'transforms a CoreModel block to AsciiDoc' do
+      it 'transforms a CoreModel example block to AsciiDoc' do
         block = Coradoc::CoreModel::Block.new(
           id: 'example-1',
+          block_semantic_type: :example,
           delimiter_type: '====',
           content: "Line 1\nLine 2"
         )
 
         result = transformer.transform(block)
 
-        expect(result).to be_a(Coradoc::AsciiDoc::Model::Block::Core)
+        expect(result).to be_a(Coradoc::AsciiDoc::Model::Block::Example)
         expect(result.id).to eq('example-1')
-        expect(result.delimiter).to eq('====')
       end
     end
 

data/coradoc-adoc/spec/transform/to_core_model_spec.rb

@@ -54,6 +54,7 @@ RSpec.describe Coradoc::AsciiDoc::Transform::ToCoreModel do
         result = transformer.transform(block)
 
         expect(result).to be_a(Coradoc::CoreModel::Block)
+        expect(result.block_semantic_type).to eq('example')
         expect(result.delimiter_type).to eq('====')
         expect(result.content).to eq("Line 1\nLine 2")
       end

data/coradoc-html/lib/coradoc/html/converters/base.rb

@@ -169,40 +169,64 @@ module Coradoc
             # Get renderable content (children if present, otherwise content)
             renderable = block.renderable_content
 
-            # Check element_type first for paragraph handling
-            case block.element_type
-            when 'paragraph'
+            semantic = resolve_block_semantic_type(block)
+
+            case semantic
+            when :paragraph
               content = convert_content_to_html(renderable, state)
               return "<p#{attrs}>#{content}</p>" if content && !content.empty?
 
               ''
-            end
-
-            # Then check delimiter_type for special blocks
-            case block.delimiter_type
-            when '----', 'source'
+            when :source_code
               lang = block.language || block.metadata&.dig(:language)
               lang_attr = lang ? " data-lang=\"#{escape_attribute(lang)}\"" : ''
               "<pre#{attrs}><code#{lang_attr}>#{escape_html(block.flat_text)}</code></pre>"
-            when '____'
+            when :quote, :verse
               "<blockquote#{attrs}>#{convert_content_to_html(renderable, state)}</blockquote>"
-            when '===='
+            when :example
               "<div class=\"example\"#{attrs}>#{convert_content_to_html(renderable, state)}</div>"
-            when '****'
+            when :sidebar
               "<aside class=\"sidebar\"#{attrs}>#{convert_content_to_html(renderable, state)}</aside>"
-            when '....'
+            when :literal
               "<pre class=\"literal\"#{attrs}>#{escape_html(block.flat_text)}</pre>"
-            when '++++'
-              block.flat_text # Pass through
-            when 'comment'
-              '' # Skip comments in output
-            when '***', '---', '___'
+            when :pass
+              block.flat_text
+            when :listing
+              "<pre#{attrs}>#{escape_html(block.flat_text)}</pre>"
+            when :open
+              "<div#{attrs}>#{convert_content_to_html(renderable, state)}</div>"
+            when :verse
+              "<blockquote#{attrs}>#{convert_content_to_html(renderable, state)}</blockquote>"
+            when :comment, :reviewer
+              ''
+            when :horizontal_rule
               "<hr#{attrs}>"
             else
               "<div#{attrs}>#{convert_content_to_html(renderable, state)}</div>"
             end
           end
 
+          # Resolve the semantic type from a block via polymorphic dispatch.
+          # Block#resolve_semantic_type handles class-level semantic_type →
+          # block_semantic_type attribute → element_type → delimiter fallback.
+          def resolve_block_semantic_type(block)
+            block.resolve_semantic_type ||
+              resolve_format_specific_semantic(block)
+          end
+
+          # Format-specific semantic mappings not covered by the core model
+          def resolve_format_specific_semantic(block)
+            delim = block.delimiter_type
+            return nil unless delim && !delim.empty?
+
+            case delim
+            when "'''", '---', '___', '***' then :horizontal_rule
+            when '[verse]' then :verse
+            when 'comment' then :comment
+            when 'paragraph' then :paragraph
+            end
+          end
+
           # Render CoreModel structural element
           def render_core_structural_element(element, state = {})
             attrs = build_html_attributes(element.id, nil)

data/coradoc-html/lib/coradoc/html/converters/example.rb

@@ -47,8 +47,7 @@ module Coradoc
           # Extract ID if present
           id = element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '====',
+          Coradoc::CoreModel::ExampleBlock.new(
             content: content,
             title: title,
             id: id

data/coradoc-html/lib/coradoc/html/converters/listing.rb

@@ -55,8 +55,7 @@ module Coradoc
           # Extract ID if present
           id = pre_elem['id'] || element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '----',
+          Coradoc::CoreModel::SourceBlock.new(
             content: content,
             title: title,
             id: id

data/coradoc-html/lib/coradoc/html/converters/literal.rb

@@ -58,8 +58,7 @@ module Coradoc
           # Extract ID if present
           id = pre_elem['id'] || element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '....',
+          Coradoc::CoreModel::LiteralBlock.new(
             content: content,
             title: title,
             id: id

data/coradoc-html/lib/coradoc/html/converters/open.rb

@@ -39,8 +39,7 @@ module Coradoc
           # Extract ID if present
           id = element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '--',
+          Coradoc::CoreModel::OpenBlock.new(
             content: content,
             id: id
           )

data/coradoc-html/lib/coradoc/html/converters/quote.rb

@@ -43,11 +43,10 @@ module Coradoc
           # Extract ID if present
           id = element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '____',
+          Coradoc::CoreModel::QuoteBlock.new(
             content: content,
             id: id,
-            metadata: attribution ? { attribution: attribution } : {}
+            attribution: attribution
           )
         end
 

data/coradoc-html/lib/coradoc/html/converters/sidebar.rb

@@ -46,8 +46,7 @@ module Coradoc
           # Extract ID if present
           id = element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '****',
+          Coradoc::CoreModel::SidebarBlock.new(
             content: content,
             title: title,
             id: id

data/coradoc-html/lib/coradoc/html/converters/source.rb

@@ -63,8 +63,7 @@ module Coradoc
           # Extract ID if present
           id = code_elem['id'] || element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '----',
+          Coradoc::CoreModel::SourceBlock.new(
             content: content,
             title: title,
             id: id,

data/coradoc-html/lib/coradoc/html/converters/source_code.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 module Coradoc
   module Html
     module Converters
+      autoload :Base, "#{__dir__}/base"
       # Converter for SourceCode blocks
       #
       # SourceCode models use the `lines` attribute, while Source models use `content`.

data/coradoc-html/lib/coradoc/html/converters/term.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 module Coradoc
   module Html
     module Converters
+      autoload :Base, "#{__dir__}/base"
       # Converter for CoreModel::InlineElement (term) elements
       #
       # Terms are used in definition lists and can have types like "acronym",

data/coradoc-html/lib/coradoc/html/converters/verse.rb

@@ -50,12 +50,11 @@ module Coradoc
           # Extract ID if present
           id = element['id']
 
-          Coradoc::CoreModel::Block.new(
-            delimiter_type: '[verse]',
+          Coradoc::CoreModel::VerseBlock.new(
             content: content,
             title: title,
             id: id,
-            metadata: attribution ? { attribution: attribution } : {}
+            attribution: attribution
           )
         end
 

data/coradoc-html/lib/coradoc/html/input/converters/aside.rb

@@ -10,7 +10,7 @@ module Coradoc
             # Use AnnotationBlock with annotation_type: "sidebar" for aside elements
             Coradoc::CoreModel::AnnotationBlock.new(
               annotation_type: 'sidebar',
-              delimiter_type: '****',
+              block_semantic_type: :sidebar,
               children: content
             )
           end

data/coradoc-html/lib/coradoc/html/input/converters/audio.rb

@@ -16,7 +16,7 @@ module Coradoc
             # with element_attributes to store audio-specific data
             Coradoc::CoreModel::Block.new(
               element_type: 'audio',
-              delimiter_type: 'audio',
+              block_semantic_type: :audio,
               content: src,
               title: title,
               id: id,

data/coradoc-html/lib/coradoc/html/input/converters/blockquote.rb

@@ -10,11 +10,10 @@ module Coradoc
             cite = node['cite']
             content = treat_children_coradoc(node, state)
 
-            Coradoc::CoreModel::Block.new(
-              delimiter_type: '____',
+            Coradoc::CoreModel::QuoteBlock.new(
               content: content,
               id: id,
-              metadata: cite ? { attribution: cite } : {}
+              attribution: cite
             )
           end
         end

data/coradoc-html/lib/coradoc/html/input/converters/div.rb

@@ -9,8 +9,7 @@ module Coradoc
             id = node['id']
             contents = treat_children_coradoc(node, state)
 
-            Coradoc::CoreModel::Block.new(
-              delimiter_type: '--',
+            Coradoc::CoreModel::OpenBlock.new(
               content: contents,
               id: id
             )