update

Author: adamant-pwn

.github/workflows/verify.yml

@@ -201,10 +201,21 @@ jobs:
       - name: Commit minified versions
         shell: bash
         run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          changes=false
+          
           if [ -n "$(git status cp-algo/min/ --porcelain)" ]; then
-            git config user.name "github-actions[bot]"
-            git config user.email "github-actions[bot]@users.noreply.github.com"
             git add cp-algo/min/
+            changes=true
+          fi
+          
+          if [ -n "$(git status cp-algo/min-bundled/ --porcelain)" ]; then
+            git add cp-algo/min-bundled/
+            changes=true
+          fi
+          
+          if [ "$changes" = true ]; then
             git commit -m "chore: update minified library versions"
             git push
           else

.verify-helper/docs/_config.yml

@@ -1,2 +1,2 @@
-exclude: ['images']
+exclude: ['images', 'cp-algo/min', 'cp-algo/min-bundled']
 title: CP-Algorithms Library

.verify-helper/scripts/generate_minified.py

@@ -133,32 +133,37 @@ def process_file(bundled_path, minified_path, committed_path=None):
 def main():
     # Source directory to minify
     source_dir = Path('cp-algo')
+    bundled_dir = Path('.competitive-verifier/bundled')
 
     # Output directories
     minified_ci_dir = Path('.competitive-verifier/minified')
+    minified_bundled_ci_dir = Path('.competitive-verifier/minified-bundled')
     minified_committed_dir = Path('cp-algo/min')
+    minified_bundled_committed_dir = Path('cp-algo/min-bundled')
 
     # Verify source directory exists
     if not source_dir.exists():
         print(f"Error: {source_dir} does not exist", file=sys.stderr)
         sys.exit(1)
 
     # Clear output directories
-    if minified_ci_dir.exists():
-        import shutil
-        shutil.rmtree(minified_ci_dir)
+    for d in [minified_ci_dir, minified_bundled_ci_dir]:
+        if d.exists():
+            import shutil
+            shutil.rmtree(d)
+        d.mkdir(parents=True, exist_ok=True)
 
-    minified_ci_dir.mkdir(parents=True, exist_ok=True)
-    minified_committed_dir.mkdir(parents=True, exist_ok=True)
+    for d in [minified_committed_dir, minified_bundled_committed_dir]:
+        d.mkdir(parents=True, exist_ok=True)
 
     print("Generating minified versions from source files...")
 
     total_files = 0
     processed_files = 0
 
-    # Process all source files in cp-algo (but not in cp-algo/min itself)
+    # Process all source files in cp-algo (but not in cp-algo/min* itself)
     for src_file in source_dir.rglob('*'):
-        # Skip files in min directory
+        # Skip files in min directories
         if 'min' in src_file.parts:
             continue
 
@@ -168,18 +173,43 @@ def main():
             # Calculate relative path within cp-algo
             rel_path = src_file.relative_to(source_dir)
 
-            # Output paths
+            # Output paths for minified source
             minified_ci_file = minified_ci_dir / 'cp-algo' / rel_path
             minified_committed_file = minified_committed_dir / rel_path
 
             if process_file(src_file, minified_ci_file, minified_committed_file):
                 processed_files += 1
 
-    print(f"\nProcessed {processed_files}/{total_files} files")
-    print(f"Generated in:")
+    print(f"\nProcessed {processed_files}/{total_files} source files")
+    print(f"Generated source minified in:")
     print(f"  - .competitive-verifier/minified/cp-algo/")
     print(f"  - cp-algo/min/")
 
+    # Now process bundled versions if they exist
+    if bundled_dir.exists():
+        print(f"\nGenerating minified bundled versions from bundled files...")
+        total_bundled = 0
+        processed_bundled = 0
+        
+        for bundled_file in bundled_dir.rglob('*'):
+            if bundled_file.is_file() and bundled_file.suffix in ['.hpp', '.cpp', '.h']:
+                total_bundled += 1
+                
+                # Calculate relative path within bundled
+                rel_path = bundled_file.relative_to(bundled_dir)
+                
+                # Output paths for minified bundled
+                minified_bundled_ci_file = minified_bundled_ci_dir / rel_path
+                minified_bundled_committed_file = minified_bundled_committed_dir / rel_path
+                
+                if process_file(bundled_file, minified_bundled_ci_file, minified_bundled_committed_file):
+                    processed_bundled += 1
+        
+        print(f"\nProcessed {processed_bundled}/{total_bundled} bundled files")
+        print(f"Generated bundled minified in:")
+        print(f"  - .competitive-verifier/minified-bundled/")
+        print(f"  - cp-algo/min-bundled/")
+    
     if processed_files < total_files and total_files > 0:
         sys.exit(1)
 

