refactor(sys): make byte string formatter reusable

Author: bavshin-f5

nginx-sys/src/detail.rs

@@ -0,0 +1,112 @@
+//! Implementation details shared between nginx-sys and ngx.
+#![allow(missing_docs)]
+
+use core::fmt;
+
+#[inline]
+pub fn debug_bytes(f: &mut fmt::Formatter<'_>, bytes: &[u8]) -> fmt::Result {
+    if f.alternate() {
+        match bytes.len() {
+            0 => Ok(()),
+            1 => write!(f, "{:02x}", bytes[0]),
+            x => {
+                for b in &bytes[..x - 1] {
+                    write!(f, "{b:02x},")?;
+                }
+                write!(f, "{:02x}", bytes[x - 1])
+            }
+        }
+    } else {
+        f.write_str("\"")?;
+        display_bytes(f, bytes)?;
+        f.write_str("\"")
+    }
+}
+
+#[inline]
+pub fn display_bytes(f: &mut fmt::Formatter<'_>, bytes: &[u8]) -> fmt::Result {
+    // The implementation is similar to an inlined `String::from_utf8_lossy`, with two
+    // important differences:
+    //
+    //  - it writes directly to the Formatter instead of allocating a temporary String
+    //  - invalid sequences are represented as escaped individual bytes
+    for chunk in bytes.utf8_chunks() {
+        f.write_str(chunk.valid())?;
+        for byte in chunk.invalid() {
+            write!(f, "\\x{byte:02x}")?;
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate alloc;
+    use alloc::format;
+    use alloc::string::ToString;
+
+    use super::*;
+
+    struct TestStr(&'static [u8]);
+
+    impl fmt::Debug for TestStr {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.write_str("TestStr(")?;
+            debug_bytes(f, self.0)?;
+            f.write_str(")")
+        }
+    }
+
+    impl fmt::Display for TestStr {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            display_bytes(f, self.0)
+        }
+    }
+
+    #[test]
+    fn test_display() {
+        let cases: &[(&[u8], &str)] = &[
+            (b"", ""),
+            (b"Ferris the \xf0\x9f\xa6\x80", "Ferris the 🦀"),
+            (b"\xF0\x90\x80", "\\xf0\\x90\\x80"),
+            (b"\xF0\x90\x80Hello World", "\\xf0\\x90\\x80Hello World"),
+            (b"Hello \xF0\x90\x80World", "Hello \\xf0\\x90\\x80World"),
+            (b"Hello World\xF0\x90\x80", "Hello World\\xf0\\x90\\x80"),
+        ];
+
+        for (bytes, expected) in cases {
+            let str = TestStr(bytes);
+            assert_eq!(str.to_string(), *expected);
+        }
+
+        // Check that the formatter arguments are ignored correctly
+        for (bytes, expected) in &cases[2..3] {
+            let str = TestStr(bytes);
+            assert_eq!(format!("{str:12.12}"), *expected);
+        }
+    }
+
+    #[test]
+    fn test_debug() {
+        let cases: &[(&[u8], &str, &str)] = &[
+            (b"", "TestStr(\"\")", "TestStr()"),
+            (b"a", "TestStr(\"a\")", "TestStr(61)"),
+            (
+                b"Ferris the \xf0\x9f\xa6\x80",
+                "TestStr(\"Ferris the 🦀\")",
+                "TestStr(46,65,72,72,69,73,20,74,68,65,20,f0,9f,a6,80)",
+            ),
+            (
+                b"\xF0\x90\x80",
+                "TestStr(\"\\xf0\\x90\\x80\")",
+                "TestStr(f0,90,80)",
+            ),
+        ];
+        for (bytes, expected, alternate) in cases {
+            let str = TestStr(bytes);
+            assert_eq!(format!("{str:?}"), *expected);
+            assert_eq!(format!("{str:#?}"), *alternate);
+        }
+    }
+}

nginx-sys/src/lib.rs

@@ -2,6 +2,7 @@
 #![warn(missing_docs)]
 #![no_std]
 
+pub mod detail;
 mod event;
 mod queue;
 
@@ -189,19 +190,9 @@ impl From<ngx_str_t> for &[u8] {
 }
 
 impl fmt::Display for ngx_str_t {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // The implementation is similar to an inlined `String::from_utf8_lossy`, with two
-        // important differences:
-        //
-        //  - it writes directly to the Formatter instead of allocating a temporary String
-        //  - invalid sequences are represented as escaped individual bytes
-        for chunk in self.as_bytes().utf8_chunks() {
-            f.write_str(chunk.valid())?;
-            for byte in chunk.invalid() {
-                write!(f, "\\x{byte:02x}")?;
-            }
-        }
-        Ok(())
+        detail::display_bytes(f, self.as_bytes())
     }
 }
 
@@ -313,41 +304,3 @@ pub unsafe fn add_to_ngx_table(
     }
     None
 }
-
-#[cfg(test)]
-mod tests {
-    extern crate alloc;
-    use alloc::format;
-    use alloc::string::ToString;
-
-    use super::*;
-
-    #[test]
-    fn ngx_str_display() {
-        let pairs: &[(&[u8], &str)] = &[
-            (b"", ""),
-            (b"Ferris the \xf0\x9f\xa6\x80", "Ferris the 🦀"),
-            (b"\xF0\x90\x80", "\\xf0\\x90\\x80"),
-            (b"\xF0\x90\x80Hello World", "\\xf0\\x90\\x80Hello World"),
-            (b"Hello \xF0\x90\x80World", "Hello \\xf0\\x90\\x80World"),
-            (b"Hello World\xF0\x90\x80", "Hello World\\xf0\\x90\\x80"),
-        ];
-
-        for (bytes, expected) in pairs {
-            let str = ngx_str_t {
-                data: bytes.as_ptr().cast_mut(),
-                len: bytes.len(),
-            };
-            assert_eq!(str.to_string(), *expected);
-        }
-
-        // Check that the formatter arguments are ignored correctly
-        for (bytes, expected) in &pairs[2..3] {
-            let str = ngx_str_t {
-                data: bytes.as_ptr().cast_mut(),
-                len: bytes.len(),
-            };
-            assert_eq!(format!("{str:12.12}"), *expected);
-        }
-    }
-}

src/core/string.rs

@@ -1,5 +1,6 @@
 #[cfg(all(not(feature = "std"), feature = "alloc"))]
 use alloc::{borrow::Cow, string::String};
+use core::fmt;
 use core::str::{self, Utf8Error};
 #[cfg(feature = "std")]
 use std::{borrow::Cow, string::String};
@@ -91,12 +92,29 @@ impl AsRef<[u8]> for NgxStr {
     }
 }
 
+impl fmt::Debug for NgxStr {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // XXX: Use debug_tuple() and feature(debug_closure_helpers) once it's stabilized
+        f.write_str("NgxStr(")?;
+        nginx_sys::detail::debug_bytes(f, &self.0)?;
+        f.write_str(")")
+    }
+}
+
 impl Default for &NgxStr {
     fn default() -> Self {
         NgxStr::from_bytes(&[])
     }
 }
 
+impl fmt::Display for NgxStr {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        nginx_sys::detail::display_bytes(f, &self.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     extern crate alloc;