coradoc-adoc 2.0.0 → 2.0.6

data/lib/coradoc/asciidoc/builder.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Builder
+      autoload :Detection, "#{__dir__}/builder/detection"
+      autoload :ListBuilder, "#{__dir__}/builder/list_builder"
+      autoload :BlockBuilder, "#{__dir__}/builder/block_builder"
+      autoload :TextBuilder, "#{__dir__}/builder/text_builder"
+      autoload :ElementBuilder, "#{__dir__}/builder/element_builder"
+
+      include Detection
+      include ListBuilder
+      include BlockBuilder
+      include TextBuilder
+      include ElementBuilder
+
+      def self.build(ast)
+        new.build_document(ast)
+      end
+
+      def build_document(ast)
+        return nil unless ast.is_a?(Hash)
+
+        if ast.key?(:document)
+          build_document_elements(ast[:document])
+        else
+          build_document_elements(ast)
+        end
+      end
+
+      def build_element(ast)
+        return nil unless ast.is_a?(Hash)
+
+        case detect_element_type(ast)
+        when :header
+          build_header(ast)
+        when :section
+          build_section(ast)
+        when :block
+          build_block(ast)
+        when :list
+          build_list(ast)
+        when :paragraph
+          build_paragraph(ast)
+        when :inline
+          build_inline(ast)
+        when :text
+          build_text(ast)
+        when :attribute
+          build_attribute(ast)
+        when :document_attributes
+          build_document_attributes(ast)
+        when :line_break
+          build_line_break(ast)
+        when :comment_line
+          build_comment_line(ast)
+        when :comment_block
+          build_comment_block(ast)
+        when :include
+          build_include(ast)
+        when :table
+          build_table(ast)
+        when :unparsed
+          build_unparsed(ast)
+        when :tag
+          build_tag(ast)
+        when :bibliography_entry
+          build_bibliography_entry(ast)
+        else
+          build_generic_element(ast)
+        end
+      end
+
+      def build_block(ast)
+        block_ast = ast[:block] || ast
+
+        case detect_block_type(block_ast)
+        when :annotation
+          build_annotation_block(block_ast)
+        when :list
+          build_list_block(block_ast)
+        else
+          build_generic_block(block_ast)
+        end
+      end
+
+      def build_list(ast)
+        if ast[:unordered]
+          build_unordered_list(ast)
+        elsif ast[:ordered]
+          build_ordered_list(ast)
+        elsif ast[:definition_list]
+          build_definition_list(ast)
+        else
+          build_list_block(ast)
+        end
+      end
+
+      def build_paragraph(ast)
+        para_ast = ast[:paragraph] || ast
+
+        Coradoc::CoreModel::ParagraphBlock.new(
+          content: build_paragraph_content(para_ast[:lines]).join("\n"),
+          id: para_ast[:id],
+          title: para_ast[:title]
+        )
+      end
+
+      def build_inline(ast)
+        format_type = detect_inline_format(ast)
+        klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
+
+        klass.new(
+          constrained: detect_constrained(ast, format_type),
+          content: extract_inline_content(ast, format_type),
+          nested_elements: build_nested_inlines(ast)
+        )
+      end
+
+      def build_attributes(attr_ast)
+        return [] unless attr_ast
+
+        case attr_ast
+        when Hash
+          attributes = []
+
+          if attr_ast[:positional]
+            Array(attr_ast[:positional]).each do |pos|
+              attributes << Coradoc::CoreModel::ElementAttribute.new(
+                name: pos.to_s
+              )
+            end
+          end
+
+          if attr_ast[:named]
+            Array(attr_ast[:named]).each do |named|
+              next unless named.is_a?(Hash)
+
+              attributes << Coradoc::CoreModel::ElementAttribute.new(
+                name: named[:key] || named[:named_key],
+                value: named[:value] || named[:named_value]
+              )
+            end
+          end
+
+          attributes
+        when Array
+          attr_ast.map { |attr| build_attribute(attr) }.compact
+        else
+          []
+        end
+      end
+
+      def build_document_attributes(ast)
+        attrs_ast = ast[:document_attributes] || ast
+
+        Array(attrs_ast).map do |attr|
+          Coradoc::CoreModel::ElementAttribute.new(
+            key: attr[:key],
+            value: attr[:value]
+          )
+        end
+      end
+
+      private
+
+      def build_text(ast)
+        Coradoc::CoreModel::InlineElement.new(
+          content: extract_text_content(ast)
+        )
+      end
+
+      def build_paragraph_content(lines)
+        return [] unless lines
+
+        Array(lines).map { |line| extract_text_content(line) }
+      end
+
+      def build_document_elements(ast)
+        elements = []
+
+        elements << build_header(ast) if ast[:header]
+
+        if ast[:sections]
+          elements.concat(
+            Array(ast[:sections]).map { |s| build_element(s) }.compact
+          )
+        end
+
+        elements << build_document_attributes(ast) if ast[:document_attributes]
+
+        %i[paragraph block list table].each do |key|
+          next unless ast[key]
+
+          Array(ast[key]).each do |item|
+            elements << build_element({ key => item })
+          end
+        end
+
+        group_document_elements(elements)
+      end
+
+      def group_document_elements(elements)
+        header = elements.find { |e| e.is_a?(CoreModel::HeaderElement) }
+        sections = elements.select { |e| e.is_a?(CoreModel::SectionElement) }
+        doc_attrs = elements.select { |e| e.is_a?(CoreModel::ElementAttribute) }
+        other_content = elements.reject do |e|
+          e.is_a?(CoreModel::HeaderElement) ||
+            e.is_a?(CoreModel::SectionElement) ||
+            e.is_a?(CoreModel::ElementAttribute)
+        end
+
+        result = {}
+        result[:header] = header if header
+        result[:sections] = sections if sections.any?
+        result[:content] = other_content if other_content.any?
+        result[:document_attributes] = doc_attrs if doc_attrs.any?
+        result
+      end
+
+      def build_attributes_private(attr_ast)
+        build_attributes(attr_ast)
+      end
+    end
+  end
+end

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

