wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/client/core/body.rs

@@ -1,34 +0,0 @@
-//! Streaming bodies for Requests and Responses
-//!
-//! For both [Clients](crate::client), requests and
-//! responses use streaming bodies, instead of complete buffering. This
-//! allows applications to not use memory they don't need, and allows exerting
-//! back-pressure on connections by only reading when asked.
-//!
-//! There are two pieces to this in crate::core::
-//!
-//! - **The [\`Body`\] trait** describes all possible bodies. crate::core: allows any body type that
-//!   implements `Body`, allowing applications to have fine-grained control over their streaming.
-//! - **The [`Incoming`] concrete type**, which is an implementation of `Body`, and returned by
-//!   crate::core: as a "receive stream" (so, for server requests and client responses).
-//!
-//! There are additional implementations available in [`http-body-util`][],
-//! such as a `Full` or `Empty` body.
-//!
-//! [`http-body-util`]: https://docs.rs/http-body-util
-
-mod incoming;
-mod length;
-
-pub(crate) use self::{
-    incoming::{Incoming, Sender},
-    length::DecodedLength,
-};
-
-fn _assert_send_sync() {
-    fn _assert_send<T: Send>() {}
-    fn _assert_sync<T: Sync>() {}
-
-    _assert_send::<Incoming>();
-    _assert_sync::<Incoming>();
-}

data/vendor/wreq/src/client/core/common/buf.rs

