switched from simd-json to serde_json

Author: leontoeides

CHANGELOG.md

@@ -3,9 +3,22 @@
 * Release notes are available on
   [GitHub](https://github.com/leontoeides/google_maps/releases).
 
+# 3.8.2
+
+* 2025-04-10: Reverted back to `serde_json` from `simd-json`.
+
+  There were issues with some Google Maps API JSON responses. They failed
+  validation according to [jsonlint.com](https://jsonlint.com/). `simd-json` was
+  having issues with this JSON.
+
+  `serde_json` seems to be more robust in handling (presumably) invalid JSON.
+
+* 2025-04-10: Ensured that all `serde` `skip_serializing_if` attributes have a
+  matching `default` attribute.
+
 # 3.8.1
 
-* 2024-01-10: A debug `println!` was accidentally left in the `Client`
+* 2025-01-10: A debug `println!` was accidentally left in the `Client`
   `get_request` method. This has been removed.
 
 # 3.8.0
@@ -16,7 +29,7 @@
   `structs`. However, I don't believe most crate end-users will notice a
   difference.
 
-* 2024-01-10: Implemented Google Maps [Address Validation
+* 2025-01-10: Implemented Google Maps [Address Validation
   API](https://developers.google.com/maps/documentation/address-validation).
   Basic example:
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "google_maps"
-version = "3.8.1"
+version = "3.8.2"
 authors = ["Dylan Bowker <dylan.bowker@arkiteq.io>"]
 edition = "2021"
 categories = ["api-bindings"]
@@ -39,10 +39,6 @@ default = [
 
 	# rust_decimal default features:
 	"decimal-serde",
-
-	# simd-json default features:
-	"simd-json-beef",
-	"simd-json-known-key",
 ]
 # google_maps features:
 autocomplete = []
@@ -97,27 +93,16 @@ decimal-serde-arbitrary-precision = ["rust_decimal/serde-arbitrary-precision"]
 decimal-serde-with-float = ["rust_decimal/serde-with-float"]
 decimal-serde-with-str = ["rust_decimal/serde-with-str"]
 decimal-serde-with-arbitrary-precision = ["rust_decimal/serde-with-arbitrary-precision"]
-# simd-json features:
-simd-json-arraybackend = ["simd-json/arraybackend"]
-simd-json-value-no-dup-keys = ["simd-json/value-no-dup-keys"]
-simd-json-128bit = ["simd-json/128bit"]
-simd-json-beef = ["simd-json/beef"]
-simd-json-known-key = ["simd-json/known-key"]
-simd-json-swar-number-parsing = ["simd-json/swar-number-parsing"]
-simd-json-approx-number-parsing = ["simd-json/approx-number-parsing"]
-simd-json-serde_impl = ["simd-json/serde_impl"]
-simd-json-alloc = ["simd-json/alloc"]
-simd-json-hints = ["simd-json/hints"]
-simd-json-runtime-detection = ["simd-json/runtime-detection"]
 
 [dependencies]
 miette = "7.5"
 percent-encoding = "2.3"
 phf = { version = "0.11", features = ["macros"] }
-rust_decimal = { version = "1", features = ["serde"] }
+rust_decimal = { version = "1", features = ["serde", "serde-float"] }
 rust_decimal_macros = "1"
 serde = { version = "1.0", features = ["derive"] }
-simd-json = "0.14"
+# simd-json = "0.14"
+serde_json = "1.0"
 thiserror = "2.0"
 tracing = { version = "0.1", features = ["log"] }
 

src/address_validation/provide_validation_feedback/request/request_body.rs

@@ -8,6 +8,6 @@ impl crate::traits::RequestBody for crate::address_validation::provide_validatio
     /// convert the above defined `RequestBody` struct into JSON for submission
     /// to Google Maps.
     fn request_body(&self) -> Result<String, crate::Error> {
-        Ok(simd_json::serde::to_string(&RequestQuery::from(self))?)
+        Ok(serde_json::to_string(&RequestQuery::from(self))?)
     } // fn
 } // impl

src/address_validation/validate_address/request/request_body.rs

@@ -10,6 +10,6 @@ impl crate::traits::RequestBody for crate::address_validation::validate_address:
     /// In this case, we'll be converting the `RequestQuery` struct into a JSON
     /// object which will be submitted inside the HTTP request's body.
     fn request_body(&self) -> Result<String, crate::Error> {
-        Ok(simd_json::serde::to_string(&RequestQuery::from(self))?)
+        Ok(serde_json::to_string(&RequestQuery::from(self))?)
     } // fn
 } // impl

src/client/get_request.rs

@@ -69,7 +69,7 @@ impl crate::Client {
                 Ok(request) => match self.reqwest_client.execute(request).await {
                     Ok(response) => if response.status().is_success() {
                         match response.text().await.map(String::into_bytes) {
-                            Ok(mut bytes) => match simd_json::serde::from_slice::<RSP>(&mut bytes) {
+                            Ok(bytes) => match serde_json::from_slice::<RSP>(&bytes) {
                                 Ok(deserialized) => {
                                     let result: Result<RSP, ERR> = deserialized.into();
                                     if let Err(error) = &result {

src/client/post_request.rs

@@ -19,8 +19,8 @@ impl crate::Client {
     ///   parameters in the request conflict with one another, or the request
     ///   parameters are set in a way that's incompatible.
     ///
-    ///   For example, Google Maps Address Validation API will refuse a 
-    ///   `PostalAddress` greater than 280 characters. This will cause a 
+    ///   For example, Google Maps Address Validation API will refuse a
+    ///   `PostalAddress` greater than 280 characters. This will cause a
     ///   validation failure.
     ///
     /// * The HTTP client cannot make a connection to the Google Maps API
@@ -77,7 +77,7 @@ impl crate::Client {
                 Ok(request) => match self.reqwest_client.execute(request).await {
                     Ok(response) => if response.status().is_success() {
                         match response.text().await.map(String::into_bytes) {
-                            Ok(mut bytes) => match simd_json::serde::from_slice::<RSP>(&mut bytes) {
+                            Ok(bytes) => match serde_json::from_slice::<RSP>(&bytes) {
                                 Ok(deserialized) => {
                                     let result: Result<RSP, ERR> = deserialized.into();
                                     if let Err(error) = &result {
@@ -100,7 +100,7 @@ impl crate::Client {
                         } // match
                     } else {
                         tracing::error!(
-                            "Google Maps API HTTP request was unsuccessful: {status}",
+                            "Google Maps API HTTP request unsuccessful: {status}",
                             status = response.status(),
                         );
                         Err(Error::from(response.status()))

src/directions/response/mod.rs

@@ -85,32 +85,32 @@ pub struct Response {
 // -----------------------------------------------------------------------------
 
 impl std::convert::TryFrom<String> for Response {
-    type Error = simd_json::Error;
+    type Error = serde_json::Error;
     /// Convert a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `String` response into a `Response` struct.
     fn try_from(s: String) -> Result<Self, Self::Error> {
-        simd_json::serde::from_slice(&mut s.into_bytes())
+        serde_json::from_slice(&mut s.into_bytes())
     } // fn
 } // impl
 
 // -----------------------------------------------------------------------------
 
 impl std::str::FromStr for Response {
-    type Err = simd_json::Error;
+    type Err = serde_json::Error;
     /// Converts a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `&str` response into a `Response` struct.
     ///
     /// # Notes
     ///
     /// * It's recommended to use the implemented `TryFrom` trait instead.
     ///
-    /// * The [simd_json](https://crates.io/crates/simd-json)'s `from_str`
+    /// * The [serde_json](https://crates.io/crates/simd-json)'s `from_str`
     ///   function implementation is unsafe and it's `from_slice` function
     ///   requires a mutable reference. Therefore this trait clones the `&str`
     ///   into a `String` to give `from_slice` mutable access to the string.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut bytes = s.to_string().into_bytes();
-        simd_json::serde::from_slice(&mut bytes)
+        serde_json::from_slice(&mut bytes)
     } // fn
 } // impl
 

src/directions/response/transit_fare.rs

@@ -4,17 +4,21 @@ use crate::directions::response::transit_currency::TransitCurrency;
 use rust_decimal::Decimal;
 use serde::{Deserialize, Serialize};
 
+// -----------------------------------------------------------------------------
+//
 /// If present, contains the total fare (that is, the total ticket costs) on
 /// this route. This property is only returned for transit requests and only for
 /// routes where fare information is available for all transit legs.
-
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
 pub struct TransitFare {
     /// An [ISO 4217 currency code](https://en.wikipedia.org/wiki/ISO_4217)
     /// indicating the currency that the amount is expressed in.
     pub currency: TransitCurrency,
+
     /// The total fare amount, formatted in the requested language.
     pub text: String,
+
     /// The total fare amount, in the currency specified above.
+    #[serde(with = "rust_decimal::serde::float")]
     pub value: Decimal,
 } // struct

src/distance_matrix/response/mod.rs

@@ -60,32 +60,32 @@ pub struct Response {
 // -----------------------------------------------------------------------------
 
 impl std::convert::TryFrom<String> for Response {
-    type Error = simd_json::Error;
+    type Error = serde_json::Error;
     /// Convert a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `String` response into a `Response` struct.
     fn try_from(s: String) -> Result<Self, Self::Error> {
-        simd_json::serde::from_slice(&mut s.into_bytes())
+        serde_json::from_slice(&mut s.into_bytes())
     } // fn
 } // impl
 
 // -----------------------------------------------------------------------------
 
 impl std::str::FromStr for Response {
-    type Err = simd_json::Error;
+    type Err = serde_json::Error;
     /// Converts a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `&str` response into a `Response` struct.
     ///
     /// # Notes
     ///
     /// * It's recommended to use the implemented `TryFrom` trait instead.
     ///
-    /// * The [simd_json](https://crates.io/crates/simd-json)'s `from_str`
+    /// * The [serde_json](https://crates.io/crates/simd-json)'s `from_str`
     ///   function implementation is unsafe and it's `from_slice` function
     ///   requires a mutable reference. Therefore this trait clones the `&str`
     ///   into a `String` to give `from_slice` mutable access to the string.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut bytes = s.to_string().into_bytes();
-        simd_json::serde::from_slice(&mut bytes)
+        serde_json::from_slice(&mut bytes)
     } // fn
 } // impl
 

src/elevation/response/mod.rs

@@ -41,32 +41,32 @@ pub struct Response {
 // -----------------------------------------------------------------------------
 
 impl std::convert::TryFrom<String> for Response {
-    type Error = simd_json::Error;
+    type Error = serde_json::Error;
     /// Convert a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `String` response into a `Response` struct.
     fn try_from(s: String) -> Result<Self, Self::Error> {
-        simd_json::serde::from_slice(&mut s.into_bytes())
+        serde_json::from_slice(&mut s.into_bytes())
     } // fn
 } // impl
 
 // -----------------------------------------------------------------------------
 
 impl std::str::FromStr for Response {
-    type Err = simd_json::Error;
+    type Err = serde_json::Error;
     /// Converts a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `&str` response into a `Response` struct.
     ///
     /// # Notes
     ///
     /// * It's recommended to use the implemented `TryFrom` trait instead.
     ///
-    /// * The [simd_json](https://crates.io/crates/simd-json)'s `from_str`
+    /// * The [serde_json](https://crates.io/crates/simd-json)'s `from_str`
     ///   function implementation is unsafe and it's `from_slice` function
     ///   requires a mutable reference. Therefore this trait clones the `&str`
     ///   into a `String` to give `from_slice` mutable access to the string.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut bytes = s.to_string().into_bytes();
-        simd_json::serde::from_slice(&mut bytes)
+        serde_json::from_slice(&mut bytes)
     } // fn
 } // impl
 

src/error.rs

@@ -114,7 +114,7 @@ pub enum Error {
     /// the JSON response if available.
     #[error(transparent)]
     #[diagnostic(code(google_maps::json))]
-    Json(#[from] simd_json::Error),
+    Json(#[from] serde_json::Error),
 
     /// Error originating from the [polyline](https://crates.io/crates/polyline)
     /// crate.
@@ -245,12 +245,7 @@ impl ClassifiableError<'_, Self> for Error {
                     ClassifiedError::Permanent(self)
                 }, // Http
 
-            Self::Json(json_error) =>
-                if json_error.classify().is_transient() {
-                    ClassifiedError::Transient(self)
-                } else {
-                    ClassifiedError::Permanent(self)
-                }, // Http
+            Self::Json(_json_error) => ClassifiedError::Permanent(self),
 
             #[cfg(feature = "polyline")]
             Self::Polyline(_polyline_error) => ClassifiedError::Permanent(self),

src/geocoding/response/mod.rs

@@ -44,32 +44,32 @@ pub struct Response {
 // -----------------------------------------------------------------------------
 
 impl std::convert::TryFrom<String> for Response {
-    type Error = simd_json::Error;
+    type Error = serde_json::Error;
     /// Convert a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `String` response into a `Response` struct.
     fn try_from(s: String) -> Result<Self, Self::Error> {
-        simd_json::serde::from_slice(&mut s.into_bytes())
+        serde_json::from_slice(&mut s.into_bytes())
     } // fn
 } // impl
 
 // -----------------------------------------------------------------------------
 
 impl std::str::FromStr for Response {
-    type Err = simd_json::Error;
+    type Err = serde_json::Error;
     /// Converts a Google Maps API [JSON](https://en.wikipedia.org/wiki/JSON)
     /// `&str` response into a `Response` struct.
     ///
     /// # Notes
     ///
     /// * It's recommended to use the implemented `TryFrom` trait instead.
     ///
-    /// * The [simd_json](https://crates.io/crates/simd-json)'s `from_str`
+    /// * The [serde_json](https://crates.io/crates/simd-json)'s `from_str`
     ///   function implementation is unsafe and it's `from_slice` function
     ///   requires a mutable reference. Therefore this trait clones the `&str`
     ///   into a `String` to give `from_slice` mutable access to the string.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut bytes = s.to_string().into_bytes();
-        simd_json::serde::from_slice(&mut bytes)
+        serde_json::from_slice(&mut bytes)
     } // fn
 } // impl
 

src/geolocation/response/mod.rs

@@ -27,11 +27,11 @@ pub struct Response {
 } // struct
 
 impl std::str::FromStr for Response {
-    type Err = simd_json::Error;
+    type Err = serde_json::Error;
     /// Parse a Google Maps Geolocation API JSON `String` into a `Response`
     /// usable `Response` struct.
-    fn from_str(s: &str) -> Result<Self, simd_json::Error> {
+    fn from_str(s: &str) -> Result<Self, serde_json::Error> {
         let mut bytes = s.to_string().into_bytes();
-        simd_json::serde::from_slice(&mut bytes)
+        serde_json::from_slice(&mut bytes)
     }
 }

src/lib.rs

@@ -431,7 +431,7 @@
     clippy::missing_errors_doc,
     clippy::module_name_repetitions,
     clippy::multiple_crate_versions,
-    clippy::negative_feature_names, // suppress clippy warning re: `simd_json` crate
+    clippy::negative_feature_names, // suppress clippy warning re: `serde_json` crate
     clippy::too_long_first_doc_paragraph, // bah!
     clippy::too_many_lines
 )]

src/places/place.rs

@@ -322,11 +322,11 @@ pub struct Place {
 // -----------------------------------------------------------------------------
 
 impl std::str::FromStr for Place {
-    type Err = simd_json::Error;
+    type Err = serde_json::Error;
     /// Parse a Google Maps Places API JSON response into a usable `Place`
     /// struct.
-    fn from_str(s: &str) -> Result<Self, simd_json::Error> {
+    fn from_str(s: &str) -> Result<Self, serde_json::Error> {
         let mut bytes = s.to_string().into_bytes();
-        simd_json::serde::from_slice(&mut bytes)
+        serde_json::from_slice(&mut bytes)
     } // fn from_str
 } // impl FromStr

src/places/place_autocomplete/response/matched_substring.rs

@@ -24,11 +24,11 @@ pub struct MatchedSubstring {
 // -----------------------------------------------------------------------------
 
 impl std::str::FromStr for MatchedSubstring {
-    type Err = simd_json::Error;
+    type Err = serde_json::Error;
     /// Parse a Google Maps Places API _Place Autocomplete_ JSON
     /// `MatchedSubstring` response into a usable `MatchedSubstring` struct.
-    fn from_str(s: &str) -> Result<Self, simd_json::Error> {
+    fn from_str(s: &str) -> Result<Self, serde_json::Error> {
         let mut bytes = s.to_string().into_bytes();
-        simd_json::serde::from_slice(&mut bytes)
+        serde_json::from_slice(&mut bytes)
     } // fn from_str
 } // impl FromStr