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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use crate::api_types::{compile, download, execute, fmt, share};
use serde::{de::DeserializeOwned, Deserialize, Serialize};

pub const BASE_URL: &str = "https://play.rust-lang.org/";
const PATH_EXECUTE: &str = "execute";
const PATH_COMPILE: &str = "compile";
const PATH_FMT: &str = "format";
const PATH_SHARE: &str = "meta/gist";
const PATH_DL: &str = "meta/gist";

pub trait API {
    fn execute(
        &self,
        req: execute::Request,
    ) -> Result<execute::Response, Box<dyn std::error::Error>>;
    fn compile(
        &self,
        req: compile::Request,
    ) -> Result<compile::Response, Box<dyn std::error::Error>>;

    fn fmt(&self, req: fmt::Request) -> Result<fmt::Response, Box<dyn std::error::Error>>;

    fn share(&self, req: share::Request) -> Result<share::Response, Box<dyn std::error::Error>>;

    fn download(
        &self,
        req: download::Request,
    ) -> Result<download::Response, Box<dyn std::error::Error>>;
}

pub struct APIClient {
    base_url: String,
}

impl APIClient {
    pub fn new() -> APIClient {
        APIClient {
            base_url: BASE_URL.to_string(),
        }
    }

    fn get<D>(&self, path: &str) -> Result<D, Box<dyn std::error::Error>>
    where
        D: DeserializeOwned,
    {
        let url = self.base_url.clone() + path;
        let res: D = reqwest::blocking::get(url)?.json()?;

        Ok(res)
    }

    fn post<S, D>(&self, path: &str, body: S) -> Result<D, Box<dyn std::error::Error>>
    where
        S: Serialize,
        D: DeserializeOwned,
    {
        let url = self.base_url.clone() + path;
        let client = reqwest::blocking::Client::new();
        let res: D = client.post(url).json(&body).send()?.json()?;

        Ok(res)
    }
}

impl API for APIClient {
    fn execute(
        &self,
        req: execute::Request,
    ) -> Result<execute::Response, Box<dyn std::error::Error>> {
        let res: execute::Response = self.post(PATH_EXECUTE, req)?;
        Ok(res)
    }

    fn compile(
        &self,
        req: compile::Request,
    ) -> Result<compile::Response, Box<dyn std::error::Error>> {
        let res: compile::Response = self.post(PATH_COMPILE, req)?;
        Ok(res)
    }

    fn fmt(&self, req: fmt::Request) -> Result<fmt::Response, Box<dyn std::error::Error>> {
        let res: fmt::Response = self.post(PATH_FMT, req)?;
        Ok(res)
    }

    fn share(&self, req: share::Request) -> Result<share::Response, Box<dyn std::error::Error>> {
        let res: share::Response = self.post(PATH_SHARE, req)?;
        Ok(res)
    }

    fn download(
        &self,
        req: download::Request,
    ) -> Result<download::Response, Box<dyn std::error::Error>> {
        let path = format!("{}/{}", PATH_DL, req.id);
        let res: download::Response = self.get(&path)?;

        Ok(res)
    }
}