extract code-blocks, run code-blocks, parse rustc output

Author: x0rw

exts/coding_guidelines/__init__.py

@@ -11,6 +11,12 @@
 from .common import logger, get_tqdm, bar_format, logging 
 from sphinx.domains import Domain
 
+import logging
+
+# Get the Sphinx logger
+logger = logging.getLogger('sphinx')
+logger.setLevel(logging.ERROR)
+
 class CodingGuidelinesDomain(Domain):
     name = "coding-guidelines"
     label = "Rust Standard Library"

exts/coding_guidelines/rust_examples_test.py

@@ -0,0 +1,20 @@
+
+from . import rust_examples_aggregate 
+from . import rustc 
+import os
+def setup(app):
+
+    app.output_rust_file = "exts/rust-code-runner/generated.rs"
+    if os.path.isfile(app.output_rust_file):
+        with open(app.output_rust_file, 'w'):
+            pass  
+
+    # we hook into 'source-read' because data is mutable at this point and easier to parse 
+    # and it also makes  this extension indepandant from `needs`
+    #
+    app.connect('source-read', rust_examples_aggregate.preprocess_rst_for_rust_code)
+    app.connect('build-finished', rustc.check_rust_test_errors)
+    return {
+        'version': '0.1',
+        'parallel_read_safe': False,
+    }

exts/rust-code-runner/__init__.py

@@ -0,0 +1,232 @@
+// ==== Code Block 1 ====
+#[test]
+fn test_block_coding_guidelines_expressions_1() {
+             #[repr(C)]
+             struct Base {
+                position: (u32, u32)
+             }
+}
+
+// ==== Code Block 2 ====
+#[test]
+fn test_block_coding_guidelines_expressions_2() {
+             #[repr(C)]
+             struct Base {
+                position: (u32, u32)
+             }
+}
+
+// ==== Code Block 1 ====
+#[test]
+fn test_block_coding_guidelines_macros_1() {
+            fn example_function() {
+                // Non-compliant implementation
+            }
+}
+
+// ==== Code Block 2 ====
+#[test]
+fn test_block_coding_guidelines_macros_2() {
+            fn example_function() {
+                // Compliant implementation
+            }
+}
+
+// ==== Code Block 3 ====
+#[test]
+fn test_block_coding_guidelines_macros_3() {
+            // TODO
+}
+
+// ==== Code Block 4 ====
+#[test]
+fn test_block_coding_guidelines_macros_4() {
+            // TODO
+}
+
+// ==== Code Block 5 ====
+#[test]
+fn test_block_coding_guidelines_macros_5() {
+            // HIDDEN START
+            use std::vec::*;
+            // HIDDEN END 
+            macro_rules! increment_and_double {
+                ($x:expr) => {
+                    {
+                        $x += 1; // mutation is implicit
+                        $x * 2
+                    }
+                };
+            }
+            let mut num = 5;
+            let vv = Vec![];
+            let result = increment_and_double!(num);
+            println!("Result: {}, Num: {}", result, num);
+            // Result: 12, Num: 6
+}
+
+// ==== Code Block 6 ====
+#[test]
+fn test_block_coding_guidelines_macros_6() {
+            fn increment_and_double(x: &mut i32) -> i32 {
+                *x += 1; // mutation is explicit 
+                *x * 2
+            }
+            let mut num = 5;
+            let result = increment_and_double(&mut num);
+            println!("Result: {}, Num: {}", result, num);
+            // Result: 12, Num: 6
+}
+
+// ==== Code Block 7 ====
+#[test]
+fn test_block_coding_guidelines_macros_7() {
+            fn example_function() {
+                // Non-compliant implementation
+            }
+}
+
+// ==== Code Block 8 ====
+#[test]
+fn test_block_coding_guidelines_macros_8() {
+            fn example_function() {
+                // Compliant implementation
+            }
+}
+
+// ==== Code Block 9 ====
+#[test]
+fn test_block_coding_guidelines_macros_9() {
+            fn example_function() {
+                // Non-compliant implementation
+            }
+}
+
+// ==== Code Block 10 ====
+#[test]
+fn test_block_coding_guidelines_macros_10() {
+            fn example_function() {
+                // Compliant implementation
+            }
+}
+
+// ==== Code Block 11 ====
+#[test]
+fn test_block_coding_guidelines_macros_11() {
+            fn example_function() {
+                // Non-compliant implementation
+            }
+}
+
+// ==== Code Block 12 ====
+#[test]
+fn test_block_coding_guidelines_macros_12() {
+            fn example_function() {
+                // Compliant implementation
+            }
+}
+
+// ==== Code Block 13 ====
+#[test]
+fn test_block_coding_guidelines_macros_13() {
+            fn example_function() {
+                // Non-compliant implementation
+            }
+}
+
+// ==== Code Block 14 ====
+#[test]
+fn test_block_coding_guidelines_macros_14() {
+            fn example_function() {
+                // Compliant implementation
+            }
+}
+
+// ==== Code Block 15 ====
+#[test]
+fn test_block_coding_guidelines_macros_15() {
+            #[tokio::main]  // non-compliant
+            async fn maind() {
+            //dd
+            }
+}
+
+// ==== Code Block 16 ====
+#[test]
+fn test_block_coding_guidelines_macros_16() {
+            fn example_function() {
+                // Compliant implementation
+            }
+}
+
+// ==== Code Block 17 ====
+#[test]
+fn test_block_coding_guidelines_macros_17() {
+            fn example_function() {
+                // Non-compliant implementation
+            }
+}
+
+// ==== Code Block 18 ====
+#[test]
+fn test_block_coding_guidelines_macros_18() {
+            // HIDDEN START
+            use std::fs;
+            use std::io::{self, Read};
+            // HIDDEN END 
+}
+
+// ==== Code Block 1 ====
+#[test]
+fn test_block_coding_guidelines_types_and_traits_1() {
+             fn calculate_next_position(current: u32, velocity: u32) -> u32 {
+                 // Potential for silent overflow in release builds
+                 current + velocity
+             }
+}
+
+// ==== Code Block 2 ====
+#[test]
+fn test_block_coding_guidelines_types_and_traits_2() {
+             fn calculate_next_position(current: u32, velocity: u32) -> u32 {
+                 // Explicitly handle potential overflow with checked addition
+                 current.checked_add(velocity).expect("Position calculation overflowed")
+             }
+}
+
+// ==== Code Block 1 ====
+#[test]
+fn test_block_process_style_guideline_1() {
+                fn calculate_next_position(current: u32, velocity: u32) -> u32 {
+                    // Potential for silent overflow in release builds
+                    current + velocity
+                }
+}
+
+// ==== Code Block 2 ====
+#[test]
+fn test_block_process_style_guideline_2() {
+                fn calculate_next_position(current: u32, velocity: u32) -> u32 {
+                    // Explicitly handle potential overflow with checked addition
+                    current.checked_add(velocity).expect("Position calculation overflowed")
+                }
+}
+
+// ==== Code Block 3 ====
+#[test]
+fn test_block_process_style_guideline_3() {
+                fn calculate_next_position(current: u32, velocity: u32) -> u32 {
+                    // Potential for silent overflow in release builds
+                    current + velocity
+                }
+}
+
+// ==== Code Block 4 ====
+#[test]
+fn test_block_process_style_guideline_4() {
+                fn calculate_next_position(current: u32, velocity: u32) -> u32 {
+                    // Explicitly handle potential overflow with checked addition
+                    current.checked_add(velocity).expect("Position calculation overflowed")
+                }
+}
+

