feat(serde): ser./deser. Path and Paths

Add serde derive Serialize/Deserialize when serde feature is active.

---------

Co-authored-by: Fredrik Söderström <tirithen@gmail.com>

Author: msvbg

.github/workflows/test.yml

@@ -4,14 +4,30 @@ on:
   pull_request:
 
 jobs:
-  test:
-    name: cargo test
+  test_all_features:
+    name: cargo test (all features)
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - uses: actions-rust-lang/setup-rust-toolchain@v1
       - run: cargo test --all-features
 
+  test_no_features:
+    name: cargo test (no features)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+      - run: cargo test
+
+  test_serde_feature:
+    name: cargo test (serde)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+      - run: cargo test --features serde
+
   # Check formatting with rustfmt
   formatting:
     name: cargo fmt

Cargo.lock

@@ -14,15 +14,18 @@ categories = ["algorithms"]
 [features]
 default = ["doc-images"]
 doc-images = []
+serde = ["dep:serde", "clipper2c-sys/serde"]
 
 [dependencies]
 libc = "0.2"
-clipper2c-sys = "0.1.1"
+clipper2c-sys = "0.1.2"
 thiserror = "1.0.59"
+serde = { version = "1", features = ["derive"], optional = true }
 
 [dev-dependencies]
 macroquad = "0.4.5"
 embed-doc-image = "0.1"
+serde_json = "1"
 
 [package.metadata.docs.rs]
 # docs.rs uses a nightly compiler, so by instructing it to use our `doc-images` feature we

Cargo.toml

@@ -19,7 +19,12 @@ use crate::{
 /// let path_from_tuples: Path = vec![(0.0, 0.0), (5.0, 0.0), (5.0, 6.0), (0.0, 6.0)].into();
 /// let path_from_slices: Path = vec![[0.0, 0.0], [5.0, 0.0], [5.0, 6.0], [0.0, 6.0]].into();
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(bound = "P: PointScaler")
+)]
 pub struct Path<P: PointScaler = Centi>(Vec<Point<P>>);
 
 impl<P: PointScaler> Path<P> {
@@ -421,4 +426,15 @@ mod test {
         let area = path.signed_area();
         assert_eq!(area, -1200.0);
     }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_serde() {
+        let path = Path::<Centi>::from(vec![(0.0, 0.0), (1.0, 1.0)]);
+        let serialized = serde_json::to_string(&path).unwrap();
+        assert_eq!(serialized, r#"[{"x":0,"y":0},{"x":100,"y":100}]"#);
+
+        let deserialized: Path<Centi> = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, path);
+    }
 }

src/path.rs

@@ -19,7 +19,12 @@ use crate::{
 /// let paths_from_single_vec: Paths = vec![(0.0, 0.0), (5.0, 0.0), (5.0, 6.0), (0.0, 6.0)].into();
 /// let paths_from_vec_of_vecs: Paths = vec![vec![(0.0, 0.0), (5.0, 0.0), (5.0, 6.0), (0.0, 6.0)]].into();
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(bound = "P: PointScaler")
+)]
 pub struct Paths<P: PointScaler = Centi>(Vec<Path<P>>);
 
 impl<P: PointScaler> Paths<P> {
@@ -453,4 +458,15 @@ mod test {
         let area = paths.signed_area();
         assert_eq!(area, 6000.0);
     }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_serde() {
+        let paths = Paths::<Centi>::from(vec![(0.4, 0.0), (5.0, 1.0)]);
+        let serialized = serde_json::to_string(&paths).unwrap();
+        assert_eq!(serialized, r#"[[{"x":40,"y":0},{"x":500,"y":100}]]"#);
+
+        let deserialized: Paths<Centi> = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, paths);
+    }
 }

src/paths.rs

@@ -25,31 +25,31 @@ pub trait PointScaler: Clone + Copy {
 }
 
 /// No scaling.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct One;
 
 impl PointScaler for One {
     const MULTIPLIER: f64 = 1.0;
 }
 
 /// Scale by 10.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct Deci;
 
 impl PointScaler for Deci {
     const MULTIPLIER: f64 = 10.0;
 }
 
 /// Scale by 100. This is the default.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct Centi;
 
 impl PointScaler for Centi {
     const MULTIPLIER: f64 = 100.0;
 }
 
 /// Scale by 1000.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct Milli;
 
 impl PointScaler for Milli {
@@ -85,7 +85,16 @@ impl PointScaler for Milli {
 /// assert_eq!(point.y_scaled(), 2000);
 /// ```
 #[derive(Debug, Copy, Clone)]
-pub struct Point<P: PointScaler = Centi>(ClipperPoint64, PhantomData<P>);
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(transparent),
+    serde(bound = "P: PointScaler")
+)]
+pub struct Point<P: PointScaler = Centi>(
+    ClipperPoint64,
+    #[cfg_attr(feature = "serde", serde(skip))] PhantomData<P>,
+);
 
 impl<P: PointScaler> Point<P> {
     /// The zero point.
@@ -239,4 +248,15 @@ mod test {
         assert_eq!(point.x_scaled(), 2000);
         assert_eq!(point.y_scaled(), 4000);
     }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_serde() {
+        let point = Point::<Centi>::new(1.0, 2.0);
+        let serialized = serde_json::to_string(&point).unwrap();
+        assert_eq!(serialized, r#"{"x":100,"y":200}"#);
+
+        let deserialized: Point<Centi> = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(point, deserialized);
+    }
 }