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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
use crate::util::web::shorten_url;
use anyhow::{Context, Error, Result};
use futures::try_join;
use reqwest::{get, Url};
use serde::{Deserialize, Serialize};
use serde_json::Result as SerdeJsonResult;
#[derive(Serialize, Deserialize, Debug)]
struct WaResponse {
queryresult: QueryResult,
}
#[derive(Serialize, Deserialize, Debug)]
struct QueryResult {
pods: Vec<Pod>,
}
#[derive(Serialize, Deserialize, Debug)]
struct Pod {
title: String,
id: String,
primary: Option<bool>,
subpods: Vec<SubPod>,
}
#[derive(Serialize, Deserialize, Debug)]
struct SubPod {
plaintext: String,
}
fn parse_json(str_data: &str) -> SerdeJsonResult<WaResponse> {
let w: WaResponse = serde_json::from_str(str_data)?;
Ok(w)
}
/// Reduces all 'pod' plaintexts to a single string.
/// Same as gonzobot does it.
fn to_single_string(wa_res: WaResponse) -> String {
wa_res
.queryresult
.pods
.iter()
.filter(|it| it.id.to_lowercase() != "input" && it.primary.is_some())
.map(|pod| {
let subpod_texts = pod
.subpods
.iter()
.map(|subpod| subpod.plaintext.clone())
.collect::<Vec<String>>()
.join(", ");
format!("{}: {}", &pod.title, subpod_texts)
})
.collect::<Vec<String>>()
.join(" - ")
}
fn get_url(query_str: &str, base_url: Option<&str>) -> String {
let app_id = "XXX"; // TODO: Get from env
let wa_url = "http://api.wolframalpha.com";
let api_url = format!(
"{}/v2/query?input={}&appid={}&output=json",
base_url.unwrap_or(wa_url),
query_str,
app_id
);
api_url
}
async fn send_wa_req(url: &str) -> Result<String, Error> {
let body = get(Url::parse(url).context("Failed to parse url")?)
.await
.context("Failed to make request")?
.text()
.await
.context("failed to get request response text")?;
Ok(body)
}
async fn handle_wa_req(url: &str) -> Result<WaResponse, Error> {
let res_body = send_wa_req(url).await?;
let parsed = parse_json(&res_body)?;
Ok(parsed)
}
/// Sends a request to the Wolfram Alpha API, returns a plain text response.
#[tracing::instrument]
async fn wa_query(query_str: &str, base_url: Option<&str>) -> Result<String, Error> {
let user_url = format!("http://www.wolframalpha.com/input/?i={}", query_str);
let user_url_shortened_fut = shorten_url(&user_url);
let url = get_url(query_str, base_url);
let wa_res_fut = handle_wa_req(&url);
// Can't just (foo.await, bar.await), smh
// https://rust-lang.github.io/async-book/06_multiple_futures/02_join.html
let (wa_res, user_url_shortened) = try_join!(wa_res_fut, user_url_shortened_fut)?;
Ok(format!(
"{} - {}",
&user_url_shortened,
to_single_string(wa_res)
))
}
#[cfg(test)]
mod tests {
use super::wa_query;
use anyhow::{Error, Result};
use mockito::{self, Matcher};
#[tokio::test]
async fn test_query_result_json_parsing() -> Result<(), Error> {
let body = include_str!("../../tests/resources/wolfram_alpha_api_response.json");
let _m = mockito::mock("GET", Matcher::Any)
// Trimmed down version of a full WA response:
.with_body(body)
.create();
mockito::start();
let res = wa_query("5/10", Some(&mockito::server_url())).await?;
let res_without_link = res.splitn(2, "-").collect::<Vec<&str>>()[1].trim();
assert_eq!(res_without_link, "Exact result: 1/2 - Decimal form: 0.5");
Ok(())
}
}
|