@@ -1,149 +0,0 @@
-use std::{collections::VecDeque, io::IoSlice};
-
-use bytes::{Buf, BufMut, Bytes, BytesMut};
-
-pub(crate) struct BufList<T> {
-    bufs: VecDeque<T>,
-}
-
-impl<T: Buf> BufList<T> {
-    pub(crate) fn new() -> BufList<T> {
-        BufList {
-            bufs: VecDeque::new(),
-        }
-    }
-
-    #[inline]
-    pub(crate) fn push(&mut self, buf: T) {
-        debug_assert!(buf.has_remaining());
-        self.bufs.push_back(buf);
-    }
-
-    #[inline]
-    pub(crate) fn bufs_cnt(&self) -> usize {
-        self.bufs.len()
-    }
-}
-
-impl<T: Buf> Buf for BufList<T> {
-    #[inline]
-    fn remaining(&self) -> usize {
-        self.bufs.iter().map(|buf| buf.remaining()).sum()
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        self.bufs.front().map(Buf::chunk).unwrap_or_default()
-    }
-
-    #[inline]
-    fn advance(&mut self, mut cnt: usize) {
-        while cnt > 0 {
-            {
-                let front = &mut self.bufs[0];
-                let rem = front.remaining();
-                if rem > cnt {
-                    front.advance(cnt);
-                    return;
-                } else {
-                    front.advance(rem);
-                    cnt -= rem;
-                }
-            }
-            self.bufs.pop_front();
-        }
-    }
-
-    #[inline]
-    fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
-        if dst.is_empty() {
-            return 0;
-        }
-        let mut vecs = 0;
-        for buf in &self.bufs {
-            vecs += buf.chunks_vectored(&mut dst[vecs..]);
-            if vecs == dst.len() {
-                break;
-            }
-        }
-        vecs
-    }
-
-    #[inline]
-    fn copy_to_bytes(&mut self, len: usize) -> Bytes {
-        // Our inner buffer may have an optimized version of copy_to_bytes, and if the whole
-        // request can be fulfilled by the front buffer, we can take advantage.
-        match self.bufs.front_mut() {
-            Some(front) if front.remaining() == len => {
-                let b = front.copy_to_bytes(len);
-                self.bufs.pop_front();
-                b
-            }
-            Some(front) if front.remaining() > len => front.copy_to_bytes(len),
-            _ => {
-                assert!(len <= self.remaining(), "`len` greater than remaining");
-                let mut bm = BytesMut::with_capacity(len);
-                bm.put(self.take(len));
-                bm.freeze()
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::ptr;
-
-    use super::*;
-
-    fn hello_world_buf() -> BufList<Bytes> {
-        BufList {
-            bufs: vec![Bytes::from("Hello"), Bytes::from(" "), Bytes::from("World")].into(),
-        }
-    }
-
-    #[test]
-    fn to_bytes_shorter() {
-        let mut bufs = hello_world_buf();
-        let old_ptr = bufs.chunk().as_ptr();
-        let start = bufs.copy_to_bytes(4);
-        assert_eq!(start, "Hell");
-        assert!(ptr::eq(old_ptr, start.as_ptr()));
-        assert_eq!(bufs.chunk(), b"o");
-        assert!(ptr::eq(old_ptr.wrapping_add(4), bufs.chunk().as_ptr()));
-        assert_eq!(bufs.remaining(), 7);
-    }
-
-    #[test]
-    fn to_bytes_eq() {
-        let mut bufs = hello_world_buf();
-        let old_ptr = bufs.chunk().as_ptr();
-        let start = bufs.copy_to_bytes(5);
-        assert_eq!(start, "Hello");
-        assert!(ptr::eq(old_ptr, start.as_ptr()));
-        assert_eq!(bufs.chunk(), b" ");
-        assert_eq!(bufs.remaining(), 6);
-    }
-
-    #[test]
-    fn to_bytes_longer() {
-        let mut bufs = hello_world_buf();
-        let start = bufs.copy_to_bytes(7);
-        assert_eq!(start, "Hello W");
-        assert_eq!(bufs.remaining(), 4);
-    }
-
-    #[test]
-    fn one_long_buf_to_bytes() {
-        let mut buf = BufList::new();
-        buf.push(b"Hello World" as &[_]);
-        assert_eq!(buf.copy_to_bytes(5), "Hello");
-        assert_eq!(buf.chunk(), b" World");
-    }
-
-    #[test]
-    #[should_panic(expected = "`len` greater than remaining")]
-    fn buf_to_bytes_too_many() {
-        hello_world_buf().copy_to_bytes(42);
-    }
-}

data/vendor/wreq/src/client/core/common/rewind.rs

@@ -1,141 +0,0 @@
-use std::{
-    cmp, io,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bytes::{Buf, Bytes};
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-
-/// Combine a buffer with an IO, rewinding reads to use the buffer.
-#[derive(Debug)]
-pub(crate) struct Rewind<T> {
-    pre: Option<Bytes>,
-    inner: T,
-}
-
-impl<T> Rewind<T> {
-    pub(crate) fn new_buffered(io: T, buf: Bytes) -> Self {
-        Rewind {
-            pre: Some(buf),
-            inner: io,
-        }
-    }
-
-    #[cfg(test)]
-    pub(crate) fn rewind(&mut self, bs: Bytes) {
-        debug_assert!(self.pre.is_none());
-        self.pre = Some(bs);
-    }
-}
-
-impl<T> AsyncRead for Rewind<T>
-where
-    T: AsyncRead + Unpin,
-{
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        if let Some(mut prefix) = self.pre.take() {
-            // If there are no remaining bytes, let the bytes get dropped.
-            if !prefix.is_empty() {
-                let copy_len = cmp::min(prefix.len(), buf.remaining());
-                // TODO: There should be a way to do following two lines cleaner...
-                buf.put_slice(&prefix[..copy_len]);
-                prefix.advance(copy_len);
-                // Put back what's left
-                if !prefix.is_empty() {
-                    self.pre = Some(prefix);
-                }
-
-                return Poll::Ready(Ok(()));
-            }
-        }
-        Pin::new(&mut self.inner).poll_read(cx, buf)
-    }
-}
-
-impl<T> AsyncWrite for Rewind<T>
-where
-    T: AsyncWrite + Unpin,
-{
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.inner).poll_write(cx, buf)
-    }
-
-    fn poll_write_vectored(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[io::IoSlice<'_>],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.inner).poll_write_vectored(cx, bufs)
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut self.inner).poll_flush(cx)
-    }
-
-    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        Pin::new(&mut self.inner).poll_shutdown(cx)
-    }
-
-    fn is_write_vectored(&self) -> bool {
-        self.inner.is_write_vectored()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use bytes::Bytes;
-    use tokio::io::AsyncReadExt;
-
-    use super::Rewind;
-
-    #[tokio::test]
-    async fn partial_rewind() {
-        let underlying = [104, 101, 108, 108, 111];
-
-        let mock = tokio_test::io::Builder::new().read(&underlying).build();
-
-        let mut stream = Rewind::new_buffered(mock, Bytes::new());
-
-        // Read off some bytes, ensure we filled o1
-        let mut buf = [0; 2];
-        stream.read_exact(&mut buf).await.expect("read1");
-
-        // Rewind the stream so that it is as if we never read in the first place.
-        stream.rewind(Bytes::copy_from_slice(&buf[..]));
-
-        let mut buf = [0; 5];
-        stream.read_exact(&mut buf).await.expect("read1");
-
-        // At this point we should have read everything that was in the MockStream
-        assert_eq!(&buf, &underlying);
-    }
-
-    #[tokio::test]
-    async fn full_rewind() {
-        let underlying = [104, 101, 108, 108, 111];
-
-        let mock = tokio_test::io::Builder::new().read(&underlying).build();
-
-        let mut stream = Rewind::new_buffered(mock, Bytes::new());
-
-        let mut buf = [0; 5];
-        stream.read_exact(&mut buf).await.expect("read1");
-
-        // Rewind the stream so that it is as if we never read in the first place.
-        stream.rewind(Bytes::copy_from_slice(&buf[..]));
-
-        let mut buf = [0; 5];
-        stream.read_exact(&mut buf).await.expect("read1");
-
-        assert_eq!(&buf, &underlying);
-    }
-}

