RubyGems - wreq-rb - Versions diffs - 0.3.0 - Mend

wreq-rb 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (167) hide show

checksums.yaml +7 -0
data/Cargo.lock +2688 -0
data/Cargo.toml +6 -0
data/README.md +179 -0
data/ext/wreq_rb/Cargo.toml +39 -0
data/ext/wreq_rb/extconf.rb +22 -0
data/ext/wreq_rb/src/client.rs +565 -0
data/ext/wreq_rb/src/error.rs +25 -0
data/ext/wreq_rb/src/lib.rs +20 -0
data/ext/wreq_rb/src/response.rs +132 -0
data/lib/wreq-rb/version.rb +5 -0
data/lib/wreq-rb.rb +17 -0
data/patches/0001-add-transfer-size-tracking.patch +292 -0
data/vendor/wreq/Cargo.toml +306 -0
data/vendor/wreq/LICENSE +202 -0
data/vendor/wreq/README.md +122 -0
data/vendor/wreq/examples/cert_store.rs +77 -0
data/vendor/wreq/examples/connect_via_lower_priority_tokio_runtime.rs +258 -0
data/vendor/wreq/examples/emulation.rs +118 -0
data/vendor/wreq/examples/form.rs +14 -0
data/vendor/wreq/examples/http1_websocket.rs +37 -0
data/vendor/wreq/examples/http2_websocket.rs +45 -0
data/vendor/wreq/examples/json_dynamic.rs +41 -0
data/vendor/wreq/examples/json_typed.rs +47 -0
data/vendor/wreq/examples/keylog.rs +16 -0
data/vendor/wreq/examples/request_with_emulation.rs +115 -0
data/vendor/wreq/examples/request_with_interface.rs +37 -0
data/vendor/wreq/examples/request_with_local_address.rs +16 -0
data/vendor/wreq/examples/request_with_proxy.rs +13 -0
data/vendor/wreq/examples/request_with_redirect.rs +22 -0
data/vendor/wreq/examples/request_with_version.rs +15 -0
data/vendor/wreq/examples/tor_socks.rs +24 -0
data/vendor/wreq/examples/unix_socket.rs +33 -0
data/vendor/wreq/src/client/body.rs +304 -0
data/vendor/wreq/src/client/conn/conn.rs +231 -0
data/vendor/wreq/src/client/conn/connector.rs +549 -0
data/vendor/wreq/src/client/conn/http.rs +1023 -0
data/vendor/wreq/src/client/conn/proxy/socks.rs +233 -0
data/vendor/wreq/src/client/conn/proxy/tunnel.rs +260 -0
data/vendor/wreq/src/client/conn/proxy.rs +39 -0
data/vendor/wreq/src/client/conn/tls_info.rs +98 -0
data/vendor/wreq/src/client/conn/uds.rs +44 -0
data/vendor/wreq/src/client/conn/verbose.rs +149 -0
data/vendor/wreq/src/client/conn.rs +323 -0
data/vendor/wreq/src/client/core/body/incoming.rs +485 -0
data/vendor/wreq/src/client/core/body/length.rs +118 -0
data/vendor/wreq/src/client/core/body.rs +34 -0
data/vendor/wreq/src/client/core/common/buf.rs +149 -0
data/vendor/wreq/src/client/core/common/rewind.rs +141 -0
data/vendor/wreq/src/client/core/common/watch.rs +76 -0
data/vendor/wreq/src/client/core/common.rs +3 -0
data/vendor/wreq/src/client/core/conn/http1.rs +342 -0
data/vendor/wreq/src/client/core/conn/http2.rs +307 -0
data/vendor/wreq/src/client/core/conn.rs +11 -0
data/vendor/wreq/src/client/core/dispatch.rs +299 -0
data/vendor/wreq/src/client/core/error.rs +435 -0
data/vendor/wreq/src/client/core/ext.rs +201 -0
data/vendor/wreq/src/client/core/http1.rs +178 -0
data/vendor/wreq/src/client/core/http2.rs +483 -0
data/vendor/wreq/src/client/core/proto/h1/conn.rs +988 -0
data/vendor/wreq/src/client/core/proto/h1/decode.rs +1170 -0
data/vendor/wreq/src/client/core/proto/h1/dispatch.rs +684 -0
data/vendor/wreq/src/client/core/proto/h1/encode.rs +580 -0
data/vendor/wreq/src/client/core/proto/h1/io.rs +879 -0
data/vendor/wreq/src/client/core/proto/h1/role.rs +694 -0
data/vendor/wreq/src/client/core/proto/h1.rs +104 -0
data/vendor/wreq/src/client/core/proto/h2/client.rs +650 -0
data/vendor/wreq/src/client/core/proto/h2/ping.rs +539 -0
data/vendor/wreq/src/client/core/proto/h2.rs +379 -0
data/vendor/wreq/src/client/core/proto/headers.rs +138 -0
data/vendor/wreq/src/client/core/proto.rs +58 -0
data/vendor/wreq/src/client/core/rt/bounds.rs +57 -0
data/vendor/wreq/src/client/core/rt/timer.rs +150 -0
data/vendor/wreq/src/client/core/rt/tokio.rs +99 -0
data/vendor/wreq/src/client/core/rt.rs +25 -0
data/vendor/wreq/src/client/core/upgrade.rs +267 -0
data/vendor/wreq/src/client/core.rs +16 -0
data/vendor/wreq/src/client/emulation.rs +161 -0
data/vendor/wreq/src/client/http/client/error.rs +142 -0
data/vendor/wreq/src/client/http/client/exec.rs +29 -0
data/vendor/wreq/src/client/http/client/extra.rs +77 -0
data/vendor/wreq/src/client/http/client/lazy.rs +79 -0
data/vendor/wreq/src/client/http/client/pool.rs +1105 -0
data/vendor/wreq/src/client/http/client/util.rs +104 -0
data/vendor/wreq/src/client/http/client.rs +1003 -0
data/vendor/wreq/src/client/http/future.rs +99 -0
data/vendor/wreq/src/client/http.rs +1629 -0
data/vendor/wreq/src/client/layer/config/options.rs +156 -0
data/vendor/wreq/src/client/layer/config.rs +116 -0
data/vendor/wreq/src/client/layer/cookie.rs +161 -0
data/vendor/wreq/src/client/layer/decoder.rs +139 -0
data/vendor/wreq/src/client/layer/redirect/future.rs +270 -0
data/vendor/wreq/src/client/layer/redirect/policy.rs +63 -0
data/vendor/wreq/src/client/layer/redirect.rs +145 -0
data/vendor/wreq/src/client/layer/retry/classify.rs +105 -0
data/vendor/wreq/src/client/layer/retry/scope.rs +51 -0
data/vendor/wreq/src/client/layer/retry.rs +151 -0
data/vendor/wreq/src/client/layer/timeout/body.rs +233 -0
data/vendor/wreq/src/client/layer/timeout/future.rs +90 -0
data/vendor/wreq/src/client/layer/timeout.rs +177 -0
data/vendor/wreq/src/client/layer.rs +15 -0
data/vendor/wreq/src/client/multipart.rs +717 -0
data/vendor/wreq/src/client/request.rs +818 -0
data/vendor/wreq/src/client/response.rs +534 -0
data/vendor/wreq/src/client/ws/json.rs +99 -0
data/vendor/wreq/src/client/ws/message.rs +453 -0
data/vendor/wreq/src/client/ws.rs +714 -0
data/vendor/wreq/src/client.rs +27 -0
data/vendor/wreq/src/config.rs +140 -0
data/vendor/wreq/src/cookie.rs +579 -0
data/vendor/wreq/src/dns/gai.rs +249 -0
data/vendor/wreq/src/dns/hickory.rs +78 -0
data/vendor/wreq/src/dns/resolve.rs +180 -0
data/vendor/wreq/src/dns.rs +69 -0
data/vendor/wreq/src/error.rs +502 -0
data/vendor/wreq/src/ext.rs +398 -0
data/vendor/wreq/src/hash.rs +143 -0
data/vendor/wreq/src/header.rs +506 -0
data/vendor/wreq/src/into_uri.rs +187 -0
data/vendor/wreq/src/lib.rs +586 -0
data/vendor/wreq/src/proxy/mac.rs +82 -0
data/vendor/wreq/src/proxy/matcher.rs +806 -0
data/vendor/wreq/src/proxy/uds.rs +66 -0
data/vendor/wreq/src/proxy/win.rs +31 -0
data/vendor/wreq/src/proxy.rs +569 -0
data/vendor/wreq/src/redirect.rs +575 -0
data/vendor/wreq/src/retry.rs +198 -0
data/vendor/wreq/src/sync.rs +129 -0
data/vendor/wreq/src/tls/conn/cache.rs +123 -0
data/vendor/wreq/src/tls/conn/cert_compression.rs +125 -0
data/vendor/wreq/src/tls/conn/ext.rs +82 -0
data/vendor/wreq/src/tls/conn/macros.rs +34 -0
data/vendor/wreq/src/tls/conn/service.rs +138 -0
data/vendor/wreq/src/tls/conn.rs +681 -0
data/vendor/wreq/src/tls/keylog/handle.rs +64 -0
data/vendor/wreq/src/tls/keylog.rs +99 -0
data/vendor/wreq/src/tls/options.rs +464 -0
data/vendor/wreq/src/tls/x509/identity.rs +122 -0
data/vendor/wreq/src/tls/x509/parser.rs +71 -0
data/vendor/wreq/src/tls/x509/store.rs +228 -0
data/vendor/wreq/src/tls/x509.rs +68 -0
data/vendor/wreq/src/tls.rs +154 -0
data/vendor/wreq/src/trace.rs +55 -0
data/vendor/wreq/src/util.rs +122 -0
data/vendor/wreq/tests/badssl.rs +228 -0
data/vendor/wreq/tests/brotli.rs +350 -0
data/vendor/wreq/tests/client.rs +1098 -0
data/vendor/wreq/tests/connector_layers.rs +227 -0
data/vendor/wreq/tests/cookie.rs +306 -0
data/vendor/wreq/tests/deflate.rs +347 -0
data/vendor/wreq/tests/emulation.rs +260 -0
data/vendor/wreq/tests/gzip.rs +347 -0
data/vendor/wreq/tests/layers.rs +261 -0
data/vendor/wreq/tests/multipart.rs +165 -0
data/vendor/wreq/tests/proxy.rs +438 -0
data/vendor/wreq/tests/redirect.rs +629 -0
data/vendor/wreq/tests/retry.rs +135 -0
data/vendor/wreq/tests/support/delay_server.rs +117 -0
data/vendor/wreq/tests/support/error.rs +16 -0
data/vendor/wreq/tests/support/layer.rs +183 -0
data/vendor/wreq/tests/support/mod.rs +9 -0
data/vendor/wreq/tests/support/server.rs +232 -0
data/vendor/wreq/tests/timeouts.rs +281 -0
data/vendor/wreq/tests/unix_socket.rs +135 -0
data/vendor/wreq/tests/upgrade.rs +98 -0
data/vendor/wreq/tests/zstd.rs +559 -0
metadata +225 -0