exts/rust-code-runner/generated.rs

@@ -0,0 +1,91 @@
+from sphinx.errors import SphinxError
+import logging
+import re
+
+logger = logging.getLogger('sphinx')
+# reducing errors temporarly for dev
+logger.setLevel(logging.ERROR) 
+
+class ExecuteRustExamples(SphinxError):
+    category = "ExecuteRustExamples Error"
+
+
+def extract_code_blocks(text):
+    pattern = re.compile(
+        r"\.\. code-block:: rust\s*\n(?:(?:\s*\n)+)?((?: {2,}.*(?:\n|$))+)",
+        re.MULTILINE
+    )
+    
+    matches = pattern.findall(text)
+    blocks = []
+    for i, block in enumerate(matches):
+        lines = block.splitlines()
+        non_empty_lines = [line for line in lines if line.strip()]
+        processed_block = "\n".join(non_empty_lines)
+        blocks.append(processed_block)
+
+        # print(f"====== code block {i + 1} ========")
+        # print(processed_block)
+        # print("====== end code block ========")
+
+    return blocks
+
+def strip_hidden(code_block):
+    lines = code_block.splitlines()
+    result = []
+    hidden = []
+    is_hidden = False
+
+    for line in lines:
+        stripped_for_marker_check = line[2:] if line.startswith("  ") else line 
+        if "// HIDDEN START" in stripped_for_marker_check:
+            is_hidden = True
+            continue
+        if "// HIDDEN END" in stripped_for_marker_check:
+            is_hidden = False
+            continue
+        if not is_hidden:
+            result.append(line)
+        else:
+            hidden.append(line)
+    return "\n".join(result), "\n".join(hidden)
+
+def remove_hidden_blocks_from_document(source_text):
+    code_block_re = re.compile(
+        r"(\.\. code-block:: rust\s*\n\n)((?: {2}.*\n)+)",
+        re.DOTALL
+    )
+    # callback for replacing
+    def replacer(match):
+        prefix = match.group(1)  
+        code_content = match.group(2)
+        cleaned_code, hidden_code = strip_hidden(code_content)
+        print("============")
+        print(hidden_code)
+        print("============")
+        return prefix + cleaned_code 
+
+    modified_text = code_block_re.sub(replacer, source_text)
+    return modified_text
+
+
+def preprocess_rst_for_rust_code(app, docname, source):
+
+    original_content = source[0]
+    code_blocks = extract_code_blocks(original_content)
+    modified_content = remove_hidden_blocks_from_document(original_content)
+    source[0] = modified_content
+
+    print(f"Original content length: {len(original_content)}")
+    print(f"Extracted {len(code_blocks)} code blocks")
+
+    output_path = "exts/rust-code-runner/generated.rs"
+    safe_docname = docname.replace("/", "_").replace("-", "_")
+    with open(output_path, "a", encoding="utf-8") as f:
+        for i, block in enumerate(code_blocks, start=1):
+            f.write(f"// ==== Code Block {i} ====\n")
+            f.write("#[test]\n")
+            f.write(f"fn test_block_{safe_docname}_{i}() {{\n")
+            for line in block.splitlines():
+                f.write(f"    {line}\n") 
+            f.write("}\n\n")