Merge branch 'main' into codex/fix-missing-readme.md-for-publish

Author: RAprogramm

CHANGELOG.md

@@ -9,13 +9,23 @@ All notable changes to this project will be documented in this file.
 - Published the shared template parser crate so `masterror-derive` no longer
   depends on a workspace-only package when uploaded to crates.io.
 
+### Documentation
+- Added a dedicated README for `masterror-template` describing installation,
+  parsing examples and formatter metadata for crates.io readers.
+### Tests
+- Added regression coverage for long classifier needles to exercise the
+  heap-allocation fallback.
+
 ### Changed
+- Added an owning `From<AppError>` conversion for `ErrorResponse` and updated the
+  Axum adapter to use it, eliminating redundant clones when building HTTP error
+  bodies.
+ - Precomputed lowercase Turnkey classifier needles with a stack-backed buffer
+  to remove repeated transformations while keeping the common zero-allocation
+  path for short patterns.
 - Bumped `masterror-derive` to `0.6.6` and `masterror-template` to `0.3.6` so
   downstream users rely on the newly published parser crate.
 
-### Documentation
-- Added a dedicated README for `masterror-template` describing installation,
-  parsing examples and formatter metadata for crates.io readers.
 
 ## [0.10.6] - 2025-09-21
 

src/convert/axum.rs

@@ -77,7 +77,7 @@ impl IntoResponse for AppError {
         #[cfg(feature = "serde_json")]
         {
             // Build the stable wire contract (includes `code`).
-            let body: ErrorResponse = (&self).into();
+            let body: ErrorResponse = self.into();
             return body.into_response();
         }
 

src/response/mapping.rs

@@ -13,6 +13,33 @@ impl Display for ErrorResponse {
     }
 }
 
+impl From<AppError> for ErrorResponse {
+    fn from(err: AppError) -> Self {
+        let AppError {
+            kind,
+            message,
+            retry,
+            www_authenticate
+        } = err;
+
+        let status = kind.http_status();
+        let code = AppCode::from(kind);
+        let message = match message {
+            Some(msg) => msg.into_owned(),
+            None => String::from("An error occurred")
+        };
+
+        Self {
+            status,
+            code,
+            message,
+            details: None,
+            retry,
+            www_authenticate
+        }
+    }
+}
+
 impl From<&AppError> for ErrorResponse {
     fn from(err: &AppError) -> Self {
         let status = err.kind.http_status();

src/response/tests.rs

@@ -147,6 +147,30 @@ fn from_app_error_uses_default_message_when_none() {
     assert_eq!(e.message, "An error occurred");
 }
 
+#[test]
+fn from_owned_app_error_moves_message_and_metadata() {
+    let err = AppError::unauthorized(String::from("owned message"))
+        .with_retry_after_secs(5)
+        .with_www_authenticate("Bearer");
+
+    let resp: ErrorResponse = err.into();
+
+    assert_eq!(resp.status, 401);
+    assert!(matches!(resp.code, AppCode::Unauthorized));
+    assert_eq!(resp.message, "owned message");
+    assert_eq!(resp.retry.unwrap().after_seconds, 5);
+    assert_eq!(resp.www_authenticate.as_deref(), Some("Bearer"));
+}
+
+#[test]
+fn from_owned_app_error_defaults_message_when_absent() {
+    let resp: ErrorResponse = AppError::bare(AppErrorKind::Internal).into();
+
+    assert_eq!(resp.status, 500);
+    assert!(matches!(resp.code, AppCode::Internal));
+    assert_eq!(resp.message, "An error occurred");
+}
+
 // --- Display formatting --------------------------------------------------
 
 #[test]

src/turnkey/classifier.rs

@@ -1,9 +1,13 @@
 use super::domain::TurnkeyErrorKind;
 
+const STACK_NEEDLE_INLINE_CAP: usize = 64;
+
 /// Heuristic classifier for raw SDK/provider messages (ASCII case-insensitive).
 ///
-/// This helper **does not allocate**; it performs case-insensitive `contains`
-/// checks over the input string to map common upstream texts to stable kinds.
+/// This helper keeps allocations to a minimum; it performs case-insensitive
+/// `contains` checks over the input string to map common upstream texts to
+/// stable kinds while reusing stack buffers for the short ASCII patterns we
+/// match.
 ///
 /// The classifier is intentionally minimal; providers can and will change
 /// messages. Prefer returning structured errors from adapters whenever
@@ -55,20 +59,41 @@ pub fn classify_turnkey_error(msg: &str) -> TurnkeyErrorKind {
 }
 
 /// Returns true if `haystack` contains `needle` ignoring ASCII case.
-/// Performs the search without allocating.
+///
+/// The search avoids heap allocations for needles up to
+/// `STACK_NEEDLE_INLINE_CAP` bytes by reusing a stack buffer. Longer needles
+/// allocate once to store their lowercased representation.
 #[inline]
 fn contains_nocase(haystack: &str, needle: &str) -> bool {
     // Fast path: empty needle always matches.
     if needle.is_empty() {
         return true;
     }
-    // Walk haystack windows and compare ASCII case-insensitively.
-    haystack.as_bytes().windows(needle.len()).any(|w| {
-        w.iter()
-            .copied()
-            .map(ascii_lower)
-            .eq(needle.as_bytes().iter().copied().map(ascii_lower))
-    })
+    let haystack_bytes = haystack.as_bytes();
+    let needle_bytes = needle.as_bytes();
+
+    let search = |needle_lower: &[u8]| {
+        haystack_bytes.windows(needle_lower.len()).any(|window| {
+            window
+                .iter()
+                .zip(needle_lower.iter())
+                .all(|(hay, lower_needle)| ascii_lower(*hay) == *lower_needle)
+        })
+    };
+
+    if needle_bytes.len() <= STACK_NEEDLE_INLINE_CAP {
+        let mut inline = [0u8; STACK_NEEDLE_INLINE_CAP];
+        for (idx, byte) in needle_bytes.iter().enumerate() {
+            inline[idx] = ascii_lower(*byte);
+        }
+        search(&inline[..needle_bytes.len()])
+    } else {
+        let mut lowercased = Vec::with_capacity(needle_bytes.len());
+        for byte in needle_bytes {
+            lowercased.push(ascii_lower(*byte));
+        }
+        search(lowercased.as_slice())
+    }
 }
 
 /// Check whether `haystack` contains any of the `needles` (ASCII
@@ -90,10 +115,17 @@ pub(super) mod internal_tests {
     use super::*;
 
     #[test]
-    fn contains_nocase_works_without_alloc() {
+    fn contains_nocase_matches_ascii_case_insensitively() {
         assert!(contains_nocase("ABCdef", "cDe"));
         assert!(contains_any_nocase("hello world", &["nope", "WORLD"]));
         assert!(!contains_nocase("rustacean", "python"));
         assert!(contains_nocase("", ""));
     }
+
+    #[test]
+    fn contains_nocase_handles_long_needles() {
+        let haystack = "prefixed".to_owned() + &"A".repeat(128) + "suffix";
+        let needle = "a".repeat(128);
+        assert!(contains_nocase(&haystack, &needle));
+    }
 }