coradoc-markdown 1.0.5 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 953ed53e8524e48cac6182bce3e847cc99deba64ba70e49add437b170186bc4c
-  data.tar.gz: 4b47acb69d7ab740fe2bb1f40e14ed0471cc4766ae7bb861efe066a94551eb33
+  metadata.gz: 87855aadbdb24171b83ced3a1f973439655bbd3b9bd676b378449df3de68bbd2
+  data.tar.gz: 7ade791de29328f8d9994490d2789d5281995cf18fe6662a32703d8f2b8e46dc
 SHA512:
-  metadata.gz: 5e46c8a03f843c7061438135d27440476f4415c29a3c9d3f253cc523ae90a13ea044fa801c839f6ab7723ecc414c88a7773ac40effd10de38177dc376fafbd62
-  data.tar.gz: 7a3480158a1aef2af7236d751577fb5297f0844f148a54218b23b2583c74fee472b42c5a8c10b356b4b2c4e13999c3521fb6be4f808d27e037893509e458ec91
+  metadata.gz: a8e33edf86e3d9f52c62f046003d69b76f2d6268268c81c0dab3d094ea645e0f9deb6f5e44caa1c0a9a32c5a2d6ad4cbbba5d63f676cdabce17bf37207ec3d76
+  data.tar.gz: 4712b2d17b3f4955a3d2c43cbaaf4d3c04578539baead870f21f379845e7f3b4d811e1c5cfd72f08de3702f542067a27a66d265fc864305f9be23e783f2ba9b5

data/lib/coradoc/markdown/model/definition_item.rb

@@ -14,8 +14,10 @@ module Coradoc
       # The definition content (text or nested blocks)
       attribute :content, :string
 
-      # Inline content can be an array of text/inline elements
-      attribute :inline_content, :string, collection: true
+      # Inline content as typed Markdown elements (Code, Strong, Text, etc.).
+      # When present, the Flat serializer renders these via
+      # `ctx.serialize_inline_join` so inline formatting is preserved.
+      attribute :inline_content, Coradoc::Markdown::Base, collection: true, default: []
 
       # Nested block content (paragraphs, code blocks, lists, etc.)
       attribute :blocks, :string, collection: true

data/lib/coradoc/markdown/model/definition_term.rb

@@ -15,16 +15,22 @@ module Coradoc
       attribute :text, :string
       attribute :definitions, Coradoc::Markdown::DefinitionItem, collection: true, default: []
 
+      # Typed inline children for the term (Code, Strong, Text, etc.).
+      # When present, the Flat serializer renders these via
+      # `ctx.serialize_inline_join` so inline formatting is preserved.
+      attribute :text_children, Coradoc::Markdown::Base, collection: true, default: []
+
       # Optional nested definition list under this term.
       # When present, the flat-PHP-Markdown-Extra syntax is no longer
       # sufficient and the serializer falls back to HTML <dl>/<dt>/<dd>.
       attribute :nested, Coradoc::Markdown::DefinitionList
 
-      def initialize(text: '', definitions: [], nested: nil, **rest)
+      def initialize(text: '', definitions: [], nested: nil, text_children: [], **rest)
         super
         @text = text
         @definitions = definitions
         @nested = nested
+        @text_children = Array(text_children)
       end
     end
   end

data/lib/coradoc/markdown/model/sidebar.rb

@@ -6,16 +6,19 @@ module Coradoc
   module Markdown
     # Sidebar block — a tangential aside, visually distinct from main flow.
     #
-    # Markdown has no native sidebar. Serialized as an HTML fallback:
-    #   <div class="sidebar">...</div>
+    # Markdown has no native sidebar. Serialized as a VitePress `:::info`
+    # custom container. When the sidebar contains structured children
+    # (code blocks, lists, etc.), they are rendered into the container.
     class Sidebar < Base
       attribute :content, :string
       attribute :title, :string
+      attribute :children, Coradoc::Markdown::Base, collection: true, default: []
 
-      def initialize(content:, title: nil, **rest)
+      def initialize(content:, title: nil, children: [], **rest)
         super
         @content = content
         @title = title
+        @children = Array(children)
       end
     end
   end

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

@@ -6,13 +6,18 @@ 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).
+        # Literal block: preformatted text with no language hint. Uses an
+        # unlabeled fenced code block so the content survives VitePress's
+        # Vue template parser (4-space indented code blocks only work in
+        # specific contexts and leak `<` characters when not separated by
+        # blank lines).
         class Literal < ElementSerializer
           handles_type ::Coradoc::Markdown::Literal
 
           def call(element, _ctx)
-            element.content.to_s.lines.map { |line| "    #{line}" }.join
+            body = element.content.to_s
+            body = body.chomp + "\n" unless body.end_with?("\n")
+            "```\n#{body}```\n"
           end
         end
       end

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

@@ -6,12 +6,25 @@ module Coradoc
   module Markdown
     class Serializer
       module Serializers
+        # Sidebar block — a callout box. VitePress maps the `:::info`
+        # custom container to a styled callout, which matches AsciiDoc's
+        # sidebar semantics without leaking raw HTML into the Markdown.
         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>)
