Fix CI errors: suppress educational code warnings

- Add module-level clippy allows for documentation style warnings
- Suppress warnings for educational code patterns
- Fix unused variable by prefixing with underscore
- Allow vec_init_then_push and approx_constant for clarity in examples

Author: guardsarm

src/buffer_overflow_prevention.rs

@@ -40,7 +40,7 @@ pub fn safe_array_access() {
     let array = [1, 2, 3, 4, 5];
 
     // Compile-time known indices are checked
-    let _first = array[0];  // OK
+    let _first = array[0]; // OK
 
     // Runtime bounds checking (panics on out-of-bounds)
     // let _invalid = array[10];  // Would panic!
@@ -123,15 +123,16 @@ mod tests {
 
     #[test]
     #[should_panic]
+    #[allow(unconditional_panic, clippy::out_of_bounds_indexing)]
     fn test_out_of_bounds_panic() {
         let array = [1, 2, 3];
-        let _ = array[10];  // Panics (controlled failure, not undefined behavior)
+        let _ = array[10]; // Panics (controlled failure, not undefined behavior)
     }
 
     #[test]
     fn test_safe_get() {
         let array = [1, 2, 3];
         assert_eq!(array.get(1), Some(&2));
-        assert_eq!(array.get(10), None);  // Safe handling
+        assert_eq!(array.get(10), None); // Safe handling
     }
 }

src/data_race_prevention.rs

@@ -102,7 +102,7 @@ struct SendableData {
 
 /// This type is NOT Send due to raw pointer
 struct NotSendable {
-    ptr: *mut i32,  // Raw pointers are not Send
+    ptr: *mut i32, // Raw pointers are not Send
 }
 
 /// Compiler enforces thread safety
@@ -178,7 +178,7 @@ pub fn scoped_threads_safe() {
     });
 
     // All spawned threads are joined before scope ends
-    data.push(4);  // Safe to modify again
+    data.push(4); // Safe to modify again
 }
 
 #[cfg(test)]

src/lib.rs

@@ -21,9 +21,16 @@
 //! These examples align with 2024 CISA/FBI guidance recommending memory-safe
 //! languages for critical infrastructure to eliminate 70% of security vulnerabilities.
 
+#![allow(clippy::empty_line_after_doc_comments)]
+#![allow(clippy::mixed_attributes_style)]
+#![allow(dead_code)]
+#![allow(clippy::vec_init_then_push)]
+#![allow(clippy::approx_constant)]
+#![allow(clippy::useless_vec)]
+
 pub mod buffer_overflow_prevention;
-pub mod use_after_free_prevention;
 pub mod data_race_prevention;
+pub mod use_after_free_prevention;
 
 /// Module demonstrating buffer overflow prevention
 pub mod buffer_overflow {
@@ -134,14 +141,14 @@ pub mod use_after_free {
 }
 
 /// Module demonstrating data race prevention
+///
+/// Data race prevention through ownership and type system
+///
+/// Rust prevents data races at compile time through the type system.
 pub mod data_race {
     use std::sync::{Arc, Mutex};
     use std::thread;
 
-    //! Data race prevention through ownership and type system
-    //!
-    //! Rust prevents data races at compile time through the type system.
-
     /// Arc and Mutex for safe concurrent access
     pub fn safe_concurrent_access() {
         let counter = Arc::new(Mutex::new(0));
@@ -376,12 +383,12 @@ pub mod uninitialized_memory {
 }
 
 /// Module demonstrating memory leak prevention with RAII
+///
+/// Memory leak prevention through RAII (Resource Acquisition Is Initialization)
 pub mod memory_leak {
     use std::fs::File;
     use std::io::Write;
 
-    //! Memory leak prevention through RAII (Resource Acquisition Is Initialization)
-
     /// RAII ensures resources are cleaned up
     pub fn raii_file_handling() {
         // File automatically closed when it goes out of scope

src/use_after_free_prevention.rs

@@ -33,23 +33,23 @@
 
 /// Example 1: Ownership prevents use-after-free
 pub fn ownership_prevents_uaf() {
-    let data = Box::new(42);  // Heap allocation
-    let value = *data;        // Copy the value
+    let data = Box::new(42); // Heap allocation
+    let value = *data; // Copy the value
 
-    drop(data);               // Explicitly free memory
+    drop(data); // Explicitly free memory
 
     // This would NOT compile:
     // println!("{}", *data); // Compile error: value moved!
 
-    println!("Copied value: {}", value);  // Safe: we copied the value
+    println!("Copied value: {}", value); // Safe: we copied the value
 }
 
 /// Example 2: References have lifetimes
 pub fn lifetime_prevents_dangling_ref() {
-    let reference;
+    let _reference: Option<&String> = None;
 
     {
-        let data = String::from("temporary");
+        let _data = String::from("temporary");
         // This would NOT compile:
         // reference = &data;  // Compile error: `data` doesn't live long enough
     }
@@ -61,15 +61,15 @@ pub fn lifetime_prevents_dangling_ref() {
 pub fn borrowing_prevents_uaf() {
     let mut data = vec![1, 2, 3];
 
-    let reference = &data[0];  // Immutable borrow
+    let reference = &data[0]; // Immutable borrow
 
     // This would NOT compile:
     // data.clear();  // Compile error: cannot mutate while borrowed!
 
     println!("First element: {}", reference);
     // reference is no longer used, borrow ends
 
-    data.clear();  // Now we can mutate
+    data.clear(); // Now we can mutate
     println!("Vector cleared");
 }
 
@@ -87,7 +87,7 @@ pub fn shared_ownership_safe() {
     // Memory is freed only when ALL Rc references are dropped
     drop(clone1);
     drop(clone2);
-    drop(data);  // Now memory is freed
+    drop(data); // Now memory is freed
 }
 
 /// Example 5: Real-world pattern - safe object lifecycle
@@ -116,7 +116,7 @@ pub fn safe_object_usage() {
     let data_ref = obj.get_data();
     println!("Data: {:?}", data_ref);
 
-    let owned_data = obj.consume();  // obj is moved here
+    let owned_data = obj.consume(); // obj is moved here
 
     // This would NOT compile:
     // obj.get_data();  // Compile error: value used after move!