notedeck

One damus client to rule them all
git clone git://jb55.com/notedeck
Log | Files | Refs | README | LICENSE

route.rs (2718B)

      1 use super::{AccountLoginResponse, AccountsViewResponse};
      2 use serde::{Deserialize, Serialize};
      3 use tokenator::{ParseError, TokenParser, TokenSerializable, TokenWriter};
      4 
      5 pub enum AccountsRouteResponse {
      6     Accounts(AccountsViewResponse),
      7     AddAccount(AccountLoginResponse),
      8 }
      9 
     10 #[derive(Debug, Eq, PartialEq, Clone, Copy, Serialize, Deserialize)]
     11 pub enum AccountsRoute {
     12     Accounts,
     13     AddAccount,
     14 }
     15 
     16 impl AccountsRoute {
     17     /// Route tokens use in both serialization and deserialization
     18     fn tokens(&self) -> &'static [&'static str] {
     19         match self {
     20             Self::Accounts => &["accounts", "show"],
     21             Self::AddAccount => &["accounts", "new"],
     22         }
     23     }
     24 }
     25 
     26 impl TokenSerializable for AccountsRoute {
     27     fn serialize_tokens(&self, writer: &mut TokenWriter) {
     28         for token in self.tokens() {
     29             writer.write_token(token);
     30         }
     31     }
     32 
     33     fn parse_from_tokens<'a>(parser: &mut TokenParser<'a>) -> Result<Self, ParseError<'a>> {
     34         parser.peek_parse_token("accounts")?;
     35 
     36         TokenParser::alt(
     37             parser,
     38             &[
     39                 |p| parse_accounts_route(p, AccountsRoute::Accounts),
     40                 |p| parse_accounts_route(p, AccountsRoute::AddAccount),
     41             ],
     42         )
     43     }
     44 }
     45 
     46 fn parse_accounts_route<'a>(
     47     parser: &mut TokenParser<'a>,
     48     route: AccountsRoute,
     49 ) -> Result<AccountsRoute, ParseError<'a>> {
     50     parser.parse_all(|p| {
     51         for token in route.tokens() {
     52             p.parse_token(token)?;
     53         }
     54         Ok(route)
     55     })
     56 }
     57 
     58 #[cfg(test)]
     59 mod tests {
     60     use super::*;
     61     use tokenator::{TokenParser, TokenSerializable, TokenWriter};
     62 
     63     #[test]
     64     fn test_accounts_route_serialize() {
     65         let data_str = "accounts:show";
     66         let data = &data_str.split(":").collect::<Vec<&str>>();
     67         let mut token_writer = TokenWriter::default();
     68         let mut parser = TokenParser::new(&data);
     69         let parsed = AccountsRoute::parse_from_tokens(&mut parser).unwrap();
     70         let expected = AccountsRoute::Accounts;
     71         parsed.serialize_tokens(&mut token_writer);
     72         assert_eq!(expected, parsed);
     73         assert_eq!(token_writer.str(), data_str);
     74     }
     75 
     76     #[test]
     77     fn test_new_accounts_route_serialize() {
     78         let data_str = "accounts:new";
     79         let data = &data_str.split(":").collect::<Vec<&str>>();
     80         let mut token_writer = TokenWriter::default();
     81         let mut parser = TokenParser::new(data);
     82         let parsed = AccountsRoute::parse_from_tokens(&mut parser).unwrap();
     83         let expected = AccountsRoute::AddAccount;
     84         parsed.serialize_tokens(&mut token_writer);
     85         assert_eq!(expected, parsed);
     86         assert_eq!(token_writer.str(), data_str);
     87     }
     88 }