cleanup

Author: abr-egn

src/bson.rs

@@ -848,7 +848,7 @@ impl Bson {
                 if let Ok(regex) = doc.get_document("$regularExpression") {
                     if let Ok(pattern) = regex.get_str("pattern") {
                         if let Ok(options) = regex.get_str("options") {
-                            if let Ok(regex) = Regex::new(pattern, options) {
+                            if let Ok(regex) = Regex::from_strings(pattern, options) {
                                 return Bson::RegularExpression(regex);
                             }
                         }
@@ -1138,7 +1138,8 @@ pub struct Regex {
 }
 
 impl Regex {
-    pub(crate) fn new(
+    #[cfg(feature = "serde")]
+    pub(crate) fn from_strings(
         pattern: impl AsRef<str>,
         options: impl AsRef<str>,
     ) -> crate::error::Result<Self> {

src/de/serde.rs

@@ -434,7 +434,7 @@ impl<'de> Visitor<'de> for BsonVisitor {
                 "$regularExpression" => {
                     let re = visitor.next_value::<extjson::models::RegexBody>()?;
                     return Ok(Bson::RegularExpression(
-                        Regex::new(re.pattern, re.options).map_err(Error::custom)?,
+                        Regex::from_strings(re.pattern, re.options).map_err(Error::custom)?,
                     ));
                 }
 

src/extjson/models.rs

@@ -135,7 +135,7 @@ pub(crate) struct RegexBody {
 
 impl Regex {
     pub(crate) fn parse(self) -> crate::error::Result<crate::Regex> {
-        crate::Regex::new(self.body.pattern, self.body.options)
+        crate::Regex::from_strings(self.body.pattern, self.body.options)
     }
 }
 

src/raw.rs

@@ -318,15 +318,3 @@ pub(crate) fn write_string(buf: &mut Vec<u8>, s: &str) {
     buf.extend(s.as_bytes());
     buf.push(0);
 }
-
-pub(crate) fn write_cstring(buf: &mut Vec<u8>, s: &str) -> Result<()> {
-    if s.contains('\0') {
-        return Err(Error::malformed_bytes(format!(
-            "cstring with interior null: {:?}",
-            s
-        )));
-    }
-    buf.extend(s.as_bytes());
-    buf.push(0);
-    Ok(())
-}

src/raw/cstr.rs

@@ -24,6 +24,12 @@ impl<'a> TryFrom<&'a str> for &'a CStr {
 }
 
 impl CStr {
+    // Convenience shorthand for making the types of TryFrom line up
+    #[cfg(feature = "serde")]
+    pub(crate) fn from_str(value: &str) -> Result<&CStr> {
+        value.try_into()
+    }
+
     const fn from_str_unchecked(value: &str) -> &Self {
         // Safety: the conversion is safe because CStr is repr(transparent), and the deref is safe
         // because the pointer came from a safe reference.

src/raw/serde/seeded_visitor.rs

@@ -6,7 +6,7 @@ use serde::{
 };
 
 use crate::{
-    raw::{write_cstring, write_string, RAW_BSON_NEWTYPE},
+    raw::{write_string, RAW_BSON_NEWTYPE},
     spec::{BinarySubtype, ElementType},
     RawBson,
     RawBsonRef,
@@ -119,7 +119,9 @@ impl<'a, 'de> SeededVisitor<'a, 'de> {
 
     /// Appends a cstring to the buffer. Returns an error if the given string contains a null byte.
     fn append_cstring(&mut self, key: &str) -> Result<(), String> {
-        write_cstring(self.buffer.get_owned_buffer(), key).map_err(|e| e.to_string())
+        Ok(crate::raw::CStr::from_str(key)
+            .map_err(|e| e.to_string())?
+            .append_to(self.buffer.get_owned_buffer()))
     }
 
     /// Appends a string and its length to the buffer.

src/raw/test/append.rs

@@ -243,11 +243,14 @@ fn undefined() {
 #[test]
 fn regex() {
     let expected = doc! {
-        "regex": Regex::new("some pattern", "abc").unwrap(),
+        "regex": Regex::from_strings("some pattern", "abc").unwrap(),
     };
 
     append_test(expected, |doc| {
-        doc.append(cstr!("regex"), Regex::new("some pattern", "abc").unwrap())
+        doc.append(
+            cstr!("regex"),
+            Regex::from_strings("some pattern", "abc").unwrap(),
+        )
     });
 }
 

src/raw/test/props.rs

@@ -22,7 +22,7 @@ pub(crate) fn arbitrary_bson() -> impl Strategy<Value = Bson> {
         any::<i32>().prop_map(Bson::Int32),
         any::<i64>().prop_map(Bson::Int64),
         any::<(String, String)>().prop_map(|(pattern, options)| {
-            Bson::RegularExpression(Regex::new(pattern, options).unwrap())
+            Bson::RegularExpression(Regex::from_strings(pattern, options).unwrap())
         }),
         any::<[u8; 12]>().prop_map(|bytes| Bson::ObjectId(crate::oid::ObjectId::from_bytes(bytes))),
         (arbitrary_binary_subtype(), any::<Vec<u8>>()).prop_map(|(subtype, bytes)| {

src/ser/raw.rs

@@ -9,7 +9,7 @@ use serde::{
 use self::value_serializer::{ValueSerializer, ValueType};
 
 use crate::{
-    raw::{write_cstring, CStr, RAW_ARRAY_NEWTYPE, RAW_DOCUMENT_NEWTYPE},
+    raw::{CStr, RAW_ARRAY_NEWTYPE, RAW_DOCUMENT_NEWTYPE},
     ser::{Error, Result},
     serde_helpers::HUMAN_READABLE_NEWTYPE,
     spec::{BinarySubtype, ElementType},
@@ -469,7 +469,7 @@ impl<'a> VariantSerializer<'a> {
         T: Serialize + ?Sized,
     {
         self.root_serializer.reserve_element_type();
-        write_cstring(&mut self.root_serializer.bytes, k)?;
+        CStr::from_str(k)?.append_to(&mut self.root_serializer.bytes);
         v.serialize(&mut *self.root_serializer)?;
 
         self.num_elements_serialized += 1;

src/ser/raw/document_serializer.rs

@@ -1,7 +1,6 @@
 use serde::{ser::Impossible, Serialize};
 
 use crate::{
-    raw::write_cstring,
     ser::{Error, Result},
     serialize_to_bson,
     Bson,
@@ -266,7 +265,8 @@ impl serde::Serializer for KeySerializer<'_> {
 
     #[inline]
     fn serialize_str(self, v: &str) -> Result<Self::Ok> {
-        Ok(write_cstring(&mut self.root_serializer.bytes, v)?)
+        crate::raw::CStr::from_str(v)?.append_to(&mut self.root_serializer.bytes);
+        Ok(())
     }
 
     #[inline]