style: Apply clippy and fmt fixes for v0.12.0 release (Refs release)

Author: noahgift

Cargo.lock

@@ -503,46 +503,46 @@ mod tests {
         let p = RandomForestParam::NEstimators;
         let cloned = p;
         assert_eq!(p, cloned);
-        assert!(format!("{:?}", p).contains("NEstimators"));
+        assert!(format!("{p:?}").contains("NEstimators"));
     }
 
     #[test]
     fn test_gradient_boosting_clone_debug() {
         let p = GradientBoostingParam::LearningRate;
         let cloned = p;
         assert_eq!(p, cloned);
-        assert!(format!("{:?}", p).contains("LearningRate"));
+        assert!(format!("{p:?}").contains("LearningRate"));
     }
 
     #[test]
     fn test_knn_clone_debug() {
         let p = KNNParam::NNeighbors;
         let cloned = p;
         assert_eq!(p, cloned);
-        assert!(format!("{:?}", p).contains("NNeighbors"));
+        assert!(format!("{p:?}").contains("NNeighbors"));
     }
 
     #[test]
     fn test_linear_clone_debug() {
         let p = LinearParam::Alpha;
         let cloned = p;
         assert_eq!(p, cloned);
-        assert!(format!("{:?}", p).contains("Alpha"));
+        assert!(format!("{p:?}").contains("Alpha"));
     }
 
     #[test]
     fn test_decision_tree_clone_debug() {
         let p = DecisionTreeParam::MaxDepth;
         let cloned = p;
         assert_eq!(p, cloned);
-        assert!(format!("{:?}", p).contains("MaxDepth"));
+        assert!(format!("{p:?}").contains("MaxDepth"));
     }
 
     #[test]
     fn test_kmeans_clone_debug() {
         let p = KMeansParam::NClusters;
         let cloned = p;
         assert_eq!(p, cloned);
-        assert!(format!("{:?}", p).contains("NClusters"));
+        assert!(format!("{p:?}").contains("NClusters"));
     }
 }

src/automl/params.rs

@@ -510,8 +510,8 @@ mod tests {
             p2 >= p1,
             "Higher predictions should give higher calibrated values"
         );
-        assert!(p1 >= 0.0 && p1 <= 1.0);
-        assert!(p2 >= 0.0 && p2 <= 1.0);
+        assert!((0.0..=1.0).contains(&p1));
+        assert!((0.0..=1.0).contains(&p2));
     }
 
     #[test]
@@ -530,9 +530,7 @@ mod tests {
             let curr = iso.predict(x);
             assert!(
                 curr >= prev - 1e-6,
-                "Isotonic should be monotonic: {} < {}",
-                curr,
-                prev
+                "Isotonic should be monotonic: {curr} < {prev}"
             );
             prev = curr;
         }

src/calibration.rs