data/vendor/wreq/src/client/core/common/watch.rs

@@ -1,76 +0,0 @@
-//! An SPSC broadcast channel.
-//!
-//! - The value can only be a `usize`.
-//! - The consumer is only notified if the value is different.
-//! - The value `0` is reserved for closed.
-
-use std::{
-    sync::{
-        Arc,
-        atomic::{AtomicUsize, Ordering},
-    },
-    task,
-};
-
-use futures_util::task::AtomicWaker;
-
-type Value = usize;
-
-pub(crate) const CLOSED: usize = 0;
-
-pub(crate) fn channel(initial: Value) -> (Sender, Receiver) {
-    debug_assert!(
-        initial != CLOSED,
-        "watch::channel initial state of 0 is reserved"
-    );
-
-    let shared = Arc::new(Shared {
-        value: AtomicUsize::new(initial),
-        waker: AtomicWaker::new(),
-    });
-
-    (
-        Sender {
-            shared: shared.clone(),
-        },
-        Receiver { shared },
-    )
-}
-
-pub(crate) struct Sender {
-    shared: Arc<Shared>,
-}
-
-pub(crate) struct Receiver {
-    shared: Arc<Shared>,
-}
-
-struct Shared {
-    value: AtomicUsize,
-    waker: AtomicWaker,
-}
-
-impl Sender {
-    pub(crate) fn send(&mut self, value: Value) {
-        if self.shared.value.swap(value, Ordering::SeqCst) != value {
-            self.shared.waker.wake();
-        }
-    }
-}
-
-impl Drop for Sender {
-    fn drop(&mut self) {
-        self.send(CLOSED);
-    }
-}
-
-impl Receiver {
-    pub(crate) fn load(&mut self, cx: &mut task::Context<'_>) -> Value {
-        self.shared.waker.register(cx.waker());
-        self.shared.value.load(Ordering::SeqCst)
-    }
-
-    pub(crate) fn peek(&self) -> Value {
-        self.shared.value.load(Ordering::Relaxed)
-    }
-}

data/vendor/wreq/src/client/core/common.rs

@@ -1,3 +0,0 @@
-pub(crate) mod buf;
-pub(crate) mod rewind;
-pub(crate) mod watch;