@@ -138,8 +138,7 @@ module Coradoc
                 sections << element
 
               else
-                warn "Unknown element type: #{element.class}"
-                warn "Element: #{element.inspect}"
+                next if element.is_a?(String)
               end
             end
 

data/lib/coradoc/asciidoc/model/serialization/asciidoc_mapping.rb

@@ -7,6 +7,7 @@ module Coradoc
         # Define the DSL for defining mappings in Asciidoc format
         class AsciidocMapping < Lutaml::Model::Mapping
           attr_reader :mappings
+          attr_writer :mappings
 
           def initialize
             super

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

@@ -90,13 +90,13 @@ module Coradoc
             alias_name = :"#{rule_name}_#{dispatch_hash}"
             Coradoc::AsciiDoc::Parser::Base.class_exec do
               rule(alias_name) do
-                send(rule_name, *args, **kwargs)
+                public_send(rule_name, *args, **kwargs)
               end
             end
             @dispatch_data[dispatch_hash] = alias_name
           end
           dispatch_method = @dispatch_data[dispatch_hash]
-          send(dispatch_method)
+          public_send(dispatch_method)
         end
 
         def self.config(key)
@@ -140,7 +140,7 @@ module Coradoc
             Coradoc::AsciiDoc::Parser::Base.class_exec do
               alias_method alias_name, rule_name
               rule(rule_name) do
-                send(alias_name)
+                public_send(alias_name)
               end
             end
           elsif config(:add_dispatch) && config(:with_params)

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

@@ -74,11 +74,11 @@ module Coradoc
         end
 
         def block_content(n_deep = 3)
-          c = block_image |
-              list |
-              text_line(false, unguarded: true) |
-              empty_line.as(:line_break)
+          c = block_image
           c |= block(n_deep - 1) if n_deep.positive?
+          c |= list
+          c |= text_line(false, unguarded: true)
+          c |= empty_line.as(:line_break)
           c.repeat(1)
         end
 
@@ -111,27 +111,22 @@ module Coradoc
         # @param repeater [Integer] Minimum number of delimiter characters (default: 4)
         # @param type [Symbol] Block type for special handling (e.g., :pass)
         def block_style(n_deep = 3, delimiter = '*', repeater = 4, type = nil, verbatim: false)
-          # repeat(repeater,) means repeater or more characters
-          current_delimiter = str(delimiter).repeat(repeater).capture(:delimit)
+          capture_key = :"delimit_#{delimiter}_#{n_deep}"
+          current_delimiter = str(delimiter).repeat(repeater).capture(capture_key)
           closing_delimiter = dynamic do |_s, c|
-            str(c.captures[:delimit].to_s.strip)
+            str(c.captures[capture_key].to_s.strip)
           end
 
-          # Create a block content parser that respects the closing delimiter
-          # This prevents nested blocks from consuming the closing delimiter
           block_content_with_closing = dynamic do |_s, c|
-            delim_str = c.captures[:delimit].to_s.strip
+            delim_str = c.captures[capture_key].to_s.strip
             closing_pattern = str(delim_str) >> newline
 
-            # Build content that doesn't match the closing delimiter
-            content = block_image | list | text_line(false, unguarded: true,
-                                                            verbatim: verbatim) | empty_line.as(:line_break)
-            if n_deep.positive?
-              # For nested blocks, also prevent them from consuming the closing delimiter
-              content |= block(n_deep - 1)
-            end
+            content = block_image
+            content |= block(n_deep - 1) if n_deep.positive?
+            content |= list
+            content |= text_line(false, unguarded: true, verbatim: verbatim)
+            content |= empty_line.as(:line_break)
 
-            # Each content element must not start with the closing delimiter
             (closing_pattern.absent? >> content).repeat(1)
           end
 
@@ -142,7 +137,6 @@ module Coradoc
             if type == :pass
               (text_line(false, unguarded: true, verbatim: verbatim) | empty_line.as(:line_break)).repeat(1).as(:lines)
             else
-              # Use dynamic block content that respects closing delimiter
               block_content_with_closing.as(:lines)
             end >>
             line_start? >>
