playwright/imp/core/message/
ser.rs

1use crate::imp::{
2    core::{Guid, OnlyGuid},
3    prelude::*
4};
5use serde::ser;
6use std::{cell::RefCell, mem, rc::Rc};
7
8#[derive(Debug, thiserror::Error)]
9pub enum Error {
10    #[error("{0:}")]
11    Msg(String),
12    #[error("Couldn't construct map from odd number of values")]
13    OddMap,
14    #[error("Key must be string")]
15    InvalidKey,
16    #[error("Not supported")]
17    NotSupported,
18    #[error("Failed to serialize JsHandle")]
19    JsHandle,
20    #[error("Failed to serialize DateTime")]
21    DateTime,
22    #[error(transparent)]
23    Serde(#[from] serde_json::error::Error)
24}
25
26impl serde::ser::Error for Error {
27    fn custom<T>(msg: T) -> Self
28    where
29        T: std::fmt::Display
30    {
31        Self::Msg(msg.to_string())
32    }
33}
34
35#[derive(Clone, Default)]
36pub(crate) struct Serializer {
37    handles: Rc<RefCell<Vec<OnlyGuid>>>,
38
39    seq: Vec<Seq>,
40    t: Vec<TupleVariant>,
41    om: Vec<ObjectM>,
42    os: Vec<ObjectS>,
43    s: Vec<StructVariant>
44}
45
46// XXX: None
47pub(crate) fn to_value<T>(x: &T) -> Result<Value, Error>
48where
49    T: Serialize
50{
51    let mut serializer = Serializer::default();
52    let value = x.serialize(&mut serializer)?;
53    let mut m = Map::new();
54    m.insert("value".into(), value);
55    m.insert(
56        "handles".into(),
57        serde_json::to_value(serializer.handles())?
58    );
59    Ok(m.into())
60}
61
62impl Serializer {
63    fn handles(self) -> Vec<OnlyGuid> { self.handles.take() }
64}
65
66fn convert_kv<M: IntoIterator<Item = (String, Value)>>(map: M) -> Map<String, Value> {
67    let entries = Value::Array(
68        map.into_iter()
69            .map(|(k, v)| {
70                let mut entry = Map::new();
71                entry.insert("k".into(), k.into());
72                entry.insert("v".into(), v);
73                Value::from(entry)
74            })
75            .collect()
76    );
77    let mut res = Map::new();
78    res.insert("o".into(), entries);
79    res
80}
81
82impl<'a> ser::Serializer for &'a mut Serializer {
83    type Ok = Value;
84    type Error = Error;
85
86    type SerializeSeq = &'a mut Seq;
87    type SerializeTuple = &'a mut Seq;
88    type SerializeTupleStruct = &'a mut Seq;
89    type SerializeTupleVariant = &'a mut TupleVariant;
90    type SerializeMap = &'a mut ObjectM;
91    type SerializeStruct = &'a mut ObjectS;
92    type SerializeStructVariant = &'a mut StructVariant;
93
94    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
95        let mut m = Map::new();
96        m.insert("b".into(), v.into());
97        Ok(m.into())
98    }
99
100    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
101        let mut m = Map::new();
102        m.insert("n".into(), v.into());
103        Ok(m.into())
104    }
105    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> { self.serialize_i64(v.into()) }
106    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> { self.serialize_i64(v.into()) }
107    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> { self.serialize_i64(v.into()) }
108
109    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
110        let mut m = Map::new();
111        m.insert("n".into(), v.into());
112        Ok(m.into())
113    }
114    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> { self.serialize_u64(v.into()) }
115    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> { self.serialize_u64(v.into()) }
116    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> { self.serialize_u64(v.into()) }
117
118    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
119        let mut m = Map::new();
120        if v.is_nan() {
121            m.insert("v".into(), "NaN".into())
122        } else if v.is_infinite() {
123            m.insert(
124                "v".into(),
125                if v.is_sign_negative() {
126                    "-Infinity"
127                } else {
128                    "Infinity"
129                }
130                .into()
131            )
132        } else if v.is_sign_negative() && v == -0.0 {
133            m.insert("v".into(), "-0".into())
134        } else {
135            m.insert("n".into(), v.into())
136        };
137        Ok(m.into())
138    }
139    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> { Ok(f64::from(v).into()) }
140
141    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
142        let mut m = Map::new();
143        m.insert("s".into(), v.into());
144        Ok(m.into())
145    }
146    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
147        let mut m = Map::new();
148        m.insert("s".into(), v.to_string().into());
149        Ok(m.into())
150    }
151
152    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
153        Err(Error::NotSupported)
154    }
155
156    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
157        let mut m = Map::new();
158        m.insert("v".into(), "null".into());
159        Ok(m.into())
160    }
161    fn serialize_some<T>(self, v: &T) -> Result<Self::Ok, Self::Error>
162    where
163        T: ?Sized + Serialize
164    {
165        v.serialize(self)
166    }
167    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
168        let mut m = Map::new();
169        m.insert("v".into(), "undefined".into());
170        Ok(m.into())
171    }
172    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
173        self.serialize_unit()
174    }
175
176    fn serialize_unit_variant(
177        self,
178        _name: &'static str,
179        _variant_index: u32,
180        variant: &'static str
181    ) -> Result<Self::Ok, Self::Error> {
182        self.serialize_str(variant)
183    }
184
185    fn serialize_newtype_struct<T>(
186        self,
187        _name: &'static str,
188        value: &T
189    ) -> Result<Self::Ok, Self::Error>
190    where
191        T: ?Sized + Serialize
192    {
193        value.serialize(self)
194    }
195
196    fn serialize_newtype_variant<T>(
197        self,
198        _name: &'static str,
199        _variant_index: u32,
200        variant: &'static str,
201        value: &T
202    ) -> Result<Self::Ok, Self::Error>
203    where
204        T: ?Sized + Serialize
205    {
206        let map = convert_kv(Some((variant.into(), value.serialize(self)?)));
207        Ok(map.into())
208    }
209
210    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
211        self.seq.push(Seq::new(self.clone()));
212        Ok(self.seq.last_mut().unwrap())
213    }
214
215    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeSeq, Self::Error> {
216        self.serialize_seq(Some(len))
217    }
218
219    fn serialize_tuple_struct(
220        self,
221        _name: &'static str,
222        len: usize
223    ) -> Result<Self::SerializeSeq, Self::Error> {
224        self.serialize_seq(Some(len))
225    }
226
227    fn serialize_tuple_variant(
228        self,
229        _name: &'static str,
230        _variant_index: u32,
231        variant: &'static str,
232        _len: usize
233    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
234        self.t.push(TupleVariant::new(self.clone(), variant));
235        Ok(self.t.last_mut().unwrap())
236    }
237
238    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
239        self.om.push(ObjectM::new(self.clone()));
240        Ok(self.om.last_mut().unwrap())
241    }
242
243    fn serialize_struct(
244        self,
245        name: &'static str,
246        _len: usize
247    ) -> Result<Self::SerializeStruct, Self::Error> {
248        self.os.push(ObjectS::new(self.clone(), name));
249        Ok(self.os.last_mut().unwrap())
250    }
251
252    fn serialize_struct_variant(
253        self,
254        _name: &'static str,
255        _variant_index: u32,
256        variant: &'static str,
257        _len: usize
258    ) -> Result<Self::SerializeStructVariant, Self::Error> {
259        self.s.push(StructVariant::new(self.clone(), variant));
260        Ok(self.s.last_mut().unwrap())
261    }
262}
263
264#[derive(Clone)]
265pub(crate) struct Seq {
266    values: Vec<Value>,
267    prime: Serializer
268}
269
270impl Seq {
271    fn new(prime: Serializer) -> Self {
272        Self {
273            values: Vec::new(),
274            prime
275        }
276    }
277}
278
279impl<'a> ser::SerializeSeq for &'a mut Seq {
280    type Ok = Value;
281    type Error = Error;
282
283    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
284    where
285        T: ?Sized + Serialize
286    {
287        self.values.push(value.serialize(&mut self.prime)?);
288        Ok(())
289    }
290
291    fn end(self) -> Result<Self::Ok, Self::Error> {
292        let mut m = Map::new();
293        let mut vs = Vec::new();
294        mem::swap(&mut self.values, &mut vs);
295        m.insert("a".into(), vs.into());
296        Ok(m.into())
297    }
298}
299
300impl<'a> ser::SerializeTuple for &'a mut Seq {
301    type Ok = Value;
302    type Error = Error;
303
304    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
305    where
306        T: ?Sized + Serialize
307    {
308        self.values.push(value.serialize(&mut self.prime)?);
309        Ok(())
310    }
311
312    fn end(self) -> Result<Self::Ok, Self::Error> {
313        let mut m = Map::new();
314        let mut vs = Vec::new();
315        mem::swap(&mut self.values, &mut vs);
316        m.insert("a".into(), vs.into());
317        Ok(m.into())
318    }
319}
320
321impl<'a> ser::SerializeTupleStruct for &'a mut Seq {
322    type Ok = Value;
323    type Error = Error;
324
325    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
326    where
327        T: ?Sized + Serialize
328    {
329        self.values.push(value.serialize(&mut self.prime)?);
330        Ok(())
331    }
332
333    fn end(self) -> Result<Self::Ok, Self::Error> {
334        let mut m = Map::new();
335        let mut vs = Vec::new();
336        mem::swap(&mut self.values, &mut vs);
337        m.insert("a".into(), vs.into());
338        Ok(m.into())
339    }
340}
341
342#[derive(Clone)]
343pub(crate) struct TupleVariant {
344    values: Vec<Value>,
345    variant: &'static str,
346    prime: Serializer
347}
348
349impl TupleVariant {
350    fn new(prime: Serializer, variant: &'static str) -> Self {
351        Self {
352            values: Vec::new(),
353            variant,
354            prime
355        }
356    }
357}
358
359impl<'a> ser::SerializeTupleVariant for &'a mut TupleVariant {
360    type Ok = Value;
361    type Error = Error;
362
363    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
364    where
365        T: ?Sized + Serialize
366    {
367        self.values.push(value.serialize(&mut self.prime)?);
368        Ok(())
369    }
370
371    fn end(self) -> Result<Self::Ok, Self::Error> {
372        let a = {
373            let mut a = Map::new();
374            let mut vs = Vec::new();
375            mem::swap(&mut self.values, &mut vs);
376            a.insert("a".into(), vs.into());
377            a
378        };
379        let o = convert_kv(Some((self.variant.into(), a.into())));
380        Ok(o.into())
381    }
382}
383
384#[derive(Clone)]
385pub(crate) struct ObjectS {
386    name: &'static str,
387    map: Map<String, Value>,
388    prime: Serializer,
389    guid: Option<Str<Guid>>,
390    d: Option<String>
391}
392
393#[derive(Clone)]
394pub(crate) struct ObjectM {
395    keys: Vec<String>,
396    values: Vec<Value>,
397    prime: Serializer,
398    turn: bool
399}
400
401impl ObjectS {
402    fn new(prime: Serializer, name: &'static str) -> Self {
403        Self {
404            name,
405            prime,
406            map: Map::new(),
407            guid: None,
408            d: None
409        }
410    }
411}
412
413impl ObjectM {
414    fn new(prime: Serializer) -> Self {
415        Self {
416            prime,
417            keys: Vec::new(),
418            values: Vec::new(),
419            turn: false
420        }
421    }
422}
423
424impl<'a> ser::SerializeStruct for &'a mut ObjectS {
425    type Ok = Value;
426    type Error = Error;
427
428    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
429    where
430        T: ?Sized + Serialize
431    {
432        let v = value.serialize(&mut self.prime)?;
433        if (self.name == "4a9c3811-6f00-49e5-8a81-939f932d9061"
434            || self.name == "fff9ae7f-9070-480f-9a8a-3d4b66923f7d")
435            && key == "guid"
436        {
437            let g = match v {
438                Value::Object(m) => {
439                    let (_, v) = m.into_iter().next().ok_or(Error::JsHandle)?;
440                    let s = match v {
441                        Value::String(s) => s,
442                        _ => return Err(Error::JsHandle)
443                    };
444                    Str::validate(s).unwrap()
445                }
446                _ => return Err(Error::JsHandle)
447            };
448            self.guid = Some(g);
449            return Ok(());
450        }
451        if self.name == "e7ee19d3-64cb-4286-8762-6dd8ab78eb89" && key == "d" {
452            let d = match v {
453                Value::Object(m) => {
454                    let (_, v) = m.into_iter().next().ok_or(Error::DateTime)?;
455                    match v {
456                        Value::String(s) => s,
457                        _ => return Err(Error::DateTime)
458                    }
459                }
460                _ => return Err(Error::JsHandle)
461            };
462            self.d = Some(d);
463            return Ok(());
464        }
465        self.map.insert(key.into(), v);
466        Ok(())
467    }
468
469    fn end(self) -> Result<Self::Ok, Self::Error> {
470        if self.name == "4a9c3811-6f00-49e5-8a81-939f932d9061"
471            || self.name == "fff9ae7f-9070-480f-9a8a-3d4b66923f7d"
472        {
473            let handles = &mut self.prime.handles.borrow_mut();
474            let guid = self.guid.take().ok_or(Error::JsHandle)?;
475            handles.push(OnlyGuid { guid });
476            let idx = handles.len() - 1;
477            let mut m = Map::new();
478            m.insert("h".into(), idx.into());
479            Ok(m.into())
480        } else if self.name == "e7ee19d3-64cb-4286-8762-6dd8ab78eb89" {
481            let d = self.d.take().ok_or(Error::DateTime)?;
482            let mut m = Map::new();
483            m.insert("d".into(), d.into());
484            Ok(m.into())
485        } else {
486            let mut m = Map::new();
487            mem::swap(&mut self.map, &mut m);
488            let o = convert_kv(m);
489            Ok(o.into())
490        }
491    }
492}
493
494impl<'a> ser::SerializeMap for &'a mut ObjectM {
495    type Ok = Value;
496    type Error = Error;
497
498    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
499    where
500        T: ?Sized + Serialize
501    {
502        if self.turn {
503            return Err(Error::OddMap);
504        }
505        let serialized = key.serialize(&mut self.prime)?;
506        let key = match serialized {
507            Value::String(s) => s,
508            _ => return Err(Error::InvalidKey)
509        };
510        self.keys.push(key);
511        self.turn = true;
512        Ok(())
513    }
514
515    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
516    where
517        T: ?Sized + Serialize
518    {
519        if !self.turn {
520            return Err(Error::OddMap);
521        }
522        self.values.push(value.serialize(&mut self.prime)?);
523        self.turn = false;
524        Ok(())
525    }
526
527    fn end(self) -> Result<Self::Ok, Self::Error> {
528        if self.turn {
529            return Err(Error::OddMap);
530        }
531        let mut ks = Vec::new();
532        let mut vs = Vec::new();
533        mem::swap(&mut self.keys, &mut ks);
534        mem::swap(&mut self.values, &mut vs);
535        let entries = ks.into_iter().zip(vs.into_iter());
536        let o = convert_kv(entries);
537        Ok(o.into())
538    }
539}
540
541#[derive(Clone)]
542pub(crate) struct StructVariant {
543    m: Map<String, Value>,
544    variant: &'static str,
545    prime: Serializer
546}
547
548impl StructVariant {
549    fn new(prime: Serializer, variant: &'static str) -> Self {
550        Self {
551            m: Map::new(),
552            variant,
553            prime
554        }
555    }
556}
557
558impl<'a> ser::SerializeStructVariant for &'a mut StructVariant {
559    type Ok = Value;
560    type Error = Error;
561
562    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
563    where
564        T: ?Sized + Serialize
565    {
566        self.m.insert(key.into(), value.serialize(&mut self.prime)?);
567        Ok(())
568    }
569
570    fn end(self) -> Result<Self::Ok, Self::Error> {
571        let mut m = Map::new();
572        mem::swap(&mut self.m, &mut m);
573        let inner = convert_kv(m);
574        let external = convert_kv(Some((self.variant.into(), inner.into())));
575        Ok(external.into())
576    }
577}
578
579#[cfg(test)]
580mod tests {
581    use super::*;
582
583    #[test]
584    fn r#struct() {
585        #[derive(Serialize)]
586        struct Test {
587            int: u32,
588            seq: Vec<&'static str>
589        }
590
591        let test = Test {
592            int: 1,
593            seq: vec!["a", "b"]
594        };
595        let expected = r#"{
596                "value":{"o":[{"k":"int","v":{"n":1}},{"k":"seq","v":{"a": [{"s":"a"},{"s":"b"}]}}]},
597                "handles":[]}"#;
598        let v: Value = serde_json::from_str(expected).unwrap();
599        dbg!(&v);
600        assert_eq!(to_value(&test).unwrap(), v);
601    }
602
603    #[test]
604    fn option() {
605        let expected = r#"{
606            "value":{"n":3},
607            "handles": []}"#;
608        let v: Value = serde_json::from_str(expected).unwrap();
609        assert_eq!(to_value(&Some(3)).unwrap(), v);
610        let expected = r#"{
611            "value":{"v":"null"},
612            "handles": []}"#;
613        let v: Value = serde_json::from_str(expected).unwrap();
614        assert_eq!(to_value(&Option::<i32>::None).unwrap(), v);
615    }
616
617    #[test]
618    fn r#enum() {
619        #[derive(Serialize)]
620        enum E {
621            Unit,
622            Newtype(u32),
623            Tuple(u32, u32),
624            Struct { a: u32 }
625        }
626
627        let u = E::Unit;
628        let expected = r#"{"value":{"s":"Unit"}, "handles":[]}"#;
629        let v: Value = serde_json::from_str(expected).unwrap();
630        assert_eq!(to_value(&u).unwrap(), v);
631
632        let u = E::Newtype(1);
633        let expected = r#"{"value":{"o":[{"k":"Newtype","v":{"n":1}}]}, "handles":[]}"#;
634        let v: Value = serde_json::from_str(expected).unwrap();
635        assert_eq!(to_value(&u).unwrap(), v);
636
637        let u = E::Tuple(1, 2);
638        let expected =
639            r#"{"value": {"o":[{"k":"Tuple","v":{"a":[{"n":1},{"n":2}]}}]}, "handles":[]}"#;
640        let v: Value = serde_json::from_str(expected).unwrap();
641        assert_eq!(to_value(&u).unwrap(), v);
642
643        let u = E::Struct { a: 1 };
644        let expected =
645            r#"{"value":{"o":[{"k":"Struct","v":{"o":[{"k":"a","v":{"n":1}}]}}]},"handles":[]}"#;
646        let v: Value = serde_json::from_str(expected).unwrap();
647        assert_eq!(to_value(&u).unwrap(), v);
648    }
649}
playwright/imp/core/message/ser.rs

playwright/imp/core/message/
ser.rs
