coradoc-markdown 1.0.2 → 1.0.4

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        class Table < ElementSerializer
+          handles_type ::Coradoc::Markdown::Table
+
+          def call(element, _ctx)
+            cols = [element.headers.size, *element.rows.map { |r| row_cells(r).size }].max
+            return '' if cols.zero?
+
+            headers = element.headers.empty? ? Array.new(cols, '') : element.headers
+            header_row = "| #{headers.join(' | ')} |"
+            separator = "| #{headers.map { '---' }.join(' | ')} |"
+            rows = element.rows.map do |row|
+              cells = row_cells(row).fill('', row_cells(row).size...cols)
+              "| #{cells.join(' | ')} |"
+            end
+
+            [header_row, separator, *rows].join("\n")
+          end
+
+          private
+
+          # Rows are stored as either Array<String> (cells) or pipe-joined String
+          def row_cells(row)
+            row.is_a?(Array) ? row : row.to_s.split(' | ')
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../element_serializer'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Serializers
+        # Verse: blockquote with hard line breaks preserved. The verse
+        # semantic is lost but line breaks survive.
+        class Verse < ElementSerializer
+          handles_type ::Coradoc::Markdown::Verse
+
+          def call(element, _ctx)
+            body = element.content.to_s
+            attribution = element.attribution
+            citetitle = element.citetitle
+            attribution_line = if attribution && citetitle
+                                 "\n>\n> — #{attribution}, <cite>#{citetitle}</cite>"
+                               elsif attribution
+                                 "\n>\n> — #{attribution}"
+                               else
+                                 ''
+                               end
+            body.lines.map { |line| "> #{line}".rstrip }.join("\n").concat(attribution_line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/admonition/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Admonition
+          # Each strategy renders an admonition (type, content, optional
+          # title) for a specific output form. The active strategy is
+          # chosen by `config.admonition_style`.
+          #
+          # Strategies are stateless; all state flows through arguments.
+          # Adding a new admonition form = adding one file + one entry
+          # in Registry::MODES.
+          class Base
+            class << self
+              def render(_admonition, _ctx)
+                raise NotImplementedError
+              end
+
+              def mode_name
+                name.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+              end
+
+              # Render the admonition body, preferring typed children
+              # (so cross-refs, code spans, etc. survive) and falling
+              # back to the plain-text content attribute when there are
+              # no children or the ctx can't serialize them.
+              def render_body(admonition, ctx)
+                children = admonition.children
+                return admonition.content.to_s if children.nil? || children.empty?
+
+                ctx.serialize_inline_join(children)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/admonition/container.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Admonition
+          # Container syntax (VitePress, markdown-it-container):
+          #
+          #   :::note
+          #   content
+          #   :::
+          #
+          # Custom title:
+          #
+          #   :::note[Custom Title]
+          #   content
+          #   :::
+          class Container < Base
+            class << self
+              def render(admonition, ctx)
+                type = admonition.admonition_type.to_s
+                title_suffix = admonition.title ? "[#{admonition.title}]" : ''
+                ":::#{type}#{title_suffix}\n#{render_body(admonition, ctx)}\n:::"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/admonition/gfm_alert.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Admonition
+          # GFM Alerts (native since Dec 2023): `> [!TYPE]\n> content`.
+          # Recognized types: NOTE, TIP, IMPORTANT, WARNING, CAUTION.
+          # Source: https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#alerts
+          class GfmAlert < Base
+            class << self
+              def render(admonition, ctx)
+                type = admonition.admonition_type.to_s.capitalize
+                body = render_body(admonition, ctx)
+                body = body.lines.map { |line| "> #{line}".rstrip }.join("\n")
+                title_suffix = admonition.title ? " \"#{admonition.title}\"" : ''
+                "> [!#{type}]#{title_suffix}\n#{body}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/admonition/github.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Admonition
+          # GitHub-style: a styled blockquote with `**TYPE:**` prefix.
+          # Renders correctly in GitHub, GitLab, and most renderers that
+          # recognize the bold-prefix pattern.
+          class Github < Base
+            class << self
+              def render(admonition, ctx)
+                type = admonition.admonition_type.to_s.upcase
+                body = render_body(admonition, ctx)
+                body = "**#{admonition.title}**\n\n#{body}" if admonition.title && !admonition.title.to_s.strip.empty?
+                "> **#{type}:** #{body}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end