@@ -1148,11 +1148,11 @@ mod tests {
     fn test_rust_compiler_compile_valid_code() {
         let compiler = RustCompiler::new();
         // Use library-compatible code (no main function)
-        let code = r#"
+        let code = r"
 pub fn add(a: i32, b: i32) -> i32 {
     a + b
 }
-"#;
+";
         let result = compiler.compile(code, &CompileOptions::default());
         assert!(result.is_ok());
         let result = result.expect("Should compile");
@@ -1264,7 +1264,7 @@ pub fn add(a: i32, b: i32) -> i32 {
             .write_to_temp()
             .expect("Should write");
 
-        let dir = project.project_dir().expect("Has dir").to_path_buf();
+        let dir = project.project_dir().expect("Has dir").clone();
         assert!(dir.exists());
 
         drop(project);

src/citl/compiler.rs

@@ -666,8 +666,7 @@ mod tests {
         let similarity = e1.cosine_similarity(&e2);
         assert!(
             similarity > 0.5,
-            "Similar errors should have similarity > 0.5, got {}",
-            similarity
+            "Similar errors should have similarity > 0.5, got {similarity}"
         );
     }
 
@@ -701,8 +700,7 @@ mod tests {
         let similarity = e1.cosine_similarity(&e2);
         assert!(
             similarity < 0.9,
-            "Different errors should have similarity < 0.9, got {}",
-            similarity
+            "Different errors should have similarity < 0.9, got {similarity}"
         );
     }
 

src/citl/encoder.rs

@@ -1044,7 +1044,7 @@ mod tests {
         let suggestion = citl.suggest_fix(&diag, "let x: String = 42;");
         // Should find a suggestion (may or may not match well depending on embedding)
         // The key is that it doesn't panic and returns Some when pattern exists
-        assert!(suggestion.is_some() || citl.pattern_library.len() > 0);
+        assert!(suggestion.is_some() || !citl.pattern_library.is_empty());
     }
 
     #[test]
@@ -1285,15 +1285,15 @@ pub fn greet(name: &str) -> String {
         });
 
         // Valid code
-        let code = r#"
+        let code = r"
 pub fn multiply(a: f64, b: f64) -> f64 {
     a * b
 }
 
 pub fn is_positive(n: i32) -> bool {
     n > 0
 }
-"#;
+";
 
         let result = compiler.compile(code, &CompileOptions::default());
         assert!(result.is_ok());

src/citl/mod.rs

@@ -1401,8 +1401,7 @@ mod tests {
         let norm: f32 = embedding.iter().map(|x| x * x).sum::<f32>().sqrt();
         assert!(
             (norm - 1.0).abs() < 0.01,
-            "Embedding norm should be ~1.0, got {}",
-            norm
+            "Embedding norm should be ~1.0, got {norm}"
         );
     }
 
@@ -1436,9 +1435,7 @@ mod tests {
         // Similar errors should have higher similarity
         assert!(
             sim_12 > sim_13,
-            "Similar errors should have higher similarity: sim_12={}, sim_13={}",
-            sim_12,
-            sim_13
+            "Similar errors should have higher similarity: sim_12={sim_12}, sim_13={sim_13}"
         );
     }
 
@@ -1457,7 +1454,7 @@ mod tests {
         // Should still be somewhat similar (both are type errors)
         let sim = cosine_sim(&emb_rust, &emb_python);
         // Just verify it's a valid similarity value
-        assert!(sim >= -1.0 && sim <= 1.0);
+        assert!((-1.0..=1.0).contains(&sim));
     }
 
     // ==================== ContrastiveLoss Tests ====================

src/citl/neural.rs

@@ -1174,7 +1174,7 @@ mod tests {
     #[test]
     fn test_template_borrow_instead_of_move() {
         let template = templates::borrow_instead_of_move();
-        assert!(template.pattern.contains("&"));
+        assert!(template.pattern.contains('&'));
         assert!(template.applies_to("E0382"));
         assert!(template.confidence > 0.7);
     }

src/citl/pattern.rs

@@ -32,7 +32,7 @@ mod tests {
         let gating = SoftmaxGating::new(4, 3).with_temperature(0.01);
         let input = vec![1.0, 2.0, 3.0, 4.0];
         let weights = gating.forward(&input);
-        let max_weight = weights.iter().cloned().fold(0.0f32, f32::max);
+        let max_weight = weights.iter().copied().fold(0.0f32, f32::max);
         assert!(max_weight > 0.9);
     }
 
@@ -58,7 +58,7 @@ mod tests {
             .build()
             .expect("build");
         let output = moe.predict(&[1.0, 2.0, 3.0, 4.0]);
-        assert!(output >= 10.0 && output <= 20.0);
+        assert!((10.0..=20.0).contains(&output));
     }
 
     #[test]

src/ensemble/mod.rs

@@ -749,7 +749,7 @@ mod tests {
         ];
         for t in types {
             assert_eq!(t, t);
-            assert!(!format!("{:?}", t).is_empty());
+            assert!(!format!("{t:?}").is_empty());
         }
     }
 
@@ -773,7 +773,7 @@ mod tests {
         ];
         for t in types {
             assert_eq!(t, t);
-            assert!(!format!("{:?}", t).is_empty());
+            assert!(!format!("{t:?}").is_empty());
         }
     }
 
@@ -787,7 +787,7 @@ mod tests {
         assert_eq!(t, GgufValueType::Uint8);
         let cloned = t;
         assert_eq!(t, cloned);
-        assert!(format!("{:?}", t).contains("Uint8"));
+        assert!(format!("{t:?}").contains("Uint8"));
     }
 
     #[test]
@@ -796,14 +796,14 @@ mod tests {
         assert_eq!(t, GgmlType::F32);
         let cloned = t;
         assert_eq!(t, cloned);
-        assert!(format!("{:?}", t).contains("F32"));
+        assert!(format!("{t:?}").contains("F32"));
     }
 
     #[test]
     fn test_gguf_value_clone() {
         let v = GgufValue::String("test".to_string());
         let cloned = v.clone();
-        assert!(format!("{:?}", cloned).contains("test"));
+        assert!(format!("{cloned:?}").contains("test"));
     }
 
     #[test]
@@ -816,7 +816,7 @@ mod tests {
         let cloned = h.clone();
         assert_eq!(cloned.version, 3);
         assert_eq!(cloned.tensor_count, 10);
-        assert!(format!("{:?}", cloned).contains("GgufHeader"));
+        assert!(format!("{cloned:?}").contains("GgufHeader"));
     }
 }