coradoc-mirror 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a1079e6734d1795dd52788ca44ac74475590dbf6ccb9a576a5fcf4ef92f020d
-  data.tar.gz: ab04156585e16f2b4fa61337e3a9eca6b0f758ea82db4233c38f4422686fe611
+  metadata.gz: 4d7f1f75e597c4f6a4afe4b9d290d219ee3563b425dc31583918623f8228d048
+  data.tar.gz: 408570af8c07418f349e96c129d07f0f21b8ccb9100f7f3aee6a9bae5727443f
 SHA512:
-  metadata.gz: d3e532a097d574ac76f76c3ba863ad82fefc8c4007572a30c7d4c4bcad66f14008236a0ef9e4aca550c4f55b91f5dbc75740afac67aa2bcc18bce5c9aae0f0b9
-  data.tar.gz: 7bf8e4d4c71e20cb6cb1f71ef4a6e9c5cb1109a81c4fc1b5e85a2b462af197e3f5801827ceb30bce5ed7ce5f897ca3c2300d9fa27db699ee5a9eb239da9d4272
+  metadata.gz: f2091e8e24d6906ed7b2e40ad53538334d7cabc80a4f480f667b8e343c0e2670866ae50c13550e95bf2b08aa1c79bf629387195503688a16b8ee064b7f3994e3
+  data.tar.gz: 7e970c3b58e0a6824e1b9eb967cbb5bf8383ac88f9833334874bbf131771a1a571ab9bda4d38bd70a99f8ab8e3292e2c6a1f0cc6f082187c3e76683b37e90236

data/lib/coradoc/mirror/core_model_to_mirror.rb

@@ -139,6 +139,24 @@ module Coradoc
         Node::Footnotes.new(content: entries)
       end
 
+      # Public entrypoint for handlers that need to dispatch a nested
+      # CoreModel element through the same registry path as a top-level
+      # walk (e.g., `+`-continuation blocks attached to a dlist dd must
+      # be transformed by their own registered handler rather than
+      # inlined as text). Returns an Array of Mirror nodes (possibly
+      # empty). Single source of truth for "transform one element" so
+      # handlers don't bypass source-line propagation.
+      def transform_element(element)
+        result = @registry.handle(element, context: self)
+        return [] unless result
+
+        value, = result
+        return [] unless value
+
+        propagate_source_line(value, element)
+        Array(value)
+      end
+
       private
 
       def element_has_text_content?(element)

data/lib/coradoc/mirror/handlers/definition_list.rb

@@ -19,19 +19,45 @@ module Coradoc
         class << self
           private
 
+          # One `<dt>` per term + one `<dd>` per item. Multi-term `<dt>`'s
+          # (AsciiDoc `term1::\nterm2::\ndef`) emit two `<dt>` elements
+          # sharing one `<dd>`. Single-term items — the common case —
+          # emit one `<dt>` + one `<dd>`.
           def definition_entry(item, context)
-            term_node = build_term(item, context)
+            term_nodes = build_terms(item, context)
             desc_node = build_description(item, context)
-            return nil unless term_node || desc_node
+            return nil if term_nodes.empty? && desc_node.nil?
 
-            [term_node, desc_node].compact
+            term_nodes + [desc_node].compact
           end
 
-          def build_term(item, context)
-            term_text = item.term
-            return nil unless term_text && !term_text.to_s.empty?
+          # Emit one DefinitionTerm node per term in `item.terms`.
+          # Falls back to `[term]` for items populated via paths that
+          # only set the singular `term` accessor (backward compat).
+          def build_terms(item, context)
+            term_list = terms_for(item)
+            return [] if term_list.empty?
 
-            term_children = item.term_children if item.is_a?(CoreModel::DefinitionItem)
+            term_list.map { |term| build_term_node(term, item, context) }
+          end
+
+          # Source of truth for "the terms on this `<dt>`": the `terms`
+          # collection when populated, else `[term]` for legacy callers.
+          def terms_for(item)
+            collection = item.terms if item.is_a?(CoreModel::DefinitionItem)
+            return Array(collection) unless collection.nil? || collection.empty?
+
+            primary = item.term
+            primary.to_s.empty? ? [] : [primary.to_s]
+          end
+
+          # Build a single DefinitionTerm node for one term string,
+          # carrying inline children when the source had them. Children
+          # map 1:1 to the FIRST term only (multi-term `<dt>`'s with
+          # inline markup on later terms is rare; the parser doesn't
+          # capture per-term children today).
+          def build_term_node(term_text, item, context)
+            term_children = (item.term_children if (term_text == terms_for(item).first) && item.is_a?(CoreModel::DefinitionItem))
             if term_children && !term_children.empty?
               inline_nodes = term_children.flat_map do |child|
                 Handlers::Inline.process_child(child, context)
