nu_serde/
lib.rs

1//! Convert any value implementing `serde::Serialize` into a
2//! `nu_protocol::Value` using `nu_serde::to_value`. Compare the below manual
3//! implemeentation and the one using `nu_serde`.
4//!
5//! ```
6//! use nu_protocol::{Dictionary, Primitive, UntaggedValue, Value};
7//! use nu_source::Tag;
8//! use serde::Serialize;
9//!
10//! #[derive(Serialize)]
11//! struct MyStruct {
12//!     index: usize,
13//!     name: String,
14//! }
15//!
16//! fn manual(s: MyStruct, tag: Tag) -> Value {
17//!     let mut dict = Dictionary::default();
18//!     dict.insert(
19//!         "index".into(),
20//!         Value {
21//!             value: UntaggedValue::Primitive(Primitive::Int(s.index as i64)),
22//!             tag: tag.clone(),
23//!         },
24//!     );
25//!     dict.insert(
26//!         "name".into(),
27//!         Value {
28//!             value: UntaggedValue::Primitive(Primitive::String(s.name)),
29//!             tag: tag.clone(),
30//!         },
31//!     );
32//!
33//!     Value {
34//!         value: UntaggedValue::Row(dict),
35//!         tag,
36//!     }
37//! }
38//!
39//! fn auto(s: &MyStruct, tag: Tag) -> Value {
40//!     nu_serde::to_value(s, tag).unwrap()
41//! }
42//! ```
43
44use bigdecimal::{BigDecimal, FromPrimitive};
45use nu_protocol::value::dict::Dictionary;
46use nu_protocol::{Primitive, ReturnSuccess, ReturnValue, UntaggedValue, Value};
47use nu_source::Tag;
48use serde::Serialize;
49
50#[cfg(test)]
51mod test;
52
53#[derive(Debug, thiserror::Error, Serialize)]
54pub enum Error {
55    #[error("{0}")]
56    SerdeCustom(String),
57
58    #[error("Expceted serializer to provide map implementation with a key before value")]
59    MapValueLackedKey,
60
61    #[error("Expceted map key to be string, found {0:?}")]
62    InvalidMapKey(Value),
63
64    #[error("Failed to convert f32 value into BigDecimal")]
65    F32BigDecimalError(f32),
66
67    #[error("Failed to convert f64 value into BigDecimal")]
68    F64BigDecimalError(f64),
69}
70
71impl serde::ser::Error for Error {
72    fn custom<T>(msg: T) -> Self
73    where
74        T: std::fmt::Display,
75    {
76        Self::SerdeCustom(msg.to_string())
77    }
78}
79
80/// Convert any value into a `nu_protocol::Value`
81pub fn to_value<T>(value: T, tag: impl Into<Tag>) -> Result<Value, Error>
82where
83    T: Serialize,
84{
85    value.serialize(&Serializer { tag: tag.into() })
86}
87
88/// Convenience function that takes an iterator over values and turns them into
89/// a `Vec<ReturnValue>` (all successful). This is necessary for the return
90/// signatures of most functions in the `nu_plugin::Plugin` trait.
91pub fn to_success_return_values<T>(
92    values: impl IntoIterator<Item = T>,
93    tag: impl Into<Tag>,
94) -> Result<Vec<ReturnValue>, Error>
95where
96    T: Serialize,
97{
98    let tag = tag.into();
99
100    let mut out_values = Vec::new();
101
102    for value in values {
103        let value = to_value(&value, &tag)?;
104
105        out_values.push(ReturnValue::Ok(ReturnSuccess::Value(value)));
106    }
107
108    Ok(out_values)
109}
110
111struct Serializer {
112    tag: Tag,
113}
114
115struct SeqSerializer<'a> {
116    seq: Vec<Value>,
117    serializer: &'a Serializer,
118}
119
120struct MapSerializer<'a> {
121    dict: Dictionary,
122    serializer: &'a Serializer,
123    current_key: Option<String>,
124}
125
126impl Serializer {
127    fn value(&self, untagged: UntaggedValue) -> Value {
128        Value {
129            value: untagged,
130            tag: self.tag.clone(),
131        }
132    }
133}
134
135impl<'a> serde::ser::SerializeSeq for SeqSerializer<'a> {
136    type Ok = Value;
137    type Error = Error;
138
139    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
140    where
141        T: Serialize,
142    {
143        self.seq.push(value.serialize(self.serializer)?);
144
145        Ok(())
146    }
147
148    fn end(self) -> Result<Self::Ok, Self::Error> {
149        Ok(self.serializer.value(UntaggedValue::Table(self.seq)))
150    }
151}
152
153impl<'a> serde::ser::SerializeTuple for SeqSerializer<'a> {
154    type Ok = Value;
155    type Error = Error;
156
157    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
158    where
159        T: Serialize,
160    {
161        self.seq.push(value.serialize(self.serializer)?);
162
163        Ok(())
164    }
165
166    fn end(self) -> Result<Self::Ok, Self::Error> {
167        Ok(self.serializer.value(UntaggedValue::Table(self.seq)))
168    }
169}
170
171impl<'a> serde::ser::SerializeTupleStruct for SeqSerializer<'a> {
172    type Ok = Value;
173    type Error = Error;
174
175    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
176    where
177        T: Serialize,
178    {
179        self.seq.push(value.serialize(self.serializer)?);
180
181        Ok(())
182    }
183
184    fn end(self) -> Result<Self::Ok, Self::Error> {
185        Ok(self.serializer.value(UntaggedValue::Table(self.seq)))
186    }
187}
188
189impl<'a> serde::ser::SerializeTupleVariant for SeqSerializer<'a> {
190    type Ok = Value;
191
192    type Error = Error;
193
194    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
195    where
196        T: Serialize,
197    {
198        self.seq.push(value.serialize(self.serializer)?);
199
200        Ok(())
201    }
202
203    fn end(self) -> Result<Self::Ok, Self::Error> {
204        Ok(self.serializer.value(UntaggedValue::Table(self.seq)))
205    }
206}
207
208impl<'a> serde::ser::SerializeMap for MapSerializer<'a> {
209    type Ok = Value;
210    type Error = Error;
211
212    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
213    where
214        T: Serialize,
215    {
216        let key_value = key.serialize(self.serializer)?;
217
218        let key = match key_value.value {
219            UntaggedValue::Primitive(Primitive::String(s)) => s,
220            _ => return Err(Error::InvalidMapKey(key_value)),
221        };
222
223        self.current_key = Some(key);
224
225        Ok(())
226    }
227
228    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
229    where
230        T: Serialize,
231    {
232        let key = self.current_key.take().ok_or(Error::MapValueLackedKey)?;
233
234        self.dict.insert(key, value.serialize(self.serializer)?);
235
236        Ok(())
237    }
238
239    fn end(self) -> Result<Self::Ok, Self::Error> {
240        Ok(self.serializer.value(UntaggedValue::Row(self.dict)))
241    }
242}
243
244impl<'a> serde::ser::SerializeStruct for MapSerializer<'a> {
245    type Ok = Value;
246
247    type Error = Error;
248
249    fn serialize_field<T: ?Sized>(
250        &mut self,
251        key: &'static str,
252        value: &T,
253    ) -> Result<(), Self::Error>
254    where
255        T: Serialize,
256    {
257        self.dict
258            .insert(key.to_owned(), value.serialize(self.serializer)?);
259
260        Ok(())
261    }
262
263    fn end(self) -> Result<Self::Ok, Self::Error> {
264        Ok(self.serializer.value(UntaggedValue::Row(self.dict)))
265    }
266}
267
268impl<'a> serde::ser::SerializeStructVariant for MapSerializer<'a> {
269    type Ok = Value;
270
271    type Error = Error;
272
273    fn serialize_field<T: ?Sized>(
274        &mut self,
275        key: &'static str,
276        value: &T,
277    ) -> Result<(), Self::Error>
278    where
279        T: Serialize,
280    {
281        self.dict
282            .insert(key.to_owned(), value.serialize(self.serializer)?);
283
284        Ok(())
285    }
286
287    fn end(self) -> Result<Self::Ok, Self::Error> {
288        Ok(self.serializer.value(UntaggedValue::Row(self.dict)))
289    }
290}
291
292impl<'a> SeqSerializer<'a> {
293    fn new(serializer: &'a Serializer) -> Self {
294        Self {
295            seq: Vec::new(),
296            serializer,
297        }
298    }
299}
300
301impl<'a> MapSerializer<'a> {
302    fn new(serializer: &'a Serializer) -> Self {
303        Self {
304            dict: Dictionary::default(),
305            current_key: None,
306            serializer,
307        }
308    }
309}
310
311impl<'a> serde::Serializer for &'a Serializer {
312    type Ok = Value;
313    type Error = Error;
314
315    type SerializeSeq = SeqSerializer<'a>;
316    type SerializeTuple = SeqSerializer<'a>;
317    type SerializeTupleStruct = SeqSerializer<'a>;
318    type SerializeTupleVariant = SeqSerializer<'a>;
319    type SerializeMap = MapSerializer<'a>;
320    type SerializeStruct = MapSerializer<'a>;
321    type SerializeStructVariant = MapSerializer<'a>;
322
323    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
324        Ok(self.value(UntaggedValue::Primitive(Primitive::Boolean(v))))
325    }
326
327    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
328        Ok(self.value(UntaggedValue::Primitive(Primitive::Int(v as i64))))
329    }
330
331    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
332        Ok(self.value(UntaggedValue::Primitive(Primitive::Int(v as i64))))
333    }
334
335    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
336        Ok(self.value(UntaggedValue::Primitive(Primitive::Int(v as i64))))
337    }
338
339    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
340        Ok(self.value(UntaggedValue::Primitive(Primitive::Int(v as i64))))
341    }
342
343    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
344        Ok(self.value(UntaggedValue::Primitive(Primitive::Int(v as i64))))
345    }
346
347    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
348        Ok(self.value(UntaggedValue::Primitive(Primitive::Int(v as i64))))
349    }
350
351    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
352        Ok(self.value(UntaggedValue::Primitive(Primitive::Int(v as i64))))
353    }
354
355    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
356        Ok(self.value(UntaggedValue::Primitive(Primitive::BigInt(v.into()))))
357    }
358
359    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
360        Ok(self.value(UntaggedValue::Primitive(Primitive::Decimal(
361            BigDecimal::from_f32(v).ok_or(Error::F32BigDecimalError(v))?,
362        ))))
363    }
364
365    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
366        Ok(self.value(UntaggedValue::Primitive(Primitive::Decimal(
367            BigDecimal::from_f64(v).ok_or(Error::F64BigDecimalError(v))?,
368        ))))
369    }
370
371    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
372        Ok(self.value(UntaggedValue::Primitive(Primitive::String(v.into()))))
373    }
374
375    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
376        Ok(self.value(UntaggedValue::Primitive(Primitive::String(v.into()))))
377    }
378
379    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
380        Ok(self.value(UntaggedValue::Primitive(Primitive::Binary(v.into()))))
381    }
382
383    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
384        Ok(self.value(UntaggedValue::Primitive(Primitive::Nothing)))
385    }
386
387    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
388    where
389        T: Serialize,
390    {
391        value.serialize(self)
392    }
393
394    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
395        // TODO: is this OK?
396        Ok(self.value(UntaggedValue::Primitive(Primitive::Nothing)))
397    }
398
399    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
400        // TODO: is this OK?
401        Ok(self.value(UntaggedValue::Primitive(Primitive::Nothing)))
402    }
403
404    fn serialize_unit_variant(
405        self,
406        _name: &'static str,
407        _variant_index: u32,
408        _variant: &'static str,
409    ) -> Result<Self::Ok, Self::Error> {
410        // TODO: is this OK?
411        Ok(self.value(UntaggedValue::Primitive(Primitive::Nothing)))
412    }
413
414    fn serialize_newtype_struct<T: ?Sized>(
415        self,
416        _name: &'static str,
417        value: &T,
418    ) -> Result<Self::Ok, Self::Error>
419    where
420        T: Serialize,
421    {
422        value.serialize(self)
423    }
424
425    fn serialize_newtype_variant<T: ?Sized>(
426        self,
427        _name: &'static str,
428        _variant_index: u32,
429        _variant: &'static str,
430        value: &T,
431    ) -> Result<Self::Ok, Self::Error>
432    where
433        T: Serialize,
434    {
435        value.serialize(self)
436    }
437
438    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
439        Ok(SeqSerializer::new(self))
440    }
441
442    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
443        Ok(SeqSerializer::new(self))
444    }
445
446    fn serialize_tuple_struct(
447        self,
448        _name: &'static str,
449        _len: usize,
450    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
451        Ok(SeqSerializer::new(self))
452    }
453
454    fn serialize_tuple_variant(
455        self,
456        _name: &'static str,
457        _variant_index: u32,
458        _variant: &'static str,
459        _len: usize,
460    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
461        Ok(SeqSerializer::new(self))
462    }
463
464    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
465        Ok(MapSerializer::new(self))
466    }
467
468    fn serialize_struct(
469        self,
470        _name: &'static str,
471        _len: usize,
472    ) -> Result<Self::SerializeStruct, Self::Error> {
473        Ok(MapSerializer::new(self))
474    }
475
476    fn serialize_struct_variant(
477        self,
478        _name: &'static str,
479        _variant_index: u32,
480        _variant: &'static str,
481        _len: usize,
482    ) -> Result<Self::SerializeStructVariant, Self::Error> {
483        Ok(MapSerializer::new(self))
484    }
485}
nu_serde/lib.rs

nu_serde/
lib.rs
