notedeck

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

route.rs (2895B)

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