@@ -44,9 +70,43 @@ module Coradoc
 
           def build_description(item, context)
             desc_nodes = description_nodes(item, context)
-            return nil if desc_nodes.empty?
+            attached_nodes = attached_block_nodes(item, context)
+            nested_nodes = nested_dl_nodes(item, context)
+            all_nodes = desc_nodes.concat(attached_nodes).concat(nested_nodes)
+            return nil if all_nodes.empty?
+
+            Node::DefinitionDescription.new(content: all_nodes)
+          end
 
-            Node::DefinitionDescription.new(content: desc_nodes)
+          # `+`-continuation blocks attached to this dd in AsciiDoc source
+          # become children of the same DefinitionDescription node so they
+          # render inside the same <dd> element. Dispatch each through
+          # `context.transform_element` — same registry path as a top-level
+          # walk, so every registered block handler (paragraph, admonition,
+          # source, etc.) applies.
+          def attached_block_nodes(item, context)
+            return [] unless item.is_a?(CoreModel::DefinitionItem)
+            return [] if item.attached_children.empty?
+
+            item.attached_children.flat_map do |block|
+              context.transform_element(block)
+            end
+          end
+
+          # Multi-level dlist: AsciiDoc `::`/`:::`/`::::` delimiters
+          # express nesting depth. The parser builds the tree
+          # (CoreModel::DefinitionItem#nested); the mirror handler must
+          # recurse so the nested <dl> renders INSIDE the parent <dd>.
+          # Single source of truth: this method recurses through
+          # `DefinitionList.call`, so nested items use the same dispatch
+          # path as top-level items (DRY).
+          def nested_dl_nodes(item, context)
+            return [] unless item.is_a?(CoreModel::DefinitionItem)
+
+            nested = item.nested
+            return [] unless nested && nested.items.any?
+
+            [DefinitionList.call(nested, context: context)].compact
           end
 
           # Emit one text node per source — never both. Rich
@@ -56,7 +116,9 @@ module Coradoc
           # instances populated by paths that don't build inline children.
           def description_nodes(item, context)
             unless item.is_a?(CoreModel::DefinitionItem)
-              return Array(item.definitions).map { |defn| context.text_node(defn.to_s) }
+              return Array(item.definitions).map do |defn|
+                context.text_node(defn.to_s)
+              end
             end
 
             children = item.definition_children

data/lib/coradoc/mirror/handlers/inline.rb

@@ -123,10 +123,59 @@ module Coradoc
           end
 
           def build_simple_mark(element, context, mark_class)
-            text = extract_inline_text(element)
-            return nil if text.empty?
+            # InlineElement always has children after the dual-shape fix
+            # (Bug 16A follow-up). Walk the children and apply this mark
+            # to each text leaf. Inner mark elements get the outer mark
+            # added to their marks list, producing ProseMirror's flat
+            # text-node-with-marks shape.
+            #
+            # Fallback: programmatically constructed elements (e.g. in
+            # specs or other format gems) may not have children. Fall
+            # back to the content string in that case.
+            children = element.children
+            if children.nil? || children.empty?
+              text = extract_inline_text(element)
+              return nil if text.empty?
+
+              return context.text_node(text, marks: [mark_class.new])
+            end
 
-            context.text_node(text, marks: [mark_class.new])
+            flatten_marked_children(children, [mark_class.new], context)
+          end
+
+          # Walk a list of children, attaching the active set of marks
+          # to each text leaf. When a child is itself an InlineElement
+          # with its own mark (e.g. CodeElement inside BoldElement),
+          # the inner mark is added to the active set and recursion
+          # proceeds into its children. Produces the conjunction of
+          # marks for each text run that ProseMirror expects:
+          #   **a `b` c** → text("a ", [bold]), text("b", [bold, code]), text(" c", [bold])
+          def flatten_marked_children(children, active_marks, context)
+            result = []
+            children.each do |child|
+              case child
+              when CoreModel::TextContent
+                next if child.text.nil? || child.text.empty?
+
+                result << context.text_node(child.text, marks: active_marks.dup)
+              when CoreModel::InlineElement
+                inner_mark_class = SIMPLE_MARK_TYPES[child.class]
+                if inner_mark_class && child.children&.any?
+                  combined = active_marks + [inner_mark_class.new]
+                  result.concat(flatten_marked_children(child.children, combined, context))
+                elsif inner_mark_class
+                  text = extract_inline_text(child)
+                  next if text.empty?
+
+                  combined = active_marks + [inner_mark_class.new]
+                  result << context.text_node(text, marks: combined)
+                else
+                  nested = dispatch_inline(child, context)
+                  result << nested if nested
+                end
+              end
+            end
+            result
           end
 
           def build_link_mark(element, context)

data/lib/coradoc/mirror/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module Mirror
-    VERSION = '0.1.8'
+    VERSION = '0.1.10'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-mirror
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Ribose Inc.