jokers 0.1.0

API wrapper for https://v2.jokeapi.dev/
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use crate::{Error, params::*};
use serde::Deserialize;
use std::fmt;

pub type Result<T> = std::result::Result<T, Error>;

pub enum Joke {
    Single(String),
    Twopart(String, String),
}

pub fn parse_joke(resp: &str, format: &Format) -> Result<Joke> {
    match format {
        Format::Json => parse_json(resp),
        #[cfg(feature = "yaml")]
        Format::Yaml => parse_yaml(resp),
        _ => parse_json(resp),
    }
}

fn parse_json(resp: &str) -> Result<Joke> {
    let joke_resp: JokeResponse = serde_json::from_str(resp)?;

    if joke_resp.error {
        Err(Error::ApiResponse("error:true".to_string()))
    } else {
        Ok(joke_resp.joke())
    }
}

#[cfg(feature = "yaml")]
fn parse_yaml(resp: &str) -> Result<Joke> {
    let joke_resp: JokeResponse = serde_yaml::from_str(resp)?;
    Ok(joke_resp.joke())
}

#[derive(Debug, Deserialize)]
struct JokeResponse {
    error: bool,
    #[serde(rename = "type")]
    joke_type: JokeType,
    // Single joke
    joke: Option<String>,
    // Two-part joke
    setup: Option<String>,
    delivery: Option<String>,
}

impl JokeResponse {
    pub fn joke(&self) -> Joke {
        match self.joke_type {
            JokeType::Single => Joke::Single(self.joke.clone().unwrap()),
            JokeType::Twopart => {
                Joke::Twopart(self.setup.clone().unwrap(), self.delivery.clone().unwrap())
            }
        }
    }
}

impl fmt::Display for Joke {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::Single(joke) => write!(f, "{}", joke),
            Self::Twopart(setup, delivery) => write!(f, "{}\n{}", setup, delivery),
        }
    }
}