coradoc-markdown 1.0.0

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

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    module Transform
+      # Transforms CoreModel models to Markdown equivalents
+      #
+      # This transformer converts the canonical CoreModel representation
+      # to format-specific Markdown model.
+      class FromCoreModel
+        class << self
+          # Transform a CoreModel to Markdown model
+          #
+          # @param model [Coradoc::CoreModel::Base] CoreModel to transform
+          # @return [Coradoc::Markdown::Base] Markdown model equivalent
+          def transform(model)
+            case model
+            when Coradoc::CoreModel::StructuralElement
+              transform_structural_element(model)
+            when Coradoc::CoreModel::AnnotationBlock
+              # Must be checked before Block since AnnotationBlock < Block
+              transform_annotation_block(model)
+            when Coradoc::CoreModel::Block
+              transform_block(model)
+            when Coradoc::CoreModel::ListBlock
+              transform_list(model)
+            when Coradoc::CoreModel::DefinitionList
+              transform_definition_list(model)
+            when Coradoc::CoreModel::Table
+              transform_table(model)
+            when Coradoc::CoreModel::Image
+              transform_image(model)
+            when Coradoc::CoreModel::InlineElement
+              transform_inline(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::Toc
+              Coradoc::Markdown::Extension.toc
+            when Coradoc::CoreModel::Term
+              Coradoc::Markdown::Strong.new(text: model.text.to_s)
+            when Coradoc::CoreModel::Bibliography
+              transform_bibliography(model)
+            when Coradoc::CoreModel::BibliographyEntry
+              transform_bibliography_entry(model)
+            when Coradoc::CoreModel::TocEntry
+              Coradoc::Markdown::Text.new(content: model.title.to_s)
+            when Array
+              model.map { |item| transform(item) }
+            else
+              model
+            end
+          end
+
+          private
+
+          def transform_structural_element(element)
+            case element.element_type
+            when 'document'
+              transform_document(element)
+            when 'section'
+              transform_section(element)
+            else
+              transform_generic_element(element)
+            end
+          end
+
+          def transform_document(doc)
+            blocks = Array(doc.children).map { |child| transform(child) }
+
+            Coradoc::Markdown::Document.new(
+              id: doc.id,
+              blocks: blocks
+            )
+          end
+
+          def transform_section(section)
+            Coradoc::Markdown::Heading.new(
+              level: section.level || 1,
+              text: section.title.to_s
+            )
+          end
+
+          def transform_generic_element(element)
+            blocks = Array(element.children).map { |child| transform(child) }
+
+            Coradoc::Markdown::Document.new(
+              id: element.id,
+              blocks: blocks
+            )
+          end
+
+          def transform_block(block)
+            case block.element_type
+            when 'paragraph'
+              transform_paragraph(block)
+            when 'comment'
+              Coradoc::Markdown::Extension.comment(block.content.to_s)
+            else
+              transform_delimited_block(block)
+            end
+          end
+
+          def transform_paragraph(block)
+            content = block.renderable_content
+            if content.is_a?(Array) && content.any? { |c| !c.is_a?(String) }
+              # Mixed content with inline elements
+              children = content.map { |c| transform_inline_content(c) }
+              Coradoc::Markdown::Paragraph.new(text: block.flat_text, children: children)
+            else
+              Coradoc::Markdown::Paragraph.new(text: block.flat_text)
+            end
+          end
+
+          def transform_inline_content(element)
+            case element
+            when Coradoc::CoreModel::InlineElement
+              transform_inline(element)
+            when String
+              element
+            else
+              element.to_s
+            end
+          end
+
+          def transform_delimited_block(block)
+            semantic = resolve_markdown_semantic(block)
+
+            case semantic
+            when :source_code, :listing
+              transform_code_block(block)
+            when :quote, :verse
+              transform_blockquote(block)
+            when :horizontal_rule
+              transform_horizontal_rule(block)
+            when :pass
+              Coradoc::Markdown::Extension.nomarkdown(block.content.to_s)
+            when :literal
+              transform_code_block(block)
+            else
+              transform_paragraph(block)
+            end
+          end
+
+          def resolve_markdown_semantic(block)
+            # Polymorphic dispatch: typed classes override semantic_type
+            semantic = block.resolve_semantic_type
+            return semantic if semantic
+
+            # Backward compat: derive from delimiter_type
+            markdown_delimiter_to_semantic(block.delimiter_type)
+          end
+
+          def markdown_delimiter_to_semantic(delimiter)
+            case delimiter
+            when '```', '~' then :source_code
+            when '>' then :quote
+            when '---', '***', '___' then :horizontal_rule
+            when '++++' then :pass
+            else nil
+            end
+          end
+
+          def transform_code_block(block)
+            Coradoc::Markdown::CodeBlock.new(
+              code: block.content.to_s,
+              language: block.language
+            )
+          end
+
+          def transform_blockquote(block)
+            content = block.flat_text
+
+            Coradoc::Markdown::Blockquote.new(content: content)
+          end
+
+          def transform_horizontal_rule(_block)
+            Coradoc::Markdown::HorizontalRule.new
+          end
+
+          def transform_list(list)
+            items = Array(list.items).map do |item|
+              content = item.renderable_content
+              if content.is_a?(Array) && content.any? { |c| !c.is_a?(String) }
+                children = content.map { |c| transform_inline_content(c) }
+                Coradoc::Markdown::ListItem.new(text: item.flat_text, children: children)
+              else
+                Coradoc::Markdown::ListItem.new(text: item.flat_text)
+              end
+            end
+
+            Coradoc::Markdown::List.new(
+              ordered: list.marker_type == 'ordered',
+              items: items
+            )
+          end
+
+          def transform_table(table)
+            # Extract headers from first row if cells are marked as headers
+            headers = []
+            rows = []
+
+            table_rows = Array(table.rows)
+            if table_rows.any?
+              first_row = table_rows.first
+              first_row_cells = Array(first_row&.cells)
+
+              # Check if first row has header cells
+              if first_row_cells.any?(&:header)
+                headers = first_row_cells.map(&:flat_text)
+                table_rows = table_rows[1..] || []
+              end
+
+              # Convert remaining rows to pipe-separated strings
+              rows = table_rows.map do |row|
+                Array(row.cells).map(&:flat_text).join(' | ')
+              end
+            end
+
+            Coradoc::Markdown::Table.new(
+              headers: headers,
+              rows: rows
+            )
+          end
+
+          def transform_image(image)
+            Coradoc::Markdown::Image.new(
+              src: image.src,
+              alt: image.alt.to_s
+            )
+          end
+
+          def transform_inline(element)
+            case element.format_type
+            when 'bold'
+              Coradoc::Markdown::Strong.new(text: element.content.to_s)
+            when 'italic'
+              Coradoc::Markdown::Emphasis.new(text: element.content.to_s)
+            when 'monospace'
+              Coradoc::Markdown::Code.new(text: element.content.to_s)
+            when 'link'
+              Coradoc::Markdown::Link.new(
+                text: element.content.to_s,
+                url: element.target.to_s
+              )
+            when 'footnote'
+              Coradoc::Markdown::FootnoteReference.new(id: element.target.to_s)
+            when 'stem'
+              Coradoc::Markdown::Math.inline(element.content.to_s)
+            when 'highlight'
+              Coradoc::Markdown::Highlight.new(text: element.content.to_s)
+            when 'strikethrough'
+              Coradoc::Markdown::Strikethrough.new(text: element.content.to_s)
+            when 'subscript'
+              "<sub>#{element.content}</sub>"
+            when 'superscript'
+              "<sup>#{element.content}</sup>"
+            when 'underline'
+              "<u>#{element.content}</u>"
+            when 'xref'
+              "[#{element.content}](##{element.target})"
+            else
+              element.content.to_s
+            end
+          end
+
+          def transform_definition_list(dl)
+            items = Array(dl.items).map do |item|
+              definitions = Array(item.definitions).map do |defn|
+                Coradoc::Markdown::DefinitionItem.new(content: defn.to_s)
+              end
+              Coradoc::Markdown::DefinitionTerm.new(
+                text: item.term.to_s,
+                definitions: definitions
+              )
+            end
+
+            Coradoc::Markdown::DefinitionList.new(items: items)
+          end
+
+          def transform_footnote(fn)
+            Coradoc::Markdown::Footnote.new(
+              id: fn.id.to_s,
+              content: fn.content.to_s,
+              backlink: fn.backlink
+            )
+          end
+
+          def transform_footnote_reference(ref)
+            Coradoc::Markdown::FootnoteReference.new(id: ref.id.to_s)
+          end
+
+          def transform_abbreviation(abbr)
+            Coradoc::Markdown::Abbreviation.new(
+              term: abbr.term.to_s,
+              definition: abbr.definition.to_s
+            )
+          end
+
+          def transform_annotation_block(annotation)
+            text = annotation.flat_text
+            Coradoc::Markdown::Paragraph.new(
+              text: "**#{annotation.annotation_type}:** #{text}"
+            )
+          end
+
+          def transform_bibliography(bib)
+            entries = Array(bib.entries).map { |e| transform(e) }
+            blocks = []
+            blocks << Coradoc::Markdown::Heading.new(level: 2, text: bib.title.to_s) if bib.title
+            blocks.concat(entries)
+            Coradoc::Markdown::Document.new(id: bib.id, blocks: blocks)
+          end
+
+          def transform_bibliography_entry(entry)
+            Coradoc::Markdown::Paragraph.new(text: entry.display_text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/transform/text_extraction.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    module Transform
+      # Shared text extraction for Markdown model objects.
+      #
+      # Handles nil, plain strings, and Markdown::Text instances.
+      module TextExtraction
+        def extract_text(text)
+          return '' if text.nil?
+          return text.content.to_s if text.is_a?(Coradoc::Markdown::Text)
+
+          text.to_s
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/transform/to_core_model.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require 'coradoc/core_model'
+
+module Coradoc
+  module Markdown
+    module Transform
+      # Transforms Markdown models to CoreModel equivalents
+      #
+      # This transformer converts the format-specific Markdown model
+      # to the canonical CoreModel representation.
+      class ToCoreModel
+        class << self
+          include TextExtraction
+          # Transform a Markdown model to CoreModel
+          #
+          # @param model [Coradoc::Markdown::Base] Markdown model to transform
+          # @return [Coradoc::CoreModel::Base] CoreModel equivalent
+          def transform(model)
+            case model
+            when Coradoc::Markdown::Document
+              transform_document(model)
+            when Coradoc::Markdown::Heading
+              transform_heading(model)
+            when Coradoc::Markdown::Paragraph
+              transform_paragraph(model)
+            when Coradoc::Markdown::CodeBlock
+              transform_code_block(model)
+            when Coradoc::Markdown::Blockquote
+              transform_blockquote(model)
+            when Coradoc::Markdown::List
+              transform_list(model)
+            when Coradoc::Markdown::DefinitionList
+              transform_definition_list(model)
+            when Coradoc::Markdown::Table
+              transform_table(model)
+            when Coradoc::Markdown::Image
+              transform_image(model)
+            when Coradoc::Markdown::Link
+              transform_link(model)
+            when Coradoc::Markdown::Emphasis
+              transform_inline(model, 'italic')
+            when Coradoc::Markdown::Strong
+              transform_inline(model, 'bold')
+            when Coradoc::Markdown::Code
+              transform_inline(model, 'monospace')
+            when Coradoc::Markdown::Highlight
+              transform_inline(model, 'highlight')
+            when Coradoc::Markdown::Strikethrough
+              transform_inline(model, 'strikethrough')
+            when Coradoc::Markdown::Footnote
+              transform_footnote(model)
+            when Coradoc::Markdown::FootnoteReference
+              transform_footnote_reference(model)
+            when Coradoc::Markdown::Abbreviation
+              transform_abbreviation(model)
+            when Coradoc::Markdown::HorizontalRule
+              transform_horizontal_rule(model)
+            when Coradoc::Markdown::Math
+              transform_math(model)
+            when Coradoc::Markdown::Extension
+              transform_extension(model)
+            when Coradoc::Markdown::AttributeList
+              transform_attribute_list(model)
+            when Coradoc::Markdown::Text
+              model.content.to_s
+            when Array
+              model.map { |item| transform(item) }
+            else
+              model
+            end
+          end
+
+          private
+
+          def transform_document(doc)
+            children = Array(doc.blocks).map { |block| transform(block) }
+
+            Coradoc::CoreModel::StructuralElement.new(
+              element_type: 'document',
+              id: doc.id,
+              title: extract_title(doc),
+              children: children
+            )
+          end
+
+          def transform_heading(heading)
+            Coradoc::CoreModel::StructuralElement.new(
+              element_type: 'section',
+              level: heading.level,
+              title: extract_text(heading.text),
+              children: []
+            )
+          end
+
+          def transform_paragraph(para)
+            content = extract_text(para.text)
+
+            Coradoc::CoreModel::Block.new(
+              element_type: 'paragraph',
+              content: content
+            )
+          end
+
+          def transform_code_block(block)
+            Coradoc::CoreModel::SourceBlock.new(
+              element_type: 'block',
+              content: block.code.to_s,
+              language: block.language
+            )
+          end
+
+          def transform_blockquote(blockquote)
+            Coradoc::CoreModel::QuoteBlock.new(
+              element_type: 'block',
+              content: blockquote.content.to_s
+            )
+          end
+
+          def transform_list(list)
+            items = Array(list.items).map do |item|
+              Coradoc::CoreModel::ListItem.new(
+                content: extract_text(item.text),
+                marker: list.ordered ? '1.' : '*'
+              )
+            end
+
+            Coradoc::CoreModel::ListBlock.new(
+              marker_type: list.ordered ? 'ordered' : 'unordered',
+              items: items
+            )
+          end
+
+          def transform_table(table)
+            # Convert Markdown table to CoreModel table
+            rows = []
+
+            # Add header row if present
+            if table.headers.any?
+              rows << Coradoc::CoreModel::TableRow.new(
+                cells: table.headers.map do |h|
+                  Coradoc::CoreModel::TableCell.new(content: h.to_s, header: true)
+                end
+              )
+            end
+
+            # Add data rows
+            table.rows.each do |row|
+              cells = if row.is_a?(Array)
+                        row.map { |c| Coradoc::CoreModel::TableCell.new(content: c.to_s, header: false) }
+                      else
+                        [Coradoc::CoreModel::TableCell.new(content: row.to_s, header: false)]
+                      end
+              rows << Coradoc::CoreModel::TableRow.new(cells: cells)
+            end
+
+            Coradoc::CoreModel::Table.new(rows: rows)
+          end
+
+          def transform_image(image)
+            Coradoc::CoreModel::Image.new(
+              src: image.src,
+              alt: image.alt.to_s
+            )
+          end
+
+          def transform_link(link)
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'link',
+              target: link.url,
+              content: extract_text(link.text)
+            )
+          end
+
+          def transform_inline(inline, format_type)
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: format_type,
+              content: extract_text(inline.text)
+            )
+          end
+
+          def transform_horizontal_rule(_rule)
+            Coradoc::CoreModel::Block.new(
+              element_type: 'block',
+              block_semantic_type: :horizontal_rule
+            )
+          end
+
+          def transform_definition_list(dl)
+            items = Array(dl.items).map do |term|
+              definitions = Array(term.definitions).map do |defn|
+                defn.content.to_s
+              end
+              Coradoc::CoreModel::DefinitionItem.new(
+                term: term.text.to_s,
+                definitions: definitions
+              )
+            end
+
+            Coradoc::CoreModel::DefinitionList.new(items: items)
+          end
+
+          def transform_footnote(fn)
+            Coradoc::CoreModel::Footnote.new(
+              id: fn.id.to_s,
+              content: fn.content.to_s,
+              backlink: fn.backlink.nil? || fn.backlink
+            )
+          end
+
+          def transform_footnote_reference(ref)
+            Coradoc::CoreModel::FootnoteReference.new(id: ref.id.to_s)
+          end
+
+          def transform_abbreviation(abbr)
+            Coradoc::CoreModel::Abbreviation.new(
+              term: abbr.term.to_s,
+              definition: abbr.definition.to_s
+            )
+          end
+
+          def transform_math(math)
+            if math.inline?
+              Coradoc::CoreModel::InlineElement.new(
+                format_type: 'stem',
+                content: math.content.to_s
+              )
+            else
+              Coradoc::CoreModel::PassBlock.new(
+                element_type: 'block',
+                content: math.content.to_s,
+                language: 'latexmath'
+              )
+            end
+          end
+
+          def transform_extension(ext)
+            case ext.name.to_sym
+            when :toc
+              Coradoc::CoreModel::Toc.new
+            when :comment
+              Coradoc::CoreModel::Block.new(
+                element_type: 'comment',
+                content: ext.content.to_s
+              )
+            when :nomarkdown
+              Coradoc::CoreModel::PassBlock.new(
+                element_type: 'block',
+                content: ext.content.to_s
+              )
+            else
+              # Unknown extensions: preserve content as a generic block
+              Coradoc::CoreModel::Block.new(
+                element_type: 'paragraph',
+                content: ext.content.to_s
+              )
+            end
+          end
+
+          def transform_attribute_list(attr_list)
+            attrs = []
+            attrs << Coradoc::CoreModel::ElementAttribute.new(name: 'id', value: attr_list.id.to_s) if attr_list.id
+            attr_list.classes.each do |cls|
+              attrs << Coradoc::CoreModel::ElementAttribute.new(name: 'class', value: cls.to_s)
+            end
+            attr_list.attributes.each do |k, v|
+              attrs << Coradoc::CoreModel::ElementAttribute.new(name: k.to_s, value: v.to_s)
+            end
+
+            Coradoc::CoreModel::StructuralElement.new(
+              element_type: 'attribute_list',
+              children: attrs
+            )
+          end
+
+          def extract_title(doc)
+            # Try to get title from first heading
+            first_block = Array(doc.blocks).first
+            return extract_text(first_block.text) if first_block.is_a?(Coradoc::Markdown::Heading)
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end