Add more re-implementations of the bolt protocol (#171)

* Move packstream mod into a more expected directory structure

* Allow for differnt vis than pub on cenums

* Add Commit protocol message

* Add Discard protocol message

* Add Goodbye protocol message

* Add Hello protocol message

* Add Reset protocol message

* Add Rollback protocol message

* Export new protocol messages

* Silence dead_code warnings until feature is done

Author: knutwalker

lib/src/bolt/mod.rs

@@ -1,4 +1,4 @@
-#![allow(unused_imports)]
+#![allow(unused_imports, dead_code)]
 
 use std::marker::PhantomData;
 
@@ -10,13 +10,15 @@ use serde::{
 
 mod detail;
 mod packstream;
+mod request;
 mod summary;
 
-pub use detail::Detail;
 #[cfg(debug_assertions)]
 pub use packstream::debug::Dbg;
-use packstream::ser::AsMap;
-pub use packstream::{de, ser};
+#[cfg(test)]
+pub use packstream::value::{bolt, BoltBytesBuilder};
+pub use packstream::{de, from_bytes, ser, to_bytes};
+pub use request::{Commit, Discard, Goodbye, Hello, Reset, Rollback, WrapExtra};
 pub use summary::{Failure, Streaming, StreamingSummary, Success, Summary};
 
 pub(crate) trait Message: Serialize {
@@ -93,3 +95,15 @@ impl<'de, R: Deserialize<'de>, S: Deserialize<'de>> Deserialize<'de> for Respons
         )
     }
 }
+
+impl<R: std::fmt::Debug, S: std::fmt::Debug> Response<R, S> {
+    pub fn into_error(self, msg: &'static str) -> crate::errors::Error {
+        match self {
+            Response::Failure(f) => f.into_error(msg),
+            otherwise => crate::Error::UnexpectedMessage(format!(
+                "unexpected response for {}: {:?}",
+                msg, otherwise
+            )),
+        }
+    }
+}

lib/src/bolt/de.rs renamed to lib/src/bolt/packstream/de.rs

@@ -18,8 +18,7 @@ impl<'a: 'de, 'de> de::Deserializer<'de> for Deserializer<'a> {
 
     forward_to_deserialize_any! {
         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 str
-        string newtype_struct ignored_any
-        map unit_struct struct enum identifier
+        string ignored_any map unit_struct struct enum identifier
     }
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -118,6 +117,21 @@ impl<'a: 'de, 'de> de::Deserializer<'de> for Deserializer<'a> {
         self.deserialize_bytes(visitor)
     }
 
+    fn deserialize_newtype_struct<V>(
+        self,
+        name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if name == "__neo4rs::RawBytes" {
+            self.parse_next_item(Visitation::RawBytes, visitor)
+        } else {
+            self.parse_next_item(Visitation::default(), visitor)
+        }
+    }
+
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
@@ -158,14 +172,21 @@ impl<'de> Deserializer<'de> {
             return Err(Error::Empty);
         }
 
-        if let Visitation::SeqAsTuple(2) = v {
-            return if self.bytes[0] == 0x92 {
-                self.bytes.advance(1);
-                Self::parse_list(v, 2, self.bytes, visitor)
-            } else {
-                visitor.visit_seq(ItemsParser::new(2, self.bytes))
-            };
-        }
+        match v {
+            Visitation::SeqAsTuple(2) => {
+                return if self.bytes[0] == 0x92 {
+                    self.bytes.advance(1);
+                    Self::parse_list(v, 2, self.bytes, visitor)
+                } else {
+                    visitor.visit_seq(ItemsParser::new(2, self.bytes))
+                };
+            }
+            Visitation::RawBytes => {
+                let bytes = self.next_item_as_bytes()?;
+                return visitor.visit_bytes(&bytes);
+            }
+            _ => (),
+        };
 
         Self::parse(v, self.bytes, visitor)
     }
@@ -175,6 +196,22 @@ impl<'de> Deserializer<'de> {
             .map(|_| ())
     }
 
+    fn next_item_as_bytes(self) -> Result<Bytes, Error> {
+        let mut full_bytes = self.bytes.clone();
+
+        {
+            let this = Deserializer { bytes: self.bytes };
+            this.skip_next_item()?;
+        }
+
+        let start = full_bytes.as_ptr();
+        let end = self.bytes.as_ptr();
+
+        let len = unsafe { end.offset_from(start) };
+        full_bytes.truncate(len.unsigned_abs());
+        Ok(full_bytes)
+    }
+
     fn parse<V: Visitor<'de>>(
         v: Visitation,
         bytes: &'de mut Bytes,
