finalize_unsafe added, finalize -> Result changed to finalize -> FixedStr, cleanup

Author: crabcode

CHANGELOG.md

@@ -6,20 +6,23 @@ All notable changes to this project will be documented in this file.
 
 ### Added
 - **`truncate(len)` method:** Added `truncate()` to `FixedStr` and `FixedStrBuf` for shortening visible string length in-place.
+- **`finalize_unsafe()` method:** for cases requiring direct construction without UTF‑8 validation.
 
 ### Changed
 - **Updated crate-level and function-level docs** for clarity, accuracy, and consistency with actual behavior.
-- **Corrected misleading note** on `FixedStr::new_const` to reflect that UTF‑8 is now always respected, even at compile time.
+- **`FixedStrBuf::finalize()` now returns `FixedStr` directly** (was `Result`), reflecting that `finalize()` only produces valid UTF‑8.
+- **Implemented `From<FixedStrBuf<N>> for FixedStr<N>`** for ergonomic conversion from builder to fixed string.
 - Improved descriptions for `from_bytes`, `set_lossy`, and other modifiers to better reflect truncation and null-termination behavior.
-
+    
 ### Removed
 - `FixedStr::as_hex()` and `FixedStr::hex_dump()`: Removed from the core type to avoid side effects and formatting logic in core APIs.
 
   Hex formatting is still available via the `fast_format_hex()` and `dump_as_hex()` helper functions for manual use.
 
 ### Fixed
-- Corrected docblocks and comments referring to outdated runtime validation behavior.
+- **Corrected misleading note** on `FixedStr::new_const` to reflect that UTF‑8 is now always respected, even at compile time.
 - Corrected the conversion implementations for `FixedStrBuf` (from `FixedStr` and via `TryFrom<&[u8]>`) so that the effective length (up to the first null byte) is used rather than the full array capacity. This ensures that builder operations such as appending and truncating behave correctly.
+- Corrected docblocks and comments referring to outdated runtime validation behavior.
 
 
 ## [0.9.0] - 2025-03-25

README.md

