coradoc-adoc 2.0.7 → 2.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a29195095ab66adca7be3bdfcb331f71fdd69954c09ea3fc0cef33c4583b8d8c
-  data.tar.gz: 805db091f5043a01ce0b4ff1501c009814c4fdd079ca402a0232b2e3abf073dd
+  metadata.gz: d76a16bad8dc3e4567d425b8c464bd4469db6bb55cab06aa48621ffe8ed2dc60
+  data.tar.gz: 7d2c531af059b0108780acdeace458051a5f484cb130f695d329cd5e1c7376c0
 SHA512:
-  metadata.gz: a306bb17db95c5732e1a7e76f101c45a00363c356ebdc0b3d699961caa1a82c6ce2be1f69c531922cb83f53eb49c58735ca814e14a0559a431ee8c9a5ed56a00
-  data.tar.gz: 42c724be473f6bbdd0b9db339b0ac5a02590fa760f74178088536226380994ef52a812bb7730038e5fe66e25ad888a03b0a4b38c993dbdb5748a4f56e00923df
+  metadata.gz: ae0aed7da09b650dd45e5781f929b99923530840741509be68721f8a978511840d0f211b7572997309f40205597fccce47e914f0fa2a33d606865ffa8d927404
+  data.tar.gz: 7b09ddcf81d699f4deab3c6a7dbb74f42c91dddf1607ea20b1dfe439fd0fafa05144b5f667b3391e6b9e05542c6cb321012467598b7fe492160aa58383dfb05f

