Put third party crates behind feature flags (#12)

.github/workflows/ci.yml

@@ -0,0 +1,78 @@
+name: Continuous integration
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+  pull_request:
+  merge_group:
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+
+  format:
+    name: Check format
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Check format
+        run: cargo fmt --all --check
+
+  check:
+    name: Check workspace
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Check workspace
+        run: cargo check --workspace
+
+  clippy:
+    name: Check clippy
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Run clippy
+        run: cargo clippy --all-targets --all-features --tests -- -D warnings
+
+  test:
+    name: Run tests
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Test with no features
+        run: cargo test --workspace
+
+      - name: Test with all features
+        run: cargo test --all-features --workspace

Cargo.toml

@@ -16,18 +16,21 @@ categories = ["encoding"]
 [workspace]
 members = ["derive"]
 
+[features]
+default = []
+
 [dependencies]
 bincode = "1.3.3"
-chrono = { version = "0.4.26", features = ["serde"] }
+chrono = { version = "0.4.26", features = ["serde"], optional = true }
 derive = { version = "0.5.0", package = "revision-derive", path = "derive" }
-geo = { version = "0.26.0", features = ["use-serde"] }
-ordered-float = "3"
-regex = "1.9.3"
-rust_decimal = "1.31.0"
+geo = { version = "0.26.0", features = ["use-serde"], optional = true }
+ordered-float = { version = "3", optional = true }
+regex = { version = "1.9.3", optional = true }
+roaring = { version = "0.10.2", features = ["serde"], optional = true }
+rust_decimal = { version = "1.31.0", optional = true }
 serde = "1.0.183"
 thiserror = "1.0.44"
-uuid = "1.4.1"
-roaring = { version = "0.10.2", features = ["serde"] }
+uuid = { version = "1.4.1", optional = true }
 
 [dev-dependencies]
 rand = "0.8.5"

src/implementations/chrono.rs

@@ -1,6 +1,8 @@
+#![cfg(feature = "chrono")]
+
 use super::super::Error;
 use super::super::Revisioned;
-use chrono::{offset::TimeZone, DateTime, Utc, NaiveDate, Datelike, NaiveTime, Timelike};
+use chrono::{offset::TimeZone, DateTime, Datelike, NaiveDate, NaiveTime, Timelike, Utc};
 
 impl Revisioned for DateTime<Utc> {
 	#[inline]
@@ -74,10 +76,10 @@ impl Revisioned for NaiveTime {
 
 #[cfg(test)]
 mod tests {
-	use chrono::{NaiveDate, NaiveTime};
 	use super::DateTime;
 	use super::Revisioned;
 	use super::Utc;
+	use chrono::{NaiveDate, NaiveTime};
 
 	#[test]
 	fn test_datetime_min() {
@@ -107,8 +109,7 @@ mod tests {
 		let mut mem: Vec<u8> = vec![];
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 3);
-		let out =
-			<NaiveDate as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
+		let out = <NaiveDate as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
 		assert_eq!(val, out);
 	}
 
@@ -118,8 +119,7 @@ mod tests {
 		let mut mem: Vec<u8> = vec![];
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 5);
-		let out =
-			<NaiveDate as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
+		let out = <NaiveDate as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
 		assert_eq!(val, out);
 	}
 
@@ -129,8 +129,7 @@ mod tests {
 		let mut mem: Vec<u8> = vec![];
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 4);
-		let out =
-			<NaiveTime as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
+		let out = <NaiveTime as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
 		assert_eq!(val, out);
 	}
 
@@ -140,8 +139,7 @@ mod tests {
 		let mut mem: Vec<u8> = vec![];
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 8);
-		let out =
-			<NaiveTime as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
+		let out = <NaiveTime as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
 		assert_eq!(val, out);
 	}
 }

src/implementations/decimal.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "rust_decimal")]
+
 use super::super::Error;
 use super::super::Revisioned;
 use rust_decimal::Decimal;

src/implementations/geo.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "geo")]
+
 use super::super::Error;
 use super::super::Revisioned;
 use bincode::Options;

src/implementations/notnan.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "ordered-float")]
+
 use super::super::Error;
 use super::super::Revisioned;
 use ordered_float::{Float, NotNan};
@@ -13,10 +15,8 @@ where
 
 	#[inline]
 	fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {
-		Ok(NotNan::new(
-            T::deserialize_revisioned(reader)?).map_err(|e| 
-            Error::Deserialize(format!("{:?}", e))
-        )?)
+		NotNan::new(T::deserialize_revisioned(reader)?)
+			.map_err(|e| Error::Deserialize(format!("{:?}", e)))
 	}
 
 	fn revision() -> u16 {
@@ -28,16 +28,15 @@ where
 mod tests {
 
 	use super::Revisioned;
-    use ordered_float::NotNan;
+	use ordered_float::NotNan;
 
 	#[test]
 	fn test_wrapping() {
 		let val: NotNan<f32> = NotNan::new(f32::MAX).unwrap();
 		let mut mem: Vec<u8> = vec![];
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 4);
-		let out =
-			<NotNan<f32> as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
+		let out = <NotNan<f32> as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
 		assert_eq!(val, out);
 	}
 }

src/implementations/regex.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "regex")]
+
 use super::super::Error;
 use super::super::Revisioned;
 use bincode::Options;

src/implementations/roaring.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "roaring")]
+
 use super::super::Error;
 use super::super::Revisioned;
 use roaring::{RoaringBitmap, RoaringTreemap};

src/implementations/trees.rs

@@ -8,7 +8,9 @@ use std::collections::HashSet;
 use std::hash::BuildHasher;
 use std::hash::Hash;
 
-impl<K: Revisioned + Eq + Hash, V: Revisioned, S: BuildHasher + Default> Revisioned for HashMap<K, V, S> {
+impl<K: Revisioned + Eq + Hash, V: Revisioned, S: BuildHasher + Default> Revisioned
+	for HashMap<K, V, S>
+{
 	#[inline]
 	fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {
 		self.len().serialize_revisioned(writer)?;
@@ -147,9 +149,9 @@ mod tests {
 
 	use super::BTreeMap;
 	use super::BTreeSet;
+	use super::BinaryHeap;
 	use super::HashMap;
 	use super::HashSet;
-	use super::BinaryHeap;
 	use super::Revisioned;
 
 	#[test]
@@ -189,8 +191,7 @@ mod tests {
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 11);
 		let out =
-			<HashSet<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice())
-				.unwrap();
+			<HashSet<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
 		assert_eq!(val, out);
 	}
 
@@ -203,8 +204,7 @@ mod tests {
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 11);
 		let out =
-			<BTreeSet<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice())
-				.unwrap();
+			<BTreeSet<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice()).unwrap();
 		assert_eq!(val, out);
 	}
 
@@ -216,9 +216,8 @@ mod tests {
 		let mut mem: Vec<u8> = vec![];
 		val.serialize_revisioned(&mut mem).unwrap();
 		assert_eq!(mem.len(), 11);
-		let out =
-			<BinaryHeap<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice())
-				.unwrap();
+		let out = <BinaryHeap<String> as Revisioned>::deserialize_revisioned(&mut mem.as_slice())
+			.unwrap();
 		assert_eq!(val.into_sorted_vec(), out.into_sorted_vec());
 	}
 }

src/implementations/uuid.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "uuid")]
+
 use super::super::Error;
 use super::super::Revisioned;
 use uuid::Uuid;

tests/test.rs

@@ -1,3 +1,6 @@
+#![allow(clippy::excessive_precision)]
+#![allow(clippy::box_collection)]
+
 use revision::revisioned;
 use revision::Error;
 use revision::Revisioned;