data/vendor/wreq/src/client/response.rs ADDED Viewed

@@ -0,0 +1,534 @@
+use std::{
+    net::SocketAddr,
+    pin::Pin,
+    task::{Context, Poll},
+};
+use bytes::Bytes;
+#[cfg(feature = "charset")]
+use encoding_rs::{Encoding, UTF_8};
+#[cfg(feature = "stream")]
+use futures_util::Stream;
+use http::{HeaderMap, StatusCode, Uri, Version};
+use http_body::{Body as HttpBody, Frame};
+use http_body_util::{BodyExt, Collected};
+#[cfg(feature = "charset")]
+use mime::Mime;
+#[cfg(feature = "json")]
+use serde::de::DeserializeOwned;
+use super::{
+    conn::HttpInfo,
+    core::{ext::ReasonPhrase, upgrade},
+};
+#[cfg(feature = "cookies")]
+use crate::cookie;
+use crate::{Body, Error, Upgraded, error::BoxError, ext::RequestUri};
+/// A Response to a submitted [`crate::Request`].
+#[derive(Debug)]
+pub struct Response {
+    uri: Uri,
+    res: http::Response<Body>,
+}
+impl Response {
+    pub(super) fn new<B>(res: http::Response<B>, uri: Uri) -> Response
+    where
+        B: HttpBody + Send + Sync + 'static,
+        B::Data: Into<Bytes>,
+        B::Error: Into<BoxError>,
+    {
+        Response {
+            uri,
+            res: res.map(Body::wrap),
+        }
+    }
+    /// Get the final [`Uri`] of this [`Response`].
+    #[inline]
+    pub fn uri(&self) -> &Uri {
+        &self.uri
+    }
+    /// Get the [`StatusCode`] of this [`Response`].
+    #[inline]
+    pub fn status(&self) -> StatusCode {
+        self.res.status()
+    }
+    /// Get the HTTP [`Version`] of this [`Response`].
+    #[inline]
+    pub fn version(&self) -> Version {
+        self.res.version()
+    }
+    /// Get the [`HeaderMap`] of this [`Response`].
+    #[inline]
+    pub fn headers(&self) -> &HeaderMap {
+        self.res.headers()
+    }
+    /// Get a mutable reference to the [`HeaderMap`] of this [`Response`].
+    #[inline]
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        self.res.headers_mut()
+    }
+    /// Get the content length of the [`Response`], if it is known.
+    ///
+    /// This value does not directly represents the value of the `Content-Length`
+    /// header, but rather the size of the response's body. To read the header's
+    /// value, please use the [`Response::headers`] method instead.
+    ///
+    /// Reasons it may not be known:
+    ///
+    /// - The response does not include a body (e.g. it responds to a `HEAD` request).
+    /// - The response is gzipped and automatically decoded (thus changing the actual decoded
+    ///   length).
+    #[inline]
+    pub fn content_length(&self) -> Option<u64> {
+        HttpBody::size_hint(self.res.body()).exact()
+    }
+    /// Retrieve the cookies contained in the [`Response`].
+    ///
+    /// Note that invalid 'Set-Cookie' headers will be ignored.
+    ///
+    /// # Optional
+    ///
+    /// This requires the optional `cookies` feature to be enabled.
+    #[cfg(feature = "cookies")]
+    pub fn cookies(&self) -> impl Iterator<Item = cookie::Cookie<'_>> {
+        self.res
+            .headers()
+            .get_all(crate::header::SET_COOKIE)
+            .iter()
+            .map(cookie::Cookie::parse)
+            .filter_map(Result::ok)
+    }
+    /// Get the local address used to get this [`Response`].
+    pub fn local_addr(&self) -> Option<SocketAddr> {
+        self.res
+            .extensions()
+            .get::<HttpInfo>()
+            .map(HttpInfo::local_addr)
+    }
+    /// Get the remote address used to get this [`Response`].
+    pub fn remote_addr(&self) -> Option<SocketAddr> {
+        self.res
+            .extensions()
+            .get::<HttpInfo>()
+            .map(HttpInfo::remote_addr)
+    }
+    // body methods
+    /// Get the full response text.
+    ///
+    /// This method decodes the response body with BOM sniffing
+    /// and with malformed sequences replaced with the [`char::REPLACEMENT_CHARACTER`].
+    /// Encoding is determined from the `charset` parameter of `Content-Type` header,
+    /// and defaults to `utf-8` if not presented.
+    ///
+    /// Note that the BOM is stripped from the returned String.
+    ///
+    /// # Note
+    ///
+    /// If the `charset` feature is disabled the method will only attempt to decode the
+    /// response as UTF-8, regardless of the given `Content-Type`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    /// let content = wreq::Client::new()
+    ///     .get("http://httpbin.org/range/26")
+    ///     .send()
+    ///     .await?
+    ///     .text()
+    ///     .await?;
+    ///
+    /// println!("text: {content:?}");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn text(self) -> crate::Result<String> {
+        #[cfg(feature = "charset")]
+        {
+            self.text_with_charset("utf-8").await
+        }
+        #[cfg(not(feature = "charset"))]
+        {
+            let full = self.bytes().await?;
+            let text = String::from_utf8_lossy(&full);
+            Ok(text.into_owned())
+        }
+    }
+    /// Get the full response text given a specific encoding.
+    ///
+    /// This method decodes the response body with BOM sniffing
+    /// and with malformed sequences replaced with the
+    /// [`char::REPLACEMENT_CHARACTER`].
+    /// You can provide a default encoding for decoding the raw message, while the
+    /// `charset` parameter of `Content-Type` header is still prioritized. For more information
+    /// about the possible encoding name, please go to [`encoding_rs`] docs.
+    ///
+    /// Note that the BOM is stripped from the returned String.
+    ///
+    /// [`encoding_rs`]: https://docs.rs/encoding_rs/0.8/encoding_rs/#relationship-with-windows-code-pages
+    ///
+    /// # Optional
+    ///
+    /// This requires the optional `encoding_rs` feature enabled.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    /// let content = wreq::Client::new()
+    ///     .get("http://httpbin.org/range/26")
+    ///     .send()
+    ///     .await?
+    ///     .text_with_charset("utf-8")
+    ///     .await?;
+    ///
+    /// println!("text: {content:?}");
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(feature = "charset")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "charset")))]
+    pub async fn text_with_charset(
+        self,
+        default_encoding: impl AsRef<str>,
+    ) -> crate::Result<String> {
+        let content_type = self
+            .headers()
+            .get(crate::header::CONTENT_TYPE)
+            .and_then(|value| value.to_str().ok())
+            .and_then(|value| value.parse::<Mime>().ok());
+        let encoding_name = content_type
+            .as_ref()
+            .and_then(|mime| mime.get_param("charset").map(|charset| charset.as_str()))
+            .unwrap_or(default_encoding.as_ref());
+        let encoding = Encoding::for_label(encoding_name.as_bytes()).unwrap_or(UTF_8);
+        let full = self.bytes().await?;
+        let (text, _, _) = encoding.decode(&full);
+        Ok(text.into_owned())
+    }
+    /// Try to deserialize the response body as JSON.
+    ///
+    /// # Optional
+    ///
+    /// This requires the optional `json` feature enabled.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate wreq;
+    /// # extern crate serde;
+    /// #
+    /// # use wreq::Error;
+    /// # use serde::Deserialize;
+    /// #
+    /// // This `derive` requires the `serde` dependency.
+    /// #[derive(Deserialize)]
+    /// struct Ip {
+    ///     origin: String,
+    /// }
+    ///
+    /// # async fn run() -> Result<(), Error> {
+    /// let ip = wreq::Client::new()
+    ///     .get("http://httpbin.org/ip")
+    ///     .send()
+    ///     .await?
+    ///     .json::<Ip>()
+    ///     .await?;
+    ///
+    /// println!("ip: {}", ip.origin);
+    /// # Ok(())
+    /// # }
+    /// #
+    /// # fn main() { }
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever the response body is not in JSON format
+    /// or it cannot be properly deserialized to target type `T`. For more
+    /// details please see [`serde_json::from_reader`].
+    ///
+    /// [`serde_json::from_reader`]: https://docs.serde.rs/serde_json/fn.from_reader.html
+    #[cfg(feature = "json")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+    pub async fn json<T: DeserializeOwned>(self) -> crate::Result<T> {
+        let full = self.bytes().await?;
+        serde_json::from_slice(&full).map_err(Error::decode)
+    }
+    /// Get the full response body as [`Bytes`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    /// let bytes = wreq::Client::new()
+    ///     .get("http://httpbin.org/ip")
+    ///     .send()
+    ///     .await?
+    ///     .bytes()
+    ///     .await?;
+    ///
+    /// println!("bytes: {bytes:?}");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn bytes(self) -> crate::Result<Bytes> {
+        BodyExt::collect(self.res.into_body())
+            .await
+            .map(Collected::<Bytes>::to_bytes)
+    }
+    /// Stream a chunk of the response body.
+    ///
+    /// When the response body has been exhausted, this will return `None`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut res = wreq::get("https://hyper.rs").send().await?;
+    ///
+    /// while let Some(chunk) = res.chunk().await? {
+    ///     println!("Chunk: {chunk:?}");
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn chunk(&mut self) -> crate::Result<Option<Bytes>> {
+        loop {
+            if let Some(res) = self.res.body_mut().frame().await {
+                if let Ok(buf) = res?.into_data() {
+                    return Ok(Some(buf));
+                }
+            } else {
+                return Ok(None);
+            }
+        }
+    }
+    /// Convert the response into a [`Stream`] of [`Bytes`] from the body.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use futures_util::StreamExt;
+    ///
+    /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    /// let mut stream = wreq::Client::new()
+    ///     .get("http://httpbin.org/ip")
+    ///     .send()
+    ///     .await?
+    ///     .bytes_stream();
+    ///
+    /// while let Some(item) = stream.next().await {
+    ///     println!("Chunk: {:?}", item?);
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// # Optional
+    ///
+    /// This requires the optional `stream` feature to be enabled.
+    #[cfg(feature = "stream")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "stream")))]
+    pub fn bytes_stream(self) -> impl Stream<Item = crate::Result<Bytes>> {
+        http_body_util::BodyDataStream::new(self.res.into_body())
+    }
+    // extension methods
+    /// Returns a reference to the associated extensions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wreq::{Client, tls::TlsInfo};
+    /// # async fn run() -> wreq::Result<()> {
+    /// // Build a client that records TLS information.
+    /// let client = Client::builder()
+    ///     .tls_info(true)
+    ///     .build()?;
+    ///
+    /// // Make a request.
+    /// let resp = client.get("https://www.google.com").send().await?;
+    ///
+    /// // Take the TlsInfo extension to inspect it.
+    /// if let Some(tls_info) = resp.extensions().get::<TlsInfo>() {
+    ///     // Now you own the TlsInfo and can process it.
+    ///     println!("Peer certificate: {:?}", tls_info.peer_certificate());
+    /// }
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn extensions(&self) -> &http::Extensions {
+        self.res.extensions()
+    }
+    /// Returns a mutable reference to the associated extensions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wreq::{Client, tls::TlsInfo};
+    /// # async fn run() -> wreq::Result<()> {
+    /// // Build a client that records TLS information.
+    /// let client = Client::builder()
+    ///     .tls_info(true)
+    ///     .build()?;
+    ///
+    /// // Make a request.
+    /// let mut resp = client.get("https://www.google.com").send().await?;
+    ///
+    /// // Take the TlsInfo extension to inspect it.
+    /// if let Some(tls_info) = resp.extensions_mut().remove::<TlsInfo>() {
+    ///     // Now you own the TlsInfo and can process it.
+    ///     println!("Peer certificate: {:?}", tls_info.peer_certificate());
+    /// }
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn extensions_mut(&mut self) -> &mut http::Extensions {
+        self.res.extensions_mut()
+    }
+    // util methods
+    /// Turn a response into an error if the server returned an error.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wreq::Response;
+    /// fn on_response(res: Response) {
+    ///     match res.error_for_status() {
+    ///         Ok(_res) => (),
+    ///         Err(err) => {
+    ///             // asserting a 400 as an example
+    ///             // it could be any status between 400...599
+    ///             assert_eq!(err.status(), Some(wreq::StatusCode::BAD_REQUEST));
+    ///         }
+    ///     }
+    /// }
+    /// # fn main() {}
+    /// ```
+    pub fn error_for_status(mut self) -> crate::Result<Self> {
+        let status = self.status();
+        if status.is_client_error() || status.is_server_error() {
+            let reason = self.res.extensions_mut().remove::<ReasonPhrase>();
+            Err(Error::status_code(self.uri, status, reason))
+        } else {
+            Ok(self)
+        }
+    }
+    /// Turn a reference to a response into an error if the server returned an error.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wreq::Response;
+    /// fn on_response(res: &Response) {
+    ///     match res.error_for_status_ref() {
+    ///         Ok(_res) => (),
+    ///         Err(err) => {
+    ///             // asserting a 400 as an example
+    ///             // it could be any status between 400...599
+    ///             assert_eq!(err.status(), Some(wreq::StatusCode::BAD_REQUEST));
+    ///         }
+    ///     }
+    /// }
+    /// # fn main() {}
+    /// ```
+    pub fn error_for_status_ref(&self) -> crate::Result<&Self> {
+        let status = self.status();
+        if status.is_client_error() || status.is_server_error() {
+            let reason = self.res.extensions().get::<ReasonPhrase>().cloned();
+            Err(Error::status_code(self.uri.clone(), status, reason))
+        } else {
+            Ok(self)
+        }
+    }
+    /// Consumes the [`Response`] and returns a future for a possible HTTP upgrade.
+    pub async fn upgrade(self) -> crate::Result<Upgraded> {
+        upgrade::on(self.res).await.map_err(Error::upgrade)
+    }
+}
+/// I'm not sure this conversion is that useful... People should be encouraged
+/// to use [`http::Response`], not `wreq::Response`.
+impl<T: Into<Body>> From<http::Response<T>> for Response {
+    fn from(r: http::Response<T>) -> Response {
+        let mut res = r.map(Into::into);
+        let uri = res
+            .extensions_mut()
+            .remove::<RequestUri>()
+            .unwrap_or_else(|| RequestUri(Uri::from_static("http://no.url.provided.local")));
+        Response { res, uri: uri.0 }
+    }
+}
+/// A [`Response`] can be converted into a [`http::Response`].
+// It's supposed to be the inverse of the conversion above.
+impl From<Response> for http::Response<Body> {
+    fn from(r: Response) -> http::Response<Body> {
+        let mut res = r.res.map(Body::wrap);
+        res.extensions_mut().insert(RequestUri(r.uri));
+        res
+    }
+}
+/// A [`Response`] can be piped as the [`Body`] of another request.
+impl From<Response> for Body {
+    fn from(r: Response) -> Body {
+        Body::wrap(r.res.into_body())
+    }
+}
+/// A [`Response`] implements [`HttpBody`] to allow streaming the body.
+impl HttpBody for Response {
+    type Data = Bytes;
+    type Error = Error;
+    #[inline]
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
+        Pin::new(self.res.body_mut()).poll_frame(cx)
+    }
+    #[inline]
+    fn is_end_stream(&self) -> bool {
+        self.res.body().is_end_stream()
+    }
+    #[inline]
+    fn size_hint(&self) -> http_body::SizeHint {
+        self.res.body().size_hint()
+    }
+}

