chore: fix formatting and ignore LaTeX build artifacts

mivertowski · claude · mivertowski · commit 915069766d6d · 2026-02-07T14:05:05.000+01:00
Run cargo fmt to fix style drift from recent merges (import ordering,
line wrapping, assert formatting) and add LaTeX output files to .gitignore.

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/.gitignore b/.gitignore
@@ -22,3 +22,7 @@ target
 
 # Generated documentation
 docs/book/
+docs/rustkernels-executive-overview.aux
+docs/rustkernels-executive-overview.log
+docs/rustkernels-executive-overview.out
+docs/rustkernels-executive-overview.toc
diff --git a/crates/rustkernel-core/src/domain.rs b/crates/rustkernel-core/src/domain.rs
@@ -430,17 +430,29 @@ mod tests {
     fn test_from_ring_domain_renamed_variants() {
         use ringkernel_core::domain::Domain as RD;
 
-        assert_eq!(Domain::from_ring_domain(RD::TimeSeries), Domain::TemporalAnalysis);
-        assert_eq!(Domain::from_ring_domain(RD::RiskManagement), Domain::RiskAnalytics);
+        assert_eq!(
+            Domain::from_ring_domain(RD::TimeSeries),
+            Domain::TemporalAnalysis
+        );
+        assert_eq!(
+            Domain::from_ring_domain(RD::RiskManagement),
+            Domain::RiskAnalytics
+        );
         assert_eq!(Domain::from_ring_domain(RD::General), Domain::Core);
     }
 
     #[test]
     fn test_from_ring_domain_closest_match() {
         use ringkernel_core::domain::Domain as RD;
 
-        assert_eq!(Domain::from_ring_domain(RD::NetworkAnalysis), Domain::GraphAnalytics);
-        assert_eq!(Domain::from_ring_domain(RD::FraudDetection), Domain::Banking);
+        assert_eq!(
+            Domain::from_ring_domain(RD::NetworkAnalysis),
+            Domain::GraphAnalytics
+        );
+        assert_eq!(
+            Domain::from_ring_domain(RD::FraudDetection),
+            Domain::Banking
+        );
         assert_eq!(Domain::from_ring_domain(RD::Settlement), Domain::Clearing);
         assert_eq!(Domain::from_ring_domain(RD::MarketData), Domain::Core);
         assert_eq!(Domain::from_ring_domain(RD::Simulation), Domain::Core);
diff --git a/crates/rustkernel-core/src/memory/mod.rs b/crates/rustkernel-core/src/memory/mod.rs
@@ -35,8 +35,8 @@ pub use reduction::{
 
 // Re-export ringkernel-core 0.4.2 memory primitives for deep integration.
 pub use ringkernel_core::analytics_context as ring_analytics_context;
-pub use ringkernel_core::reduction as ring_reduction;
 pub use ringkernel_core::memory as ring_memory;
+pub use ringkernel_core::reduction as ring_reduction;
 
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
diff --git a/crates/rustkernel-core/src/observability/mod.rs b/crates/rustkernel-core/src/observability/mod.rs
@@ -39,11 +39,11 @@ pub use metrics::{KernelMetrics, MetricsConfig, MetricsExporter};
 pub use tracing::{KernelSpan, SpanContext, TracingConfig};
 
 // Re-export ringkernel-core 0.4.2 observability primitives for deep integration.
+pub use ringkernel_core::alerting as ring_alerting;
+pub use ringkernel_core::logging as ring_logging;
 pub use ringkernel_core::observability as ring_observability;
 pub use ringkernel_core::telemetry as ring_telemetry;
 pub use ringkernel_core::telemetry_pipeline as ring_telemetry_pipeline;
-pub use ringkernel_core::alerting as ring_alerting;
-pub use ringkernel_core::logging as ring_logging;
 
 use serde::{Deserialize, Serialize};
 
diff --git a/crates/rustkernel-core/src/registry.rs b/crates/rustkernel-core/src/registry.rs
@@ -7,9 +7,7 @@ use crate::domain::Domain;
 use crate::error::{KernelError, Result};
 use crate::kernel::{KernelMetadata, KernelMode};
 use crate::license::{LicenseError, LicenseValidator, SharedLicenseValidator};
-use crate::traits::{
-    BatchKernel, BatchKernelDyn, GpuKernel, RingKernelDyn, TypeErasedBatchKernel,
-};
+use crate::traits::{BatchKernel, BatchKernelDyn, GpuKernel, RingKernelDyn, TypeErasedBatchKernel};
 use hashbrown::HashMap;
 use std::sync::{Arc, RwLock};
 use tracing::{debug, info, warn};
@@ -480,11 +478,7 @@ impl KernelRegistry {
     ///
     /// Returns `KernelNotFound` if no batch kernel with this ID exists, or
     /// propagates any execution error from the kernel.
-    pub async fn execute_batch(
-        &self,
-        kernel_id: &str,
-        input_json: &[u8],
-    ) -> Result<Vec<u8>> {
+    pub async fn execute_batch(&self, kernel_id: &str, input_json: &[u8]) -> Result<Vec<u8>> {
         let entry = self
             .get_batch(kernel_id)
             .ok_or_else(|| KernelError::KernelNotFound(kernel_id.to_string()))?;
diff --git a/crates/rustkernel-core/src/resilience/mod.rs b/crates/rustkernel-core/src/resilience/mod.rs
@@ -36,8 +36,8 @@ pub use timeout::{DeadlineContext, TimeoutConfig, TimeoutError};
 
 // Re-export ringkernel-core 0.4.2 health/resilience primitives for deep integration.
 pub use ringkernel_core::health as ring_health;
-pub use ringkernel_core::timeout as ring_timeout;
 pub use ringkernel_core::rate_limiting as ring_rate_limiting;
+pub use ringkernel_core::timeout as ring_timeout;
 
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
diff --git a/crates/rustkernel-core/src/security/mod.rs b/crates/rustkernel-core/src/security/mod.rs
@@ -38,10 +38,10 @@ pub use tenancy::{ResourceQuota, Tenant, TenantConfig, TenantId};
 
 // Re-export ringkernel-core 0.4.2 security primitives for deep integration.
 // These complement our higher-level security abstractions with low-level ring security.
-pub use ringkernel_core::security as ring_security;
 pub use ringkernel_core::auth as ring_auth;
 pub use ringkernel_core::rbac as ring_rbac;
 pub use ringkernel_core::secrets as ring_secrets;
+pub use ringkernel_core::security as ring_security;
 pub use ringkernel_core::tenancy as ring_tenancy;
 
 use serde::{Deserialize, Serialize};
diff --git a/crates/rustkernel-core/src/traits.rs b/crates/rustkernel-core/src/traits.rs
@@ -670,8 +670,7 @@ where
         let typed_input: I = serde_json::from_slice(input)
             .map_err(|e| KernelError::DeserializationError(e.to_string()))?;
         let output = self.inner.execute(typed_input).await?;
-        serde_json::to_vec(&output)
-            .map_err(|e| KernelError::SerializationError(e.to_string()))
+        serde_json::to_vec(&output).map_err(|e| KernelError::SerializationError(e.to_string()))
     }
 }
 
@@ -740,8 +739,7 @@ where
         let typed_msg: M = serde_json::from_slice(msg)
             .map_err(|e| KernelError::DeserializationError(e.to_string()))?;
         let response = self.inner.handle(ctx, typed_msg).await?;
-        serde_json::to_vec(&response)
-            .map_err(|e| KernelError::SerializationError(e.to_string()))
+        serde_json::to_vec(&response).map_err(|e| KernelError::SerializationError(e.to_string()))
     }
 }
 
diff --git a/crates/rustkernel-ecosystem/src/actix_integration.rs b/crates/rustkernel-ecosystem/src/actix_integration.rs
@@ -140,7 +140,9 @@ impl Handler<ExecuteKernel> for KernelActor {
 
         let request_id = uuid::Uuid::new_v4().to_string();
         let timeout = Duration::from_millis(
-            msg.metadata.timeout_ms.unwrap_or(self.config.default_timeout.as_millis() as u64),
+            msg.metadata
+                .timeout_ms
+                .unwrap_or(self.config.default_timeout.as_millis() as u64),
         );
 
         // Try batch kernel execution
diff --git a/crates/rustkernel-ecosystem/src/axum_integration.rs b/crates/rustkernel-ecosystem/src/axum_integration.rs
@@ -200,10 +200,7 @@ fn build_cors(config: &ServiceConfig) -> tower_http::cors::CorsLayer {
 }
 
 /// Middleware that propagates X-Request-ID from request to response headers
-async fn request_id_middleware(
-    req: axum::extract::Request,
-    next: Next,
-) -> Response {
+async fn request_id_middleware(req: axum::extract::Request, next: Next) -> Response {
     let request_id = req
         .headers()
         .get(headers::X_REQUEST_ID)
@@ -476,9 +473,10 @@ async fn execute_kernel(
         })?;
 
         // Execute with timeout
-        let timeout_ms = request.metadata.timeout_ms.unwrap_or(
-            state.config.default_timeout.as_millis() as u64,
-        );
+        let timeout_ms = request
+            .metadata
+            .timeout_ms
+            .unwrap_or(state.config.default_timeout.as_millis() as u64);
         let timeout = std::time::Duration::from_millis(timeout_ms);
 
         let result = tokio::time::timeout(timeout, kernel.execute_dyn(&input_bytes)).await;
@@ -494,10 +492,7 @@ async fn execute_kernel(
                             StatusCode::INTERNAL_SERVER_ERROR,
                             Json(ErrorResponse {
                                 code: "OUTPUT_DESERIALIZATION_ERROR".to_string(),
-                                message: format!(
-                                    "Failed to deserialize kernel output: {}",
-                                    e
-                                ),
+                                message: format!("Failed to deserialize kernel output: {}", e),
                                 request_id: Some(request_id.clone()),
                                 details: None,
                             }),
@@ -540,10 +535,7 @@ async fn execute_kernel(
                     StatusCode::GATEWAY_TIMEOUT,
                     Json(ErrorResponse {
                         code: "EXECUTION_TIMEOUT".to_string(),
-                        message: format!(
-                            "Kernel execution timed out after {}ms",
-                            timeout_ms
-                        ),
+                        message: format!("Kernel execution timed out after {}ms", timeout_ms),
                         request_id: Some(request_id),
                         details: None,
                     }),
diff --git a/crates/rustkernel-ecosystem/src/common.rs b/crates/rustkernel-ecosystem/src/common.rs
@@ -223,13 +223,16 @@ impl ServiceMetrics {
 
     /// Get minimum latency in microseconds (returns 0 if no requests)
     pub fn min_latency_us(&self) -> u64 {
-        let val = self.min_latency_us.load(std::sync::atomic::Ordering::Relaxed);
+        let val = self
+            .min_latency_us
+            .load(std::sync::atomic::Ordering::Relaxed);
         if val == u64::MAX { 0 } else { val }
     }
 
     /// Get maximum latency in microseconds
     pub fn max_latency_us(&self) -> u64 {
-        self.max_latency_us.load(std::sync::atomic::Ordering::Relaxed)
+        self.max_latency_us
+            .load(std::sync::atomic::Ordering::Relaxed)
     }
 }
 
diff --git a/crates/rustkernel-ecosystem/src/tower_integration.rs b/crates/rustkernel-ecosystem/src/tower_integration.rs
@@ -68,12 +68,9 @@ impl KernelService {
 
             match result {
                 Ok(Ok(output_bytes)) => {
-                    let output: serde_json::Value = serde_json::from_slice(&output_bytes)
-                        .map_err(|e| {
-                            EcosystemError::InternalError(format!(
-                                "Output deserialization: {}",
-                                e
-                            ))
+                    let output: serde_json::Value =
+                        serde_json::from_slice(&output_bytes).map_err(|e| {
+                            EcosystemError::InternalError(format!("Output deserialization: {}", e))
                         })?;
 
                     let duration_us = start.elapsed().as_micros() as u64;

Original file line number	Diff line number	Diff line change
`@@ -670,8 +670,7 @@ where`
`670`	`670`	`let typed_input: I = serde_json::from_slice(input)`
`671`	`671`	`.map_err(\|e\| KernelError::DeserializationError(e.to_string()))?;`
`672`	`672`	`let output = self.inner.execute(typed_input).await?;`
`673`		`- serde_json::to_vec(&output)`
`674`		`- .map_err(\|e\| KernelError::SerializationError(e.to_string()))`
	`673`	`+ serde_json::to_vec(&output).map_err(\|e\| KernelError::SerializationError(e.to_string()))`
`675`	`674`	`}`
`676`	`675`	`}`
`677`	`676`
`@@ -740,8 +739,7 @@ where`
`740`	`739`	`let typed_msg: M = serde_json::from_slice(msg)`
`741`	`740`	`.map_err(\|e\| KernelError::DeserializationError(e.to_string()))?;`
`742`	`741`	`let response = self.inner.handle(ctx, typed_msg).await?;`
`743`		`- serde_json::to_vec(&response)`
`744`		`- .map_err(\|e\| KernelError::SerializationError(e.to_string()))`
	`742`	`+ serde_json::to_vec(&response).map_err(\|e\| KernelError::SerializationError(e.to_string()))`
`745`	`743`	`}`
`746`	`744`	`}`
`747`	`745`