Repository navigation
Expand file tree
/
Copy pathremote_node_index.rs
More file actions
115 lines (102 loc) 路 3.26 KB
/
Copy pathremote_node_index.rs
File metadata and controls
115 lines (102 loc) 路 3.26 KB
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
use crate::{pretty_serde::DecodeError, version::Version};
use serde::Deserialize;
use url::Url;
mod lts_status {
use serde::{Deserialize, Deserializer};
#[derive(Deserialize, Debug, PartialEq, Eq)]
#[serde(untagged)]
enum LtsStatus {
Nope(bool),
Yes(String),
}
impl From<LtsStatus> for Option<String> {
fn from(status: LtsStatus) -> Self {
match status {
LtsStatus::Nope(_) => None,
LtsStatus::Yes(x) => Some(x),
}
}
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
where
D: Deserializer<'de>,
{
Ok(LtsStatus::deserialize(deserializer)?.into())
}
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
#[derive(Deserialize)]
struct TestSubject {
#[serde(deserialize_with = "deserialize")]
lts: Option<String>,
}
#[test]
fn test_false_deserialization() {
let json = serde_json::json!({ "lts": false });
let subject: TestSubject =
serde_json::from_value(json).expect("Can't deserialize json");
assert_eq!(subject.lts, None);
}
#[test]
fn test_value_deserialization() {
let json = serde_json::json!({ "lts": "dubnium" });
let subject: TestSubject =
serde_json::from_value(json).expect("Can't deserialize json");
assert_eq!(subject.lts, Some("dubnium".into()));
}
}
}
#[derive(Deserialize, Debug)]
pub struct IndexedNodeVersion {
pub version: Version,
#[serde(with = "lts_status")]
pub lts: Option<String>,
// pub date: chrono::NaiveDate,
// pub files: Vec<String>,
}
#[derive(Debug, thiserror::Error, miette::Diagnostic)]
pub enum Error {
#[error("can't get remote versions file: {0}")]
#[diagnostic(transparent)]
Http(#[from] crate::http::Error),
#[error("can't decode remote versions file: {0}")]
#[diagnostic(transparent)]
Decode(#[from] DecodeError),
}
/// Prints
///
/// ```rust
/// use crate::remote_node_index::list;
/// ```
pub fn list(base_url: &Url) -> Result<Vec<IndexedNodeVersion>, Error> {
let base_url = base_url.as_str().trim_end_matches('/');
let index_json_url = format!("{base_url}/index.json");
let resp = crate::http::get(&index_json_url)?
.error_for_status()
.map_err(crate::http::Error::from)?;
let text = resp.text().map_err(crate::http::Error::from)?;
let mut value: Vec<IndexedNodeVersion> =
serde_json::from_str(&text[..]).map_err(|cause| DecodeError::from_serde(text, cause))?;
value.sort_by(|a, b| a.version.cmp(&b.version));
Ok(value)
}
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
#[test]
fn test_list() {
let base_url = Url::parse("https://nodejs.org/dist").unwrap();
let expected_version = Version::parse("12.0.0").unwrap();
let mut versions = list(&base_url).expect("Can't get HTTP data");
assert_eq!(
versions
.drain(..)
.find(|x| x.version == expected_version)
.map(|x| x.version),
Some(expected_version)
);
}
}