data/vendor/wreq/src/client/ws/json.rs ADDED Viewed

@@ -0,0 +1,99 @@
+use serde::{Serialize, de::DeserializeOwned};
+use super::{Message, Utf8Bytes};
+use crate::Error;
+impl Message {
+    /// Tries to serialize the JSON as a [`Message::Text`].
+    ///
+    /// # Optional
+    ///
+    /// This requires the optional `json` feature enabled.
+    ///
+    /// # Errors
+    ///
+    /// Serialization can fail if `T`'s implementation of `Serialize` decides to
+    /// fail, or if `T` contains a map with non-string keys.
+    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+    pub fn text_from_json<T: Serialize + ?Sized>(json: &T) -> crate::Result<Self> {
+        serde_json::to_string(json)
+            .map(Utf8Bytes::from)
+            .map(Message::Text)
+            .map_err(Error::decode)
+    }
+    /// Tries to serialize the JSON as a [`Message::Binary`].
+    ///
+    /// # Optional
+    ///
+    /// This requires that the optional `json` feature is enabled.
+    ///
+    /// # Errors
+    ///
+    /// Serialization can fail if `T`'s implementation of `Serialize` decides to
+    /// fail, or if `T` contains a map with non-string keys.
+    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+    pub fn binary_from_json<T: Serialize + ?Sized>(json: &T) -> crate::Result<Self> {
+        serde_json::to_vec(json)
+            .map(bytes::Bytes::from)
+            .map(Message::Binary)
+            .map_err(Error::decode)
+    }
+    /// Tries to deserialize the message body as JSON.
+    ///
+    /// # Optional
+    ///
+    /// This requires that the optional `json` feature is enabled.
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever the response body is not in `JSON` format,
+    /// or it cannot be properly deserialized to target type `T`.
+    ///
+    /// For more details please see [`serde_json::from_str`] and
+    /// [`serde_json::from_slice`].
+    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+    pub fn json<T: DeserializeOwned>(&self) -> crate::Result<T> {
+        use serde::de::Error as _;
+        match self {
+            Self::Text(x) => serde_json::from_str(x).map_err(Error::decode),
+            Self::Binary(x) => serde_json::from_slice(x).map_err(Error::decode),
+            Self::Ping(_) | Self::Pong(_) | Self::Close { .. } => Err(Error::decode(
+                serde_json::Error::custom("neither text nor binary"),
+            )),
+        }
+    }
+}
+#[cfg(test)]
+mod test {
+    use serde::{Deserialize, Serialize};
+    use super::Message;
+    #[derive(Default, Serialize, Deserialize)]
+    struct Content {
+        message: String,
+    }
+    #[test]
+    pub fn text_json() -> crate::Result<()> {
+        let content = Content::default();
+        let message = Message::text_from_json(&content)?;
+        assert!(matches!(message, Message::Text(_)));
+        let _: Content = message.json()?;
+        Ok(())
+    }
+    #[test]
+    pub fn binary_json() -> crate::Result<()> {
+        let content = Content::default();
+        let message = Message::binary_from_json(&content)?;
+        assert!(matches!(message, Message::Binary(_)));
+        let _: Content = message.json()?;
+        Ok(())
+    }
+}