coradoc-adoc 2.0.0 → 2.0.6

data/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) }.compact if model.is_a?(Array)
+            return model.filter_map { |item| transform(item) } if model.is_a?(Array)
             return model unless model.is_a?(Coradoc::AsciiDoc::Model::Base)
 
             transformer = Registry.lookup(model.class)
@@ -79,8 +79,7 @@ module Coradoc
             when Coradoc::AsciiDoc::Model::Inline::Stem
               transform_stem(model)
             when Coradoc::AsciiDoc::Model::CommentBlock
-              Coradoc::CoreModel::Block.new(
-                element_type: 'comment',
+              Coradoc::CoreModel::CommentBlock.new(
                 content: model.text.to_s
               )
             when Coradoc::AsciiDoc::Model::Bibliography
@@ -99,8 +98,7 @@ 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',
+            Coradoc::CoreModel::DocumentElement.new(
               id: doc.id,
               title: title_text,
               attributes: attributes,
@@ -108,14 +106,19 @@ module Coradoc
             )
           end
 
-          def transform_section(section)
+          def transform_section(section, parent_id: nil)
             title_text = extract_title_text(section.title)
+            section_id = section.id || Coradoc::CoreModel::IdGenerator.generate_from_title(
+              title_text, parent_id: parent_id
+            )
+
             content_children = transform(section.contents || [])
-            nested_sections = transform(section.sections || [])
+            nested_sections = (section.sections || []).map do |child|
+              transform_section(child, parent_id: section_id)
+            end
 
-            Coradoc::CoreModel::StructuralElement.new(
-              element_type: 'section',
-              id: section.id,
+            Coradoc::CoreModel::SectionElement.new(
+              id: section_id,
               level: section.level,
               title: title_text,
               children: content_children + nested_sections
@@ -125,9 +128,7 @@ module Coradoc
           def transform_paragraph(para)
             children = transform_inline_content(para.content)
 
-            Coradoc::CoreModel::Block.new(
-              element_type: 'paragraph',
-              block_semantic_type: :paragraph,
+            Coradoc::CoreModel::ParagraphBlock.new(
               id: para.id,
               content: extract_text_content(para.content),
               children: children
@@ -145,7 +146,6 @@ module Coradoc
             language = extract_block_language(block)
 
             Coradoc::CoreModel::SourceBlock.new(
-              element_type: 'block',
               id: block.id,
               title: extract_title_text(block.title),
               content: content_lines,
@@ -162,7 +162,6 @@ module Coradoc
                             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,
@@ -173,16 +172,32 @@ module Coradoc
           end
 
           def transform_typed_block(block, klass, extra_attrs = {})
-            content_lines = extract_block_lines(block)
+            lines = Array(block.lines).reject do |line|
+              line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+            end
 
-            klass.new(
-              element_type: 'block',
-              id: block.id,
-              title: extract_title_text(block.title),
-              content: content_lines,
-              language: extract_block_language(block),
-              **extra_attrs
-            )
+            has_nested_blocks = lines.any?(Coradoc::AsciiDoc::Model::Block::Core)
+
+            if has_nested_blocks
+              children = lines.map { |line| transform(line) }
+              klass.new(
+                id: block.id,
+                title: extract_title_text(block.title),
+                children: children,
+                language: extract_block_language(block),
+                **extra_attrs
+              )
+            else
+              content_lines = lines.map { |line| extract_text_content(line) }.join("\n")
+              klass.new(
+                id: block.id,
+                title: extract_title_text(block.title),
+                content: content_lines,
+                language: extract_block_language(block),
+                **extra_attrs
+              )
+            end
           end
 
           def extract_block_lines(block)
@@ -230,16 +245,40 @@ module Coradoc
             )
           end
 
+          def list_marker_type(list)
+            case list
+            when Coradoc::AsciiDoc::Model::List::Ordered then 'ordered'
+            when Coradoc::AsciiDoc::Model::List::Unordered then 'unordered'
+            when Coradoc::AsciiDoc::Model::List::Definition then 'definition'
+            else 'unordered'
+            end
+          end
+
           def transform_list(list, marker_type)
             items = Array(list.items).map do |item|
               if item.is_a?(Coradoc::AsciiDoc::Model::List::DefinitionItem)
                 term_content = item.terms
                 def_content = item.contents
 
-                Coradoc::CoreModel::DefinitionItem.new(
-                  term: extract_text_content(term_content),
-                  definitions: [extract_text_content(def_content)]
+                # Re-parse raw text through inline parser for structured content
+                term_parts = term_content.is_a?(Array) ? term_content : [term_content]
+                parsed_terms = term_parts.flat_map do |part|
+                  parse_inline_text(part)
+                end
+
+                parsed_defs = parse_inline_text(def_content)
+
+                term_children = transform_inline_content(parsed_terms)
+                def_children = transform_inline_content(parsed_defs)
+
+                di = Coradoc::CoreModel::DefinitionItem.new(
+                  term: extract_text_content(term_children),
+                  definitions: [extract_text_content(def_children)],
+                  term_children: term_children,
+                  definition_children: def_children
                 )
+                di.id = item.id if item.id
+                di
               else
                 content_val = item.content
                 children = transform_inline_content(content_val)
@@ -249,6 +288,18 @@ module Coradoc
                   marker: item.marker
                 )
                 li.children = children
+
+                if item.nested.is_a?(Coradoc::AsciiDoc::Model::List::Core)
+                  nested_core = transform_list(item.nested, list_marker_type(item.nested))
+                  li.children << nested_core
+                elsif item.nested.is_a?(Array)
+                  item.nested.each do |n|
+                    next unless n.is_a?(Coradoc::AsciiDoc::Model::List::Core)
+
+                    li.children << transform_list(n, list_marker_type(n))
+                  end
+                end
+
                 li
               end
             end
@@ -272,54 +323,53 @@ module Coradoc
           end
 
           def transform_admonition(admonition)
-            Coradoc::CoreModel::AnnotationBlock.new(
+            children = transform_inline_content(admonition.content)
+            block = Coradoc::CoreModel::AnnotationBlock.new(
               annotation_type: admonition.type,
               content: extract_text_content(admonition.content)
             )
+            block.children = children
+            block
           end
 
           def transform_inline(inline, format_type)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: format_type,
+            klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
+            klass.new(
               content: extract_text_content(inline.content)
             )
           end
 
           def transform_inline_text(inline, format_type)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: format_type,
+            klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
+            klass.new(
               content: inline.text.to_s
             )
           end
 
           def transform_inline_footnote(footnote)
             parsed_content = parse_and_transform_inline(footnote.text.to_s)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: 'footnote',
+            Coradoc::CoreModel::FootnoteElement.new(
               target: footnote.id,
               content: parsed_content
             )
           end
 
           def transform_link(link)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: 'link',
+            Coradoc::CoreModel::LinkElement.new(
               target: link.path,
               content: link.name || link.path
             )
           end
 
           def transform_cross_reference(xref)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: 'xref',
+            Coradoc::CoreModel::CrossReferenceElement.new(
               target: xref.href,
               content: xref.args&.first || xref.href
             )
           end
 
           def transform_stem(stem)
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: 'stem',
+            Coradoc::CoreModel::StemElement.new(
               content: stem.content,
               stem_type: stem.type || 'stem'
             )
@@ -376,9 +426,13 @@ module Coradoc
           end
 
           def extract_document_attributes(doc)
-            return {} unless doc.document_attributes
+            return nil unless doc.document_attributes
 
-            doc.document_attributes.to_hash
+            metadata = Coradoc::CoreModel::Metadata.new
+            doc.document_attributes.to_hash.each do |key, value|
+              metadata[key.to_s] = value.to_s
+            end
+            metadata
           end
 
           def extract_block_language(block)
@@ -396,26 +450,62 @@ module Coradoc
             positional[1]&.value&.to_s if positional.length > 1
           end
 
+          # Parse raw text through the inline parser to extract inline elements
+          # (anchors, cross-references, monospace, etc.)
+          def parse_inline_text(raw_text)
+            return [] if raw_text.nil? || raw_text.to_s.strip.empty?
+
+            text = raw_text.to_s
+            parser = Coradoc::AsciiDoc::Parser::Base.new
+            transformer = Coradoc::AsciiDoc::Transformer.new
+
+            parsed = parser.text_any.parse(text)
+            result = transformer.apply({ text: parsed })
+
+            case result
+            when Coradoc::AsciiDoc::Model::TextElement
+              result.content.is_a?(Array) ? result.content : [result.content]
+            when Array
+              result
+            when Coradoc::AsciiDoc::Model::Base
+              [result]
+            else
+              [text]
+            end
+          rescue Parslet::ParseFailed
+            [text]
+          end
+
           def transform_inline_content(content)
             return [] if content.nil?
 
             case content
             when Array
-              content.flat_map { |item| transform_inline_content(item) }
+              result = []
+              content.each_with_index do |item, idx|
+                transformed = transform_inline_content(item)
+                next if transformed.empty?
+
+                needs_space = idx.positive? &&
+                              item.is_a?(Coradoc::AsciiDoc::Model::TextElement) &&
+                              item.line_break != '+'
+                result << Coradoc::CoreModel::TextContent.new(text: ' ') if needs_space
+                result.concat(transformed)
+              end
+              result
             when Coradoc::AsciiDoc::Model::TextElement
               transform_inline_content(content.content)
             when Coradoc::AsciiDoc::Model::Term
-              [Coradoc::CoreModel::InlineElement.new(
-                format_type: 'term',
+              [Coradoc::CoreModel::TermElement.new(
                 content: content.term.to_s
               )]
             when String
-              content.empty? ? [] : [content]
+              content.empty? ? [] : [Coradoc::CoreModel::TextContent.new(text: content)]
             when Coradoc::AsciiDoc::Model::Base
               [transform(content)]
             else
               text = extract_text_content(content)
-              text.empty? ? [] : [text]
+              text.empty? ? [] : [Coradoc::CoreModel::TextContent.new(text: text)]
             end
           end
 
@@ -502,8 +592,12 @@ module Coradoc
               "{#{content.name}}"
             when Coradoc::AsciiDoc::Model::Term
               content.term.to_s
+            when Coradoc::CoreModel::TextContent
+              content.text.to_s
             when Coradoc::CoreModel::Image
               content.alt || content.src || ''
+            when Coradoc::AsciiDoc::Model::Image::Core
+              content.alt || content.src || ''
             when Coradoc::AsciiDoc::Model::Base
               if content.content
                 extract_text_content(content.content)
@@ -548,8 +642,8 @@ module Coradoc
 
               transformed = transform_inline_content(content_array)
 
-              if transformed.all? { |item| item.is_a?(String) }
-                transformed.join
+              if transformed.all?(Coradoc::CoreModel::TextContent)
+                transformed.map(&:text).join
               else
                 transformed
               end

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

@@ -64,8 +64,7 @@ module Coradoc
             Registry.register(
               Coradoc::AsciiDoc::Model::CommentBlock,
               lambda { |model|
-                Coradoc::CoreModel::Block.new(
-                  element_type: 'comment',
+                Coradoc::CoreModel::CommentBlock.new(
                   content: model.text.to_s
                 )
               }

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

@@ -19,11 +19,17 @@ module Coradoc
 
               # Convert nested array to proper List object if needed
               if nested.is_a?(Array) && nested.any?
-                first_marker = nested.first.is_a?(Model::List::Item) ? nested.first.marker : marker
-                nested = if first_marker.to_s.start_with?('.', '1', 'a', 'A', 'i', 'I')
-                           Model::List::Ordered.new(items: nested)
+                nested = if nested.all?(Model::List::Core)
+                           nested.first
+                         elsif nested.all?(Model::List::Item)
+                           first_marker = nested.first.marker
+                           if first_marker.to_s.lstrip.start_with?('.', '1', 'a', 'A', 'i', 'I')
+                             Model::List::Ordered.new(items: nested)
+                           else
+                             Model::List::Unordered.new(items: nested)
+                           end
                          else
-                           Model::List::Unordered.new(items: nested)
+                           nested
                          end
               end
 
@@ -61,9 +67,21 @@ module Coradoc
               Model::List::Ordered.new(items: list_items, attrs: attribute_list)
             end
 
-            # Definition list term
-            rule(dlist_term: simple(:term), delimiter: simple(:_delim)) do
-              term.to_s
+            # Definition list term (with optional anchor)
+            rule(dlist_term: subtree(:term_data), delimiter: simple(:_delim)) do
+              case term_data
+              when Hash
+                text = term_data[:text]
+                text = text.to_s if text.is_a?(Parslet::Slice) || text.is_a?(String)
+                text = text.content.to_s if text.is_a?(Model::TextElement)
+                id = term_data[:id]
+                id = id.to_s if id.is_a?(Parslet::Slice)
+                { text: text.to_s, id: id }
+              when Model::TextElement
+                { text: term_data.content.to_s, id: term_data.id }
+              else
+                { text: term_data.to_s, id: nil }
+              end
             end
 
             # Definition list item
@@ -73,7 +91,17 @@ module Coradoc
                 definition: simple(:contents)
               }
             ) do
-              Model::List::DefinitionItem.new(terms: terms, contents: contents)
+              term_strings = terms.map do |t|
+                t.is_a?(Hash) ? t[:text].to_s : t.to_s
+              end
+              item_id = nil
+              terms.each do |t|
+                next unless t.is_a?(Hash) && t[:id]
+
+                item_id = t[:id].to_s
+                break
+              end
+              Model::List::DefinitionItem.new(terms: term_strings, contents: contents, id: item_id)
             end
 
             # Definition list item with hash terms (single term case)
@@ -83,11 +111,13 @@ module Coradoc
               terms_data = item_data[:terms]
               definition = item_data[:definition]
 
-              # Extract terms
+              # Extract terms and optional id from structured dlist_term output
+              item_id = nil
               terms = if terms_data.is_a?(Array)
                         terms_data.map do |t|
-                          if t.is_a?(Hash) && t[:dlist_term]
-                            t[:dlist_term].to_s
+                          if t.is_a?(Hash)
+                            item_id ||= t[:id].to_s if t[:id]
+                            t[:text].to_s
                           else
                             t.to_s
                           end
@@ -97,11 +127,9 @@ module Coradoc
                       end
 
               # Extract definition
-              if definition.is_a?(Parslet::Slice)
-              end
               contents = definition.to_s
 
-              Model::List::DefinitionItem.new(terms: terms, contents: contents)
+              Model::List::DefinitionItem.new(terms: terms, contents: contents, id: item_id)
             end
 
             rule(definition_list: sequence(:list_items)) do
@@ -115,14 +143,6 @@ module Coradoc
             ) do
               Model::List::Definition.new(items: list_items, attrs: attribute_list)
             end
-
-            # List containing definition_list
-            rule(
-              attribute_list: simple(:attribute_list),
-              definition_list: sequence(:list_items)
-            ) do
-              Model::List::Definition.new(items: list_items, attrs: attribute_list)
-            end
           end
         end
       end

data/lib/coradoc/asciidoc/transformer.rb

@@ -223,8 +223,11 @@ module Coradoc
           cell_opts[:repeat] = true if format_str.include?('*')
         end
 
+        # Strip escaped delimiters (\| → |) in cell content
+        unescaped_content = content.to_s.gsub(/\\([|!,:;])/, '\1')
+
         # Parse content based on style
-        parsed_content = parse_inline_content(content, style)
+        parsed_content = parse_inline_content(unescaped_content, style)
         cell_opts[:content] = parsed_content
 
         Model::TableCell.new(**cell_opts)

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.0'
+    VERSION = '2.0.6'
   end
 end

data/lib/coradoc/asciidoc.rb

@@ -32,6 +32,7 @@ module Coradoc
     autoload :Transformer, "#{__dir__}/asciidoc/transformer"
     autoload :Serializer, "#{__dir__}/asciidoc/serializer"
     autoload :Transform, "#{__dir__}/asciidoc/transform"
+    autoload :Builder, "#{__dir__}/asciidoc/builder"
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.6
 platform: ruby
 authors:
 - Ribose Inc.
@@ -13,30 +13,30 @@ dependencies:
   name: coradoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -103,7 +103,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- Rakefile
 - lib/coradoc/asciidoc.rb
+- lib/coradoc/asciidoc/builder.rb
+- lib/coradoc/asciidoc/builder/block_builder.rb
+- lib/coradoc/asciidoc/builder/detection.rb
+- lib/coradoc/asciidoc/builder/element_builder.rb
+- lib/coradoc/asciidoc/builder/list_builder.rb
+- lib/coradoc/asciidoc/builder/text_builder.rb
 - lib/coradoc/asciidoc/model.rb
 - lib/coradoc/asciidoc/model/admonition.rb
 - lib/coradoc/asciidoc/model/anchorable.rb
@@ -330,7 +337,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="