diff --git a/src/networking/ip.rs b/src/ip.rs similarity index 87% rename from src/networking/ip.rs rename to src/ip.rs index 207e8cb..52e5c0c 100644 --- a/src/networking/ip.rs +++ b/src/ip.rs @@ -9,8 +9,11 @@ pub struct InvalidIPErr; /// # Example /// ``` /// //Loopback Addresses: -/// IpAddr::V4(127, 0, 0, 1) -/// IpAddr::V6(String::from("::1")) +/// use subnet_calculator::ip::IpAddr; +/// use std::str::FromStr; +/// +/// IpAddr::V4(127, 0, 0, 1); +/// IpAddr::V6(String::from("::1")); /// ``` #[allow(unused)] #[derive(Debug, PartialEq, Eq, Clone)] @@ -27,10 +30,12 @@ impl IpAddr { /// Currently only works for IPs of type IPv4 /// # Example /// ``` + /// use subnet_calculator::ip::IpAddr; + /// /// let ip: IpAddr = IpAddr::V4(127, 0, 0, 1); /// - /// let ip_add: [u8; 4] = ip.to_arr(); - /// >>> ip_add = [127, 0, 0, 1] + /// let ip_add: [u8; 4] = ip.to_arr().unwrap(); + /// assert_eq!(ip_add, [127, 0, 0, 1]); /// ``` pub fn to_arr(&self) -> Result<[u8; 4], NetworkingErr> { match self { @@ -48,10 +53,12 @@ impl IpAddr { /// Currently only works for IPs of type IPv4 /// # Example /// ``` + /// use subnet_calculator::ip::IpAddr; + /// /// let ip_add: [u8; 4] = [127, 0, 0, 1]; /// - /// let ip: IpAddr = IpAddr::V4(127, 0, 0, 1); - /// >>> ip_add = [127, 0, 0, 1] + /// let ip: IpAddr = IpAddr::from_arr(&ip_add).unwrap(); + /// assert_eq!(ip, IpAddr::V4(127, 0, 0, 1)); /// ``` pub fn from_arr(arr: &[u8; 4]) -> Result { Ok(IpAddr::V4(arr[0], arr[1], arr[2], arr[3])) @@ -66,10 +73,12 @@ impl From for u32 { /// Currently only works for IPs of type IPv4 /// # Example /// ``` + /// use subnet_calculator::ip::IpAddr; + /// /// let ip: IpAddr = IpAddr::V4(127, 0, 0, 1); /// /// let ip_u32: u32 = u32::from(ip); - /// >>> ip_u32 = 2130706433; + /// assert_eq!(ip_u32, 2130706433); /// ``` fn from(ip: IpAddr) -> Self { u32::from_be_bytes(ip.to_arr().unwrap()) @@ -84,10 +93,12 @@ impl From for IpAddr { /// Currently only works for IPs of type IPv4 /// # Example /// ``` + /// use subnet_calculator::ip::IpAddr; + /// /// let ip: u32 = 2_130_706_433; /// - /// let ip_addr: u32 = IpAddr::from(ip); - /// >>> ip_addr = IpAddr::V4(127, 0, 0, 1); + /// let ip_addr: IpAddr = IpAddr::from(ip); + /// assert_eq!(ip_addr, IpAddr::V4(127, 0, 0, 1)); /// ``` fn from(ip: u32) -> Self { IpAddr::from_arr(&(ip.to_be_bytes() as [u8; 4])).unwrap() @@ -112,10 +123,13 @@ impl FromStr for IpAddr { /// Currently only works for IPs of type IPv4 /// # Example /// ``` + /// use subnet_calculator::ip::IpAddr; + /// use std::str::FromStr; + /// /// let ip: &str = "127.0.0.1"; /// - /// let parsed_ip: IpAddr = IpAddr::from_str(ip); - /// ///parsed_ip = IpAddr::V4(127,0,0,1) + /// let parsed_ip: IpAddr = IpAddr::from_str(ip).unwrap(); + /// assert_eq!(parsed_ip, IpAddr::V4(127,0,0,1)); /// ``` fn from_str(s: &str) -> Result { let split_ip = s.split('.'); @@ -143,6 +157,8 @@ impl FromStr for IpAddr { /// /// # Example /// ``` +/// use subnet_calculator::ip::{IpAddr, print_ip}; +/// /// let ip = IpAddr::V4(127, 0, 0, 1); /// /// print_ip(ip); diff --git a/src/networking/mod.rs b/src/lib.rs similarity index 91% rename from src/networking/mod.rs rename to src/lib.rs index 3de22cd..e0006b7 100644 --- a/src/networking/mod.rs +++ b/src/lib.rs @@ -1,5 +1,5 @@ -use std::{str::FromStr, vec}; use ip::IpAddr; +use std::str::FromStr; pub mod ip; @@ -35,9 +35,10 @@ impl Network { /// Function that constucts a network struct. /// /// ``` - /// let network = Network::new(&IpAddr::V4(127, 0, 0, 1), 32); + /// //Awaiting implementation before creating doctest + /// //let network = Network::new(&IpAddr::V4(127, 0, 0, 1), 32); /// ``` - pub fn new(given_address: &IpAddr, subnet_mask: &IpAddr) -> Network { + fn new(given_address: &IpAddr, subnet_mask: &IpAddr) -> Network { Network { network_address: given_address.clone(), broadcast_addr: given_address.clone(), @@ -49,7 +50,12 @@ impl Network { /// Function that constucts a subnet, returning a vector of all subnets included /// /// ``` - /// let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 1), 32); + /// use subnet_calculator::ip::IpAddr; + /// use subnet_calculator::Network; + /// + /// let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 1), 16).unwrap(); + /// + /// assert_eq!(networks.len(), 256); /// ``` pub fn create_subnet(network_address: &IpAddr, cidr: u8) -> Result, NetworkingErr> { //Get number of host and network bits. @@ -102,9 +108,11 @@ impl Network { /// Function that is used to determine the class of network that an IP is in. /// - /// ``` - /// let network_class = Network::get_network_class(&[127, 0, 0, 1])?; - /// >>> NetworkClass::A + /// ```ignore + /// use subnet_calculator::Network; + /// + /// let network_class = Network::get_network_class(&[127, 0, 0, 1]).unwrap(); + /// assert_eq!(network_class, NetworkClass::A); /// ``` fn get_network_class(network_address: &IpAddr) -> Result { let network_address = network_address.to_arr()?; @@ -123,11 +131,11 @@ impl Network { #[allow(unused)] /// Function that takes in a u8 CIDR and converts it to an IP address. /// - /// ``` - /// let cidr: u8 = 22 - /// let subnet_mask: [u8; 4] = gen_subnet_mask(cidr); + /// ```ignore + /// let cidr: u8 = 22; + /// let subnet_mask: [u8; 4] = gen_subnet_mask(cidr).unwrap(); /// - /// >> IpAddr::V4(255, 255, 252, 0) + /// assert_eq!(subnet_mask, IpAddr::V4(255, 255, 252, 0)); /// ``` fn gen_subnet_mask(mut cidr: u8) -> Result { if cidr > 32 { @@ -160,13 +168,16 @@ impl Network { /// both its Address and CIDR /// /// ``` +/// use subnet_calculator::ip_and_cidr_from_string; +/// use subnet_calculator::ip::IpAddr; +/// /// let ip_string = String::from("192.168.0.1/24"); /// let result = match ip_and_cidr_from_string(&ip_string) { /// Err(_) => panic!(), /// Ok(ip_and_cidr) => ip_and_cidr /// }; /// -/// >> (IpAddr::V4(192, 168, 0, 1), 24) +/// assert_eq!(result, (IpAddr::V4(192, 168, 0, 1), 24)); /// ``` pub fn ip_and_cidr_from_string(ip_and_cidr: &String) -> Result<(IpAddr, u8), ip::InvalidIPErr>{ let mut cidr: u8 = Default::default(); diff --git a/src/main.rs b/src/main.rs deleted file mode 100644 index 351579a..0000000 --- a/src/main.rs +++ /dev/null @@ -1,34 +0,0 @@ -use std::{io}; - -use networking::Network; - - -mod networking; - -fn main() { - println!("Enter the IP and cidr for your given network"); - - let ip_and_cidr: (networking::ip::IpAddr, u8); - - loop { - let mut ip_buf = String::new(); - io::stdin().read_line(&mut ip_buf).unwrap_or_default(); - - ip_and_cidr = match networking::ip_and_cidr_from_string(&ip_buf) { - Err(_) => { - println!("{} is an invalid IP Address... Please try again", ip_buf); - continue; - }, - Ok(ip_and_cidr) => ip_and_cidr - }; - - break; - } - - let networks = Network::create_subnet(&ip_and_cidr.0, ip_and_cidr.1).unwrap_or_default(); - - for network in networks.iter() { - networking::ip::print_ip(network.clone()); - } - println!("There are {} networks available", networks.len()); -}