.verify-helper/scripts/inject_minified_docs.py

@@ -29,7 +29,7 @@ def get_minified_code(file_path, minified_dir):
     return None
 
 
-def inject_minified_to_markdown(markdown_file, minified_code):
+def inject_minified_to_markdown(markdown_file, minified_code=None, minified_bundled_code=None):
     """Inject minified code into markdown file's front matter."""
     try:
         with open(markdown_file, 'r', encoding='utf-8') as f:
@@ -47,27 +47,65 @@ def inject_minified_to_markdown(markdown_file, minified_code):
         front_matter = parts[1]
         body = parts[2]
 
-        # Parse front matter to check if minifiedCode already exists
-        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:
+        updated = False
+        
+        # Handle minifiedCode
+        if minified_code:
+            if 'minifiedCode:' in front_matter:
+                # Replace existing minifiedCode
                 front_matter = re.sub(
-                    r'(  bundledCode: ".*?")(\n  [a-zA-Z_]|\n$)',
-                    rf'\1\n  minifiedCode: "{minified_code}"\2',
+                    r'  minifiedCode: ".*?"(?=\n  [a-zA-Z_]|\n$)',
+                    f'  minifiedCode: "{minified_code}"',
                     front_matter,
                     flags=re.DOTALL
                 )
             else:
-                # Add at the end of front matter
-                front_matter = front_matter.rstrip() + f'\n  minifiedCode: "{minified_code}"'
+                # 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}"'
+            updated = True
+        
+        # Handle 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}"'
+            updated = True
+        
+        if not updated:
+            return False
 
         # Write updated content
         new_content = f'---{front_matter}---{body}'
@@ -81,12 +119,19 @@ def inject_minified_to_markdown(markdown_file, minified_code):
 
 
 def main():
-    markdown_dir = Path('.verify-helper/markdown')
+    markdown_dir = Path('_jekyll')
     minified_dir = Path('cp-algo/min')
+    minified_bundled_dir = Path('cp-algo/min-bundled')
+    
+    # If _jekyll doesn't exist, try the verify-helper path (for local testing)
+    if not markdown_dir.exists():
+        markdown_dir = Path('.verify-helper/markdown')
 
     if not minified_dir.exists():
         print(f"Warning: {minified_dir} does not exist", file=sys.stderr)
-        return 0
+    
+    if not minified_bundled_dir.exists():
+        print(f"Warning: {minified_bundled_dir} does not exist", file=sys.stderr)
 
     if not markdown_dir.exists():
         print(f"Error: {markdown_dir} does not exist", file=sys.stderr)
@@ -95,29 +140,45 @@ def main():
     print("Injecting minified code into documentation...")
 
     count = 0
-    # Find all markdown files with bundledCode
+    # Find all markdown files
     for md_file in markdown_dir.rglob('*.md'):
         # Get relative path without .md extension
         rel_path = md_file.relative_to(markdown_dir)
         path_without_ext = str(rel_path)[:-3]  # Remove .md
 
-        # Try to find corresponding minified file
-        possible_extensions = ['hpp', 'cpp', 'h']
         minified_code = None
+        minified_bundled_code = None
+        
+        # Try to find corresponding minified source file
+        possible_extensions = ['hpp', 'cpp', 'h']
+        
+        for ext in possible_extensions:
+            if minified_code is None and minified_dir.exists():
+                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
 
+        # Try to find corresponding minified bundled file
         for ext in possible_extensions:
-            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
-                break
+            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
 
-        if minified_code and inject_minified_to_markdown(md_file, minified_code):
+        # 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):
             count += 1
             print(f"  Updated: {path_without_ext}")