Fix parsing of mathblocks

Author: jhobbs

mathnotes/block_index.py

@@ -145,16 +145,34 @@ def _render_all_blocks(self):
             # Initialize rendered blocks storage for this file
             self.rendered_blocks[file_path] = {}
 
-            # Render all blocks in this file
-            for marker_id, block in block_markers.items():
-                # Ensure trailing slash before fragment
+            # Process blocks in dependency order: children before parents
+            # First, identify root blocks (blocks without parents) and process recursively
+            processed_blocks = set()
+            
+            def process_block_tree(block, marker_id):
+                """Recursively process a block and its children."""
+                if marker_id in processed_blocks:
+                    return
+                    
+                # First process all child blocks
+                for child_marker_id, child_block in block_markers.items():
+                    if child_block.parent == block:
+                        process_block_tree(child_block, child_marker_id)
+                
+                # Now process this block
                 base_url = f"/mathnotes/{canonical_url}"
                 if not base_url.endswith('/'):
                     base_url += '/'
                 full_url = f"{base_url}#{block.label}" if block.label else base_url
                 self._process_block_content(block, block_markers, parser, full_url)
                 # Store the rendered HTML by marker ID
                 self.rendered_blocks[file_path][marker_id] = block.rendered_html
+                processed_blocks.add(marker_id)
+            
+            # Process all root blocks (blocks without parents)
+            for marker_id, block in block_markers.items():
+                if block.parent is None:
+                    process_block_tree(block, marker_id)
 
         # Clean up temporary storage
         del self._pending_files
@@ -191,7 +209,20 @@ def _process_block_content(self, block: MathBlock, block_markers: Dict[str, Math
             html_content = html_content.replace(r"\*", "*")
             html_content = html_content.replace(r"\~", "~")
 
+            # Remove child block markers for tooltip use
+            # Tooltips should only show the block's own content, not nested blocks
+            clean_html = html_content
+            for marker_id, child_block in block_markers.items():
+                if child_block.parent == block and marker_id in clean_html:
+                    # Remove the marker entirely - don't include child content in tooltips
+                    clean_html = clean_html.replace(f"<p>{marker_id}</p>", "")
+                    clean_html = clean_html.replace(marker_id, "")
+            
+            # Store the clean inner HTML content (for tooltips and other uses)
+            block.content_html = clean_html
+            
             # Render the complete block HTML using the same method as page view
+            # This will wrap the content and replace child markers with full child HTML
             block.rendered_html = parser.render_block_html(block, html_content, block_markers, self.md, full_url)
 
 

mathnotes/sitegenerator/builder.py

@@ -83,10 +83,11 @@ def setup_global_context(self):
         if self.block_index and hasattr(self.block_index, 'index'):
             tooltip_data = {}
             for label, ref in self.block_index.index.items():
+                # Use the processed HTML content (with references converted to links)
                 tooltip_data[label] = {
                     'type': ref.block.block_type.value,
                     'title': ref.block.title or '',
-                    'content': ref.block.content,
+                    'content': ref.block.content_html,
                     'url': ref.full_url
                 }
 

mathnotes/structured_math.py

@@ -41,6 +41,7 @@ class MathBlock:
     metadata: Dict[str, Any] = field(default_factory=dict)
     children: List["MathBlock"] = field(default_factory=list)
     parent: Optional["MathBlock"] = None
+    content_html: Optional[str] = None  # Stores the inner HTML content (without wrapper)
 
     @property
     def css_class(self) -> str:
@@ -422,8 +423,8 @@ def render_block_html(
         # Render child blocks that are referenced in the content
         for marker_id, child_block in block_markers.items():
             if child_block.parent == block and marker_id in processed_content:
-                # Render the child block
-                child_html = self._render_child_block(child_block, block_markers, md_processor)
+                # Child blocks are always processed first, so rendered_html is available
+                child_html = child_block.rendered_html
                 # Replace marker with rendered child
                 processed_content = processed_content.replace(f"<p>{marker_id}</p>", child_html)
                 processed_content = processed_content.replace(marker_id, child_html)
@@ -441,41 +442,6 @@ def render_block_html(
 
         return "\n".join(html_parts)
 
-    def _render_child_block(
-        self, block: MathBlock, block_markers: Dict[str, MathBlock], md_processor
-    ) -> str:
-        """Render a child block with its content."""
-        # Process the block's content through markdown
-        block_content = block.content
-
-        # Process cross-references using the unified processor (first pass)
-        block_ref_processor = BlockReferenceProcessor(
-            block_markers=block_markers,
-            current_file=self.current_file,
-            block_index=self.block_index,
-        )
-        block_content = block_ref_processor.process_references(block_content)
-
-        # Protect math before markdown processing
-        child_math_protector = MathProtector(prefix="CHILDMATH")
-        block_content = child_math_protector.protect_math(block_content)
-
-        # Process through markdown
-        block_html = md_processor.convert(block_content)
-        md_processor.reset()
-
-        # Restore math
-        block_html = child_math_protector.restore_math(block_html)
-        
-        # Process embedded blocks after markdown conversion (second pass)
-        if block_ref_processor.embedded_blocks:
-            block_html = block_ref_processor.process_embedded_blocks(block_html, md_processor)
-
-        # Render the block with nested support
-        # For child blocks on the same page, use #label as URL
-        url = f"#{block.label}" if block.label else None
-        return self.render_block_html(block, block_html, block_markers, md_processor, url)
-
     def get_blocks_by_type(self, block_type: MathBlockType) -> List[MathBlock]:
         """Get all blocks of a specific type."""
         return [block for block in self.blocks if block.block_type == block_type]