coradoc-markdown 1.0.0

data/lib/coradoc/markdown/serializer.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    # Serializer for Markdown Document models.
+    #
+    # This serializer converts Document model objects back into
+    # Markdown text format.
+    #
+    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
+          element.to_md
+        when Highlight
+          element.to_md
+        when AttributeList
+          element.to_md
+        when Math
+          element.to_md
+        when Extension
+          element.to_md
+        when String
+          element
+        else
+          raise ArgumentError,
+                "Unknown element type for serialization: #{element.class}. " \
+                'Expected a known Markdown model type.'
+        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
+        end
+      end
+
+      def serialize_inline_content(element)
+        case element
+        when String
+          element
+        when Emphasis, Strong, Code, Link, Image, FootnoteReference, Math, Extension, Strikethrough, Highlight
+          serialize(element)
+        else
+          if element.is_a?(Base)
+            element.to_md
+          else
+            raise ArgumentError,
+                  "Cannot serialize inline content of type #{element.class}. " \
+                  'Expected String, known inline model, or Base subclass.'
+          end
+        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
+    end
+  end
+end

data/lib/coradoc/markdown/toc_generator.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    module Model
+      autoload :Base, "#{__dir__}/model/base"
+      autoload :Heading, "#{__dir__}/model/heading"
+      autoload :Document, "#{__dir__}/model/document"
+    end
+
+    # Table of Contents Generator
+    #
+    # Generates a table of contents from document headings.
+    # Supports Kramdown-style TOC with options for levels, depth, etc.
+    #
+    # @example Basic usage
+    #   doc = Coradoc::Markdown.parse(markdown_text)
+    #   toc = Coradoc::Markdown::TocGenerator.generate(doc)
+    #   puts toc.to_markdown
+    #
+    # @example With options
+    #   toc = Coradoc::Markdown::TocGenerator.generate(doc,
+    #     min_level: 2,
+    #     max_level: 4,
+    #     numbered: true
+    #   )
+    #
+    class TocGenerator
+      include Transform::TextExtraction
+
+      # Default options for TOC generation
+      DEFAULT_OPTIONS = {
+        min_level: 1,
+        max_level: 6,
+        numbered: false,
+        styled: false,
+        link_headings: true
+      }.freeze
+
+      # Represents a single TOC entry
+      class Entry
+        attr_accessor :id, :text, :level, :children, :number
+
+        def initialize(id:, text:, level:, number: nil)
+          @id = id
+          @text = text
+          @level = level
+          @number = number
+          @children = []
+        end
+
+        def to_markdown(indent: 0)
+          prefix = '  ' * indent
+          link = @id && @id != @text ? "[#{@text}](##{@id})" : @text
+          number_prefix = @number ? "#{@number} " : ''
+          "#{prefix}* #{number_prefix}#{link}\n".tap do |result|
+            @children.each do |child|
+              result << child.to_markdown(indent: indent + 1)
+            end
+          end
+        end
+
+        # Convert entry to hash representation
+        # @return [Hash] Hash with id, text, level, number, and optional children
+        def to_h
+          result = { id: @id, text: @text, level: @level, number: @number }
+          result[:children] = @children.map(&:to_h) unless @children.empty?
+          result
+        end
+      end
+
+      # Generate a TOC from a document
+      #
+      # @param document [Coradoc::Markdown::Document] The document to process
+      # @param options [Hash] Generation options
+      # @option options [Integer] :min_level (1) Minimum heading level to include
+      # @option options [Integer] :max_level (6) Maximum heading level to include
+      # @option options [Boolean] :numbered (false) Whether to add section numbers
+      # @option options [Boolean] :styled (false) Whether to add styling classes
+      # @option options [Boolean] :link_headings (true) Whether to link to headings
+      # @return [Entry, nil] The root TOC entry or nil if no headings
+      def self.generate(document, options = {})
+        new(options).generate(document)
+      end
+
+      # Generate TOC as Markdown string
+      #
+      # @param document [Coradoc::Markdown::Document] The document to process
+      # @param options [Hash] Generation options
+      # @return [String] Markdown-formatted TOC
+      def self.generate_markdown(document, options = {})
+        toc = generate(document, options)
+        toc ? toc.to_markdown : ''
+      end
+
+      # Generate TOC as array structure
+      #
+      # @param document [Coradoc::Markdown::Document] The document to process
+      # @param options [Hash] Generation options
+      # @return [Array<Hash>] Array of TOC entries
+      def self.generate_array(document, options = {})
+        toc = generate(document, options)
+        return [] unless toc
+
+        toc.children.map(&:to_h)
+      end
+
+      def initialize(options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @min_level = @options[:min_level]
+        @max_level = @options[:max_level]
+        @numbered = @options[:numbered]
+      end
+
+      # Generate TOC from document
+      #
+      # @param document [Coradoc::Markdown::Document] The document
+      # @return [Entry, nil] Root TOC entry
+      def generate(document)
+        headings = extract_headings(document)
+        return nil if headings.empty?
+
+        root = Entry.new(id: nil, text: 'Table of Contents', level: 0)
+        build_toc_tree(root, headings)
+        root
+      end
+
+      private
+
+      # Extract headings from document blocks
+      def extract_headings(document)
+        headings = []
+        return headings unless document.is_a?(Coradoc::Markdown::Document)
+
+        Array(document.blocks).each do |block|
+          if block.is_a?(Coradoc::Markdown::Heading)
+            headings << block if within_level_range?(block.level)
+          elsif block.is_a?(Coradoc::Markdown::Base) && block.class.attributes.key?(:blocks)
+            headings.concat(extract_headings_from_nested(block))
+          end
+        end
+
+        headings
+      end
+
+      def extract_headings_from_nested(block)
+        headings = []
+        return headings unless block.is_a?(Coradoc::Markdown::Base) && block.class.attributes.key?(:blocks)
+
+        Array(block.blocks).each do |nested|
+          if nested.is_a?(Coradoc::Markdown::Heading)
+            headings << nested if within_level_range?(nested.level)
+          elsif nested.is_a?(Coradoc::Markdown::Base) && nested.class.attributes.key?(:blocks)
+            headings.concat(extract_headings_from_nested(nested))
+          end
+        end
+
+        headings
+      end
+
+      def within_level_range?(level)
+        level >= @min_level && level <= @max_level
+      end
+
+      # Build the hierarchical TOC tree
+      def build_toc_tree(root, headings)
+        return if headings.empty?
+
+        # Track section numbers for each level
+        counters = {}
+
+        # Stack of entries at each level
+        stack = [root]
+
+        headings.each do |heading|
+          level = heading.level
+
+          # Update counters
+          counters[level] ||= 0
+          counters[level] += 1
+          # Reset counters for deeper levels
+          (level + 1..6).each { |l| counters[l] = 0 }
+
+          # Generate number if needed
+          number = (generate_section_number(counters, level) if @numbered)
+
+          # Create entry
+          entry = Entry.new(
+            id: heading.heading_id,
+            text: extract_text(heading.text),
+            level: level,
+            number: number
+          )
+
+          # Find the correct parent in the stack
+          stack.pop while stack.length > level - @min_level + 1
+
+          # Add to current parent
+          stack.last.children << entry
+
+          # Push for potential children
+          stack.push(entry)
+        end
+      end
+
+      def generate_section_number(counters, level)
+        parts = []
+        (@min_level..level).each do |l|
+          parts << counters[l] if counters[l]&.positive?
+        end
+        parts.join('.')
+      end
+    end
+  end
+end