coradoc-adoc 2.0.7 → 2.0.9

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(
@@ -344,22 +298,29 @@ module Coradoc
             )
           end
 
-          def transform_definition_list(definition_list)
+          def transform_definition_list(definition_list, depth = 1)
+            delimiter = ':' * (depth + 1)
             items = Array(definition_list.items).map do |item|
-              transform_definition_item(item)
+              transform_definition_item(item, depth)
             end
-            Coradoc::AsciiDoc::Model::List::Definition.new(items: items)
+            list = Coradoc::AsciiDoc::Model::List::Definition.new(items: items)
+            list.delimiter = delimiter
+            list
           end
 
-          def transform_definition_item(item)
+          def transform_definition_item(item, depth = 1)
+            delimiter = ':' * (depth + 1)
             term = Coradoc::AsciiDoc::Model::Term.new(term: item.term.to_s)
             contents = Array(item.definitions).map do |defn|
               Coradoc::AsciiDoc::Model::TextElement.new(content: defn.to_s)
             end
-            Coradoc::AsciiDoc::Model::List::DefinitionItem.new(
+            di = Coradoc::AsciiDoc::Model::List::DefinitionItem.new(
               terms: [term],
-              contents: contents
+              contents: contents,
+              delimiter: delimiter
             )
+            di.nested << transform_definition_list(item.nested, depth + 1) if item.nested&.items&.any?
+            di
           end
 
           def transform_toc(_toc)
@@ -376,35 +337,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 +351,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

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Transform
+      # Visits AsciiDoc inline model nodes and extracts plain text.
+      #
+      # Replaces the 70-line extract_text_content case/when in ToCoreModel.
+      # Each visit_ method handles one model type — locality per element.
+      class TextExtractVisitor
+        def extract(model)
+          visit(model)
+        end
+
+        private
+
+        # Scalars
+        def visit_nil(_)
+          ''
+        end
+
+        def visit_string(model)
+          model
+        end
+
+        def visit_parslet_slice(model)
+          model.to_s
+        end
+
+        # Text carriers
+        def visit_text_element(model)
+          content = model.content
+          content.is_a?(Array) ? visit_array(content) : visit(content)
+        end
+
+        # Inline formatting — recurse into content
+        def visit_inline(model)
+          visit(model.content)
+        end
+
+        def visit_term(model)
+          model.term.to_s
+        end
+
+        def visit_link(model)
+          model.name || model.path || ''
+        end
+
+        def visit_cross_reference(model)
+          model.href || ''
+        end
+
+        def visit_stem(model)
+          model.content.to_s
+        end
+
+        def visit_footnote(model)
+          model.text ? visit(model.text) : ''
+        end
+
+        def visit_attribute_reference(model)
+          "{#{model.name}}"
+        end
+
+        def visit_core_model_text_content(model)
+          model.text.to_s
+        end
+
+        def visit_core_model_image(model)
+          model.alt || model.src || ''
+        end
+
+        def visit_adoc_image(model)
+          model.alt || model.src || ''
+        end
+
+        def visit_base_model(model)
+          model.content ? visit(model.content) : ''
+        end
+
+        def visit_core_model_inline(model)
+          model.content.to_s
+        end
+
+        # Collections
+        def visit_array(models)
+          result = []
+          models.each_with_index do |item, idx|
+            text = visit(item)
+            next if text.empty?
+
+            result << text
+            next unless idx < models.length - 1 && !text.empty?
+
+            result << ' ' if item.is_a?(Model::TextElement) && item.line_break != '+'
+          end
+          result.join
+        end
+
+        # Dispatch
+        def visit(model)
+          case model
+          when nil then visit_nil(model)
+          when String then visit_string(model)
+          when Parslet::Slice then visit_parslet_slice(model)
+          when CoreModel::TextContent then visit_core_model_text_content(model)
+          when CoreModel::Image then visit_core_model_image(model)
+          when CoreModel::InlineElement then visit_core_model_inline(model)
+          when Array then visit_array(model)
+          when Model::TextElement then visit_text_element(model)
+          when Model::Term then visit_term(model)
+          when Model::Inline::Link then visit_link(model)
+          when Model::Inline::CrossReference then visit_cross_reference(model)
+          when Model::Inline::Stem then visit_stem(model)
+          when Model::Inline::Footnote then visit_footnote(model)
+          when Model::Inline::AttributeReference then visit_attribute_reference(model)
+          when Model::Image::Core then visit_adoc_image(model)
+          when Model::Base then visit_base_model(model)
+          else
+            model.class.name.start_with?('Parslet::') ? model.to_s : ''
+          end
+        end
+      end
+    end
+  end
+end