From b0aaeac53ef3e5a3d81709e538d2bf7a3ff57ffe Mon Sep 17 00:00:00 2001 From: Steven Allen Date: Wed, 28 Nov 2018 12:51:46 -0800 Subject: [PATCH 1/5] update deps --- Cargo.toml | 8 ++++---- src/errors.rs | 7 ------- tests/lib.rs | 6 +++--- 3 files changed, 7 insertions(+), 14 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index d0ef7992..da2700aa 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,9 +9,9 @@ readme = "README.md" version = "0.3.0" [dependencies] -byteorder = "~0.4" -cid = "~0.2" -integer-encoding = "~1.0.3" +byteorder = "1.0" +cid = "~0.3" +integer-encoding = "1.0.3" [dev-dependencies] -data-encoding = "~1.1.2" +data-encoding = "2.0.0" diff --git a/src/errors.rs b/src/errors.rs index b7dd5c73..ded8082c 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -1,6 +1,5 @@ use std::{net, fmt, error, io, num, string}; use cid; -use byteorder; pub type Result = ::std::result::Result; @@ -58,12 +57,6 @@ impl From for Error { } } -impl From for Error { - fn from(err: byteorder::Error) -> Error { - Error::ParsingError(err.into()) - } -} - impl From for Error { fn from(err: num::ParseIntError) -> Error { Error::ParsingError(err.into()) diff --git a/tests/lib.rs b/tests/lib.rs index 6eec658e..36062e5f 100644 --- a/tests/lib.rs +++ b/tests/lib.rs @@ -1,7 +1,7 @@ extern crate multiaddr; extern crate data_encoding; -use data_encoding::hex; +use data_encoding::HEXUPPER; use multiaddr::*; use std::net::{SocketAddrV4, SocketAddrV6, Ipv4Addr, Ipv6Addr}; @@ -18,10 +18,10 @@ fn protocol_to_name() { fn ma_valid(source: &str, target: &str, protocols: Vec) { let parsed = source.parse::().unwrap(); - assert_eq!(hex::encode(parsed.to_bytes().as_slice()), target); + assert_eq!(HEXUPPER.encode(parsed.to_bytes().as_slice()), target); assert_eq!(parsed.iter().map(|addr| addr.protocol_id()).collect::>(), protocols); assert_eq!(source.parse::().unwrap().to_string(), source); - assert_eq!(Multiaddr::from_bytes(hex::decode(target.as_bytes()).unwrap()).unwrap(), parsed); + assert_eq!(Multiaddr::from_bytes(HEXUPPER.decode(target.as_bytes()).unwrap()).unwrap(), parsed); } #[test] From b2effe83f00315c891eb4957a361cbbc118e5f71 Mon Sep 17 00:00:00 2001 From: Steven Allen Date: Wed, 28 Nov 2018 12:56:17 -0800 Subject: [PATCH 2/5] rustfmt --- src/errors.rs | 4 +- src/lib.rs | 34 +++---- src/protocol.rs | 105 +++++++++----------- tests/lib.rs | 247 +++++++++++++++++++++++++++++------------------- 4 files changed, 211 insertions(+), 179 deletions(-) diff --git a/src/errors.rs b/src/errors.rs index ded8082c..84859f08 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -1,5 +1,5 @@ -use std::{net, fmt, error, io, num, string}; use cid; +use std::{error, fmt, io, net, num, string}; pub type Result = ::std::result::Result; @@ -34,7 +34,7 @@ impl error::Error for Error { fn cause(&self) -> Option<&error::Error> { match *self { Error::ParsingError(ref err) => Some(&**err), - _ => None + _ => None, } } } diff --git a/src/lib.rs b/src/lib.rs index 24c92c93..5c68d8b4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,15 +6,15 @@ extern crate byteorder; extern crate cid; extern crate integer_encoding; -mod protocol; mod errors; +mod protocol; -pub use errors::{Result, Error}; -pub use protocol::{Protocol, ProtocolArgSize, AddrComponent}; +pub use errors::{Error, Result}; +pub use protocol::{AddrComponent, Protocol, ProtocolArgSize}; use std::fmt; use std::iter::FromIterator; -use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6, IpAddr, Ipv4Addr, Ipv6Addr}; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6}; use std::str::FromStr; /// Representation of a Multiaddr. @@ -135,9 +135,9 @@ impl Multiaddr { /// #[inline] pub fn append(&mut self, component: AddrComponent) { - component.write_bytes(&mut self.bytes).expect( - "writing to a Vec never fails", - ) + component + .write_bytes(&mut self.bytes) + .expect("writing to a Vec never fails") } /// Remove the outermost address. @@ -191,7 +191,9 @@ impl Multiaddr { } if !matches { - return Ok(Multiaddr { bytes: self.bytes.clone() }); + return Ok(Multiaddr { + bytes: self.bytes.clone(), + }); } let mut bytes = self.bytes.clone(); @@ -243,9 +245,8 @@ impl Multiaddr { impl From for Multiaddr { fn from(addr: AddrComponent) -> Multiaddr { let mut out = Vec::new(); - addr.write_bytes(&mut out).expect( - "writing to a Vec never fails", - ); + addr.write_bytes(&mut out) + .expect("writing to a Vec never fails"); Multiaddr { bytes: out } } } @@ -267,9 +268,8 @@ impl FromIterator for Multiaddr { { let mut bytes = Vec::new(); for cmp in iter { - cmp.write_bytes(&mut bytes).expect( - "writing to a Vec never fails", - ); + cmp.write_bytes(&mut bytes) + .expect("writing to a Vec never fails"); } Multiaddr { bytes: bytes } } @@ -300,9 +300,9 @@ impl FromStr for Multiaddr { } }; - addr_component.write_bytes(&mut bytes).expect( - "writing to a Vec never fails", - ); + addr_component + .write_bytes(&mut bytes) + .expect("writing to a Vec never fails"); } Ok(Multiaddr { bytes: bytes }) diff --git a/src/protocol.rs b/src/protocol.rs index 4848f37d..48640c88 100644 --- a/src/protocol.rs +++ b/src/protocol.rs @@ -1,12 +1,12 @@ -use std::net::{Ipv4Addr, Ipv6Addr}; -use std::str::FromStr; -use std::convert::From; -use std::io::{Cursor, Write, Result as IoResult}; use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt}; use cid::Cid; use integer_encoding::{VarInt, VarIntWriter}; +use std::convert::From; +use std::io::{Cursor, Result as IoResult, Write}; +use std::net::{Ipv4Addr, Ipv6Addr}; +use std::str::FromStr; -use {Result, Error}; +use {Error, Result}; ///! # Protocol ///! @@ -80,7 +80,8 @@ impl ToString for Protocol { Protocol::Libp2pWebrtcStar => "p2p-webrtc-star", Protocol::Libp2pWebrtcDirect => "p2p-webrtc-direct", Protocol::P2pCircuit => "p2p-circuit", - }.to_owned() + } + .to_owned() } } @@ -117,7 +118,6 @@ impl FromStr for Protocol { } } - impl Protocol { /// Convert a `u64` based code to a `Protocol`. /// @@ -232,12 +232,8 @@ impl Protocol { let addr = Ipv6Addr::from_str(a)?; Ok(AddrComponent::IP6(addr)) } - Protocol::DNS4 => { - Ok(AddrComponent::DNS4(a.to_owned())) - } - Protocol::DNS6 => { - Ok(AddrComponent::DNS6(a.to_owned())) - } + Protocol::DNS4 => Ok(AddrComponent::DNS4(a.to_owned())), + Protocol::DNS6 => Ok(AddrComponent::DNS6(a.to_owned())), Protocol::TCP => { let parsed: u16 = a.parse()?; Ok(AddrComponent::TCP(parsed)) @@ -262,12 +258,10 @@ impl Protocol { let bytes = Cid::from(a)?.to_bytes(); Ok(AddrComponent::IPFS(bytes)) } - Protocol::ONION => unimplemented!(), // TODO: + Protocol::ONION => unimplemented!(), // TODO: Protocol::QUIC => Ok(AddrComponent::QUIC), Protocol::UTP => Ok(AddrComponent::UTP), - Protocol::UNIX => { - Ok(AddrComponent::UNIX(a.to_owned())) - } + Protocol::UNIX => Ok(AddrComponent::UNIX(a.to_owned())), Protocol::UDT => Ok(AddrComponent::UDT), Protocol::HTTP => Ok(AddrComponent::HTTP), Protocol::HTTPS => Ok(AddrComponent::HTTPS), @@ -342,25 +336,21 @@ impl AddrComponent { /// Builds an `AddrComponent` from an array that starts with a bytes representation. On /// success, also returns the rest of the slice. pub fn from_bytes(input: &[u8]) -> Result<(AddrComponent, &[u8])> { - let (proto_num, proto_id_len) = u64::decode_var(input); // TODO: will panic if ID too large + let (proto_num, proto_id_len) = u64::decode_var(input); // TODO: will panic if ID too large let protocol_id = Protocol::from(proto_num)?; let (data_offset, data_size) = match protocol_id.size() { - ProtocolArgSize::Fixed { bytes } => { - (0, bytes) - }, + ProtocolArgSize::Fixed { bytes } => (0, bytes), ProtocolArgSize::Variable => { - let (data_size, varint_len) = u64::decode_var(&input[proto_id_len..]); // TODO: will panic if ID too large + let (data_size, varint_len) = u64::decode_var(&input[proto_id_len..]); // TODO: will panic if ID too large (varint_len, data_size as usize) - }, + } }; let (data, rest) = input[proto_id_len..][data_offset..].split_at(data_size); let addr_component = match protocol_id { - Protocol::IP4 => { - AddrComponent::IP4(Ipv4Addr::new(data[0], data[1], data[2], data[3])) - }, + Protocol::IP4 => AddrComponent::IP4(Ipv4Addr::new(data[0], data[1], data[2], data[3])), Protocol::IP6 => { let mut rdr = Cursor::new(data); let mut seg = vec![]; @@ -369,22 +359,13 @@ impl AddrComponent { seg.push(rdr.read_u16::()?); } - let addr = Ipv6Addr::new(seg[0], - seg[1], - seg[2], - seg[3], - seg[4], - seg[5], - seg[6], - seg[7]); + let addr = Ipv6Addr::new( + seg[0], seg[1], seg[2], seg[3], seg[4], seg[5], seg[6], seg[7], + ); AddrComponent::IP6(addr) } - Protocol::DNS4 => { - AddrComponent::DNS4(String::from_utf8(data.to_owned())?) - } - Protocol::DNS6 => { - AddrComponent::DNS6(String::from_utf8(data.to_owned())?) - } + Protocol::DNS4 => AddrComponent::DNS4(String::from_utf8(data.to_owned())?), + Protocol::DNS6 => AddrComponent::DNS6(String::from_utf8(data.to_owned())?), Protocol::TCP => { let mut rdr = Cursor::new(data); let num = rdr.read_u16::()?; @@ -405,9 +386,7 @@ impl AddrComponent { let num = rdr.read_u16::()?; AddrComponent::SCTP(num) } - Protocol::UNIX => { - AddrComponent::UNIX(String::from_utf8(data.to_owned())?) - } + Protocol::UNIX => AddrComponent::UNIX(String::from_utf8(data.to_owned())?), Protocol::P2P => { let bytes = Cid::from(data)?.to_bytes(); AddrComponent::P2P(bytes) @@ -416,7 +395,7 @@ impl AddrComponent { let bytes = Cid::from(data)?.to_bytes(); AddrComponent::IPFS(bytes) } - Protocol::ONION => unimplemented!(), // TODO: + Protocol::ONION => unimplemented!(), // TODO: Protocol::QUIC => AddrComponent::QUIC, Protocol::UTP => AddrComponent::UTP, Protocol::UDT => AddrComponent::UDT, @@ -446,8 +425,10 @@ impl AddrComponent { out.write_u16::(segment)?; } } - AddrComponent::TCP(port) | AddrComponent::UDP(port) | AddrComponent::DCCP(port) | - AddrComponent::SCTP(port) => { + AddrComponent::TCP(port) + | AddrComponent::UDP(port) + | AddrComponent::DCCP(port) + | AddrComponent::SCTP(port) => { out.write_u16::(port)?; } AddrComponent::DNS4(s) | AddrComponent::DNS6(s) | AddrComponent::UNIX(s) => { @@ -460,19 +441,19 @@ impl AddrComponent { out.write_all(&bytes)?; } AddrComponent::ONION(_) => { - unimplemented!() // TODO: - }, - AddrComponent::QUIC | - AddrComponent::UTP | - AddrComponent::UDT | - AddrComponent::HTTP | - AddrComponent::HTTPS | - AddrComponent::WS | - AddrComponent::WSS | - AddrComponent::Libp2pWebsocketStar | - AddrComponent::Libp2pWebrtcStar | - AddrComponent::Libp2pWebrtcDirect | - AddrComponent::P2pCircuit => {} + unimplemented!() // TODO: + } + AddrComponent::QUIC + | AddrComponent::UTP + | AddrComponent::UDT + | AddrComponent::HTTP + | AddrComponent::HTTPS + | AddrComponent::WS + | AddrComponent::WSS + | AddrComponent::Libp2pWebsocketStar + | AddrComponent::Libp2pWebrtcStar + | AddrComponent::Libp2pWebrtcDirect + | AddrComponent::P2pCircuit => {} }; Ok(()) @@ -497,15 +478,15 @@ impl ToString for AddrComponent { // TODO: meh for cloning let c = Cid::from(bytes.clone()).expect("cid is known to be valid"); format!("/p2p/{}", c) - }, + } AddrComponent::IPFS(ref bytes) => { // TODO: meh for cloning let c = Cid::from(bytes.clone()).expect("cid is known to be valid"); format!("/ipfs/{}", c) - }, + } AddrComponent::HTTP => format!("/http"), AddrComponent::HTTPS => format!("/https"), - AddrComponent::ONION(_) => unimplemented!(),//format!("/onion"), // TODO: + AddrComponent::ONION(_) => unimplemented!(), //format!("/onion"), // TODO: AddrComponent::QUIC => format!("/quic"), AddrComponent::WS => format!("/ws"), AddrComponent::WSS => format!("/wss"), diff --git a/tests/lib.rs b/tests/lib.rs index 36062e5f..eab941b3 100644 --- a/tests/lib.rs +++ b/tests/lib.rs @@ -1,9 +1,9 @@ -extern crate multiaddr; extern crate data_encoding; +extern crate multiaddr; use data_encoding::HEXUPPER; use multiaddr::*; -use std::net::{SocketAddrV4, SocketAddrV6, Ipv4Addr, Ipv6Addr}; +use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6}; #[test] fn protocol_to_code() { @@ -15,13 +15,21 @@ fn protocol_to_name() { assert_eq!(Protocol::TCP.to_string(), "tcp"); } - fn ma_valid(source: &str, target: &str, protocols: Vec) { let parsed = source.parse::().unwrap(); assert_eq!(HEXUPPER.encode(parsed.to_bytes().as_slice()), target); - assert_eq!(parsed.iter().map(|addr| addr.protocol_id()).collect::>(), protocols); + assert_eq!( + parsed + .iter() + .map(|addr| addr.protocol_id()) + .collect::>(), + protocols + ); assert_eq!(source.parse::().unwrap().to_string(), source); - assert_eq!(Multiaddr::from_bytes(HEXUPPER.decode(target.as_bytes()).unwrap()).unwrap(), parsed); + assert_eq!( + Multiaddr::from_bytes(HEXUPPER.decode(target.as_bytes()).unwrap()).unwrap(), + parsed + ); } #[test] @@ -43,9 +51,11 @@ fn construct_success() { ma_valid("/ip4/1.2.3.4", "0401020304", vec![IP4]); ma_valid("/ip4/0.0.0.0", "0400000000", vec![IP4]); ma_valid("/ip6/::1", "2900000000000000000000000000000001", vec![IP6]); - ma_valid("/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21", - "29260100094F819700803ECA6566E80C21", - vec![IP6]); + ma_valid( + "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21", + "29260100094F819700803ECA6566E80C21", + vec![IP6], + ); ma_valid("/udp/0", "91020000", vec![UDP]); ma_valid("/tcp/0", "060000", vec![TCP]); ma_valid("/sctp/0", "84010000", vec![SCTP]); @@ -54,118 +64,159 @@ fn construct_success() { ma_valid("/sctp/1234", "840104D2", vec![SCTP]); ma_valid("/udp/65535", "9102FFFF", vec![UDP]); ma_valid("/tcp/65535", "06FFFF", vec![TCP]); - ma_valid("/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", - "A503221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", - vec![IPFS]); + ma_valid( + "/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", + "A503221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", + vec![IPFS], + ); ma_valid("/udp/1234/sctp/1234", "910204D2840104D2", vec![UDP, SCTP]); ma_valid("/udp/1234/udt", "910204D2AD02", vec![UDP, UDT]); ma_valid("/udp/1234/utp", "910204D2AE02", vec![UDP, UTP]); ma_valid("/tcp/1234/http", "0604D2E003", vec![TCP, HTTP]); ma_valid("/tcp/1234/https", "0604D2BB03", vec![TCP, HTTPS]); - ma_valid("/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234", - "A503221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B0604D2", - vec![IPFS, TCP]); - ma_valid("/ip4/127.0.0.1/udp/1234", - "047F000001910204D2", - vec![IP4, UDP]); + ma_valid( + "/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234", + "A503221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B0604D2", + vec![IPFS, TCP], + ); + ma_valid( + "/ip4/127.0.0.1/udp/1234", + "047F000001910204D2", + vec![IP4, UDP], + ); ma_valid("/ip4/127.0.0.1/udp/0", "047F00000191020000", vec![IP4, UDP]); - ma_valid("/ip4/127.0.0.1/tcp/1234", - "047F0000010604D2", - vec![IP4, TCP]); - ma_valid("/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", - "047F000001A503221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", - vec![IP4, IPFS]); - ma_valid("/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234", - "047F000001A503221220D52EBB89D85B02A284948203A\ -62FF28389C57C9F42BEEC4EC20DB76A68911C0B0604D2", - vec![IP4, IPFS, TCP]); + ma_valid( + "/ip4/127.0.0.1/tcp/1234", + "047F0000010604D2", + vec![IP4, TCP], + ); + ma_valid( + "/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", + "047F000001A503221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", + vec![IP4, IPFS], + ); + ma_valid( + "/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234", + "047F000001A503221220D52EBB89D85B02A284948203A\ + 62FF28389C57C9F42BEEC4EC20DB76A68911C0B0604D2", + vec![IP4, IPFS, TCP], + ); // /unix/a/b/c/d/e, // /unix/stdio, // /ip4/1.2.3.4/tcp/80/unix/a/b/c/d/e/f, // /ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234/unix/stdio - ma_valid("/ip6/2001:8a0:7ac5:4201:3ac9:86ff:fe31:\ - 7095/tcp/8000/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", - "29200108A07AC542013AC986FFFE317095061F40DD03A5\ -03221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", - vec![IP6, TCP, WS, IPFS]); - ma_valid("/p2p-webrtc-star/ip4/127.0.0.\ - 1/tcp/9090/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", - "9302047F000001062382DD03A503221220D52EBB89D85B\ -02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", - vec![Libp2pWebrtcStar, IP4, TCP, WS, IPFS]); - ma_valid("/ip6/2001:8a0:7ac5:4201:3ac9:86ff:fe31:\ - 7095/tcp/8000/wss/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", - "29200108A07AC542013AC986FFFE317095061F40DE03A503221220D52EBB8\ -9D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", - vec![IP6, TCP, WSS, IPFS]); - ma_valid("/ip4/127.0.0.1/tcp/9090/p2p-circuit/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", - "047F000001062382A202A503221220D52EBB89D85B\ -02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", - vec![IP4, TCP, P2pCircuit, IPFS]); + ma_valid( + "/ip6/2001:8a0:7ac5:4201:3ac9:86ff:fe31:\ + 7095/tcp/8000/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", + "29200108A07AC542013AC986FFFE317095061F40DD03A5\ + 03221220D52EBB89D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", + vec![IP6, TCP, WS, IPFS], + ); + ma_valid( + "/p2p-webrtc-star/ip4/127.0.0.\ + 1/tcp/9090/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", + "9302047F000001062382DD03A503221220D52EBB89D85B\ + 02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", + vec![Libp2pWebrtcStar, IP4, TCP, WS, IPFS], + ); + ma_valid( + "/ip6/2001:8a0:7ac5:4201:3ac9:86ff:fe31:\ + 7095/tcp/8000/wss/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", + "29200108A07AC542013AC986FFFE317095061F40DE03A503221220D52EBB8\ + 9D85B02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", + vec![IP6, TCP, WSS, IPFS], + ); + ma_valid( + "/ip4/127.0.0.1/tcp/9090/p2p-circuit/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC", + "047F000001062382A202A503221220D52EBB89D85B\ + 02A284948203A62FF28389C57C9F42BEEC4EC20DB76A68911C0B", + vec![IP4, TCP, P2pCircuit, IPFS], + ); } #[test] fn construct_fail() { - let addresses = ["/ip4", - "/ip4/::1", - "/ip4/fdpsofodsajfdoisa", - "/ip6", - "/udp", - "/tcp", - "/sctp", - "/udp/65536", - "/tcp/65536", - // "/onion/9imaq4ygg2iegci7:80", - // "/onion/aaimaq4ygg2iegci7:80", - // "/onion/timaq4ygg2iegci7:0", - // "/onion/timaq4ygg2iegci7:-1", - // "/onion/timaq4ygg2iegci7", - // "/onion/timaq4ygg2iegci@:666", - "/udp/1234/sctp", - "/udp/1234/udt/1234", - "/udp/1234/utp/1234", - "/ip4/127.0.0.1/udp/jfodsajfidosajfoidsa", - "/ip4/127.0.0.1/udp", - "/ip4/127.0.0.1/tcp/jfodsajfidosajfoidsa", - "/ip4/127.0.0.1/tcp", - "/ip4/127.0.0.1/ipfs", - "/ip4/127.0.0.1/ipfs/tcp", - "/p2p-circuit/50"]; + let addresses = [ + "/ip4", + "/ip4/::1", + "/ip4/fdpsofodsajfdoisa", + "/ip6", + "/udp", + "/tcp", + "/sctp", + "/udp/65536", + "/tcp/65536", + // "/onion/9imaq4ygg2iegci7:80", + // "/onion/aaimaq4ygg2iegci7:80", + // "/onion/timaq4ygg2iegci7:0", + // "/onion/timaq4ygg2iegci7:-1", + // "/onion/timaq4ygg2iegci7", + // "/onion/timaq4ygg2iegci@:666", + "/udp/1234/sctp", + "/udp/1234/udt/1234", + "/udp/1234/utp/1234", + "/ip4/127.0.0.1/udp/jfodsajfidosajfoidsa", + "/ip4/127.0.0.1/udp", + "/ip4/127.0.0.1/tcp/jfodsajfidosajfoidsa", + "/ip4/127.0.0.1/tcp", + "/ip4/127.0.0.1/ipfs", + "/ip4/127.0.0.1/ipfs/tcp", + "/p2p-circuit/50", + ]; for address in &addresses { assert!(address.parse::().is_err(), address.to_string()); } } - #[test] fn to_multiaddr() { - assert_eq!(Ipv4Addr::new(127, 0, 0, 1).to_multiaddr().unwrap(), - "/ip4/127.0.0.1".parse::().unwrap()); - assert_eq!(Ipv6Addr::new(0x2601, 0x9, 0x4f81, 0x9700, 0x803e, 0xca65, 0x66e8, 0xc21) - .to_multiaddr() - .unwrap(), - "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21".parse::().unwrap()); - assert_eq!("/ip4/127.0.0.1/tcp/1234".to_string().to_multiaddr().unwrap(), - "/ip4/127.0.0.1/tcp/1234".parse::().unwrap()); - assert_eq!("/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21".to_multiaddr().unwrap(), - "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21".parse::().unwrap()); - assert_eq!(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 1234).to_multiaddr().unwrap(), - "/ip4/127.0.0.1/tcp/1234".parse::().unwrap()); - assert_eq!(SocketAddrV6::new(Ipv6Addr::new(0x2601, - 0x9, - 0x4f81, - 0x9700, - 0x803e, - 0xca65, - 0x66e8, - 0xc21), - 1234, - 0, - 0) - .to_multiaddr() - .unwrap(), - "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21/tcp/1234".parse::().unwrap()); + assert_eq!( + Ipv4Addr::new(127, 0, 0, 1).to_multiaddr().unwrap(), + "/ip4/127.0.0.1".parse::().unwrap() + ); + assert_eq!( + Ipv6Addr::new(0x2601, 0x9, 0x4f81, 0x9700, 0x803e, 0xca65, 0x66e8, 0xc21) + .to_multiaddr() + .unwrap(), + "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21" + .parse::() + .unwrap() + ); + assert_eq!( + "/ip4/127.0.0.1/tcp/1234" + .to_string() + .to_multiaddr() + .unwrap(), + "/ip4/127.0.0.1/tcp/1234".parse::().unwrap() + ); + assert_eq!( + "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21" + .to_multiaddr() + .unwrap(), + "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21" + .parse::() + .unwrap() + ); + assert_eq!( + SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 1234) + .to_multiaddr() + .unwrap(), + "/ip4/127.0.0.1/tcp/1234".parse::().unwrap() + ); + assert_eq!( + SocketAddrV6::new( + Ipv6Addr::new(0x2601, 0x9, 0x4f81, 0x9700, 0x803e, 0xca65, 0x66e8, 0xc21), + 1234, + 0, + 0 + ) + .to_multiaddr() + .unwrap(), + "/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21/tcp/1234" + .parse::() + .unwrap() + ); } #[test] From 9cc5370bf11fe02e1825351f6dbae491f4806bc2 Mon Sep 17 00:00:00 2001 From: Steven Allen Date: Wed, 28 Nov 2018 13:02:26 -0800 Subject: [PATCH 3/5] fix some clippy lints --- src/lib.rs | 8 ++++---- src/protocol.rs | 6 +++--- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 5c68d8b4..d0169e53 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -118,7 +118,7 @@ impl Multiaddr { bytes.extend(new.to_bytes()); - Ok(Multiaddr { bytes: bytes }) + Ok(Multiaddr { bytes }) } /// Adds an already-parsed address component to the end of this multiaddr. @@ -199,7 +199,7 @@ impl Multiaddr { let mut bytes = self.bytes.clone(); bytes.truncate(input_pos); - Ok(Multiaddr { bytes: bytes }) + Ok(Multiaddr { bytes }) } /// Returns the components of this multiaddress. @@ -271,7 +271,7 @@ impl FromIterator for Multiaddr { cmp.write_bytes(&mut bytes) .expect("writing to a Vec never fails"); } - Multiaddr { bytes: bytes } + Multiaddr { bytes } } } @@ -305,7 +305,7 @@ impl FromStr for Multiaddr { .expect("writing to a Vec never fails"); } - Ok(Multiaddr { bytes: bytes }) + Ok(Multiaddr { bytes }) } } diff --git a/src/protocol.rs b/src/protocol.rs index 48640c88..c3534a7d 100644 --- a/src/protocol.rs +++ b/src/protocol.rs @@ -50,7 +50,7 @@ impl From for u32 { impl From for u64 { fn from(proto: Protocol) -> u64 { - proto as u32 as u64 + u64::from(proto as u32) } } @@ -169,8 +169,8 @@ impl Protocol { /// assert_eq!(Protocol::TCP.size(), ProtocolArgSize::Fixed { bytes: 2 }); /// ``` /// - pub fn size(&self) -> ProtocolArgSize { - match *self { + pub fn size(self) -> ProtocolArgSize { + match self { Protocol::IP4 => ProtocolArgSize::Fixed { bytes: 4 }, Protocol::TCP => ProtocolArgSize::Fixed { bytes: 2 }, Protocol::UDP => ProtocolArgSize::Fixed { bytes: 2 }, From 37c224a46c3a8f6d77300daa04a913cbaf911c0f Mon Sep 17 00:00:00 2001 From: Steven Allen Date: Wed, 28 Nov 2018 13:08:55 -0800 Subject: [PATCH 4/5] use Display instead of ToString (allocates less) --- src/protocol.rs | 64 ++++++++++++++++++++++++------------------------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/src/protocol.rs b/src/protocol.rs index c3534a7d..7358e4ae 100644 --- a/src/protocol.rs +++ b/src/protocol.rs @@ -4,6 +4,7 @@ use integer_encoding::{VarInt, VarIntWriter}; use std::convert::From; use std::io::{Cursor, Result as IoResult, Write}; use std::net::{Ipv4Addr, Ipv6Addr}; +use std::fmt; use std::str::FromStr; use {Error, Result}; @@ -54,9 +55,9 @@ impl From for u64 { } } -impl ToString for Protocol { - fn to_string(&self) -> String { - match *self { +impl fmt::Display for Protocol { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(match *self { Protocol::IP4 => "ip4", Protocol::TCP => "tcp", Protocol::UDP => "udp", @@ -80,8 +81,7 @@ impl ToString for Protocol { Protocol::Libp2pWebrtcStar => "p2p-webrtc-star", Protocol::Libp2pWebrtcDirect => "p2p-webrtc-direct", Protocol::P2pCircuit => "p2p-circuit", - } - .to_owned() + }) } } @@ -460,40 +460,40 @@ impl AddrComponent { } } -impl ToString for AddrComponent { - fn to_string(&self) -> String { - match *self { - AddrComponent::IP4(ref addr) => format!("/ip4/{}", addr), - AddrComponent::TCP(port) => format!("/tcp/{}", port), - AddrComponent::UDP(port) => format!("/udp/{}", port), - AddrComponent::DCCP(port) => format!("/dccp/{}", port), - AddrComponent::IP6(ref addr) => format!("/ip6/{}", addr), - AddrComponent::DNS4(ref s) => format!("/dns4/{}", s.clone()), - AddrComponent::DNS6(ref s) => format!("/dns6/{}", s.clone()), - AddrComponent::SCTP(port) => format!("/sctp/{}", port), - AddrComponent::UDT => format!("/udt"), - AddrComponent::UTP => format!("/utp"), - AddrComponent::UNIX(ref s) => format!("/unix/{}", s.clone()), - AddrComponent::P2P(ref bytes) => { +impl fmt::Display for AddrComponent { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + AddrComponent::IP4(addr) => write!(f, "/ip4/{}", addr), + AddrComponent::TCP(port) => write!(f, "/tcp/{}", port), + AddrComponent::UDP(port) => write!(f, "/udp/{}", port), + AddrComponent::DCCP(port) => write!(f, "/dccp/{}", port), + AddrComponent::IP6(addr) => write!(f, "/ip6/{}", addr), + AddrComponent::DNS4(s) => write!(f, "/dns4/{}", s.clone()), + AddrComponent::DNS6(s) => write!(f, "/dns6/{}", s.clone()), + AddrComponent::SCTP(port) => write!(f, "/sctp/{}", port), + AddrComponent::UDT => write!(f, "/udt"), + AddrComponent::UTP => write!(f, "/utp"), + AddrComponent::UNIX(s) => write!(f, "/unix/{}", s.clone()), + AddrComponent::P2P(bytes) => { // TODO: meh for cloning let c = Cid::from(bytes.clone()).expect("cid is known to be valid"); - format!("/p2p/{}", c) + write!(f, "/p2p/{}", c) } - AddrComponent::IPFS(ref bytes) => { + AddrComponent::IPFS(bytes) => { // TODO: meh for cloning let c = Cid::from(bytes.clone()).expect("cid is known to be valid"); - format!("/ipfs/{}", c) + write!(f, "/ipfs/{}", c) } - AddrComponent::HTTP => format!("/http"), - AddrComponent::HTTPS => format!("/https"), + AddrComponent::HTTP => write!(f, "/http"), + AddrComponent::HTTPS => write!(f, "/https"), AddrComponent::ONION(_) => unimplemented!(), //format!("/onion"), // TODO: - AddrComponent::QUIC => format!("/quic"), - AddrComponent::WS => format!("/ws"), - AddrComponent::WSS => format!("/wss"), - AddrComponent::Libp2pWebsocketStar => format!("/p2p-websocket-star"), - AddrComponent::Libp2pWebrtcStar => format!("/p2p-webrtc-star"), - AddrComponent::Libp2pWebrtcDirect => format!("/p2p-webrtc-direct"), - AddrComponent::P2pCircuit => format!("/p2p-circuit"), + AddrComponent::QUIC => write!(f, "/quic"), + AddrComponent::WS => write!(f, "/ws"), + AddrComponent::WSS => write!(f, "/wss"), + AddrComponent::Libp2pWebsocketStar => write!(f, "/p2p-websocket-star"), + AddrComponent::Libp2pWebrtcStar => write!(f, "/p2p-webrtc-star"), + AddrComponent::Libp2pWebrtcDirect => write!(f, "/p2p-webrtc-direct"), + AddrComponent::P2pCircuit => write!(f, "/p2p-circuit"), } } } From a3d1ef76206ebbee196818c71b0f902920da81cd Mon Sep 17 00:00:00 2001 From: Steven Allen Date: Wed, 28 Nov 2018 13:14:55 -0800 Subject: [PATCH 5/5] release 0.3.1 --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index da2700aa..57fa0a1b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ keywords = ["multiaddr", "ipfs"] license = "MIT" name = "multiaddr" readme = "README.md" -version = "0.3.0" +version = "0.3.1" [dependencies] byteorder = "1.0"