@@ -227,12 +264,11 @@ impl<'de> Deserializer<'de> {
         bytes: &'de mut Bytes,
         visitor: V,
     ) -> Result<V::Value, Error> {
-        debug_assert!(bytes.len() >= len);
-
-        let bytes = bytes.split_to(len);
+        let bytes = Self::take_slice(len, bytes);
         if v.visit_bytes_as_bytes() {
-            let bytes: &'de [u8] = unsafe { std::mem::transmute(bytes.as_ref()) };
-            visitor.visit_borrowed_bytes(bytes)
+            visitor.visit_borrowed_bytes(unsafe {
+                std::slice::from_raw_parts(bytes.as_ptr(), bytes.len())
+            })
         } else {
             visitor.visit_seq(SeqDeserializer::new(bytes.into_iter()))
         }
@@ -243,17 +279,20 @@ impl<'de> Deserializer<'de> {
         bytes: &'de mut Bytes,
         visitor: V,
     ) -> Result<V::Value, Error> {
-        debug_assert!(bytes.len() >= len);
-
-        let bytes = bytes.split_to(len);
-        let bytes: &'de [u8] = unsafe { std::mem::transmute(bytes.as_ref()) };
-
-        match std::str::from_utf8(bytes) {
-            Ok(s) => visitor.visit_borrowed_str(s),
+        let bytes = Self::take_slice(len, bytes);
+        match std::str::from_utf8(&bytes) {
+            Ok(s) => visitor.visit_borrowed_str(unsafe {
+                std::str::from_utf8_unchecked(std::slice::from_raw_parts(s.as_ptr(), s.len()))
+            }),
             Err(e) => Err(Error::InvalidUtf8(e)),
         }
     }
 
+    fn take_slice(len: usize, bytes: &mut Bytes) -> Bytes {
+        debug_assert!(bytes.len() >= len);
+        bytes.split_to(len)
+    }
+
     fn parse_list<V: Visitor<'de>>(
         v: Visitation,
         len: usize,
@@ -299,6 +338,7 @@ impl<'de> Deserializer<'de> {
     }
 }
 
+#[derive(Debug)]
 struct ItemsParser<'a> {
     len: usize,
     excess: usize,
@@ -339,6 +379,10 @@ impl<'a, 'de> SeqAccess<'de> for ItemsParser<'a> {
         let bytes = self.bytes.get();
         seed.deserialize(Deserializer { bytes }).map(Some)
     }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(self.len)
+    }
 }
 
 impl<'a, 'de> MapAccess<'de> for ItemsParser<'a> {
@@ -364,94 +408,42 @@ impl<'a, 'de> MapAccess<'de> for ItemsParser<'a> {
         let bytes = self.bytes.get();
         seed.deserialize(Deserializer { bytes })
     }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(self.len)
+    }
 }
 
 impl<'a, 'de> VariantAccess<'de> for ItemsParser<'a> {
     type Error = Error;
 
     fn unit_variant(mut self) -> Result<(), Self::Error> {
         self.next_value()
-        // if self.len != 0 {
-        //     return Err(Error::InvalidLength {
-        //         expected: 0,
-        //         actual: self.len,
-        //     });
-        // }
-        // Ok(())
     }
 
     fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
     where
         T: DeserializeSeed<'de>,
     {
         self.next_value_seed(seed)
-        // let bytes = self.bytes.get();
-        // seed.deserialize(Deserializer { bytes })
     }
 
-    fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
-        struct TupleVariant<V> {
-            len: usize,
-            visitor: V,
-        }
-
-        impl<'de, V> DeserializeSeed<'de> for TupleVariant<V>
-        where
-            V: Visitor<'de>,
-        {
-            type Value = V::Value;
-
-            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                deserializer.deserialize_tuple(self.len, self.visitor)
-            }
-        }
-
-        self.next_value_seed(TupleVariant { len, visitor })
-
-        // if len != self.len {
-        //     return Err(Error::InvalidLength {
-        //         expected: len,
-        //         actual: self.len,
-        //     });
-        // }
-        // visitor.visit_seq(self)
+        visitor.visit_seq(self)
     }
 
     fn struct_variant<V>(
-        mut self,
+        self,
         _fields: &'static [&'static str],
         visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
-        struct StructVariant<V> {
-            visitor: V,
-        }
-
-        impl<'de, V> DeserializeSeed<'de> for StructVariant<V>
-        where
-            V: Visitor<'de>,
-        {
-            type Value = V::Value;
-
-            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                deserializer.deserialize_map(self.visitor)
-            }
-        }
-
-        self.next_value_seed(StructVariant { visitor })
-
-        // visitor.visit_map(self)
+        visitor.visit_seq(self)
     }
 }
 
@@ -479,6 +471,7 @@ enum Visitation {
     #[default]
     Default,
     BytesAsBytes,
+    RawBytes,
     MapAsSeq,
     SeqAsTuple(usize),
 }
@@ -498,6 +491,13 @@ struct SharedBytes<'a> {
     _lifetime: PhantomData<&'a mut ()>,
 }
 
+#[cfg(debug_assertions)]
+impl<'a> fmt::Debug for SharedBytes<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        crate::bolt::Dbg(unsafe { &*self.bytes }).fmt(f)
+    }
+}
+
 impl<'a> SharedBytes<'a> {
     fn new(bytes: &'a mut Bytes) -> Self {
         Self {