coradoc-markdown 1.0.2 → 1.0.4

data/lib/coradoc/markdown/serializer.rb

@@ -1,262 +1,48 @@
 # frozen_string_literal: true
 
+require_relative 'serializer/builder'
+require_relative 'serializer/flavor'
+
 module Coradoc
   module Markdown
     # Serializer for Markdown Document models.
     #
-    # This serializer converts Document model objects back into
-    # Markdown text format.
+    # Two equivalent entry points:
+    #
+    #   # Build a configured runner (preferred for non-default options)
+    #   Serializer.build(:gfm) do |config|
+    #     config.admonition_style = :container
+    #     config.suppress_comments = false
+    #   end.call(element)
     #
+    #   # One-shot with overrides
+    #   Serializer.call(element, markdown_flavor: :vitepress)
+    #
+    # The legacy `serialize(element, options = {})` class method is kept
+    # as a thin alias for `call` so existing callers don't break.
     class Serializer
-      # Serialize a document model to Markdown string
-      #
-      # @param document [Coradoc::Markdown::Base] The document or element to serialize
-      # @param options [Hash] Serialization options
-      # @return [String] The Markdown output
-      def self.serialize(document, options = {})
-        new.serialize(document, options)
-      end
-
-      # Serialize a document model to Markdown string
-      #
-      # @param element [Coradoc::Markdown::Base] The element to serialize
-      # @param options [Hash] Serialization options
-      # @return [String] The Markdown output
-      def serialize(element, _options = {})
-        case element
-        when Document
-          serialize_document(element)
-        when Heading
-          serialize_heading(element)
-        when Paragraph
-          serialize_paragraph(element)
-        when List
-          serialize_list(element)
-        when CodeBlock
-          serialize_code_block(element)
-        when Blockquote
-          serialize_blockquote(element)
-        when Link
-          serialize_link(element)
-        when Image
-          serialize_image(element)
-        when HorizontalRule
-          serialize_horizontal_rule(element)
-        when Table
-          serialize_table(element)
-        when Emphasis
-          serialize_emphasis(element)
-        when Strong
-          serialize_strong(element)
-        when Code
-          serialize_code(element)
-        when DefinitionList
-          serialize_definition_list(element)
-        when Footnote
-          serialize_footnote(element)
-        when FootnoteReference
-          serialize_footnote_reference(element)
-        when Abbreviation
-          serialize_abbreviation(element)
-        when Strikethrough
-          serialize_strikethrough(element)
-        when Highlight
-          serialize_highlight(element)
-        when Subscript
-          serialize_subscript(element)
-        when Superscript
-          serialize_superscript(element)
-        when Underline
-          serialize_underline(element)
-        when CrossReference
-          serialize_cross_reference(element)
-        when AttributeList
-          serialize_attribute_list(element)
-        when Math
-          serialize_math(element)
-        when Extension
-          serialize_extension(element)
-        when String
-          element
-        else
-          raise ArgumentError,
-                "Unknown element type for serialization: #{element.class}. " \
-                'Expected a known Markdown model type.'
+      class << self
+        def build(flavor = Flavor::DEFAULT_FLAVOR, &block)
+          builder = Builder.new(flavor)
+          block&.call(builder)
+          builder.runner
         end
-      end
-
-      private
-
-      def serialize_document(doc)
-        doc.blocks.map { |block| serialize(block) }.join("\n\n")
-      end
-
-      def serialize_heading(heading)
-        "#{'#' * heading.level} #{heading.text}"
-      end
 
-      def serialize_paragraph(para)
-        if para.children.any?
-          para.children.map { |child| serialize_inline_content(child) }.join
-        else
-          para.text.to_s
+        def call(element, **options)
+          flavor = options.delete(:markdown_flavor) || options.delete(:flavor) || Flavor::DEFAULT_FLAVOR
+          Builder.new(flavor).apply(options).call(element)
         end
-      end
 
-      def serialize_inline_content(element)
-        case element
-        when String
-          element
-        when Emphasis, Strong, Code, Link, Image, FootnoteReference, Math, Extension,
-             Strikethrough, Highlight, Subscript, Superscript, Underline, CrossReference,
-             AttributeList, DefinitionList
-          serialize(element)
-        when Base
-          serialize(element)
-        else
-          raise ArgumentError,
-                "Cannot serialize inline content of type #{element.class}. " \
-                'Expected String, known inline model, or Base subclass.'
+        def serialize(element, options = {})
+          call(element, **options)
         end