data/lib/coradoc/asciidoc/delimiter_mapping.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module DelimiterMapping
+      CHAR_TO_SEMANTIC = {
+        '-' => :source_code,
+        '=' => :example,
+        '_' => :quote,
+        '*' => :sidebar,
+        '.' => :literal,
+        '+' => :pass
+      }.freeze
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/block_transformer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class BlockTransformer
+          class << self
+            def transform_paragraph(para)
+              children = ToCoreModel.transform_inline_content(para.content)
+
+              Coradoc::CoreModel::ParagraphBlock.new(
+                id: para.id,
+                content: ToCoreModel.extract_text_content(para.content),
+                children: children
+              )
+            end
+
+            def transform_source_block(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)
+              end
+              content_lines = non_break_lines.map do |line|
+                ToCoreModel.extract_text_content(line)
+              end.join("\n")
+
+              language = ToCoreModel.extract_block_language(block)
+
+              Coradoc::CoreModel::SourceBlock.new(
+                id: block.id,
+                title: ToCoreModel.extract_title_text(block.title),
+                content: content_lines,
+                language: language
+              )
+            end
+
+            def transform_block(block, semantic_type_or_delimiter)
+              content_lines = ToCoreModel.extract_block_lines(block)
+              semantic_type = if semantic_type_or_delimiter.is_a?(Symbol)
+                                semantic_type_or_delimiter
+                              else
+                                ToCoreModel.asciidoc_delimiter_to_semantic(semantic_type_or_delimiter)
+                              end
+
+              Coradoc::CoreModel::Block.new(
+                block_semantic_type: semantic_type,
+                delimiter_type: semantic_type_or_delimiter.is_a?(String) ? semantic_type_or_delimiter : nil,
+                id: block.id,
+                title: ToCoreModel.extract_title_text(block.title),
+                content: content_lines,
+                language: ToCoreModel.extract_block_language(block)
+              )
+            end
+
+            def transform_typed_block(block, klass, extra_attrs = {})
+              lines = Array(block.lines).reject do |line|
+                line.is_a?(Coradoc::AsciiDoc::Model::LineBreak) ||
+                  line.is_a?(Coradoc::AsciiDoc::Model::Break::PageBreak)
+              end
+
+              has_nested_blocks = lines.any?(Coradoc::AsciiDoc::Model::Block::Core)
+
+              if has_nested_blocks
+                children = lines.map { |line| ToCoreModel.transform(line) }
+                klass.new(
+                  id: block.id,
+                  title: ToCoreModel.extract_title_text(block.title),
+                  children: children,
+                  language: ToCoreModel.extract_block_language(block),
+                  **extra_attrs
+                )
+              else
+                content_lines = lines.map { |line| ToCoreModel.extract_text_content(line) }.join("\n")
+                klass.new(
+                  id: block.id,
+                  title: ToCoreModel.extract_title_text(block.title),
+                  content: content_lines,
+                  language: ToCoreModel.extract_block_language(block),
+                  **extra_attrs
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/document_transformer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class DocumentTransformer
+          class << self
+            def transform_document(doc)
+              title_text = ToCoreModel.extract_title_text(doc.header&.title)
+              attributes = ToCoreModel.extract_document_attributes(doc)
+              Coradoc::CoreModel::DocumentElement.new(
+                id: doc.id,
+                title: title_text,
+                attributes: attributes,
+                children: ToCoreModel.transform(doc.sections || doc.contents || [])
+              )
+            end
+
+            def transform_section(section, parent_id: nil)
+              title_text = ToCoreModel.extract_title_text(section.title)
+              section_id = section.id || Coradoc::CoreModel::IdGenerator.generate_from_title(
+                title_text, parent_id: parent_id
+              )
+
+              content_children = ToCoreModel.transform(section.contents || [])
+              nested_sections = (section.sections || []).map do |child|
+                transform_section(child, parent_id: section_id)
+              end
+
+              Coradoc::CoreModel::SectionElement.new(
+                id: section_id,
+                level: section.level,
+                title: title_text,
+                children: content_children + nested_sections
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/inline_transformer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class InlineTransformer
+          class << self
+            def transform_inline(inline, format_type)
+              klass = Coradoc::CoreModel::InlineElement.format_type_class(format_type)
+              klass.new(
+                content: ToCoreModel.extract_text_content(inline.content)
+              )
+            end
+
+            def transform_inline_text(inline, 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 = ToCoreModel.parse_and_transform_inline(footnote.text.to_s)
+              Coradoc::CoreModel::FootnoteElement.new(
+                target: footnote.id,
+                content: parsed_content
+              )
+            end
+
+            def transform_link(link)
+              Coradoc::CoreModel::LinkElement.new(
+                target: link.path,
+                content: link.name || link.path
+              )
+            end
+
+            def transform_cross_reference(xref)
+              Coradoc::CoreModel::CrossReferenceElement.new(
+                target: xref.href,
+                content: xref.args&.first || xref.href
+              )
+            end
+
+            def transform_stem(stem)
+              Coradoc::CoreModel::StemElement.new(
+                content: stem.content,
+                stem_type: stem.type || 'stem'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/list_transformer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class ListTransformer
+          class << self
+            def transform_list(list, marker_type)
+              items = Array(list.items).map do |item|
+                if item.is_a?(Coradoc::AsciiDoc::Model::List::DefinitionItem)
+                  transform_definition_item(item)
+                else
+                  transform_list_item(item)
+                end
+              end
+
+              if marker_type == 'definition'
+                Coradoc::CoreModel::DefinitionList.new(items: items)
+              else
+                Coradoc::CoreModel::ListBlock.new(
+                  marker_type: marker_type,
+                  items: items
+                )
+              end
+            end
+
+            private
+
+            def transform_definition_item(item)
+              term_content = item.terms
+              def_content = item.contents
+
+              term_parts = term_content.is_a?(Array) ? term_content : [term_content]
+              parsed_terms = term_parts.flat_map do |part|
+                ToCoreModel.parse_inline_text(part)
+              end
+
+              parsed_defs = ToCoreModel.parse_inline_text(def_content)
+
+              term_children = ToCoreModel.transform_inline_content(parsed_terms)
+              def_children = ToCoreModel.transform_inline_content(parsed_defs)
+
+              di = Coradoc::CoreModel::DefinitionItem.new(
+                term: ToCoreModel.extract_text_content(term_children),
+                definitions: [ToCoreModel.extract_text_content(def_children)],
+                term_children: term_children,
+                definition_children: def_children
+              )
+              di.id = item.id if item.id
+              di
+            end
+
+            def transform_list_item(item)
+              content_val = item.content
+              children = ToCoreModel.transform_inline_content(content_val)
+
+              li = Coradoc::CoreModel::ListItem.new(
+                content: ToCoreModel.extract_text_content(content_val),
+                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
+
+            def list_marker_type(list)
+              case list
+              when Coradoc::AsciiDoc::Model::List::Ordered then 'ordered'
+              when Coradoc::AsciiDoc::Model::List::Definition then 'definition'
+              else 'unordered'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/other_transformer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class OtherTransformer
+          class << self
+            def transform_term(term)
+              Coradoc::CoreModel::Term.new(
+                text: term.term.to_s,
+                type: term.type&.to_s || 'preferred',
+                lang: term.lang&.to_s || 'en'
+              )
+            end
+
+            def transform_admonition(admonition)
+              children = ToCoreModel.transform_inline_content(admonition.content)
+              block = Coradoc::CoreModel::AnnotationBlock.new(
+                annotation_type: admonition.type,
+                content: ToCoreModel.extract_text_content(admonition.content)
+              )
+              block.children = children
+              block
+            end
+
+            def transform_image(image)
+              Coradoc::CoreModel::Image.new(
+                src: image.src,
+                alt: image.title&.to_s,
+                width: image.attributes&.[]('width'),
+                height: image.attributes&.[]('height')
+              )
+            end
+
+            def transform_bibliography(bib)
+              entries = Array(bib.entries).map do |entry|
+                transform_bibliography_entry(entry)
+              end
+
+              Coradoc::CoreModel::Bibliography.new(
+                id: bib.id,
+                title: bib.title.to_s,
+                level: nil,
+                entries: entries
+              )
+            end
+
+            def transform_bibliography_entry(entry)
+              Coradoc::CoreModel::BibliographyEntry.new(
+                anchor_name: entry.anchor_name,
+                document_id: entry.document_id,
+                ref_text: entry.ref_text.to_s
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/transform/element_transformers/table_transformer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        class TableTransformer
+          class << self
+            def transform_table(table)
+              rows = Array(table.rows).map do |row|
+                transform_table_row(row)
+              end
+
+              Coradoc::CoreModel::Table.new(
+                id: table.id,
+                title: table.title&.to_s,
+                rows: rows
+              )
+            end
+
+            def transform_table_row(row)
+              cells = Array(row.columns).map do |cell|
+                transform_table_cell(cell)
+              end
+              Coradoc::CoreModel::TableRow.new(
+                cells: cells,
+                header: row.header
+              )
+            end
+
+            def transform_table_cell(cell)
+              children = ToCoreModel.transform_inline_content(cell.content)
+
+              Coradoc::CoreModel::TableCell.new(
+                content: ToCoreModel.extract_text_content(cell.content),
+                alignment: cell.horizontal_alignment,
+                vertical_alignment: cell.vertical_alignment,
+                colspan: cell.colspan,
+                rowspan: cell.rowspan,
+                style: cell.style_name,
+                children: children
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      module ElementTransformers
+        autoload :DocumentTransformer, "#{__dir__}/element_transformers/document_transformer"
+        autoload :BlockTransformer, "#{__dir__}/element_transformers/block_transformer"
+        autoload :ListTransformer, "#{__dir__}/element_transformers/list_transformer"
+        autoload :InlineTransformer, "#{__dir__}/element_transformers/inline_transformer"
+        autoload :TableTransformer, "#{__dir__}/element_transformers/table_transformer"
+        autoload :OtherTransformer, "#{__dir__}/element_transformers/other_transformer"
+      end
+    end
+  end
+end

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

@@ -7,9 +7,7 @@ module Coradoc
     module Transform
       # Transforms CoreModel to AsciiDoc models
       class FromCoreModel
-        def transform(model)
-          self.class.transform(model)
-        end
+        include Coradoc::Transform::Base
 
         class << self
           def transform(model)
@@ -17,52 +15,7 @@ module Coradoc
             return model unless model.is_a?(Coradoc::CoreModel::Base)
 
             transformer = Registry.lookup(model.class)
-            return transformer.call(model) if transformer
-
-            transform_with_case(model)
-          end
-
-          def transform_with_case(model)
-            case model
-            when Coradoc::CoreModel::StructuralElement
-              transform_structural_element(model)
-            when Coradoc::CoreModel::AnnotationBlock
-              transform_annotation(model)
-            when Coradoc::CoreModel::Block
-              transform_block(model)
-            when Coradoc::CoreModel::Table
-              transform_table(model)
-            when Coradoc::CoreModel::ListBlock
-              transform_list(model)
-            when Coradoc::CoreModel::ListItem
-              transform_list_item(model)
-            when Coradoc::CoreModel::Term
-              transform_term(model)
-            when Coradoc::CoreModel::InlineElement
-              transform_inline(model)
-            when Coradoc::CoreModel::Image
-              transform_image(model)
-            when Coradoc::CoreModel::Footnote
-              transform_footnote(model)
-            when Coradoc::CoreModel::FootnoteReference
-              transform_footnote_reference(model)
-            when Coradoc::CoreModel::Abbreviation
-              transform_abbreviation(model)
-            when Coradoc::CoreModel::DefinitionList
-              transform_definition_list(model)
-            when Coradoc::CoreModel::DefinitionItem
-              transform_definition_item(model)
-            when Coradoc::CoreModel::Toc
-              transform_toc(model)
-            when Coradoc::CoreModel::TocEntry
-              transform_toc_entry(model)
-            when Coradoc::CoreModel::Bibliography
-              transform_bibliography(model)
-            when Coradoc::CoreModel::BibliographyEntry
-              transform_bibliography_entry(model)
-            else
-              model
-            end
+            transformer ? transformer.call(model) : model
           end
 
           def transform_structural_element(element)
@@ -173,7 +126,8 @@ module Coradoc
               Coradoc::AsciiDoc::Model::Block::Quote.new(
                 id: block.id,
                 title: block.title,
-                lines: content_text.split("\n")
+                lines: content_text.split("\n"),
+                delimiter: '[verse]'
               )
             when :reviewer
               Coradoc::AsciiDoc::Model::Block::ReviewerComment.new(
@@ -183,7 +137,7 @@ module Coradoc
               )
             else
               delim = block.delimiter_type.to_s
-              delim_char = delim.chars.first
+              delim_char = delim[0]
               delim_len = delim.length
 
               Coradoc::AsciiDoc::Model::Block::Core.new(
@@ -376,35 +330,10 @@ 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)
             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?
 
@@ -415,7 +344,7 @@ module Coradoc
             when "'''", '---', '___', '***' then :horizontal_rule
             else
               char = delim[0]
-              DELIMITER_CHAR_TO_SEMANTIC[char] || nil
+              DelimiterMapping::CHAR_TO_SEMANTIC[char] || nil
             end
           end
 

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      # Visits AsciiDoc inline content and produces CoreModel inline elements.
+      #
+      # Replaces the 50-line transform_inline_content case/when in ToCoreModel.
+      # Handles whitespace insertion between adjacent TextElements.
+      class InlineTransformVisitor
+        def initialize(to_core_model)
+          @to_core_model = to_core_model
+        end
+
+        def transform(content)
+          visit_content(content)
+        end
+
+        private
+
+        def visit_content(content)
+          case content
+          when nil then []
+          when Array then visit_array(content)
+          when Model::TextElement then visit_content(content.content)
+          when Model::Term
+            [CoreModel::TermElement.new(content: content.term.to_s)]
+          when String
+            content.empty? ? [] : [CoreModel::TextContent.new(text: content)]
+          when Model::Base
+            [visit_model(content)]
+          else
+            text = TextExtractVisitor.new.extract(content)
+            text.empty? ? [] : [CoreModel::TextContent.new(text: text)]
+          end
+        end
+
+        def visit_array(items)
+          result = []
+          items.each_with_index do |item, idx|
+            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.concat(transformed)
+          end
+          result
+        end
+
+        def visit_model(model)
+          @to_core_model.transform(model)
+        end
+      end
+    end
+  end
+end