Merge pull request #459 from tox-rs/nom

refactor(nom): update to the latest version

Author: kurnevsky

tox_binary_io/Cargo.toml

@@ -15,7 +15,7 @@ license = "GPL-3.0+"
 edition = "2018"
 
 [dependencies]
-nom = "5.1"
+nom = "7.0"
 cookie-factory = "0.3"
 crypto_box = { version = "0.7", optional = true }
 

tox_binary_io/src/crypto.rs

@@ -1,15 +1,18 @@
 use std::convert::TryInto;
 
-use nom::{map, map_opt, named, take};
+use nom::IResult;
+use nom::bytes::streaming::take;
+use nom::combinator::{map, map_opt};
 
 use crypto_box::{PublicKey, SecretKey, KEY_SIZE};
 
 use super::FromBytes;
 
 
 impl FromBytes for PublicKey {
-    // TODO: use map_from with new nom version
-    named!(from_bytes<PublicKey>, map!(map_opt!(take!(KEY_SIZE), |pk: &[u8]| pk.try_into().ok()), |pk: [u8; KEY_SIZE]| pk.into()));
+    fn from_bytes(input: &[u8]) -> IResult<&[u8], Self> {
+        map(map_opt(take(KEY_SIZE), |pk: &[u8]| pk.try_into().ok()), |pk: [u8; KEY_SIZE]| pk.into())(input)
+    }
 }
 
 /* TODO
@@ -26,8 +29,9 @@ impl FromBytes for PublicKey {
 */
 
 impl FromBytes for SecretKey {
-    // TODO: use map_from with new nom version
-    named!(from_bytes<SecretKey>, map!(map_opt!(take!(KEY_SIZE), |sk: &[u8]| sk.try_into().ok()), |sk: [u8; KEY_SIZE]| sk.into()));
+    fn from_bytes(input: &[u8]) -> IResult<&[u8], Self> {
+        map(map_opt(take(KEY_SIZE), |sk: &[u8]| sk.try_into().ok()), |sk: [u8; KEY_SIZE]| sk.into())(input)
+    }
 }
 
 #[cfg(test)]

tox_binary_io/src/lib.rs

@@ -1,8 +1,10 @@
 pub use nom::IResult;
 pub use cookie_factory::GenError;
 
