coradoc-markdown 1.0.0 → 1.0.3

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,30 @@
+# 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
+            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#{admonition.content.to_s}\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 = admonition.content.to_s
+                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,29 @@
+# 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 = admonition.content.to_s
+                if admonition.title
+                  body = "**#{admonition.title}**\n\n#{body}" unless admonition.title.to_s.strip.empty?
+                end
+                "> **#{type}:** #{body}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Admonition
+          # HTML fallback: a div with `class="<type>"` and optional
+          # `<div class="title">` for the title.
+          class Html < Base
+            class << self
+              def render(admonition, _ctx)
+                type = admonition.admonition_type.to_s
+                title_html = admonition.title ? %(<div class="title">#{admonition.title}</div>\n) : ''
+                %(<div class="#{type}">\n#{title_html}#{admonition.content.to_s}\n</div>)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'github'
+require_relative 'gfm_alert'
+require_relative 'container'
+require_relative 'html'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Admonition
+          # Resolves the active admonition strategy from `config.admonition_style`.
+          #
+          # Modes:
+          #   :github    → > **NOTE:** text         (broad compat — DEFAULT for :gfm)
+          #   :gfm_alert → > [!NOTE]\n> text         (GFM native since 2024)
+          #   :container → :::note\n... \n:::         (VitePress / markdown-it)
+          #   :html      → <div class="note">...</div>
+          module Registry
+            MODES = {
+              github: Github,
+              gfm_alert: GfmAlert,
+              container: Container,
+              html: Html
+            }.freeze
+
+            class << self
+              def lookup(mode)
+                MODES.fetch(mode.to_sym) do
+                  raise ArgumentError, "Unknown admonition mode: #{mode.inspect}. " \
+                                       "Known: #{MODES.keys.inspect}"
+                end
+              end
+
+              def resolve(ctx:)
+                lookup(ctx.config.admonition_style)
+              end
+
+              def render(admonition, ctx:)
+                resolve(ctx: ctx).render(admonition, ctx)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/autolink/angle.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Autolink
+          # CommonMark angle-bracket autolink: <https://example.com>
+          # Renders identically across all HTML-aware renderers.
+          class Angle < Base
+            class << self
+              def applies?(url, text, ctx)
+                ctx.config.autolinks && url_eql_text?(url, text)
+              end
+
+              def render(url, _text, _ctx)
+                "<#{url}>"
+              end
+
+              private
+
+              def url_eql_text?(url, text)
+                return false unless url && text
+
+                url.to_s.strip == text.to_s.strip
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/autolink/bare.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'angle'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Autolink
+          # GFM bare-URL autolink: https://example.com (no brackets).
+          # Supported by GFM and most modern renderers; minimal noise.
+          class Bare < Angle
+            class << self
+              def render(url, _text, _ctx)
+                url.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Autolink
+          # A link whose text equals its URL is a bare URL. Each strategy
+          # decides how to format it. `applies?` is checked first; if no
+          # strategy applies, the caller falls back to standard link syntax.
+          #
+          # Adding a new autolink form = adding one file + one entry in
+          # Registry::MODES. No call-site changes — Open/Closed.
+          class Base
+            class << self
+              def applies?(_url, _text, _ctx)
+                raise NotImplementedError
+              end
+
+              def render(_url, _text, _ctx)
+                raise NotImplementedError
+              end
+
+              def mode_name
+                name.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/autolink/none.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Autolink
+          # No autolink form — emit standard [text](url). The default
+          # when `autolinks: false` or when text differs from url.
+          class None < Base
+            class << self
+              def applies?(_url, _text, _ctx)
+                false
+              end
+
+              def render(_url, _text, _ctx)
+                raise NotImplementedError, 'None strategy never renders'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/autolink/registry.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'angle'
+require_relative 'bare'
+require_relative 'none'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module Autolink
+          # Resolves an autolink strategy from a Config + (url, text).
+          #
+          # Mode lookup:
+          #   autolinks == true  → Angle (default, CommonMark-safe)
+          #   autolinks == false → None (use standard link syntax)
+          #
+          # The angle form is preferred over bare because angle brackets
+          # disambiguate the URL in flowing text and render identically
+          # across HTML-aware Markdown processors.
+          #
+          # Use `Bare` explicitly for GFM-targeted output where minimal
+          # noise is preferred.
+          module Registry
+            MODES = {
+              angle: Angle,
+              bare: Bare,
+              none: None
+            }.freeze
+
+            class << self
+              def lookup(mode)
+                MODES.fetch(mode.to_sym) do
+                  raise ArgumentError, "Unknown autolink mode: #{mode.inspect}. " \
+                                       "Known: #{MODES.keys.inspect}"
+                end
+              end
+
+              def resolve(url:, text:, ctx:)
+                mode = ctx.config.autolinks ? :angle : :none
+                strategy = lookup(mode)
+                return nil unless strategy.applies?(url, text, ctx)
+
+                strategy
+              end
+
+              def render_or_default(url:, text:, ctx:, default:)
+                strategy = resolve(url: url, text: text, ctx: ctx)
+                strategy ? strategy.render(url, text, ctx) : default
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module DefinitionList
+          # Each strategy renders a full DefinitionList (with all items,
+          # including nested ones) for a specific output form.
+          #
+          # Strategy is selected by inspecting the list: flat lists with
+          # no nesting use Flat (PHP Markdown Extra); lists containing
+          # any nesting use NestedHtml (HTML fallback per the spec).
+          #
+          # `config.definition_list_nested` overrides the auto choice:
+          #   :html    → always NestedHtml when any nesting exists
+          #   :flatten  → strip nesting (information loss; opt-in)
+          class Base
+            class << self
+              def applies?(_list, _ctx)
+                raise NotImplementedError
+              end
+
+              def render(_list, _ctx)
+                raise NotImplementedError
+              end
+
+              def mode_name
+                name.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/definition_list/flat.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module DefinitionList
+          # PHP Markdown Extra flat syntax:
+          #
+          #   term
+          #   : definition
+          #
+          #   term2
+          #   : first
+          #   : second
+          #
+          # Only applies when no item has a nested DefinitionList —
+          # the flat syntax has no nesting mechanism.
+          class Flat < Base
+            class << self
+              def applies?(list, _ctx)
+                list.items.none? { |term| term.nested }
+              end
+
+              def render(list, _ctx)
+                list.items.map do |term|
+                  lines = [term.text.to_s]
+                  term.definitions.each do |defn|
+                    content_str = defn.content.to_s
+                    content_str.lines.each_with_index do |line, i|
+                      stripped = line.rstrip
+                      next if i.positive? && stripped.empty?
+
+                      lines << ": #{stripped}"
+                    end
+                  end
+                  lines.join("\n")
+                end.join("\n\n")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/definition_list/nested_html.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'flat'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module DefinitionList
+          # HTML fallback for nested definition lists (Markdown syntax
+          # cannot express nesting). Renders `<dl>` with recursive
+          # `<dl>` inside `<dd>` for nested entries.
+          #
+          # For flat lists (no nesting), delegates to Flat to keep the
+          # output Markdown-native and editable.
+          class NestedHtml < Base
+            class << self
+              def applies?(list, _ctx)
+                list.items.any? { |term| term.nested }
+              end
+
+              def render(list, ctx)
+                # When the caller asked to flatten, never emit HTML.
+                return Flat.render(list, ctx) if ctx.config.definition_list_nested == :flatten
+
+                render_dl(list)
+              end
+
+              private
+
+              def render_dl(list)
+                items_html = list.items.map { |term| render_term(term) }.join
+                "<dl>\n#{items_html}</dl>"
+              end
+
+              def render_term(term)
+                dt = "<dt>#{term.text.to_s}</dt>"
+                dds = term.definitions.map { |d| render_dd(d) }.join
+                nested = term.nested ? "\n  #{render_dl(term.nested)}" : ''
+                "#{dt}\n#{dds}#{nested unless nested.empty?}"
+              end
+
+              def render_dd(definition)
+                content_str = definition.content.to_s.strip
+                "<dd>\n  #{content_str}\n</dd>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/serializer/strategies/definition_list/registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'flat'
+require_relative 'nested_html'
+
+module Coradoc
+  module Markdown
+    class Serializer
+      module Strategies
+        module DefinitionList
+          # Picks the right strategy for a given list:
+          #
+          #   1. If no item has nesting → Flat (PHP Markdown Extra)
+          #   2. If any item has nesting → NestedHtml (HTML fallback)
+          #   3. If config says :flatten and list has nesting → Flat
+          #      (drops nesting — explicit information-loss opt-in)
+          module Registry
+            STRATEGIES = [NestedHtml, Flat].freeze
+
+            class << self
+              def resolve(list, ctx)
+                return Flat if ctx.config.definition_list_nested == :flatten
+
+                STRATEGIES.find { |s| s.applies?(list, ctx) } || Flat
+              end
+
+              def render(list, ctx)
+                resolve(list, ctx).render(list, ctx)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end