-      end
-
-      def serialize_list(list)
-        marker = list.ordered ? '1.' : '-'
-        list.items.map do |item|
-          text = if item.children.any?
-                   item.children.map { |child| serialize_inline_content(child) }.join
-                 else
-                   item.text.to_s
-                 end
-          if item.checked == true
-            "- [x] #{text.sub(/^- \[[ x]\] /, '')}"
-          elsif item.checked == false
-            "- [ ] #{text.sub(/^- \[[ x]\] /, '')}"
-          else
-            "#{marker} #{text}"
-          end
-        end.join("\n")
-      end
-
-      def serialize_code_block(block)
-        "```#{block.language}\n#{block.code}\n```"
-      end
-
-      def serialize_blockquote(quote)
-        quote.content.to_s.lines.map { |line| "> #{line}" }.join
-      end
-
-      def serialize_link(link)
-        "[#{link.text}](#{link.url}#{link.title ? " \"#{link.title}\"" : ''})"
-      end
-
-      def serialize_image(img)
-        "![#{img.alt}](#{img.src}#{img.title ? " \"#{img.title}\"" : ''})"
-      end
-
-      def serialize_horizontal_rule(rule)
-        rule.style || '---'
-      end
-
-      def serialize_table(table)
-        return '' if table.headers.empty?
-
-        header_row = "| #{table.headers.join(' | ')} |"
-        separator = "| #{table.headers.map { |_| '---' }.join(' | ')} |"
-        rows = table.rows.map { |row| "| #{Array(row).join(' | ')} |" }
-
-        [header_row, separator, *rows].join("\n")
-      end
-
-      def serialize_emphasis(em)
-        "*#{em.text}*"
-      end
 
