coradoc-mirror 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d0dddcebf58649933def45133c70a5ed3caf8f1441d1a789b9ea95d49fa8d24
-  data.tar.gz: 6275f1315af45cb267762a26862bdcb1d2bb65e29fd4657cd411a98200b6c0f9
+  metadata.gz: 4d7f1f75e597c4f6a4afe4b9d290d219ee3563b425dc31583918623f8228d048
+  data.tar.gz: 408570af8c07418f349e96c129d07f0f21b8ccb9100f7f3aee6a9bae5727443f
 SHA512:
-  metadata.gz: 13c8d02108886f582cf93f501a9e503361c450c224f0105e255583200323bd4d170d3303b2250510922ee4dad0aa92b45a987caf690528098f77d90b18e2672a
-  data.tar.gz: 3eef4445a831dfce49faaa0e777ad4cd28fb54d9d7b71db640e45585ea557267f87b831031839da32077bf6886ae53f9d085e65200ac6aa2cc939c393f93df1d
+  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,19 +123,24 @@ module Coradoc
           end
 
           def build_simple_mark(element, context, mark_class)
-            # When the mark carries parsed children (Bug 16B — nested
-            # inline marks like `**bold \`code\`**`), 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.
-            if element.children&.any?
-              return flatten_marked_children(element.children, [mark_class.new], context)
+            # 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
 
-            text = extract_inline_text(element)
-            return nil if text.empty?
-
-            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

data/lib/coradoc/mirror/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module Mirror
-    VERSION = '0.1.9'
+    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.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Ribose Inc.