Cut a new release for v0.20.0 (#158)

* show failed test cases

* add proper JSON schema

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to crates.io
+on:
+  workflow_dispatch:
+  push:
+    tags:        
+      - 'v.*.*'
+      
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+          toolchain: stable
+          override: true
+    - uses: katyo/publish-crates@v1
+      with:
+          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/rust.yml

@@ -23,6 +23,6 @@ jobs:
     - name: Build
       run: cargo build --verbose
     - name: Run tests
-      run: cargo test --verbose
+      run: cargo test --verbose --all-features
     - name: Build docs
       run: cargo doc --verbose

Cargo.toml

@@ -1,23 +1,23 @@
 [package]
 name = "ipnetwork"
-version = "0.16.0" # When updating version, also modify html_root_url in the lib.rs
+version = "0.20.0"
 authors = ["Abhishek Chanda <abhishek.becs@gmail.com>", "Linus Färnstrand <faern@faern.net>"]
 description = "A library to work with IP CIDRs in Rust"
-license = "Apache-2.0"
+license = "MIT OR Apache-2.0"
 repository = "https://github.com/achanda/ipnetwork"
 keywords = ["network", "ip", "address", "cidr"]
 readme = "README.md"
 categories = ["network-programming", "parser-implementations"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
-clippy = {version = "0.0.302", optional = true}
+serde = { version = "1", optional = true }
-serde = { version = ">=0.8.0, <2.0", optional = true }
+schemars = { version = "0.8.10", optional = true }
 
 [dev-dependencies]
 serde_json = "1.0"
-serde_derive = ">=0.8.0, <2.0"
+criterion = {version = "0.3.4", features= ["html_reports"]}
-criterion = "0.3.0"
+does-it-json = "0.0.3"
 
 [badges]
 travis-ci = { repository = "achanda/ipnetwork" }
@@ -25,7 +25,6 @@ maintenance = { status = "passively-maintained" }
 
 [features]
 default = ["serde"]
-dev = ["clippy"]
 
 [[bench]]
 name = "parse_bench"

LICENSE-MIT.md

@@ -0,0 +1,25 @@
+Copyright 2020 Developers of the ipnetwork project
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -1,14 +1,14 @@
 ipnetwork
 ===
-This is a library to work with IPv4 and v6 CIDRs in rust
+This is a library to work with IPv4 and IPv6 CIDRs in Rust
-The IPv4 implementation is stable, IPv6 implementation is not done yet.
 
 [![Build Status](https://travis-ci.org/achanda/ipnetwork.svg?branch=master)](https://travis-ci.org/achanda/ipnetwork)
 [![Merit Badge](http://meritbadge.herokuapp.com/ipnetwork)](https://crates.io/crates/ipnetwork)
 
 Run Clippy by doing
 ```
-cargo test --features "dev"
+rustup component add clippy
+cargo clippy
 ```
 
 ### Installation
@@ -20,7 +20,7 @@ cargo test
 ```
 
 You can also add `ipnetwork` as a dependency to your project's `Cargo.toml`:
-```
+```toml
 [dependencies]
 ipnetwork = "*"
 ```

benches/parse_bench.rs

@@ -21,18 +21,18 @@ fn parse_ipv4_netmask_benchmark(c: &mut Criterion) {
 }
 
 fn contains_ipv4_benchmark(c: &mut Criterion) {
+    let cidr = "74.125.227.0/25".parse::<Ipv4Network>().unwrap();
     c.bench_function("contains ipv4", |b| {
         b.iter(|| {
-            let cidr = "74.125.227.0/25".parse::<Ipv4Network>().unwrap();
             cidr.contains(Ipv4Addr::new(74, 125, 227, 4))
         })
     });
 }
 
 fn contains_ipv6_benchmark(c: &mut Criterion) {
+    let cidr = "FF01:0:0:17:0:0:0:2/65".parse::<Ipv6Network>().unwrap();
     c.bench_function("contains ipv6", |b| {
         b.iter(|| {
-            let cidr = "FF01:0:0:17:0:0:0:2/65".parse::<Ipv6Network>().unwrap();
             cidr.contains(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0x7fff, 0, 0, 0x2))
         })
     });

src/common.rs

@@ -36,17 +36,17 @@ pub fn cidr_parts(cidr: &str) -> Result<(&str, Option<&str>), IpNetworkError> {
         let (ip, prefix) = cidr.split_at(sep);
         // Error if cidr has multiple slashes
         if prefix[1..].find('/').is_some() {
-            return Err(IpNetworkError::InvalidCidrFormat(format!(
+            Err(IpNetworkError::InvalidCidrFormat(format!(
                 "CIDR must contain a single '/': {}",
                 cidr
-            )));
+            )))
         } else {
             // Handle the case when cidr has exactly one slash
-            return Ok((ip, Some(&prefix[1..])));
+            Ok((ip, Some(&prefix[1..])))
         }
     } else {
         // Handle the case when cidr does not have a slash
-        return Ok((cidr, None));
+        Ok((cidr, None))
     }
 }
 

src/ipv4.rs

@@ -1,5 +1,5 @@
 use crate::common::{cidr_parts, parse_prefix, IpNetworkError};
-use std::{fmt, net::Ipv4Addr, str::FromStr};
+use std::{convert::TryFrom, fmt, net::Ipv4Addr, str::FromStr};
 
 const IPV4_BITS: u8 = 32;
 
@@ -27,7 +27,37 @@ impl serde::Serialize for Ipv4Network {
     where
         S: serde::Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for Ipv4Network {
+    fn schema_name() -> String {
+        "Ipv4Network".to_string()
+    }
+
+    fn json_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        schemars::schema::SchemaObject {
+            instance_type: Some(schemars::schema::InstanceType::String.into()),
+            string: Some(Box::new(schemars::schema::StringValidation {
+                pattern: Some(
+                    concat!(
+                        r#"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}"#,
+                        r#"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"#,
+                        r#"\/(3[0-2]|[0-2]?[0-9])$"#,
+                    )
+                    .to_string(),
+                ),
+                ..Default::default()
+            })),
+            extensions: [("x-rust-type".to_string(), "ipnetwork::Ipv4Network".into())]
+                .iter()
+                .cloned()
+                .collect(),
+            ..Default::default()
+        }
+        .into()
     }
 }
 
@@ -35,7 +65,7 @@ impl Ipv4Network {
     /// Constructs a new `Ipv4Network` from any `Ipv4Addr` and a prefix denoting the network size.
     ///
     /// If the prefix is larger than 32 this will return an `IpNetworkError::InvalidPrefix`.
-    pub fn new(addr: Ipv4Addr, prefix: u8) -> Result<Ipv4Network, IpNetworkError> {
+    pub const fn new(addr: Ipv4Addr, prefix: u8) -> Result<Ipv4Network, IpNetworkError> {
         if prefix > IPV4_BITS {
             Err(IpNetworkError::InvalidPrefix)
         } else {
@@ -61,7 +91,7 @@ impl Ipv4Network {
     /// Returns an iterator over `Ipv4Network`. Each call to `next` will return the next
     /// `Ipv4Addr` in the given network. `None` will be returned when there are no more
     /// addresses.
-    pub fn iter(&self) -> Ipv4NetworkIterator {
+    pub fn iter(self) -> Ipv4NetworkIterator {
         let start = u32::from(self.network());
         let end = start + (self.size() - 1);
         Ipv4NetworkIterator {
@@ -70,11 +100,11 @@ impl Ipv4Network {
         }
     }
 
-    pub fn ip(&self) -> Ipv4Addr {
+    pub fn ip(self) -> Ipv4Addr {
         self.addr
     }
 
-    pub fn prefix(&self) -> u8 {
+    pub fn prefix(self) -> u8 {
         self.prefix
     }
 
@@ -109,7 +139,7 @@ impl Ipv4Network {
     /// let net: Ipv4Network = "127.0.0.0/16".parse().unwrap();
     /// assert_eq!(net.mask(), Ipv4Addr::new(255, 255, 0, 0));
     /// ```
-    pub fn mask(&self) -> Ipv4Addr {
+    pub fn mask(self) -> Ipv4Addr {
         let prefix = self.prefix;
         let mask = !(0xffff_ffff as u64 >> prefix) as u32;
         Ipv4Addr::from(mask)
@@ -127,7 +157,7 @@ impl Ipv4Network {
     /// let net: Ipv4Network = "10.1.9.32/16".parse().unwrap();
     /// assert_eq!(net.network(), Ipv4Addr::new(10, 1, 0, 0));
     /// ```
-    pub fn network(&self) -> Ipv4Addr {
+    pub fn network(self) -> Ipv4Addr {
         let mask = u32::from(self.mask());
         let ip = u32::from(self.addr) & mask;
         Ipv4Addr::from(ip)
@@ -145,7 +175,7 @@ impl Ipv4Network {
     /// let net: Ipv4Network = "10.9.0.32/16".parse().unwrap();
     /// assert_eq!(net.broadcast(), Ipv4Addr::new(10, 9, 255, 255));
     /// ```
-    pub fn broadcast(&self) -> Ipv4Addr {
+    pub fn broadcast(self) -> Ipv4Addr {
         let mask = u32::from(self.mask());
         let broadcast = u32::from(self.addr) | !mask;
         Ipv4Addr::from(broadcast)
@@ -163,7 +193,8 @@ impl Ipv4Network {
     /// assert!(net.contains(Ipv4Addr::new(127, 0, 0, 70)));
     /// assert!(!net.contains(Ipv4Addr::new(127, 0, 1, 70)));
     /// ```
-    pub fn contains(&self, ip: Ipv4Addr) -> bool {
+    #[inline]
+    pub fn contains(self, ip: Ipv4Addr) -> bool {
         let mask = !(0xffff_ffff as u64 >> self.prefix) as u32;
         let net = u32::from(self.addr) & mask;
         (u32::from(ip) & mask) == net
@@ -183,7 +214,7 @@ impl Ipv4Network {
     /// let tinynet: Ipv4Network = "0.0.0.0/32".parse().unwrap();
     /// assert_eq!(tinynet.size(), 1);
     /// ```
-    pub fn size(&self) -> u32 {
+    pub fn size(self) -> u32 {
         let host_bits = u32::from(IPV4_BITS - self.prefix);
         (2 as u32).pow(host_bits)
     }
@@ -205,7 +236,7 @@ impl Ipv4Network {
     /// let net2: Ipv4Network = "10.0.0.0/16".parse().unwrap();
     /// assert_eq!(net2.nth(256).unwrap(), Ipv4Addr::new(10, 0, 1, 0));
     /// ```
-    pub fn nth(&self, n: u32) -> Option<Ipv4Addr> {
+    pub fn nth(self, n: u32) -> Option<Ipv4Addr> {
         if n < self.size() {
             let net = u32::from(self.network());
             Some(Ipv4Addr::from(net + n))
@@ -236,7 +267,7 @@ impl fmt::Display for Ipv4Network {
 /// ```
 impl FromStr for Ipv4Network {
     type Err = IpNetworkError;
-    fn from_str(s: &str) -> Result<Ipv4Network, IpNetworkError> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         let (addr_str, prefix_str) = cidr_parts(s)?;
         let addr = Ipv4Addr::from_str(addr_str)
             .map_err(|_| IpNetworkError::InvalidAddr(addr_str.to_string()))?;
@@ -254,6 +285,14 @@ impl FromStr for Ipv4Network {
     }
 }
 
+impl TryFrom<&str> for Ipv4Network {
+    type Error = IpNetworkError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        Ipv4Network::from_str(s)
+    }
+}
+
 impl From<Ipv4Addr> for Ipv4Network {
     fn from(a: Ipv4Addr) -> Ipv4Network {
         Ipv4Network {

src/ipv6.rs

@@ -1,5 +1,5 @@
 use crate::common::{cidr_parts, parse_prefix, IpNetworkError};
-use std::{cmp, fmt, net::Ipv6Addr, str::FromStr};
+use std::{cmp, convert::TryFrom, fmt, net::Ipv6Addr, str::FromStr};
 
 const IPV6_BITS: u8 = 128;
 const IPV6_SEGMENT_BITS: u8 = 16;
@@ -28,7 +28,47 @@ impl serde::Serialize for Ipv6Network {
     where
         S: serde::Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for Ipv6Network {
+    fn schema_name() -> String {
+        "Ipv6Network".to_string()
+    }
+
+    fn json_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        schemars::schema::SchemaObject {
+            instance_type: Some(schemars::schema::InstanceType::String.into()),
+            string: Some(Box::new(schemars::schema::StringValidation {
+                pattern: Some(
+                    concat!(
+                        r#"^("#,
+                        r#"([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,7}:"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}"#,
+                        r#"|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})"#,
+                        r#"|:((:[0-9a-fA-F]{1,4}){1,7}|:)"#,
+                        r#"|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}"#,
+                        r#"|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"#,
+                        r#"|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"#,
+                        r#"")[/](12[0-8]|1[0-1][0-9]|[0-9]?[0-9])$"#,
+                    ).to_string(),
+                ),
+                ..Default::default()
+            })),
+            extensions: [("x-rust-type".to_string(), "ipnetwork::Ipv6Network".into())]
+                .iter()
+                .cloned()
+                .collect(),
+            ..Default::default()
+        }
+        .into()
     }
 }
 
@@ -36,7 +76,7 @@ impl Ipv6Network {
     /// Constructs a new `Ipv6Network` from any `Ipv6Addr` and a prefix denoting the network size.
     ///
     /// If the prefix is larger than 128 this will return an `IpNetworkError::InvalidPrefix`.
-    pub fn new(addr: Ipv6Addr, prefix: u8) -> Result<Ipv6Network, IpNetworkError> {
+    pub const fn new(addr: Ipv6Addr, prefix: u8) -> Result<Ipv6Network, IpNetworkError> {
         if prefix > IPV6_BITS {
             Err(IpNetworkError::InvalidPrefix)
         } else {
@@ -72,7 +112,7 @@ impl Ipv6Network {
 
         Ipv6NetworkIterator {
             next: Some(start),
-            end: end,
+            end,
         }
     }
 
@@ -174,6 +214,7 @@ impl Ipv6Network {
     /// assert!(net.contains(Ipv6Addr::new(0xff01, 0, 0, 0, 0, 0, 0, 0x1)));
     /// assert!(!net.contains(Ipv6Addr::new(0xffff, 0, 0, 0, 0, 0, 0, 0x1)));
     /// ```
+    #[inline]
     pub fn contains(&self, ip: Ipv6Addr) -> bool {
         let a = self.addr.segments();
         let b = ip.segments();
@@ -205,9 +246,22 @@ impl Ipv6Network {
     }
 }
 
+/// Creates an `Ipv6Network` from parsing a string in CIDR notation.
+///
+/// # Examples
+///
+/// ```
+/// use std::net::Ipv6Addr;
+/// use ipnetwork::Ipv6Network;
+///
+/// let new = Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 65).unwrap();
+/// let from_cidr: Ipv6Network = "FF01:0:0:17:0:0:0:2/65".parse().unwrap();
+/// assert_eq!(new.ip(), from_cidr.ip());
+/// assert_eq!(new.prefix(), from_cidr.prefix());
+/// ```
 impl FromStr for Ipv6Network {
     type Err = IpNetworkError;
-    fn from_str(s: &str) -> Result<Ipv6Network, IpNetworkError> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         let (addr_str, prefix_str) = cidr_parts(s)?;
         let addr = Ipv6Addr::from_str(addr_str)
             .map_err(|_| IpNetworkError::InvalidAddr(addr_str.to_string()))?;
@@ -219,6 +273,14 @@ impl FromStr for Ipv6Network {
     }
 }
 
+impl TryFrom<&str> for Ipv6Network {
+    type Error = IpNetworkError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        Ipv6Network::from_str(s)
+    }
+}
+
 impl From<Ipv6Addr> for Ipv6Network {
     fn from(a: Ipv6Addr) -> Ipv6Network {
         Ipv6Network {

src/lib.rs

@@ -1,20 +1,23 @@
 //! The `ipnetwork` crate provides a set of APIs to work with IP CIDRs in
 //! Rust.
-#![cfg_attr(feature = "dev", feature(plugin))]
-#![cfg_attr(feature = "dev", plugin(clippy))]
 #![crate_type = "lib"]
-#![doc(html_root_url = "https://docs.rs/ipnetwork/0.16.0")]
+#![deny(
+    missing_debug_implementations,
+    unsafe_code,
+    unused_extern_crates,
+    unused_import_braces
+)]
 
-use std::{fmt, net::IpAddr, str::FromStr};
+use std::{convert::TryFrom, fmt, net::IpAddr, str::FromStr};
 
 mod common;
 mod ipv4;
 mod ipv6;
 
 pub use crate::common::IpNetworkError;
-use crate::ipv4::Ipv4NetworkIterator;
+pub use crate::ipv4::Ipv4NetworkIterator;
 pub use crate::ipv4::{ipv4_mask_to_prefix, Ipv4Network};
-use crate::ipv6::Ipv6NetworkIterator;
+pub use crate::ipv6::Ipv6NetworkIterator;
 pub use crate::ipv6::{ipv6_mask_to_prefix, Ipv6Network};
 
 /// Represents a generic network range. This type can have two variants:
@@ -42,7 +45,75 @@ impl serde::Serialize for IpNetwork {
     where
         S: serde::Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for IpNetwork {
+    fn schema_name() -> String {
+        "IpNetwork".to_string()
+    }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        schemars::schema::SchemaObject {
+            metadata: Some(
+                schemars::schema::Metadata {
+                    ..Default::default()
+                }
+                .into(),
+            ),
+            subschemas: Some(
+                schemars::schema::SubschemaValidation {
+                    one_of: Some(vec![
+                        schemars::schema::SchemaObject {
+                            metadata: Some(
+                                schemars::schema::Metadata {
+                                    title: Some("v4".to_string()),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            subschemas: Some(
+                                schemars::schema::SubschemaValidation {
+                                    all_of: Some(vec![gen.subschema_for::<Ipv4Network>()]),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            ..Default::default()
+                        }
+                        .into(),
+                        schemars::schema::SchemaObject {
+                            metadata: Some(
+                                schemars::schema::Metadata {
+                                    title: Some("v6".to_string()),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            subschemas: Some(
+                                schemars::schema::SubschemaValidation {
+                                    all_of: Some(vec![gen.subschema_for::<Ipv6Network>()]),
+                                    ..Default::default()
+                                }
+                                .into(),
+                            ),
+                            ..Default::default()
+                        }
+                        .into(),
+                    ]),
+                    ..Default::default()
+                }
+                .into(),
+            ),
+            extensions: [("x-rust-type".to_string(), "ipnetwork::IpNetwork".into())]
+                .iter()
+                .cloned()
+                .collect(),
+            ..Default::default()
+        }
+        .into()
     }
 }
 
@@ -224,6 +295,7 @@ impl IpNetwork {
     /// assert!(!net.contains(ip2));
     /// assert!(!net.contains(ip4));
     /// ```
+    #[inline]
     pub fn contains(&self, ip: IpAddr) -> bool {
         match (*self, ip) {
             (IpNetwork::V4(net), IpAddr::V4(ip)) => net.contains(ip),
@@ -278,7 +350,7 @@ impl IpNetwork {
 /// ```
 impl FromStr for IpNetwork {
     type Err = IpNetworkError;
-    fn from_str(s: &str) -> Result<IpNetwork, IpNetworkError> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         if let Ok(net) = Ipv4Network::from_str(s) {
             Ok(IpNetwork::V4(net))
         } else if let Ok(net) = Ipv6Network::from_str(s) {
@@ -289,6 +361,14 @@ impl FromStr for IpNetwork {
     }
 }
 
+impl TryFrom<&str> for IpNetwork {
+    type Error = IpNetworkError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        IpNetwork::from_str(s)
+    }
+}
+
 impl From<Ipv4Network> for IpNetwork {
     fn from(v4: Ipv4Network) -> IpNetwork {
         IpNetwork::V4(v4)
@@ -325,6 +405,7 @@ enum IpNetworkIteratorInner {
     V6(Ipv6NetworkIterator),
 }
 
+#[derive(Clone, Debug)]
 pub struct IpNetworkIterator {
     inner: IpNetworkIteratorInner,
 }

tests/test_json.rs

@@ -3,7 +3,7 @@
 #[cfg(test)]
 mod tests {
     use ipnetwork::{IpNetwork, Ipv4Network, Ipv6Network};
-    use serde_derive::{Deserialize, Serialize};
+    use serde::{Deserialize, Serialize};
     use std::net::{Ipv4Addr, Ipv6Addr};
 
     #[test]
@@ -11,6 +11,7 @@ mod tests {
         let json_string = r#"{"ipnetwork":"127.1.0.0/24"}"#;
 
         #[derive(Serialize, Deserialize)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         struct MyStruct {
             ipnetwork: Ipv4Network,
         }
@@ -21,6 +22,11 @@ mod tests {
         assert_eq!(mystruct.ipnetwork.prefix(), 24);
 
         assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
+
+        #[cfg(feature = "schemars")]
+        if let Err(s) = does_it_json::validate_with_output(&mystruct) {
+            panic!("{}", s);
+        }
     }
 
     #[test]
@@ -28,6 +34,7 @@ mod tests {
         let json_string = r#"{"ipnetwork":"::1/0"}"#;
 
         #[derive(Serialize, Deserialize)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         struct MyStruct {
             ipnetwork: Ipv6Network,
         }
@@ -41,6 +48,11 @@ mod tests {
         assert_eq!(mystruct.ipnetwork.prefix(), 0);
 
         assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
+
+        #[cfg(feature = "schemars")]
+        if let Err(s) = does_it_json::validate_with_output(&mystruct) {
+            panic!("{}", s);
+        }
     }
 
     #[test]
@@ -48,6 +60,7 @@ mod tests {
         let json_string = r#"{"ipnetwork":["127.1.0.0/24","::1/0"]}"#;
 
         #[derive(Serialize, Deserialize)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         struct MyStruct {
             ipnetwork: Vec<IpNetwork>,
         }
@@ -63,5 +76,10 @@ mod tests {
         assert_eq!(mystruct.ipnetwork[1].prefix(), 0);
 
         assert_eq!(::serde_json::to_string(&mystruct).unwrap(), json_string);
+
+        #[cfg(feature = "schemars")]
+        if let Err(s) = does_it_json::validate_with_output(&mystruct) {
+            panic!("{}", s);
+        }
     }
 }