-use nom::number::streaming::{le_u8, le_u16};
-use nom::{named, map, map_opt, take, count};
+use nom::bytes::streaming::take;
+use nom::combinator::{map, map_opt};
+use nom::multi::count;
+use nom::number::complete::{le_u8, le_u16};
 use cookie_factory::{do_gen, gen_be_u8, gen_le_u16, gen_slice};
 
 use std::{convert::TryInto, net::{
@@ -19,7 +21,7 @@ mod crypto;
 /// The trait provides method to deserialize struct from raw bytes
 pub trait FromBytes: Sized {
     /// Deserialize struct using `nom` from raw bytes
-    fn from_bytes(i: &[u8]) -> IResult<&[u8], Self>;
+    fn from_bytes(input: &[u8]) -> IResult<&[u8], Self>;
 }
 
 /// The trait provides method to serialize struct into raw bytes
@@ -38,9 +40,11 @@ impl ToBytes for IpAddr {
 }
 
 impl FromBytes for Ipv4Addr {
-    named!(from_bytes<Ipv4Addr>, map!(count!(le_u8, 4),
-        |v| Ipv4Addr::new(v[0], v[1], v[2], v[3])
-    ));
+    fn from_bytes(input: &[u8]) -> IResult<&[u8], Self> {
+        map(count(le_u8, 4),
+            |v| Ipv4Addr::new(v[0], v[1], v[2], v[3])
+        )(input)
+    }
 }
 
 impl<const N: usize> ToBytes for [u8; N] {
@@ -50,7 +54,9 @@ impl<const N: usize> ToBytes for [u8; N] {
 }
 
 impl <const N: usize> FromBytes for [u8; N] {
-    named!(from_bytes<[u8; N]>, map_opt!(take!(N), |bytes: &[u8]| bytes.try_into().ok()));
+    fn from_bytes(input: &[u8]) -> IResult<&[u8], Self> {
+        map_opt(take(N), |bytes: &[u8]| bytes.try_into().ok())(input)
+    }
 }
 
 impl ToBytes for Ipv4Addr {
@@ -66,9 +72,11 @@ impl ToBytes for Ipv4Addr {
 }
 
 impl FromBytes for Ipv6Addr {
-    named!(from_bytes<Ipv6Addr>, map!(count!(le_u16, 8),
-        |v| Ipv6Addr::new(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7])
-    ));
+    fn from_bytes(i: &[u8]) -> IResult<&[u8], Self> {
+        map(count(le_u16, 8),
+            |v| Ipv6Addr::new(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7])
+        )(i)
+    }
 }
 
 impl ToBytes for Ipv6Addr {

tox_core/Cargo.toml

@@ -24,7 +24,7 @@ tox_packet = { version = "0.1.1", path = "../tox_packet" }
 bytes = "1.0"
 futures = { version = "0.3", default-features = false, features = ["std", "async-await"] }
 log = "0.4"
-nom = "5.1"
+nom = "7.0"
 cookie-factory = "0.3"
 get_if_addrs = "0.5"
 thiserror = "1.0"

tox_core/src/dht/codec.rs

@@ -10,7 +10,7 @@ use crate::stats::*;
 use bytes::BytesMut;
 use cookie_factory::GenError;
 use thiserror::Error;
-use nom::{error::ErrorKind, Err};
+use nom::error::Error as NomError;
 use tokio_util::codec::{Decoder, Encoder};
 
 /// A serialized `Packet` should be not longer than 2048 bytes.
@@ -29,7 +29,7 @@ pub enum DecodeError {
     #[error("Deserialize Packet error: {:?}, packet: {:?}", error, packet)]
     Deserialize {
         /// Parsing error.
-        error: nom::Err<(Vec<u8>, ErrorKind)>,
+        error: nom::Err<NomError<Vec<u8>>>,
         /// Received packet.
         packet: Vec<u8>,
     },
@@ -43,8 +43,8 @@ impl DecodeError {
         DecodeError::TooBigPacket { len }
     }
 
-    pub(crate) fn deserialize(e: Err<(&[u8], ErrorKind)>, packet: Vec<u8>) -> DecodeError {
-        DecodeError::Deserialize { error: e.to_owned(), packet }
+    pub(crate) fn deserialize(e: nom::Err<NomError<&[u8]>>, packet: Vec<u8>) -> DecodeError {
+        DecodeError::Deserialize { error: e.map(|e| NomError::new(e.input.to_vec(), e.code)), packet }
     }
 }
 
@@ -151,6 +151,7 @@ mod tests {
     use rand::thread_rng;
     use tox_packet::onion::*;
     use crypto_box::{SalsaBox, SecretKey, aead::{AeadCore, generic_array::typenum::marker_traits::Unsigned}};
+    use nom::{Err, error::ErrorKind as NomErrorKind};
 
     const ONION_RETURN_1_PAYLOAD_SIZE: usize = ONION_RETURN_1_SIZE - xsalsa20poly1305::NONCE_SIZE;
     const ONION_RETURN_2_PAYLOAD_SIZE: usize = ONION_RETURN_2_SIZE - xsalsa20poly1305::NONCE_SIZE;
@@ -327,7 +328,7 @@ mod tests {
 
         let res = codec.decode(&mut buf);
         // not enough bytes to decode EncryptedPacket
-        assert!(matches!(res, Err(DecodeError::Deserialize { error: Err::Error((_, ErrorKind::Alt)), packet: _ })));
+        assert!(matches!(res, Err(DecodeError::Deserialize { error: Err::Error(NomError { input: _, code: NomErrorKind::Tag }), packet: _ })));
     }
 
     #[test]

tox_core/src/dht/daemon_state.rs

@@ -15,24 +15,24 @@ use crate::dht::kbucket::*;
 use crate::dht::ktree::*;
 
 use thiserror::Error;
-use nom::{Err, error::ErrorKind as NomErrorKind};
+use nom::{Err, error::Error as NomError};
 
 /// An error that can occur while serializing/deserializing object.
-#[derive(Clone, Debug, Eq, PartialEq, Error)]
+#[derive(Debug, PartialEq, Error)]
 pub enum DeserializeError {
     /// Error indicates that object can't be parsed.
     #[error("Deserialize object error: {:?}, data: {:?}", error, data)]
     Deserialize {
         /// Parsing error.
-        error: nom::Err<(Vec<u8>, NomErrorKind)>,
+        error: nom::Err<NomError<Vec<u8>>>,
         /// Object serialized data.
         data: Vec<u8>,
     },
 }
 
 impl DeserializeError {
-    pub(crate) fn deserialize(e: Err<(&[u8], NomErrorKind)>, data: Vec<u8>) -> DeserializeError {
-        DeserializeError::Deserialize { error: e.to_owned(), data }
+    pub(crate) fn deserialize(e: Err<NomError<&[u8]>>, data: Vec<u8>) -> DeserializeError {
+        DeserializeError::Deserialize { error: e.map(|e| NomError::new(e.input.to_vec(), e.code)), data }
     }
 }
 
@@ -96,6 +96,7 @@ mod tests {
 
     use futures::channel::mpsc;
     use futures::StreamExt;
+    use nom::error::ErrorKind as NomErrorKind;
 
     macro_rules! unpack {
         ($variable:expr, $variant:path) => (
@@ -138,14 +139,14 @@ mod tests {
         let error = res.err().unwrap();
         let mut input = vec![2, 1, 2, 3, 4, 4, 210];
         input.extend_from_slice(&pk_org.as_bytes()[..crypto_box::KEY_SIZE - 1]);
-        assert_eq!(error, DeserializeError::Deserialize { error: Err::Error((
+        assert_eq!(error, DeserializeError::Deserialize { error: Err::Error(NomError::new(
             input, NomErrorKind::Eof)), data: serialized_vec[..serialized_len - 1].to_vec() });
 
         // test with serialized data corrupted
         let serialized_vec = [42; 10];
         let res = DaemonState::deserialize_old(&alice, &serialized_vec).await;
         let error = res.err().unwrap();
-        assert_eq!(error, DeserializeError::Deserialize { error: Err::Error((
+        assert_eq!(error, DeserializeError::Deserialize { error: Err::Error(NomError::new(
             vec![42; 10], NomErrorKind::Tag)), data: serialized_vec.to_vec() });
 
         // test with empty close list

tox_core/src/friend_connection/mod.rs

@@ -1010,8 +1010,8 @@ mod tests {
         let join = future::join(run_future, packets_future);
 
         futures::select! {
-            _ = join.fuse() => (),
-            _ = connection_status_future.fuse() => (),
+            _ = join.fuse() => {},
+            _ = connection_status_future.fuse() => {},
         }
     }
 }

tox_core/src/lib.rs

@@ -14,8 +14,6 @@ Repo: https://github.com/tox-rs/tox
 #[macro_use]
 extern crate log;
 #[macro_use]
-extern crate nom;
-#[macro_use]
 extern crate cookie_factory;
 
 pub mod io_tokio;

tox_core/src/net_crypto/errors.rs

@@ -62,7 +62,7 @@ impl PacketsArrayError {
 }
 
 /// Error that can happen when calling `handle_*` of packet.
-#[derive(Clone, Debug, Eq, PartialEq, Error)]
+#[derive(Debug, PartialEq, Error)]
 pub enum HandlePacketError {
     /// Error indicates that getting payload of received packet error.
     #[error("Get payload of received packet error")]

tox_core/src/onion/client/errors.rs

@@ -5,7 +5,7 @@ use tox_packet::dht::GetPayloadError;
 use crate::{dht::server::errors::PingError, relay::client::ConnectionError};
 
 /// Error that can happen when handling `OnionAnnounceResponse` packet.
-#[derive(Clone, Debug, Eq, PartialEq, Error)]
+#[derive(Debug, PartialEq, Error)]
 pub enum HandleAnnounceResponseError {
     /// Invalid request ID when handling OnionAnnounceResponse.
     #[error("Invalid request ID when handling OnionAnnounceResponse")]