@@ -152,18 +146,21 @@ module Coradoc
         # Block style parser with EXACT delimiter length (for open blocks)
         # Open blocks use exactly 2 dashes and cannot nest within themselves
         def block_style_exact(n_deep = 3, delimiter = '-', exact_chars = 2, type = nil)
-          current_delimiter = str(delimiter).repeat(exact_chars, exact_chars).capture(:delimit)
+          capture_key = :"delimit_#{delimiter}_exact_#{exact_chars}_#{n_deep}"
+          current_delimiter = str(delimiter).repeat(exact_chars, exact_chars).capture(capture_key)
           closing_delimiter = dynamic do |_s, c|
-            str(c.captures[:delimit].to_s.strip)
+            str(c.captures[capture_key].to_s.strip)
           end
 
-          # Create a block content parser that respects the closing delimiter
           block_content_with_closing = dynamic do |_s, c|
-            delim_str = c.captures[:delimit].to_s.strip
+            delim_str = c.captures[capture_key].to_s.strip
             closing_pattern = str(delim_str) >> newline
 
-            content = block_image | list | text_line(false, unguarded: true) | empty_line.as(:line_break)
+            content = block_image
             content |= block(n_deep - 1) if n_deep.positive?
+            content |= list
+            content |= text_line(false, unguarded: true)
+            content |= empty_line.as(:line_break)
 
             (closing_pattern.absent? >> content).repeat(1)
           end

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

@@ -41,13 +41,10 @@ module Coradoc
 
         def olist_marker(nesting_level = 1)
           # Don't match table cell format specs like ".2+^.^|"
-          # Table cells have format: [colspan][.rowspan][halign][valign][style][*]|
-          # If we see a format spec pattern followed by "|", it's a table cell, not a list
           line_start? >>
+            (nesting_level > 1 ? literal_space.maybe : str('')) >>
             str('.' * nesting_level) >>
             str('.').absent? >>
-            # Don't match if followed by table cell format spec
-            # Pattern: digits, dots, plus, alignment chars (^<>), style letters, then |
             (
               (match['0-9.<>^'] | str('+')).repeat(0, 3) >> str('|')
             ).absent?
@@ -75,11 +72,10 @@ module Coradoc
         end
 
         def ulist_marker(nesting_level = 1)
-          # Don't match table delimiters like "|==="
           line_start? >>
+            (nesting_level > 1 ? literal_space.maybe : str('')) >>
             str('*' * nesting_level) >>
             str('*').absent? >>
-            # Don't match if followed by "===" (table delimiter)
             str('===').absent?
         end
 
@@ -107,8 +103,10 @@ module Coradoc
         end
 
         def dlist_term(_delimiter)
-          match("[^\n:]").repeat(1) # >> empty_line.repeat(0)
-                         .as(:dlist_term) >> dlist_delimiter
+          (element_id_inline.maybe >>
+            match("[^\n:]").repeat(1)
+                           .as(:text)
+          ).as(:dlist_term) >> dlist_delimiter
         end
 
         def dlist_definition

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

@@ -142,12 +142,12 @@ module Coradoc
             new_row_signal = newline >> (str(delim_char) | format_spec_then_delim)
 
             # A single content character - match any char that doesn't signal end of cell
+            # Handle escaped delimiter (\|) as a literal delimiter character
+            escaped_delimiter = str('\\') >> str(delim_char)
             (
               str(closing_delim).absent? >>
               new_row_signal.absent? >>
-              str(delim_char).absent? >>
-              format_spec_then_delim.absent? >>
-              any
+              (escaped_delimiter | (str(delim_char).absent? >> any))
             ).repeat(0)
           end
         end

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

@@ -66,8 +66,8 @@ module Coradoc
           end
 
           def transform_structural_element(element)
-            case element.element_type
-            when 'document'
+            case element
+            when CoreModel::DocumentElement
               header = if element.title
                          Coradoc::AsciiDoc::Model::Header.new(
                            title: Coradoc::AsciiDoc::Model::Title.new(
@@ -84,7 +84,7 @@ module Coradoc
                 header: header,
                 sections: transform(element.children)
               )
-            when 'section'
+            when CoreModel::SectionElement
               Coradoc::AsciiDoc::Model::Section.new(
                 id: element.id,
                 level: element.level,
@@ -257,7 +257,7 @@ module Coradoc
           end
 
           def transform_inline(inline)
-            case inline.format_type
+            case inline.resolve_format_type
             when 'bold'
               Coradoc::AsciiDoc::Model::Inline::Bold.new(content: inline.content)
             when 'italic'
@@ -401,7 +401,6 @@ module Coradoc
           }.freeze
 
           def resolve_semantic_type(block)
-            # Polymorphic dispatch: typed classes override semantic_type
             semantic = block.resolve_semantic_type
             return semantic if semantic
 
@@ -411,7 +410,6 @@ module Coradoc
 
             case delim
             when 'comment' then :comment
-            when 'paragraph' then :paragraph
             when '[verse]' then :verse
             when '>' then :quote
             when "'''", '---', '___', '***' then :horizontal_rule