address.rs

address.rs

use std::iter::Peekable;
use std::str::Split;
use url::Url;

#[derive(Debug, Clone)]
pub enum Error {
    Empty,
    UnknownProtocol,
}

type Result<T> = core::result::Result<T, Error>;

#[derive(Debug, Clone)]
pub enum Protocol {
    Service(String),
}

impl Protocol {
    pub fn from_str_parts<'a, I>(mut iter: I) -> Result<Self>
    where
        I: Iterator<Item = &'a str>,
    {
        match iter.next().ok_or(Error::Empty)? {
            "service" => {
                let id = iter.next().ok_or(Error::Empty)?;
                Ok(Protocol::Service(id.into()))
            }
            _ => Err(Error::UnknownProtocol),
        }
    }
}

#[derive(Debug, Clone)]
pub struct Address(Url);

impl Address {
    fn protocols(&self) -> Result<Vec<Protocol>> {
        // parse
        let mut parts = self.0.path_segments().unwrap().peekable();
        let mut protocols = vec![];
        while parts.peek().is_some() {
            let protocol = Protocol::from_str_parts(&mut parts)?;
            protocols.push(protocol);
        }

        Ok(protocols)
    }

    fn next(&mut self) -> Result<Option<Protocol>> {
        let mut path = self.0.path_segments().unwrap().peekable();
        let result = if path.peek().is_some() {
            let protocol = Protocol::from_str_parts(&mut path)?;
            Ok(Some(protocol))
        } else {
            Ok(None)
        };
        let path = path.collect::<Vec<_>>();
        self.0.path_segments_mut().unwrap().clear().extend(path);
        result
    }
}

struct ProtocolIterator<'a> {
    iter: Peekable<Split<'a, char>>,
}

#[cfg(test)]
pub mod tests {
    use super::Address;

    #[test]
    fn route_and_resolve() {
        let mut service = Address("schema:/service/FOO_BAR".parse().unwrap());

        match service.next() {
            Ok(Some(protocol)) => println!("Protocol is {:?}", protocol),
            wtf => println!("WTF?! {:?}", wtf),
        }
    }
}