-      def serialize_strong(strong)
-        "**#{strong.text}**"
-      end
-
-      def serialize_code(code)
-        "`#{code.text}`"
-      end
-
-      def serialize_definition_list(dl)
-        dl.items.map do |term|
-          lines = [term.text.to_s]
-          term.definitions.each do |defn|
-            lines << ": #{defn.content}"
-          end
-          lines.join("\n")
-        end.join("\n\n")
-      end
-
-      def serialize_footnote(fn)
-        content = fn.content.to_s
-        "[^#{fn.id}]: #{content}"
-      end
-
-      def serialize_footnote_reference(ref)
-        "[^#{ref.id}]"
-      end
-
-      def serialize_abbreviation(abbr)
-        "*[#{abbr.term}]: #{abbr.definition}"
-      end
-
-      def serialize_strikethrough(elem)
-        "~~#{elem.text}~~"
-      end
-
-      def serialize_highlight(elem)
-        "==#{elem.text}=="
-      end
-
-      def serialize_subscript(elem)
-        "<sub>#{elem.text}</sub>"
-      end
-
-      def serialize_superscript(elem)
-        "<sup>#{elem.text}</sup>"
-      end
-
-      def serialize_underline(elem)
-        "<u>#{elem.text}</u>"
-      end
-
-      def serialize_cross_reference(elem)
-        "[#{elem.text}](##{elem.target})"
-      end
-
-      def serialize_attribute_list(elem)
-        return '' if elem.empty?
-
-        parts = []
-        parts << "##{elem.id}" if elem.id
-        parts += elem.classes.map { |c| ".#{c}" }
-        parts += elem.attributes.map { |nv| %(#{nv.name}="#{nv.value}") }
-        "{:#{parts.join(' ')}}"
-      end
-
-      def serialize_math(elem)
-        if elem.inline?
-          "$$#{elem.content}$$"
-        else
-          "$$\n#{elem.content}\n$$"
+        def new(*)
+          raise NoMethodError,
+                'Coradoc::Markdown::Serializer is no longer instantiable. ' \
+                'Use Serializer.build(:gfm) or Serializer.call(element).'
         end
       end
-
-      def serialize_extension(elem)
-        opts = elem.options.empty? ? '' : " #{extension_options_to_s(elem.options)}"
-        if elem.self_closing?
-          "{::#{elem.name}#{opts} /}"
-        else
-          "{::#{elem.name}#{opts}}#{elem.content}{:/}"
-        end
-      end
-
-      def extension_options_to_s(options)
-        options.map { |nv| %(#{nv.name}="#{nv.value}") }.join(' ')
-      end
     end
   end
 end

data/lib/coradoc/markdown/toc_generator.rb

@@ -35,12 +35,12 @@ module Coradoc
       class Entry
         attr_accessor :id, :text, :level, :children, :number
 
-        def initialize(id:, text:, level:, number: nil)
+        def initialize(id:, text:, level:, number: nil, children: [])
           @id = id
           @text = text
           @level = level
           @number = number
-          @children = []
+          @children = children
         end
 
         def to_markdown(indent: 0)

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    module Transform
+      module BlockTransformer
+        class << self
+          def transform_block(block)
+            semantic = block.resolve_semantic_type || markdown_delimiter_to_semantic(block.delimiter_type)
+
+            case semantic
+            when :paragraph
+              transform_paragraph(block)
+            when :comment
+              transform_comment_block(block)
+            when :source_code, :listing, :literal
+              transform_code_block(block)
+            when :quote
+              transform_blockquote(block)
+            when :verse
+              transform_verse_block(block)
+            when :horizontal_rule
+              transform_horizontal_rule(block)
+            when :pass
+              transform_pass_block(block)
+            when :example
+              transform_example_block(block)
+            when :sidebar
+              transform_sidebar_block(block)
+            when :open
+              transform_open_block(block)
+            when :reviewer
+              transform_reviewer_block(block)
+            else
+              transform_paragraph(block)
+            end
+          end
+
+          def transform_paragraph(block)
+            content = block.renderable_content
+            has_structured = content.is_a?(Array) && content.any? { |c| !c.is_a?(CoreModel::TextContent) }
+            if has_structured
+              children = content.map { |c| transform_content_node(c) }
+              Coradoc::Markdown::Paragraph.new(text: block.flat_text, children: children)
+            else
+              Coradoc::Markdown::Paragraph.new(text: block.flat_text)
+            end
+          end
+
+          # Transform a content node that could be inline text, an
+          # inline element, or a block-level element (e.g. a SourceBlock
+          # inside a list item via AsciiDoc continuation).
+          def transform_content_node(element)
+            case element
+            when CoreModel::InlineElement
+              InlineTransformer.transform_inline(element)
+            when CoreModel::TextContent
+              element.text
+            when CoreModel::Base
+              FromCoreModel.transform(element)
+            when String
+              element
+            else
+              element.to_s
+            end
+          end
+
+          # Kept as public alias for backward compat with existing callers
+          alias transform_inline_content transform_content_node
+
+          def markdown_delimiter_to_semantic(delimiter)
+            case delimiter
+            when '```', '~' then :source_code
+            when '>' then :quote
+            when '---', '***', '___' then :horizontal_rule
+            when '++++' then :pass
+            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_verse_block(block)
+            Coradoc::Markdown::Blockquote.new(content: block.flat_text)
+          end
+
+          def transform_horizontal_rule(_block)
+            Coradoc::Markdown::HorizontalRule.new
+          end
+
+          def transform_example_block(block)
+            content = block.flat_text
+            Coradoc::Markdown::Blockquote.new(content: content)
+          end
+
+          def transform_sidebar_block(block)
+            content = block.flat_text
+            Coradoc::Markdown::Paragraph.new(text: content)
+          end
+
+          def transform_open_block(block)
+            if block.children && !block.children.empty?
+              block.children.map { |c| FromCoreModel.transform(c) }
+            else
+              content = block.flat_text
+              Coradoc::Markdown::Paragraph.new(text: content)
+            end
+          end
+
+          def transform_reviewer_block(block)
+            text = block.flat_text
+            Coradoc::Markdown::Paragraph.new(
+              text: "**#{block.annotation_type}:** #{text}"
+            )
+          end
+
+          def transform_annotation_block(annotation)
+            text = annotation.flat_text
+            Coradoc::Markdown::Paragraph.new(
+              text: "**#{annotation.annotation_type}:** #{text}"
+            )
+          end
+
+          def transform_comment_block(block)
+            Coradoc::Markdown::Extension.comment(block.content.to_s)
+          end
+
+          def transform_pass_block(block)
+            Coradoc::Markdown::Extension.nomarkdown(block.content.to_s)
+          end
+        end
+
+        # Register subclasses first so they match before CoreModel::Block
+        FromCoreModel.register(CoreModel::AnnotationBlock, method(:transform_annotation_block))
+        FromCoreModel.register(CoreModel::ParagraphBlock, method(:transform_paragraph))
+        FromCoreModel.register(CoreModel::SourceBlock, method(:transform_code_block))
+        FromCoreModel.register(CoreModel::ListingBlock, method(:transform_code_block))
+        FromCoreModel.register(CoreModel::LiteralBlock, method(:transform_code_block))
+        FromCoreModel.register(CoreModel::QuoteBlock, method(:transform_blockquote))
+        FromCoreModel.register(CoreModel::VerseBlock, method(:transform_verse_block))
+        FromCoreModel.register(CoreModel::HorizontalRuleBlock, method(:transform_horizontal_rule))
+        FromCoreModel.register(CoreModel::PassBlock, method(:transform_pass_block))
+        FromCoreModel.register(CoreModel::ExampleBlock, method(:transform_example_block))
+        FromCoreModel.register(CoreModel::SidebarBlock, method(:transform_sidebar_block))
+        FromCoreModel.register(CoreModel::OpenBlock, method(:transform_open_block))
+        FromCoreModel.register(CoreModel::ReviewerBlock, method(:transform_reviewer_block))
+        FromCoreModel.register(CoreModel::CommentBlock, method(:transform_comment_block))
+
+        # Generic block fallback
+        FromCoreModel.register(CoreModel::Block, method(:transform_block))
+      end
+    end
+  end
+end