Another round of formatting

src/common.rs

@@ -29,23 +29,30 @@ impl Error for IpNetworkError {
             InvalidPrefix => "prefix is invalid",
             InvalidCidrFormat(_) => "cidr is invalid",
         }
-
     }
 }
 
 pub fn cidr_parts(cidr: &str) -> Result<(&str, &str), IpNetworkError> {
     let parts = cidr.split('/').collect::<Vec<&str>>();
     if parts.len() == 1 {
-        Err(IpNetworkError::InvalidCidrFormat(format!("CIDR must contain '/': {}", cidr)))
+        Err(IpNetworkError::InvalidCidrFormat(format!(
+            "CIDR must contain '/': {}",
+            cidr
+        )))
     } else if parts.len() == 2 {
         Ok((parts[0], parts[1]))
     } else {
-        Err(IpNetworkError::InvalidCidrFormat(format!("CIDR must contain a single '/': {}", cidr)))
+        Err(IpNetworkError::InvalidCidrFormat(format!(
+            "CIDR must contain a single '/': {}",
+            cidr
+        )))
     }
 }
 
 pub fn parse_prefix(prefix: &str, max: u8) -> Result<u8, IpNetworkError> {
-    let mask = prefix.parse::<u8>().map_err(|_| IpNetworkError::InvalidPrefix)?;
+    let mask = prefix
+        .parse::<u8>()
+        .map_err(|_| IpNetworkError::InvalidPrefix)?;
     if mask > max {
         Err(IpNetworkError::InvalidPrefix)
     } else {
@@ -58,7 +65,10 @@ pub fn parse_addr(addr: &str) -> Result<Ipv4Addr, IpNetworkError> {
     let mut bytes = [0; 4];
     for (i, byte) in addr_parts.enumerate() {
         if i >= 4 {
-            return Err(IpNetworkError::InvalidAddr(format!("More than 4 bytes: {}", addr)));
+            return Err(IpNetworkError::InvalidAddr(format!(
+                "More than 4 bytes: {}",
+                addr
+            )));
         }
         bytes[i] = byte.map_err(|_| {
             IpNetworkError::InvalidAddr(format!("All bytes not 0-255: {}", addr))

src/ipv4.rs

@@ -2,7 +2,7 @@ use std::fmt;
 use std::net::Ipv4Addr;
 use std::str::FromStr;
 
-use common::{IpNetworkError, cidr_parts, parse_prefix, parse_addr};
+use common::{cidr_parts, parse_addr, parse_prefix, IpNetworkError};
 
 const IPV4_BITS: u8 = 32;
 
@@ -171,7 +171,6 @@ impl fmt::Display for Ipv4Network {
     }
 }
 
-
 /// Creates an `Ipv4Network` from parsing a string in CIDR notation.
 ///
 /// # Examples
@@ -195,7 +194,6 @@ impl FromStr for Ipv4Network {
     }
 }
 
-
 impl From<Ipv4Addr> for Ipv4Network {
     fn from(a: Ipv4Addr) -> Ipv4Network {
         Ipv4Network {

src/ipv6.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use std::net::Ipv6Addr;
 use std::str::FromStr;
 
-use common::{IpNetworkError, cidr_parts, parse_prefix};
+use common::{cidr_parts, parse_prefix, IpNetworkError};
 
 const IPV6_BITS: u8 = 128;
 const IPV6_SEGMENT_BITS: u8 = 16;
@@ -34,7 +34,6 @@ impl Ipv6Network {
     /// addresses.
     #[cfg(feature = "ipv6-iterator")]
     pub fn iter(&self) -> Ipv6NetworkIterator {
-
         let dec = u128::from(self.addr);
         let max = u128::max_value();
         let prefix = self.prefix;
@@ -49,7 +48,6 @@ impl Ipv6Network {
             next: start,
             end: end,
         }
-
     }
 
     /// Returns the address of the network denoted by this `Ipv6Network`.
@@ -137,10 +135,13 @@ impl Ipv6Network {
         let a = self.addr.segments();
         let b = ip.segments();
         let addrs = Iterator::zip(a.iter(), b.iter());
-        self.mask().segments().iter().zip(addrs).all(|(mask, (a, b))| a & mask == b & mask)
+        self.mask()
+            .segments()
+            .iter()
+            .zip(addrs)
+            .all(|(mask, (a, b))| a & mask == b & mask)
     }
 
-
     /// Returns number of possible host addresses in this `Ipv6Network`.
     ///
     /// # Examples
@@ -166,7 +167,8 @@ impl FromStr for Ipv6Network {
     type Err = IpNetworkError;
     fn from_str(s: &str) -> Result<Ipv6Network, IpNetworkError> {
         let (addr_str, prefix_str) = cidr_parts(s)?;
-        let addr = Ipv6Addr::from_str(addr_str).map_err(|_| IpNetworkError::InvalidAddr(addr_str.to_string()))?;
+        let addr = Ipv6Addr::from_str(addr_str)
+            .map_err(|_| IpNetworkError::InvalidAddr(addr_str.to_string()))?;
         let prefix = parse_prefix(prefix_str, IPV6_BITS)?;
         Ipv6Network::new(addr, prefix)
     }
@@ -192,19 +194,13 @@ impl Iterator for Ipv6NetworkIterator {
     type Item = Ipv6Addr;
 
     fn next(&mut self) -> Option<Ipv6Addr> {
-
         if self.next <= self.end {
-
             let next = Ipv6Addr::from(self.next);
             self.next += 1;
             Some(next)
-
         } else {
-
             None
-
         }
-
     }
 }
 
@@ -338,10 +334,22 @@ mod test {
     fn iterator_v6() {
         let cidr: Ipv6Network = "2001:db8::/126".parse().unwrap();
         let mut iter = cidr.iter();
-        assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), iter.next().unwrap());
+        assert_eq!(
-        assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), iter.next().unwrap());
+            Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0),
-        assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 2), iter.next().unwrap());
+            iter.next().unwrap()
-        assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 3), iter.next().unwrap());
+        );
+        assert_eq!(
+            Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1),
+            iter.next().unwrap()
+        );
+        assert_eq!(
+            Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 2),
+            iter.next().unwrap()
+        );
+        assert_eq!(
+            Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 3),
+            iter.next().unwrap()
+        );
         assert_eq!(None, iter.next());
     }
 
@@ -350,7 +358,10 @@ mod test {
     fn iterator_v6_tiny() {
         let cidr: Ipv6Network = "2001:db8::/128".parse().unwrap();
         let mut iter = cidr.iter();
-        assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), iter.next().unwrap());
+        assert_eq!(
+            Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0),
+            iter.next().unwrap()
+        );
         assert_eq!(None, iter.next());
     }