fix: use proper YAML parsing in inject script instead of regex

This fixes issues with injecting minified code when YAML values contain
escaped quotes or special characters. The yaml library properly handles
parsing and serialization instead of relying on fragile regex patterns.

Author: adamant-pwn

.verify-helper/scripts/inject_minified_docs.py

@@ -1,36 +1,20 @@
 #!/usr/bin/env python3
 """
 Inject minified code into documentation markdown files.
-This script reads minified versions from .competitive-verifier/minified/ and
-adds minifiedCode fields to the documentation markdown files.
+This script reads minified versions from cp-algo/min/ and cp-algo/min-bundled/
+and adds minifiedCode and minifiedBundledCode fields to the documentation markdown files.
 """
 
 import os
 import sys
 from pathlib import Path
 import re
 import json
-
-
-def get_minified_code(file_path, minified_dir):
-    """Get minified code for a given file path."""
-    minified_file = minified_dir / file_path
-    if minified_file.exists():
-        try:
-            with open(minified_file, 'r', encoding='utf-8') as f:
-                code = f.read()
-            # Escape for YAML
-            code = code.replace('\\', '\\\\')
-            code = code.replace('"', '\\"')
-            code = code.replace('\n', '\\n')
-            return code
-        except Exception as e:
-            print(f"Error reading {minified_file}: {e}", file=sys.stderr)
-    return None
+import yaml
 
 
 def inject_minified_to_markdown(markdown_file, minified_code=None, minified_bundled_code=None):
-    """Inject minified code into markdown file's front matter."""
+    """Inject minified code into markdown file's front matter using proper YAML parsing."""
     try:
         with open(markdown_file, 'r', encoding='utf-8') as f:
             content = f.read()
@@ -39,76 +23,45 @@ def inject_minified_to_markdown(markdown_file, minified_code=None, minified_bund
         if not content.startswith('---'):
             return False
 
-        # Split front matter and content
+        # Split front matter and content at first --- and second ---
         parts = content.split('---', 2)
         if len(parts) < 3:
             return False
 
-        front_matter = parts[1]
+        front_matter_str = parts[1]
         body = parts[2]
 
+        # Parse YAML front matter
+        try:
+            front_matter = yaml.safe_load(front_matter_str)
+        except Exception as e:
+            print(f"Error parsing YAML for {markdown_file}: {e}", file=sys.stderr)
+            return False
+        
+        if not isinstance(front_matter, dict):
+            return False
+        
         updated = False
 
-        # Handle minifiedCode
+        # Add or update minifiedCode
         if minified_code:
-            if 'minifiedCode:' in front_matter:
-                # Replace existing minifiedCode
-                front_matter = re.sub(
-                    r'  minifiedCode: ".*?"(?=\n  [a-zA-Z_]|\n$)',
-                    f'  minifiedCode: "{minified_code}"',
-                    front_matter,
-                    flags=re.DOTALL
-                )
-            else:
-                # Add minifiedCode after bundledCode if it exists
-                if 'bundledCode:' in front_matter:
-                    front_matter = re.sub(
-                        r'(  bundledCode: ".*?")(\n  [a-zA-Z_]|\n$)',
-                        rf'\1\n  minifiedCode: "{minified_code}"\2',
-                        front_matter,
-                        flags=re.DOTALL
-                    )
-                else:
-                    # Add at the end of front matter
-                    front_matter = front_matter.rstrip() + f'\n  minifiedCode: "{minified_code}"'
+            front_matter['minifiedCode'] = minified_code
             updated = True
 
-        # Handle minifiedBundledCode
+        # Add or update minifiedBundledCode
         if minified_bundled_code:
-            if 'minifiedBundledCode:' in front_matter:
-                # Replace existing minifiedBundledCode
-                front_matter = re.sub(
-                    r'  minifiedBundledCode: ".*?"(?=\n  [a-zA-Z_]|\n$)',
-                    f'  minifiedBundledCode: "{minified_bundled_code}"',
-                    front_matter,
-                    flags=re.DOTALL
-                )
-            else:
-                # Add minifiedBundledCode after minifiedCode if it exists
-                if 'minifiedCode:' in front_matter:
-                    front_matter = re.sub(
-                        r'(  minifiedCode: ".*?")(\n  [a-zA-Z_]|\n$)',
-                        rf'\1\n  minifiedBundledCode: "{minified_bundled_code}"\2',
-                        front_matter,
-                        flags=re.DOTALL
-                    )
-                elif 'bundledCode:' in front_matter:
-                    front_matter = re.sub(
-                        r'(  bundledCode: ".*?")(\n  [a-zA-Z_]|\n$)',
-                        rf'\1\n  minifiedBundledCode: "{minified_bundled_code}"\2',
-                        front_matter,
-                        flags=re.DOTALL
-                    )
-                else:
-                    # Add at the end of front matter
-                    front_matter = front_matter.rstrip() + f'\n  minifiedBundledCode: "{minified_bundled_code}"'
+            front_matter['minifiedBundledCode'] = minified_bundled_code
             updated = True
 
         if not updated:
             return False
 
+        # Re-serialize YAML front matter
+        # Use default_flow_style=False to keep lists as blocks, allow_unicode=True for special chars
+        new_front_matter_str = yaml.dump(front_matter, default_flow_style=False, allow_unicode=True)
+        
         # Write updated content
-        new_content = f'---{front_matter}---{body}'
+        new_content = f'---{new_front_matter_str}---{body}'
         with open(markdown_file, 'w', encoding='utf-8') as f:
             f.write(new_content)
 
@@ -157,25 +110,17 @@ def main():
                 minified_file = minified_dir / f"{path_without_ext}.{ext}"
                 if minified_file.exists():
                     with open(minified_file, 'r', encoding='utf-8') as f:
-                        code = f.read()
-                    # Escape for YAML
-                    code = code.replace('\\', '\\\\')
-                    code = code.replace('"', '\\"')
-                    code = code.replace('\n', '\\n')
-                    minified_code = code
+                        minified_code = f.read()
+                    break
 
         # Try to find corresponding minified bundled file
         for ext in possible_extensions:
             if minified_bundled_code is None and minified_bundled_dir.exists():
                 minified_bundled_file = minified_bundled_dir / f"{path_without_ext}.{ext}"
                 if minified_bundled_file.exists():
                     with open(minified_bundled_file, 'r', encoding='utf-8') as f:
-                        code = f.read()
-                    # Escape for YAML
-                    code = code.replace('\\', '\\\\')
-                    code = code.replace('"', '\\"')
-                    code = code.replace('\n', '\\n')
-                    minified_bundled_code = code
+                        minified_bundled_code = f.read()
+                    break
 
         # Only inject if we found at least one minified version
         if (minified_code or minified_bundled_code) and inject_minified_to_markdown(md_file, minified_code, minified_bundled_code):