Re-implement json-using-serde feature

This feature was removed when we gutted `minreq` after forking it.
Turns out we need it to be able to use `bitreq` in `jsonrpc`.

Re-implement the feature by copying code from `minreq`.

Author: tcharding

Cargo-minimal.lock

@@ -165,6 +165,8 @@ dependencies = [
  "rustls",
  "rustls-native-certs",
  "rustls-webpki",
+ "serde",
+ "serde_json",
  "tiny_http",
  "tokio",
  "tokio-rustls",

Cargo-recent.lock

@@ -165,6 +165,8 @@ dependencies = [
  "rustls",
  "rustls-native-certs",
  "rustls-webpki",
+ "serde",
+ "serde_json",
  "tiny_http",
  "tokio",
  "tokio-rustls",

bitreq/Cargo.toml

@@ -20,6 +20,9 @@ maintenance = { status = "experimental" }
 urlencoding = { version = "2.1.0", optional = true }
 # For the punycode feature:
 punycode = { version = "0.4.1", optional = true }
+# For the json-using-serde feature:
+serde = { version = "1.0.101", optional = true }
+serde_json = { version = "1.0.0", optional = true }
 # For the proxy feature:
 base64 = { version = "0.22", optional = true }
 # For the https features:
@@ -37,7 +40,7 @@ tiny_http = "0.12"
 chrono = "0.4.0"
 
 [package.metadata.docs.rs]
-features = ["proxy", "https", "punycode"]
+features = ["json-using-serde", "proxy", "https", "punycode"]
 
 [features]
 default = ["std"]
@@ -46,6 +49,7 @@ log = ["dep:log"]
 https = ["https-rustls"]
 https-rustls = ["rustls", "webpki-roots", "rustls-webpki"]
 https-rustls-probe = ["rustls", "rustls-native-certs"]
+json-using-serde = ["serde", "serde_json"]
 proxy = ["base64"]
 async = ["tokio", "std"]
 async-https = ["async", "https-rustls", "tokio-rustls"]

bitreq/src/error.rs

@@ -9,6 +9,9 @@ use std::{error, io};
 // what the user might want to handle? This error doesn't really invite graceful
 // handling.
 pub enum Error {
+    #[cfg(feature = "json-using-serde")]
+    /// Ran into a Serde error.
+    SerdeJsonError(serde_json::Error),
     /// The response body contains invalid UTF-8, so the `as_str()`
     /// conversion failed.
     InvalidUtf8InBody(str::Utf8Error),
@@ -88,6 +91,8 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use Error::*;
         match self {
+            #[cfg(feature = "json-using-serde")]
+            SerdeJsonError(err) => write!(f, "{}", err),
             #[cfg(feature = "std")]
             IoError(err) => write!(f, "{}", err),
             InvalidUtf8InBody(err) => write!(f, "{}", err),
@@ -124,6 +129,8 @@ impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         use Error::*;
         match self {
+            #[cfg(feature = "json-using-serde")]
+            SerdeJsonError(err) => Some(err),
             #[cfg(feature = "std")]
             IoError(err) => Some(err),
             InvalidUtf8InBody(err) => Some(err),

bitreq/src/request.rs

@@ -173,6 +173,26 @@ impl Request {
         self
     }
 
+    /// Converts given argument to JSON and sets it as body.
+    ///
+    /// # Errors
+    ///
+    /// Returns
+    /// [`SerdeJsonError`](enum.Error.html#variant.SerdeJsonError) if
+    /// Serde runs into a problem when converting `body` into a
+    /// string.
+    #[cfg(feature = "json-using-serde")]
+    pub fn with_json<T: serde::ser::Serialize>(mut self, body: &T) -> Result<Request, Error> {
+        self.headers.insert(
+            "Content-Type".to_string(),
+            "application/json; charset=UTF-8".to_string(),
+        );
+        match serde_json::to_string(&body) {
+            Ok(json) => Ok(self.with_body(json)),
+            Err(err) => Err(Error::SerdeJsonError(err)),
+        }
+    }
+
     /// Sets the request timeout in seconds.
     pub fn with_timeout(mut self, timeout: u64) -> Request {
         self.timeout = Some(timeout);

bitreq/src/response.rs

@@ -127,6 +127,45 @@ impl Response {
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> { Ok(()) }
     /// ```
     pub fn into_bytes(self) -> Vec<u8> { self.body }
+
+    /// Converts JSON body to a `struct` using Serde.
+    ///
+    /// # Errors
+    ///
+    /// Returns
+    /// [`SerdeJsonError`](enum.Error.html#variant.SerdeJsonError) if
+    /// Serde runs into a problem, or
+    /// [`InvalidUtf8InBody`](enum.Error.html#variant.InvalidUtf8InBody)
+    /// if the body is not UTF-8.
+    ///
+    /// # Example
+    /// In case compiler cannot figure out return type you might need to declare it explicitly:
+    ///
+    /// ```no_run
+    /// use serde_json::Value;
+    ///
+    /// # fn main() -> Result<(), minreq::Error> {
+    /// # let url_to_json_resource = "http://example.org/resource.json";
+    /// // Value could be any type that implements Deserialize!
+    /// let user = minreq::get(url_to_json_resource).send()?.json::<Value>()?;
+    /// println!("User name is '{}'", user["name"]);
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(feature = "json-using-serde")]
+    pub fn json<'a, T>(&'a self) -> Result<T, Error>
+    where
+        T: serde::de::Deserialize<'a>,
+    {
+        let str = match self.as_str() {
+            Ok(str) => str,
+            Err(_) => return Err(Error::InvalidUtf8InResponse),
+        };
+        match serde_json::from_str(str) {
+            Ok(json) => Ok(json),
+            Err(err) => Err(Error::SerdeJsonError(err)),
+        }
+    }
 }
 
 /// An HTTP response, which is loaded lazily.

bitreq/tests/main.rs

@@ -14,6 +14,25 @@ fn test_https() {
     assert_eq!(get_status_code(bitreq::get("https://example.com").send()), 200,);
 }
 
+#[test]
+#[cfg(feature = "json-using-serde")]
+fn test_json_using_serde() {
+    const JSON_SRC: &str = r#"{
+        "str": "Json test",
+        "num": 42
+    }"#;
+
+    setup();
+    let original_json: serde_json::Value = serde_json::from_str(JSON_SRC).unwrap();
+    let response = bitreq::post(url("/echo"))
+        .with_json(&original_json)
+        .unwrap()
+        .send()
+        .unwrap();
+    let actual_json: serde_json::Value = response.json().unwrap();
+    assert_eq!(&actual_json, &original_json);
+}
+
 #[test]
 fn test_timeout_too_low() {
     setup();