@@ -90,8 +90,8 @@ fn main() {
 - `truncate(len: usize)`: Truncate the visible portion to a specified length.
 
 ### Views & Conversions
-- `as_str() -> &str`: View the string up to the null terminator.
-- `try_as_str() -> Result<&str, FixedStrError>`: UTF‑8 checked view.
+- `as_str() -> &str`: View the string up to the null terminator or last valid UTF-8 character.
+- `try_as_str() -> Result<&str, FixedStrError>`: UTF‑8 tested view.
 - `as_bytes() -> &[u8]`: Raw byte view of the entire buffer.
 - `effective_bytes() -> &[u8]`: View of the bytes until the first `\0`.
 - `into_string() -> String`: Convert into an owned `String` (requires `std`).

src/fs_buffer.rs

@@ -103,11 +103,22 @@ impl<const N: usize> FixedStrBuf<N> {
     /// This method zero‑pads the unused portion of the buffer and creates a `FixedStr`
     /// from the internal byte array. If the written content contains a null byte (`\0`),
     /// the resulting string will terminate at that null, ignoring any bytes that follow.
-    pub fn finalize(mut self) -> Result<FixedStr<N>, FixedStrError> {
-        for i in self.len..N {
-            self.buffer[i] = 0;
-        }
-        Ok(FixedStr::from_bytes(self.buffer))
+    pub fn finalize(mut self) -> FixedStr<N> {
+        self.buffer[self.len..N].fill(0);
+        FixedStr::from_bytes(self.buffer)
+    }
+
+    /// Finalizes the builder into a `FixedStr` without UTF-8 boundary checks.
+    ///
+    /// # Warning
+    /// Use with care—this may produce values that may cause conversions to panic or comparisons to fail.
+    ///
+    /// This method zero‑pads the unused portion of the buffer and creates a `FixedStr`
+    /// from the internal byte array. If the written content contains a null byte (`\0`),
+    /// the resulting string will terminate at that null, ignoring any bytes that follow.
+    pub fn finalize_unsafe(mut self) -> FixedStr<N> {
+        self.buffer[self.len..N].fill(0);
+        FixedStr::from_bytes_unsafe(self.buffer)
     }
 
     /// Clears the builder, resetting its effective length to zero and zero‑filling the buffer.
@@ -358,15 +369,15 @@ mod buffer_tests {
         // Any additional push will result in truncation.
         let result = buf.push_str_lossy(", world!");
         assert!(!result);
-        let fixed: FixedStr<5> = buf.finalize().unwrap();
+        let fixed: FixedStr<5> = buf.finalize();
         assert_eq!(fixed.as_str(), "Hello");
     }
 
     #[test]
     fn test_finalize_trailing_zeros() {
         let mut buf = FixedStrBuf::<10>::new();
         buf.try_push_str("Hi").unwrap();
-        let fixed: FixedStr<10> = buf.finalize().unwrap();
+        let fixed: FixedStr<10> = buf.finalize();
         // The effective string is "Hi" and the rest are zeros.
         assert_eq!(fixed.len(), 2);
         assert_eq!(fixed.as_str(), "Hi");
@@ -422,7 +433,7 @@ mod buffer_tests {
         buf.truncate(5);
         assert_eq!(buf.len(), 5);
         // Finalize the buffer and check that the effective string is "Hello".
-        let fixed = buf.finalize().unwrap();
+        let fixed = buf.finalize();
         assert_eq!(fixed.as_str(), "Hello");
         // Also check that the truncated portion of the buffer is zero.
         for &b in &buf.as_ref()[5..] {

src/fs_core.rs

@@ -125,7 +125,7 @@ impl<const N: usize> FixedStr<N> {
     /// when using `as_str()` or during comparisons.
     ///
     /// # Warning
-    /// Use with care—this may produce values that cause `as_str()` to panic or comparisons to fail.
+    /// Use with care—this may produce values that may cause conversions to panic or comparisons to fail.
     ///
     /// # Panics
     /// Panics if `N == 0`. Zero‑length strings are not supported.
@@ -155,7 +155,7 @@ impl<const N: usize> FixedStr<N> {
     /// The first null byte (`\0`) still acts as a terminator in conversions and comparisons.
     ///
     /// # Warning
-    /// Use with care—this may produce values that cause `as_str()` to panic or comparisons to fail.
+    /// Use with care—this may produce values that may cause conversions to panic or comparisons to fail.
     ///
     /// # Panics
     /// Panics if `N == 0`. Zero‑length strings are not supported.

src/fs_impl.rs

@@ -2,10 +2,10 @@
 
 use super::*;
 
-/// Implements the Debug trait for FixedStr.
+/// Implements the Debug trait for `FixedStr`.
 ///
 /// If the effective string is valid UTF‑8, it is printed using the Debug format.
-/// Otherwise, it prints "<invalid UTF-8>" followed by a hex dump of the underlying data.
+/// Otherwise, it prints a hex dump of the underlying data.
 impl<const N: usize> fmt::Debug for FixedStr<N> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.try_as_str() {
@@ -19,35 +19,35 @@ impl<const N: usize> fmt::Debug for FixedStr<N> {
     }
 }
 
-/// Implements the Display trait for FixedStr by displaying its effective string.
+/// Implements the Display trait for `FixedStr` by displaying its effective string.
 impl<const N: usize> fmt::Display for FixedStr<N> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.as_str())
     }
 }
 
-/// Allows a FixedStr to be referenced as a byte slice.
+/// Allows a `FixedStr` to be referenced as a byte slice.
 impl<const N: usize> AsRef<[u8]> for FixedStr<N> {
     fn as_ref(&self) -> &[u8] {
         &self.data
     }
 }
 
-/// Allows a FixedStr to be referenced as a str (using its effective string).
+/// Allows a `FixedStr` to be referenced as a `str` (using its effective string).
 impl<const N: usize> AsRef<str> for FixedStr<N> {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 
-/// Implements Borrow<str> for FixedStr, returning the effective string.
+/// Implements `Borrow<str>` for `FixedStr`, returning the effective string.
 impl<const N: usize> Borrow<str> for FixedStr<N> {
     fn borrow(&self) -> &str {
         self.as_str()
     }
 }
 
-/// Provides a default FixedStr where all bytes are zero.
+/// Provides a default `FixedStr` where all bytes are zero.
 impl<const N: usize> Default for FixedStr<N> {
     fn default() -> Self {
         Self { data: [0; N] }
@@ -99,6 +99,15 @@ impl<const N: usize> From<&str> for FixedStr<N> {
     }
 }
 
+/// Constructs a FixedStr from a &str using the standard constructor.
+///
+/// **Warning:** If the input contains a null byte or invalid UTF‑8, the string is truncated.
+impl<const N: usize> From<FixedStrBuf<N>> for FixedStr<N> {
+    fn from(buf: FixedStrBuf<N>) -> Self {
+        buf.finalize()
+    }
+}
+
 /// Hashes the FixedStr based only on its effective bytes (up to the first null).
 impl<const N: usize> Hash for FixedStr<N> {
     fn hash<H: Hasher>(&self, state: &mut H) {

src/string_helpers.rs

@@ -273,7 +273,7 @@ pub fn fast_format_hex<const N: usize>(
     buffer[pos..N].fill(0);
 
     // Safe due to controlled construction.
-    crate::FixedStrBuf { buffer, len: pos }.finalize().unwrap()
+    crate::FixedStrBuf { buffer, len: pos }.finalize()
 }
 
 /// Outputs the full hexadecimal representation of `bytes` by invoking the provided callback