coradoc-markdown 1.0.0 → 1.0.3

data/lib/coradoc/markdown/serializer/serializers/code_block.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class CodeBlock < ElementSerializer
+          handles_type ::Coradoc::Markdown::CodeBlock
+
+          def call(element, _ctx)
+            "```#{element.language}\n#{element.code}\n```"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/comment.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        # Comments are editorial annotations, not document content. The
+        # Markdown Serialization Spec (§Comments) requires that comments
+        # be suppressed by default.
+        #
+        # Behavior:
+        #   suppress_comments == true  → '' (no output)
+        #   suppress_comments == false → '<!-- text -->'
+        class Comment < ElementSerializer
+          handles_type ::Coradoc::Markdown::Comment
+
+          def call(element, ctx)
+            return '' if ctx.config.suppress_comments
+
+            text = element.text.to_s.strip
+            return '<!---->' if text.empty?
+
+            "<!-- #{text} -->"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/cross_reference.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class CrossReference < ElementSerializer
+          handles_type ::Coradoc::Markdown::CrossReference
+
+          def call(element, _ctx)
+            "[#{element.text}](##{element.target})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/definition_list.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+require_relative '../strategies/definition_list/registry'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class DefinitionList < ElementSerializer
+          handles_type ::Coradoc::Markdown::DefinitionList
+
+          def call(element, ctx)
+            Strategies::DefinitionList::Registry.render(element, ctx)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/document.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Document < ElementSerializer
+          handles_type ::Coradoc::Markdown::Document
+
+          def call(element, ctx)
+            body = element.blocks.map { |block| ctx.serialize(block) }.join("\n\n")
+            return body unless element.frontmatter && !element.frontmatter.empty?
+
+            "---\n#{element.frontmatter}---\n\n#{body}".strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/emphasis.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Emphasis < ElementSerializer
+          handles_type ::Coradoc::Markdown::Emphasis
+
+          def call(element, _ctx)
+            "*#{element.text}*"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/example_block.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        # Example blocks emit an HTML fallback that preserves the caption
+        # as a heading inside `<div class="example">`.
+        #
+        # When `admonition_style == :container` (VitePress), emits
+        # `:::details Caption\n... \n:::` instead.
+        class ExampleBlock < ElementSerializer
+          handles_type ::Coradoc::Markdown::ExampleBlock
+
+          def call(element, ctx)
+            if ctx.config.admonition_style == :container
+              render_container(element)
+            else
+              render_html(element)
+            end
+          end
+
+          private
+
+          def render_html(element)
+            caption_html = element.caption ? %(<h4>Example: #{element.caption}</h4>\n) : ''
+            %(<div class="example">\n#{caption_html}<p>#{element.content.to_s}</p>\n</div>)
+          end
+
+          def render_container(element)
+            title = element.caption ? " Example: #{element.caption}" : ''
+            ":::details#{title}\n#{element.content.to_s}\n:::"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/extension.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Extension < ElementSerializer
+          handles_type ::Coradoc::Markdown::Extension
+
+          def call(element, _ctx)
+            opts = element.options.empty? ? '' : " #{extension_options_to_s(element.options)}"
+            if element.self_closing?
+              "{::#{element.name}#{opts} /}"
+            else
+              "{::#{element.name}#{opts}}#{element.content}{:/}"
+            end
+          end
+
+          private
+
+          def extension_options_to_s(options)
+            options.map { |nv| %(#{nv.name}="#{nv.value}") }.join(' ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/footnote.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Footnote < ElementSerializer
+          handles_type ::Coradoc::Markdown::Footnote
+
+          def call(element, _ctx)
+            content = element.content.to_s
+            "[^#{element.id}]: #{content}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/footnote_reference.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class FootnoteReference < ElementSerializer
+          handles_type ::Coradoc::Markdown::FootnoteReference
+
+          def call(element, _ctx)
+            "[^#{element.id}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/hard_line_break.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        # Hard line break. Output depends on `config.hard_break` (not
+        # part of the 5 spec options yet — defaults to CommonMark
+        # two-trailing-spaces).
+        class HardLineBreak < ElementSerializer
+          handles_type ::Coradoc::Markdown::HardLineBreak
+
+          def call(_element, _ctx)
+            "  \n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/heading.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Heading < ElementSerializer
+          handles_type ::Coradoc::Markdown::Heading
+
+          def call(element, _ctx)
+            "#{'#' * element.level} #{element.text}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/highlight.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Highlight < ElementSerializer
+          handles_type ::Coradoc::Markdown::Highlight
+
+          def call(element, _ctx)
+            "==#{element.text}=="
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/horizontal_rule.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class HorizontalRule < ElementSerializer
+          handles_type ::Coradoc::Markdown::HorizontalRule
+
+          def call(element, _ctx)
+            element.style || '---'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/image.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Image < ElementSerializer
+          handles_type ::Coradoc::Markdown::Image
+
+          def call(element, _ctx)
+            "![#{element.alt}](#{element.src}#{element.title ? " \"#{element.title}\"" : ''})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/link.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+require_relative '../strategies/autolink/registry'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Link < ElementSerializer
+          handles_type ::Coradoc::Markdown::Link
+
+          def call(element, ctx)
+            url = element.url.to_s
+            text = element.text.to_s
+            title_suffix = element.title ? " \"#{element.title}\"" : ''
+
+            Strategies::Autolink::Registry.render_or_default(
+              url: url,
+              text: text,
+              ctx: ctx,
+              default: "[#{text}](#{url}#{title_suffix})"
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/list.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class List < ElementSerializer
+          handles_type ::Coradoc::Markdown::List
+
+          def call(element, _ctx)
+            marker = element.ordered ? '1.' : '-'
+            element.items.flat_map do |item|
+              lines = [render_item(item, marker, _ctx)]
+              if item.sublist
+                lines += call(item.sublist, _ctx).split("\n").map { |l| "    #{l}" }
+              end
+              lines
+            end.join("\n")
+          end
+
+          private
+
+          def render_item(item, marker, ctx)
+            text = serialize_item_text(item, ctx)
+            if item.checked == true
+              "- [x] #{text.sub(/^- \[[ x]\] /, '')}"
+            elsif item.checked == false
+              "- [ ] #{text.sub(/^- \[[ x]\] /, '')}"
+            else
+              "#{marker} #{text}"
+            end
+          end
+
+          def serialize_item_text(item, ctx)
+            return item.text.to_s unless item.children.any?
+
+            ctx.serialize_inline_join(item.children)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/literal.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        # Literal block: indented code block (4 leading spaces per line).
+        # Distinct from a code block (which carries a language hint).
+        class Literal < ElementSerializer
+          handles_type ::Coradoc::Markdown::Literal
+
+          def call(element, _ctx)
+            element.content.to_s.lines.map { |line| "    #{line}" }.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/math.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Math < ElementSerializer
+          handles_type ::Coradoc::Markdown::Math
+
+          def call(element, _ctx)
+            if element.inline?
+              "$$#{element.content}$$"
+            else
+              "$$\n#{element.content}\n$$"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/open_block.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        # Open block: emits children inline unless id/classes are present,
+        # in which case it wraps them in an HTML `<div>`.
+        class OpenBlock < ElementSerializer
+          handles_type ::Coradoc::Markdown::OpenBlock
+
+          def call(element, ctx)
+            children_md = element.children.map { |c| ctx.serialize(c) }.join("\n\n")
+            return children_md unless needs_wrapper?(element)
+
+            attrs = wrapper_attrs(element)
+            %(<div#{attrs}>\n#{children_md}\n</div>)
+          end
+
+          private
+
+          def needs_wrapper?(element)
+            element.id || (element.classes && element.classes.any?)
+          end
+
+          def wrapper_attrs(element)
+            parts = []
+            parts << %(id="#{element.id}") if element.id
+            element.classes&.each { |c| parts << %(class="#{c}") }
+            parts.empty? ? '' : " #{parts.join(' ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/paragraph.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Paragraph < ElementSerializer
+          handles_type ::Coradoc::Markdown::Paragraph
+
+          def call(element, ctx)
+            if element.children.any?
+              ctx.serialize_inline_join(element.children)
+            else
+              element.text.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/pass.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        # Pass block: emit content inside kramdown's nomarkdown extension
+        # so it bypasses Markdown rendering.
+        class Pass < ElementSerializer
+          handles_type ::Coradoc::Markdown::Pass
+
+          def call(element, _ctx)
+            "{::nomarkdown}#{element.content.to_s}{:/}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/sidebar.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Sidebar < ElementSerializer
+          handles_type ::Coradoc::Markdown::Sidebar
+
+          def call(element, _ctx)
+            title_html = element.title ? %(<div class="title">#{element.title}</div>\n) : ''
+            %(<div class="sidebar">\n#{title_html}#{element.content.to_s}\n</div>)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/strikethrough.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Strikethrough < ElementSerializer
+          handles_type ::Coradoc::Markdown::Strikethrough
+
+          def call(element, _ctx)
+            "~~#{element.text}~~"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/strong.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Strong < ElementSerializer
+          handles_type ::Coradoc::Markdown::Strong
+
+          def call(element, _ctx)
+            "**#{element.text}**"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/subscript.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Subscript < ElementSerializer
+          handles_type ::Coradoc::Markdown::Subscript
+
+          def call(element, _ctx)
+            "<sub>#{element.text}</sub>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/serializers/superscript.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Superscript < ElementSerializer
+          handles_type ::Coradoc::Markdown::Superscript
+
+          def call(element, _ctx)
+            "<sup>#{element.text}</sup>"
+          end
+        end
+      end
+    end
+  end
+end