deps: drop 'bstr'

It's now just a dev dependency. It wasn't really carrying its weight.

Author: BurntSushi

Cargo.toml

@@ -12,6 +12,7 @@ license = "Unlicense/MIT"
 categories = ["encoding", "parser-implementations"]
 exclude = ["/.github", "/ci/*", "/scripts/*"]
 edition = "2021"
+resolver = "2"
 
 [workspace]
 members = ["csv-core", "csv-index"]
@@ -20,13 +21,13 @@ members = ["csv-core", "csv-index"]
 bench = false
 
 [dependencies]
-bstr = { version = "0.2.1", features = ["serde1"] }
-csv-core = { path = "csv-core", version = "0.1.6" }
+csv-core = { path = "csv-core", version = "0.1.10" }
 itoa = "1"
 ryu = "1"
 serde = "1.0.55"
 
 [dev-dependencies]
+bstr = { version = "1.2.0", default-features = false, features = ["alloc", "serde"] }
 serde = { version = "1.0.55", features = ["derive"] }
 
 [profile.release]

src/byte_record.rs

@@ -5,10 +5,7 @@ use std::{
     result,
 };
 
-use {
-    bstr::{BString, ByteSlice},
-    serde::de::Deserialize,
-};
+use serde::de::Deserialize;
 
 use crate::{
     deserializer::deserialize_byte_record,
@@ -73,11 +70,12 @@ impl<'a, T: AsRef<[u8]>> PartialEq<[T]> for &'a ByteRecord {
 
 impl fmt::Debug for ByteRecord {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut fields = vec![];
-        for field in self {
-            fields.push(BString::from(field.to_vec()));
-        }
-        write!(f, "ByteRecord({:?})", fields)
+        write!(f, "ByteRecord(")?;
+        f.debug_list()
+            .entries(self.iter().map(crate::debug::Bytes))
+            .finish()?;
+        write!(f, ")")?;
+        Ok(())
     }
 }
 
@@ -375,8 +373,8 @@ impl ByteRecord {
         let mut trimmed =
             ByteRecord::with_capacity(self.as_slice().len(), self.len());
         trimmed.set_position(self.position().cloned());
-        for field in &*self {
-            trimmed.push_field(field.trim());
+        for field in self.iter() {
+            trimmed.push_field(trim_ascii(field));
         }
         *self = trimmed;
     }
@@ -552,7 +550,7 @@ impl ByteRecord {
         // Otherwise, we must check each field individually to ensure that
         // it's valid UTF-8.
         for (i, field) in self.iter().enumerate() {
-            if let Err(err) = field.to_str() {
+            if let Err(err) = std::str::from_utf8(field) {
                 return Err(new_utf8_error(i, err.valid_up_to()));
             }
         }
@@ -857,6 +855,32 @@ impl<'r> DoubleEndedIterator for ByteRecordIter<'r> {
     }
 }
 
+fn trim_ascii(bytes: &[u8]) -> &[u8] {
+    trim_ascii_start(trim_ascii_end(bytes))
+}
+
+fn trim_ascii_start(mut bytes: &[u8]) -> &[u8] {
+    while let [first, rest @ ..] = bytes {
+        if first.is_ascii_whitespace() {
+            bytes = rest;
+        } else {
+            break;
+        }
+    }
+    bytes
+}
+
+fn trim_ascii_end(mut bytes: &[u8]) -> &[u8] {
+    while let [rest @ .., last] = bytes {
+        if last.is_ascii_whitespace() {
+            bytes = rest;
+        } else {
+            break;
+        }
+    }
+    bytes
+}
+
 #[cfg(test)]
 mod tests {
     use crate::string_record::StringRecord;

src/debug.rs

@@ -0,0 +1,80 @@
+/// A type that provides a human readable debug impl for arbitrary bytes.
+///
+/// This generally works best when the bytes are presumed to be mostly UTF-8,
+/// but will work for anything.
+///
+/// N.B. This is copied nearly verbatim from regex-automata. Sigh.
+pub(crate) struct Bytes<'a>(pub(crate) &'a [u8]);
+
+impl<'a> core::fmt::Debug for Bytes<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "\"")?;
+        // This is a sad re-implementation of a similar impl found in bstr.
+        let mut bytes = self.0;
+        while let Some(result) = utf8_decode(bytes) {
+            let ch = match result {
+                Ok(ch) => ch,
+                Err(byte) => {
+                    write!(f, r"\x{:02x}", byte)?;
+                    bytes = &bytes[1..];
+                    continue;
+                }
+            };
+            bytes = &bytes[ch.len_utf8()..];
+            match ch {
+                '\0' => write!(f, "\\0")?,
+                // ASCII control characters except \0, \n, \r, \t
+                '\x01'..='\x08'
+                | '\x0b'
+                | '\x0c'
+                | '\x0e'..='\x19'
+                | '\x7f' => {
+                    write!(f, "\\x{:02x}", u32::from(ch))?;
+                }
+                '\n' | '\r' | '\t' | _ => {
+                    write!(f, "{}", ch.escape_debug())?;
+                }
+            }
+        }
+        write!(f, "\"")?;
+        Ok(())
+    }
+}
+
+/// Decodes the next UTF-8 encoded codepoint from the given byte slice.
+///
+/// If no valid encoding of a codepoint exists at the beginning of the given
+/// byte slice, then the first byte is returned instead.
+///
+/// This returns `None` if and only if `bytes` is empty.
+pub(crate) fn utf8_decode(bytes: &[u8]) -> Option<Result<char, u8>> {
+    fn len(byte: u8) -> Option<usize> {
+        if byte <= 0x7F {
+            return Some(1);
+        } else if byte & 0b1100_0000 == 0b1000_0000 {
+            return None;
+        } else if byte <= 0b1101_1111 {
+            Some(2)
+        } else if byte <= 0b1110_1111 {
+            Some(3)
+        } else if byte <= 0b1111_0111 {
+            Some(4)
+        } else {
+            None
+        }
+    }
+
+    if bytes.is_empty() {
+        return None;
+    }
+    let len = match len(bytes[0]) {
+        None => return Some(Err(bytes[0])),
+        Some(len) if len > bytes.len() => return Some(Err(bytes[0])),
+        Some(1) => return Some(Ok(char::from(bytes[0]))),
+        Some(len) => len,
+    };
+    match core::str::from_utf8(&bytes[..len]) {
+        Ok(s) => Some(Ok(s.chars().next().unwrap())),
+        Err(_) => Some(Err(bytes[0])),
+    }
+}

src/lib.rs

@@ -164,6 +164,7 @@ pub use crate::{
 
 mod byte_record;
 pub mod cookbook;
+mod debug;
 mod deserializer;
 mod error;
 mod reader;