+          def call(element, ctx)
+            title = element.title.to_s
+            header = title.empty? ? '' : " #{title}"
+            body = render_body(element, ctx)
+            ":::info#{header}\n#{body}\n:::"
+          end
+
+          private
+
+          def render_body(element, ctx)
+            return element.content.to_s.chomp if element.children.nil? || element.children.empty?
+
+            element.children.map { |c| ctx.serialize(c) }.join("\n\n").chomp
           end
         end
       end

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

@@ -24,11 +24,11 @@ module Coradoc
                 list.items.none? { |term| term.nested }
               end
 
-              def render(list, _ctx)
+              def render(list, ctx)
                 list.items.map do |term|
-                  lines = [term.text.to_s]
+                  lines = [render_term(term, ctx)]
                   term.definitions.each do |defn|
-                    content_str = defn.content.to_s
+                    content_str = render_definition(defn, ctx)
                     content_str.lines.each_with_index do |line, i|
                       stripped = line.rstrip
                       next if i.positive? && stripped.empty?
@@ -39,6 +39,22 @@ module Coradoc
                   lines.join("\n")
                 end.join("\n\n")
               end
+
+              private
+
+              def render_term(term, ctx)
+                children = term.text_children
+                return term.text.to_s if children.nil? || children.empty?
+
+                ctx.serialize_inline_join(children)
+              end
+
+              def render_definition(defn, ctx)
+                children = defn.inline_content
+                return defn.content.to_s if children.nil? || children.empty?
+
+                ctx.serialize_inline_join(children)
+              end
             end
           end
         end

data/lib/coradoc/markdown/transform/from_core_model.rb

@@ -228,7 +228,11 @@ module Coradoc
           end
 
           def transform_literal_block(block)
-            Coradoc::Markdown::Literal.new(content: block.content.to_s)
+            content = CoreModel::CalloutText.strip_markers(block.content.to_s, block.callouts)
+            literal = Coradoc::Markdown::Literal.new(content: content)
+            return literal if block.callouts.nil? || block.callouts.empty?
+
+            [literal, transform_callout_list(block.callouts)]
           end
 
           def transform_example_block(block)
@@ -241,9 +245,11 @@ module Coradoc
           end
 
           def transform_sidebar_block(block)
+            children = Array(block.children).map { |c| transform(c) }.flat_map { |c| flatten_result(c) }
             Coradoc::Markdown::Sidebar.new(
               content: block.flat_text,
-              title: block.title.to_s
+              title: block.title.to_s,
+              children: children
             )
           end
 
@@ -350,13 +356,13 @@ module Coradoc
 
               # Check if first row is marked as header, or if any of its cells are header cells
               if first_row&.header || first_row_cells.any?(&:header)
-                headers = first_row_cells.map(&:flat_text)
+                headers = first_row_cells.map { |cell| strip_cell_callouts(cell.flat_text) }
                 table_rows = table_rows[1..] || []
               end
 
               # Convert remaining rows to pipe-separated strings
               rows = table_rows.map do |row|
-                Array(row.cells).map(&:flat_text).join(' | ')
+                Array(row.cells).map { |cell| strip_cell_callouts(cell.flat_text) }.join(' | ')
               end
             end
 
@@ -366,6 +372,12 @@ module Coradoc
             )
           end
 
+          CALLOUT_MARKER_IN_CELL = /\s*<\d+>(?=\s|\z)/.freeze
+
+          def strip_cell_callouts(text)
+            text.to_s.gsub(CALLOUT_MARKER_IN_CELL, '')
+          end
+
           def transform_image(image)
             Coradoc::Markdown::Image.new(
               src: image.src,
@@ -412,13 +424,13 @@ module Coradoc
 
           def transform_definition_list(dl)
             items = Array(dl.items).map do |item|
-              definitions = Array(item.definitions).map do |defn|
-                Coradoc::Markdown::DefinitionItem.new(content: defn.to_s)
-              end
+              definition = build_definition_item(item)
               nested = item.nested ? transform_definition_list(item.nested) : nil
+              term_children = Array(item.term_children).map { |c| transform_inline_content(c) }
               Coradoc::Markdown::DefinitionTerm.new(
                 text: item.term.to_s,
-                definitions: definitions,
+                text_children: term_children,
+                definitions: [definition],
                 nested: nested
               )
             end
@@ -426,6 +438,20 @@ module Coradoc
             Coradoc::Markdown::DefinitionList.new(items: items)
           end
 
+          def build_definition_item(item)
+            children = Array(item.definition_children)
+            if children.empty?
+              content = item.definitions&.first&.to_s
+              return Coradoc::Markdown::DefinitionItem.new(content: content)
+            end
+
+            inline = children.map { |c| transform_inline_content(c) }
+            Coradoc::Markdown::DefinitionItem.new(
+              content: item.definitions&.first&.to_s,
+              inline_content: inline
+            )
+          end
+
           def transform_footnote(fn)
             Coradoc::Markdown::Footnote.new(
               id: fn.id.to_s,

data/lib/coradoc/markdown/transform/inline_transformer.rb

@@ -37,6 +37,8 @@ module Coradoc
                 text: element.content.to_s,
                 target: element.target.to_s
               )
+            when 'raw_inline'
+              element.content.to_s
             else
               element.content.to_s
             end

data/lib/coradoc/markdown/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module Markdown
-    VERSION = '1.0.5'
+    VERSION = '1.0.7'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-markdown
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.7
 platform: ruby
 authors:
 - Ribose Inc.