coradoc-markdown 1.0.2 → 1.0.4

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}#{render_body(admonition, ctx)}\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