feat: add optional serde and defmt derives for DecodeError

Feature-gated; the default and no_std builds stay dependency-free.

Author: ajsb85

Cargo.lock

@@ -22,17 +22,31 @@ exclude = ["/fuzz"]
 all-features = true
 rustdoc-args = ["--html-in-header", "docs/katex-header.html"]
 
+[dependencies]
+# Both are OPTIONAL and OFF by default, so the default build stays
+# zero-dependency and `no_std`. `serde` derives (de)serialization for the public
+# error type; `defmt` derives its `Format` for embedded logging. `serde` is
+# pulled with `default-features = false` so it keeps working in `no_std`.
+serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
+defmt = { version = "1", optional = true }
+
 [features]
 default = ["std"]
 # Enables the `*_to_vec` convenience functions and framing that allocate.
 alloc = []
 # Enables `std` (implies `alloc`). Reserved for future std-only conveniences.
 std = ["alloc"]
+# Optional ecosystem hooks; both stay off in the default build.
+serde = ["dep:serde"]
+defmt = ["dep:defmt"]
 
 [dev-dependencies]
 # Real Protocol Buffers, used only by the `protobuf_cobs` example. Dev-only, so
 # the published crate stays dependency-free for library users.
 prost = "0.14"
+# Used only by `tests/derives.rs` to round-trip an error through JSON and prove
+# the optional `serde` derive works.
+serde_json = "1"
 
 [lints.rust]
 missing_docs = "warn"

Cargo.toml

@@ -33,6 +33,8 @@ USB, TCP and other byte streams — ideal for embedded and robotics protocols.
   and `*_to_vec` conveniences.
 - **`const fn`** size helpers (`max_encoded_len`, `encoding_overhead`) for
   compile-time buffer sizing.
+- **Optional `serde` / `defmt`** — off by default; enable the matching feature
+  to derive `Serialize`/`Deserialize` or `defmt::Format` for `DecodeError`.
 
 ## Install
 

README.md

@@ -3,7 +3,13 @@
 use core::fmt;
 
 /// An error returned when decoding fails.
+///
+/// `serde::{Serialize, Deserialize}` and `defmt::Format` implementations are
+/// available behind the optional `serde` and `defmt` features, respectively;
+/// both are off by default.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[non_exhaustive]
 pub enum DecodeError {
     /// A zero (`0x00`) byte appeared in the encoded input; a valid COBS stream

src/error.rs

@@ -0,0 +1,25 @@
+//! Proves the optional `serde` derive on [`DecodeError`] works by round-tripping
+//! every variant through JSON.
+//!
+//! The whole file is gated on the `serde` feature, so without it the test crate
+//! is empty. Run it with `cargo test --features serde`.
+#![cfg(feature = "serde")]
+
+use cobs_codec_rs::DecodeError;
+
+/// Serializing then deserializing each variant must yield an equal value.
+#[test]
+fn decode_error_serde_json_round_trips() {
+    let cases = [
+        DecodeError::ZeroByte { index: 7 },
+        DecodeError::Truncated { index: 3 },
+        DecodeError::OutputTooSmall,
+        DecodeError::FrameTooLong { len: 42 },
+    ];
+
+    for original in cases {
+        let json = serde_json::to_string(&original).expect("serialize");
+        let restored: DecodeError = serde_json::from_str(&json).expect("deserialize");
+        assert_eq!(original, restored, "round-trip mismatch via {json}");
+    }
+}