Add simplified arena allocator test

Author: soareschen

crates/cgp-serde-tests/src/tests/arena_simplified.rs

@@ -0,0 +1,123 @@
+use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
+use cgp::extra::handler::CanTryCompute;
+use cgp::prelude::*;
+use cgp_error_anyhow::{RaiseAnyhowError, UseAnyhowError};
+use cgp_serde::components::{CanDeserializeValue, ValueDeserializer, ValueDeserializerComponent};
+use cgp_serde::providers::{DeserializeExtend, DeserializeRecordFields, UseSerde};
+use cgp_serde_json::code::{DeserializeJson, SerializeJson};
+use cgp_serde_json::{DeserializeFromJsonString, SerializeToJsonString};
+use typed_arena::Arena;
+
+#[cgp_auto_getter]
+pub trait HasArena<'a, T: 'a> {
+    fn arena(&self) -> &&'a Arena<T>;
+}
+
+#[cgp_impl(new DeserializeAndAllocate)]
+impl<'de, 'a, Context, Value> ValueDeserializer<'de, &'a Value> for Context
+where
+    Context: HasArena<'a, Value> + CanDeserializeValue<'de, Value>,
+{
+    fn deserialize<D>(context: &Context, deserializer: D) -> Result<&'a Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = context.deserialize(deserializer)?;
+        let value = context.arena().alloc(value);
+
+        Ok(value)
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, HasFields, BuildField)]
+pub struct Coord {
+    pub x: u64,
+    pub y: u64,
+    pub z: u64,
+}
+
+#[derive(Debug, PartialEq, Eq, HasFields, BuildField)]
+pub struct Payload<'a> {
+    pub id: u64,
+    pub coords: Vec<&'a Coord>,
+}
+
+#[derive(HasField)]
+pub struct App<'a> {
+    pub arena: &'a Arena<Coord>,
+}
+
+delegate_components! {
+    <'a> App<'a> {
+        ErrorTypeProviderComponent:
+            UseAnyhowError,
+        ErrorRaiserComponent:
+            RaiseAnyhowError,
+        ValueDeserializerComponent:
+            UseDelegate<new DeserializeComponents {
+                u64: UseSerde,
+                Coord:
+                    DeserializeRecordFields,
+                <'a> &'a Coord:
+                    DeserializeAndAllocate,
+                <'a> Vec<&'a Coord>:
+                    DeserializeExtend,
+                <'a> Payload<'a>:
+                    DeserializeRecordFields,
+
+            }>,
+        TryComputerComponent:
+            UseDelegate<new JsonEncodingComponents {
+                SerializeJson:
+                    SerializeToJsonString,
+                <T> DeserializeJson<T>:
+                    DeserializeFromJsonString
+            }>,
+    }
+}
+
+check_components! {
+    <'a> CanUseApp for App<'a> {
+        ValueDeserializerComponent:
+            (Life<'a>, Coord),
+
+    }
+}
+
+check_components! {
+    <'de, 'a> CanDeserializeApp for App<'a> {
+        ValueDeserializerComponent: [
+            (Life<'de>, u64),
+            (Life<'de>, Coord),
+            (Life<'de>, &'a Coord),
+            (Life<'de>, Payload<'a>),
+        ]
+    }
+}
+
+#[test]
+fn test_deserialize_with_arena() {
+    let serialized = r#"
+{
+    "id": 8,
+    "coords": [
+        { "x": 1, "y": 2, "z": 3 },
+        { "x": 4, "y": 5, "z": 6 }
+    ]
+}
+"#;
+
+    let arena = Arena::new();
+    let app = App { arena: &arena };
+
+    let deserialized: Payload<'_> = app
+        .try_compute(PhantomData::<DeserializeJson<Payload<'_>>>, &serialized)
+        .unwrap();
+    assert_eq!(
+        deserialized,
+        Payload {
+            id: 8,
+            coords: vec![&Coord { x: 1, y: 2, z: 3 }, &Coord { x: 4, y: 5, z: 6 },]
+        }
+    );
+}

crates/cgp-serde-tests/src/tests/mod.rs

@@ -1,3 +1,4 @@
 pub mod arena;
+pub mod arena_simplified;
 pub mod basic;
 pub mod nested;

crates/cgp-serde-tests/src/tests/nested.rs

@@ -7,21 +7,21 @@ use cgp_serde_extra::providers::{
 };
 use chrono::{DateTime, TimeZone, Utc};
 
-#[derive(HasField, HasFields)]
+#[derive(CgpData)]
 pub struct EncryptedMessage {
     pub message_id: u64,
     pub author_id: u64,
     pub date: DateTime<Utc>,
     pub encrypted_data: Vec<u8>,
 }
 
-#[derive(HasField, HasFields)]
+#[derive(CgpData)]
 pub struct MessagesByTopic {
     pub encrypted_topic: Vec<u8>,
     pub messages: Vec<EncryptedMessage>,
 }
 
-#[derive(HasField, HasFields)]
+#[derive(CgpData)]
 pub struct MessagesArchive {
     pub decryption_key: Vec<u8>,
     pub messages_by_topics: Vec<MessagesByTopic>,
@@ -125,27 +125,29 @@ fn test_nested_serialization() {
     let archive = MessagesArchive {
         decryption_key: b"top-secret".into(),
         messages_by_topics: vec![MessagesByTopic {
-            encrypted_topic: b"secret-deals".into(),
+            encrypted_topic: b"All about CGP".into(),
             messages: vec![
                 EncryptedMessage {
                     message_id: 1,
-                    author_id: 1,
-                    date: Utc.with_ymd_and_hms(2025, 1, 1, 0, 0, 0).unwrap(),
-                    encrypted_data: b"buy 1 free 1".into(),
+                    author_id: 2,
+                    date: Utc.with_ymd_and_hms(2025, 11, 3, 14, 15, 0).unwrap(),
+                    encrypted_data: b"Hello from RustLab!".into(),
                 },
                 EncryptedMessage {
-                    message_id: 2,
+                    message_id: 4,
                     author_id: 8,
-                    date: Utc.with_ymd_and_hms(2025, 1, 1, 0, 0, 0).unwrap(),
-                    encrypted_data: b"sales start tomorrow".into(),
+                    date: Utc.with_ymd_and_hms(2025, 12, 19, 23, 45, 0).unwrap(),
+                    encrypted_data: b"One year anniversary!".into(),
                 },
             ],
         }],
     };
 
-    let serialized = serde_json::to_string(&SerializeWithContext::new(&AppA, &archive)).unwrap();
+    let serialized =
+        serde_json::to_string_pretty(&SerializeWithContext::new(&AppA, &archive)).unwrap();
     println!("serialized with A: {serialized}");
 
-    let serialized = serde_json::to_string(&SerializeWithContext::new(&AppB, &archive)).unwrap();
+    let serialized =
+        serde_json::to_string_pretty(&SerializeWithContext::new(&AppB, &archive)).unwrap();
     println!("serialized with B: {serialized}");
 }