qs_rust 1.0.2

A query string encoding and decoding library for Rust. Ported from qs for JavaScript.
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
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

//! `time` integration helpers for encoding temporal values.

use time::{Date, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};

use crate::error::EncodeError;
use crate::options::EncodeOptions;
use crate::temporal::{DateTimeValue, TemporalValue, TemporalValueError};
use crate::value::{Object, Value};

/// Converts an [`OffsetDateTime`] into the crate's [`Value`] representation.
///
/// The resulting value is a core [`crate::Value::Temporal`] leaf.
pub fn to_value(value: &OffsetDateTime) -> Value {
    Value::Temporal(TemporalValue::from(*value))
}

/// Encodes an [`OffsetDateTime`] at a single root key.
///
/// # Errors
///
/// Returns [`EncodeError`] when the supplied [`EncodeOptions`] are invalid.
pub fn encode_at_key(
    key: impl Into<String>,
    value: &OffsetDateTime,
    options: &EncodeOptions,
) -> Result<String, EncodeError> {
    let mut root = Object::new();
    root.insert(key.into(), to_value(value));
    crate::encode(&Value::Object(root), options)
}

impl From<OffsetDateTime> for TemporalValue {
    fn from(value: OffsetDateTime) -> Self {
        let date = value.date();
        let time = value.time();
        Self::DateTime(
            DateTimeValue::new(
                date.year(),
                u8::from(date.month()),
                date.day(),
                time.hour(),
                time.minute(),
                time.second(),
                time.nanosecond(),
                Some(value.offset().whole_seconds()),
            )
            .expect("time::OffsetDateTime values should map to valid temporal leaves"),
        )
    }
}

impl From<PrimitiveDateTime> for TemporalValue {
    fn from(value: PrimitiveDateTime) -> Self {
        let date = value.date();
        let time = value.time();
        Self::DateTime(
            DateTimeValue::new(
                date.year(),
                u8::from(date.month()),
                date.day(),
                time.hour(),
                time.minute(),
                time.second(),
                time.nanosecond(),
                None,
            )
            .expect("time::PrimitiveDateTime values should map to valid temporal leaves"),
        )
    }
}

impl TryFrom<&TemporalValue> for OffsetDateTime {
    type Error = TemporalValueError;

    fn try_from(value: &TemporalValue) -> Result<Self, Self::Error> {
        let datetime = value.as_datetime().ok_or(TemporalValueError::OutOfRange)?;
        let offset_seconds = datetime
            .offset_seconds()
            .ok_or(TemporalValueError::MissingOffset)?;
        let month =
            Month::try_from(datetime.month()).map_err(|_| TemporalValueError::OutOfRange)?;
        let date = Date::from_calendar_date(datetime.year(), month, datetime.day())
            .map_err(|_| TemporalValueError::OutOfRange)?;
        let time = Time::from_hms_nano(
            datetime.hour(),
            datetime.minute(),
            datetime.second(),
            datetime.nanosecond(),
        )
        .map_err(|_| TemporalValueError::OutOfRange)?;
        let offset = UtcOffset::from_whole_seconds(offset_seconds)
            .map_err(|_| TemporalValueError::OutOfRange)?;
        Ok(PrimitiveDateTime::new(date, time).assume_offset(offset))
    }
}

impl TryFrom<&TemporalValue> for PrimitiveDateTime {
    type Error = TemporalValueError;

    fn try_from(value: &TemporalValue) -> Result<Self, Self::Error> {
        let datetime = value.as_datetime().ok_or(TemporalValueError::OutOfRange)?;
        if datetime.offset_seconds().is_some() {
            return Err(TemporalValueError::UnexpectedOffset);
        }

        let month =
            Month::try_from(datetime.month()).map_err(|_| TemporalValueError::OutOfRange)?;
        let date = Date::from_calendar_date(datetime.year(), month, datetime.day())
            .map_err(|_| TemporalValueError::OutOfRange)?;
        let time = Time::from_hms_nano(
            datetime.hour(),
            datetime.minute(),
            datetime.second(),
            datetime.nanosecond(),
        )
        .map_err(|_| TemporalValueError::OutOfRange)?;
        Ok(PrimitiveDateTime::new(date, time))
    }
}

#[cfg(test)]
mod tests;