Merge pull request #58 from mina86/a

Make library no_std and introduce std and unstable features

Author: chipshort

CHANGELOG.md

@@ -9,10 +9,17 @@ project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Introduce `std` (enabled by default) and `unstable` features ([#58]).  They
+  enable corresponding serde’s features and if either is enabled, `Error`
+  implements `std::error::Error` trait.  By itself, `serde-json-wasm` is now
+  `no_std`; it’s up to serde’s features whether the entire build is.  **Please
+  note:** this potentially breaks `default-features = false` builds.
+
 - Serialize / deserialize `u128`/`i128` types as numbers instead of strings
   ([#59]).<br/> **Please note:** this breaks deserialization of `u128`/`i128`
   serialized with older versions of `serde-json-wasm`.
 
+[#58]: https://github.com/CosmWasm/serde-json-wasm/pull/58
 [#59]: https://github.com/CosmWasm/serde-json-wasm/pull/59
 
 ## [0.5.1] - 2023-04-11

Cargo.lock

@@ -23,8 +23,13 @@ exclude = [
 ]
 
 [dependencies]
-serde = { version = "^1.0.80", default-features = false, features = ["alloc"] }
+serde = { version = "^1.0.181", default-features = false, features = ["alloc"] }
 
 [dev-dependencies]
 serde_derive = "^1.0.80"
 serde_json = "^1.0.99"
+
+[features]
+default = ["std"]
+std = ["serde/std"]
+unstable = ["serde/unstable"]

Cargo.toml

@@ -1,10 +1,17 @@
+use alloc::string::{String, ToString};
+
 use serde::de;
-use std::{error, fmt};
 
 /// Deserialization result
 pub type Result<T> = core::result::Result<T, Error>;
 
-/// This type represents all possible errors that can occur when deserializing JSON data
+/// This type represents all possible errors that can occur when deserializing
+/// JSON data
+///
+/// It implements [`std::error::Error`] trait so long as either `std` or
+/// `unstable` features are enabled.  `std` is enabled by default and disabling
+/// it makes the crate `no_std`.  `unstable` makes it necessary to build code
+/// with nightly compiler.
 #[derive(Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Error {
@@ -72,27 +79,16 @@ pub enum Error {
     Custom(String),
 }
 
-impl error::Error for Error {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        None
-    }
-
-    fn description(&self) -> &str {
-        "(use display)"
-    }
-}
+impl de::StdError for Error {}
 
 impl de::Error for Error {
-    fn custom<T>(msg: T) -> Self
-    where
-        T: fmt::Display,
-    {
+    fn custom<T: core::fmt::Display>(msg: T) -> Self {
         Error::Custom(msg.to_string())
     }
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "{}",

src/de/errors.rs

@@ -6,14 +6,15 @@ mod map;
 mod seq;
 mod unescape;
 
+use alloc::string::String;
+
 pub use errors::{Error, Result};
 
 use serde::de::{self, Visitor};
 
 use self::enum_::{StructVariantAccess, UnitVariantAccess};
 use self::map::MapAccess;
 use self::seq::SeqAccess;
-use std::str::from_utf8;
 
 /// Deserializer will parse serde-json-wasm flavored JSON into a
 /// serde-annotated struct
@@ -126,7 +127,7 @@ impl<'a> Deserializer<'a> {
                             )?))
                         } else {
                             Ok(StringLike::Borrowed(
-                                from_utf8(&self.slice[start..end])
+                                core::str::from_utf8(&self.slice[start..end])
                                     .map_err(|_| Error::InvalidUnicodeCodePoint)?,
                             ))
                         };
@@ -651,6 +652,11 @@ where
 #[cfg(test)]
 mod tests {
     use super::from_str;
+
+    use alloc::string::{String, ToString};
+    use alloc::vec;
+    use alloc::vec::Vec;
+
     use serde_derive::{Deserialize, Serialize};
 
     #[derive(Debug, Deserialize, PartialEq)]
@@ -1103,7 +1109,7 @@ mod tests {
 
     #[test]
     fn numbered_key_maps() {
-        use std::collections::BTreeMap;
+        use alloc::collections::BTreeMap;
 
         // u8
         let mut ranking: BTreeMap<u8, String> = BTreeMap::new();

src/de/mod.rs

@@ -1,4 +1,6 @@
-use std::convert::TryFrom;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::convert::TryFrom;
 
 use super::errors::{Error, Result};
 

src/de/unescape.rs

@@ -54,6 +54,15 @@
 #![deny(missing_docs)]
 #![deny(rust_2018_compatibility)]
 #![deny(rust_2018_idioms)]
+// Note: Even though we declare the crate as `no_std`, by default `std` feature
+// is enabled which enables serde’s `std` feature which makes our dependency
+// non-`no_std`.  This `no_std` declaration only makes sure that our code
+// doesn’t depend on `std` directly (except for tests).
+#![no_std]
+
+extern crate alloc;
+#[cfg(test)]
+extern crate std;
 
 pub mod de;
 pub mod ser;
@@ -65,7 +74,11 @@ pub use self::ser::{to_string, to_vec};
 
 #[cfg(test)]
 mod test {
-    use std::collections::BTreeMap;
+    use alloc::borrow::ToOwned;
+    use alloc::collections::BTreeMap;
+    use alloc::string::{String, ToString};
+    use alloc::vec;
+    use alloc::vec::Vec;
 
     use super::*;
     use serde_derive::{Deserialize, Serialize};
@@ -104,7 +117,7 @@ mod test {
     fn can_serde() {
         let min = Item {
             model: Model::Comment,
-            title: "".to_string(),
+            title: String::new(),
             content: None,
             list: vec![],
             published: false,
@@ -121,12 +134,12 @@ mod test {
             },
             title: "Nice message".to_string(),
             content: Some("Happy \"blogging\" 👏\n\n\tCheers, I'm out\0\0\0".to_string()),
-            list: vec![0, 1, 2, 3, 42, 154841, std::u32::MAX],
+            list: vec![0, 1, 2, 3, 42, 154841, u32::MAX],
             published: true,
             comments: vec![CommentId(2), CommentId(700)],
             stats: Stats {
-                views: std::u64::MAX,
-                score: std::i64::MIN,
+                views: u64::MAX,
+                score: i64::MIN,
             },
             balances,
         };

src/lib.rs

@@ -1,5 +1,3 @@
-use std::fmt;
-
 use serde::{ser, Serialize};
 
 use crate::ser::{Error, Result, Serializer};
@@ -55,7 +53,7 @@ struct MapKeySerializer<'a> {
 }
 
 pub(crate) fn key_must_be_a_string() -> Error {
-    Error::Custom("JSON object key is required to be a string type.".to_string())
+    Error::Custom("JSON object key is required to be a string type.".into())
 }
 
 macro_rules! serialize_unsigned_key {
@@ -252,7 +250,7 @@ impl<'a> ser::Serializer for MapKeySerializer<'a> {
 
     fn collect_str<T>(self, _value: &T) -> Result<()>
     where
-        T: ?Sized + fmt::Display,
+        T: ?Sized + core::fmt::Display,
     {
         unreachable!()
     }