wreq-rb 0.3.0

data/vendor/wreq/src/client/emulation.rs

@@ -0,0 +1,161 @@
+use http::HeaderMap;
+
+use super::{
+    core::{http1::Http1Options, http2::Http2Options},
+    layer::config::TransportOptions,
+};
+use crate::{header::OrigHeaderMap, tls::TlsOptions};
+
+/// Factory trait for creating emulation configurations.
+///
+/// This trait allows different types (enums, structs, etc.) to provide
+/// their own emulation configurations. It's particularly useful for:
+/// - Predefined browser profiles
+/// - Dynamic configuration based on runtime conditions
+/// - User-defined custom emulation strategies
+pub trait EmulationFactory {
+    /// Creates an [`Emulation`] instance from this factory.
+    fn emulation(self) -> Emulation;
+}
+
+/// Builder for creating an [`Emulation`] configuration.
+#[derive(Debug)]
+#[must_use]
+pub struct EmulationBuilder {
+    emulation: Emulation,
+}
+
+/// HTTP emulation configuration for mimicking different HTTP clients.
+///
+/// This struct combines transport-layer options (HTTP/1, HTTP/2, TLS) with
+/// request-level settings (headers, header case preservation) to provide
+/// a complete emulation profile for web browsers, mobile applications,
+/// API clients, and other HTTP implementations.
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct Emulation {
+    headers: HeaderMap,
+    orig_headers: OrigHeaderMap,
+    transport: TransportOptions,
+}
+
+// ==== impl EmulationBuilder ====
+
+impl EmulationBuilder {
+    /// Sets the  HTTP/1 options configuration.
+    #[inline]
+    pub fn http1_options(mut self, opts: Http1Options) -> Self {
+        *self.emulation.http1_options_mut() = Some(opts);
+        self
+    }
+
+    /// Sets the HTTP/2 options configuration.
+    #[inline]
+    pub fn http2_options(mut self, opts: Http2Options) -> Self {
+        *self.emulation.http2_options_mut() = Some(opts);
+        self
+    }
+
+    /// Sets the  TLS options configuration.
+    #[inline]
+    pub fn tls_options(mut self, opts: TlsOptions) -> Self {
+        *self.emulation.tls_options_mut() = Some(opts);
+        self
+    }
+
+    /// Sets the default headers.
+    #[inline]
+    pub fn headers(mut self, src: HeaderMap) -> Self {
+        crate::util::replace_headers(&mut self.emulation.headers, src);
+        self
+    }
+
+    /// Sets the original headers.
+    #[inline]
+    pub fn orig_headers(mut self, src: OrigHeaderMap) -> Self {
+        self.emulation.orig_headers.extend(src);
+        self
+    }
+
+    /// Builds the [`Emulation`] instance.
+    #[inline]
+    pub fn build(self) -> Emulation {
+        self.emulation
+    }
+}
+
+// ==== impl Emulation ====
+
+impl Emulation {
+    /// Creates a new [`EmulationBuilder`].
+    #[inline]
+    pub fn builder() -> EmulationBuilder {
+        EmulationBuilder {
+            emulation: Emulation::default(),
+        }
+    }
+
+    /// Returns a mutable reference to the TLS options, if set.
+    #[inline]
+    pub fn tls_options_mut(&mut self) -> &mut Option<TlsOptions> {
+        self.transport.tls_options_mut()
+    }
+
+    /// Returns a mutable reference to the HTTP/1 options, if set.
+    #[inline]
+    pub fn http1_options_mut(&mut self) -> &mut Option<Http1Options> {
+        self.transport.http1_options_mut()
+    }
+
+    /// Returns a mutable reference to the HTTP/2 options, if set.
+    #[inline]
+    pub fn http2_options_mut(&mut self) -> &mut Option<Http2Options> {
+        self.transport.http2_options_mut()
+    }
+
+    /// Returns a mutable reference to the emulation headers, if set.
+    #[inline]
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        &mut self.headers
+    }
+
+    /// Returns a mutable reference to the original headers, if set.
+    #[inline]
+    pub fn orig_headers_mut(&mut self) -> &mut OrigHeaderMap {
+        &mut self.orig_headers
+    }
+
+    /// Decomposes the [`Emulation`] into its components.
+    #[inline]
+    pub(crate) fn into_parts(self) -> (TransportOptions, HeaderMap, OrigHeaderMap) {
+        (self.transport, self.headers, self.orig_headers)
+    }
+}
+
+impl EmulationFactory for Emulation {
+    #[inline]
+    fn emulation(self) -> Emulation {
+        self
+    }
+}
+
+impl EmulationFactory for Http1Options {
+    #[inline]
+    fn emulation(self) -> Emulation {
+        Emulation::builder().http1_options(self).build()
+    }
+}
+
+impl EmulationFactory for Http2Options {
+    #[inline]
+    fn emulation(self) -> Emulation {
+        Emulation::builder().http2_options(self).build()
+    }
+}
+
+impl EmulationFactory for TlsOptions {
+    #[inline]
+    fn emulation(self) -> Emulation {
+        Emulation::builder().tls_options(self).build()
+    }
+}

data/vendor/wreq/src/client/http/client/error.rs

@@ -0,0 +1,142 @@
+use std::{error::Error as StdError, fmt};
+
+use http::Request;
+
+use super::pool;
+#[cfg(feature = "socks")]
+use crate::client::conn::socks;
+use crate::{
+    client::{
+        conn::{Connected, tunnel},
+        core::{self},
+    },
+    error::{BoxError, ProxyConnect},
+};
+
+#[derive(Debug)]
+pub struct Error {
+    pub(super) kind: ErrorKind,
+    pub(super) source: Option<BoxError>,
+    pub(super) connect_info: Option<Connected>,
+}
+
+#[derive(Debug)]
+pub(super) enum ErrorKind {
+    Canceled,
+    ChannelClosed,
+    Connect,
+    ProxyConnect,
+    UserUnsupportedRequestMethod,
+    UserUnsupportedVersion,
+    UserAbsoluteUriRequired,
+    SendRequest,
+}
+
+pub(super) enum ClientConnectError {
+    Normal(Error),
+    CheckoutIsClosed(pool::Error),
+}
+
+#[allow(clippy::large_enum_variant)]
+pub(super) enum TrySendError<B> {
+    Retryable {
+        error: Error,
+        req: Request<B>,
+        connection_reused: bool,
+    },
+    Nope(Error),
+}
+
+// ==== impl Error ====
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "client error ({:?})", self.kind)
+    }
+}
+
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.source.as_ref().map(|e| &**e as _)
+    }
+}
+
+impl Error {
+    pub(super) fn new<E>(kind: ErrorKind, error: E) -> Self
+    where
+        E: Into<BoxError>,
+    {
+        let error = error.into();
+
+        let kind = if error.is::<tunnel::TunnelError>() || error.is::<ProxyConnect>() || {
+            #[cfg(feature = "socks")]
+            {
+                error.is::<socks::SocksError>()
+            }
+            #[cfg(not(feature = "socks"))]
+            {
+                false
+            }
+        } {
+            ErrorKind::ProxyConnect
+        } else {
+            kind
+        };
+
+        Self {
+            kind,
+            source: Some(error),
+            connect_info: None,
+        }
+    }
+
+    #[inline]
+    pub(super) fn new_kind(kind: ErrorKind) -> Self {
+        Self {
+            kind,
+            source: None,
+            connect_info: None,
+        }
+    }
+
+    /// Returns true if this was an error from [`ErrorKind::Connect`].
+    #[inline]
+    pub fn is_connect(&self) -> bool {
+        matches!(self.kind, ErrorKind::Connect)
+    }
+
+    /// Returns true if this was an error from [`ErrorKind::ProxyConnect`].
+    #[inline]
+    pub fn is_proxy_connect(&self) -> bool {
+        matches!(self.kind, ErrorKind::ProxyConnect)
+    }
+
+    /// Returns the info of the client connection on which this error occurred.
+    #[inline]
+    pub fn connect_info(&self) -> Option<&Connected> {
+        self.connect_info.as_ref()
+    }
+
+    #[inline]
+    pub(super) fn with_connect_info(self, connect_info: Connected) -> Self {
+        Self {
+            connect_info: Some(connect_info),
+            ..self
+        }
+    }
+
+    #[inline]
+    pub(super) fn is_canceled(&self) -> bool {
+        matches!(self.kind, ErrorKind::Canceled)
+    }
+
+    #[inline]
+    pub(super) fn tx(src: core::Error) -> Self {
+        Self::new(ErrorKind::SendRequest, src)
+    }
+
+    #[inline]
+    pub(super) fn closed(src: core::Error) -> Self {
+        Self::new(ErrorKind::ChannelClosed, src)
+    }
+}

data/vendor/wreq/src/client/http/client/exec.rs

@@ -0,0 +1,29 @@
+use std::{future::Future, pin::Pin, sync::Arc};
+
+use crate::client::core::rt::Executor;
+
+pub(crate) type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+// Either the user provides an executor for background tasks, or we use `tokio::spawn`.
+#[derive(Clone)]
+pub struct Exec(Arc<dyn Executor<BoxSendFuture> + Send + Sync>);
+
+// ===== impl Exec =====
+
+impl Exec {
+    pub(crate) fn new<E>(inner: E) -> Self
+    where
+        E: Executor<BoxSendFuture> + Send + Sync + 'static,
+    {
+        Exec(Arc::new(inner))
+    }
+}
+
+impl<F> Executor<F> for Exec
+where
+    F: Future<Output = ()> + Send + 'static,
+{
+    fn execute(&self, fut: F) {
+        self.0.execute(Box::pin(fut));
+    }
+}

data/vendor/wreq/src/client/http/client/extra.rs

@@ -0,0 +1,77 @@
+use std::sync::Arc;
+
+use http::{Uri, Version};
+
+use crate::{
+    client::{
+        conn::TcpConnectOptions,
+        layer::config::{RequestOptions, TransportOptions},
+    },
+    hash::HashMemo,
+    proxy::Matcher as ProxyMacher,
+    tls::{AlpnProtocol, TlsOptions},
+};
+
+/// Unique identity for a reusable connection.
+pub(crate) type ConnectIdentity = Arc<HashMemo<ConnectExtra>>;
+
+/// Metadata describing a reusable network connection.
+///
+/// [`ConnectExtra`] holds connection-specific parameters such as the target URI, ALPN protocol,
+/// proxy settings, and optional TCP/TLS options. Used for connection
+#[must_use]
+#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+pub(crate) struct ConnectExtra {
+    uri: Uri,
+    extra: Option<RequestOptions>,
+}
+
+impl ConnectExtra {
+    /// Create a new [`ConnectExtra`] with the given URI and extra.
+    #[inline]
+    pub(super) fn new<T>(uri: Uri, extra: T) -> Self
+    where
+        T: Into<Option<RequestOptions>>,
+    {
+        Self {
+            uri,
+            extra: extra.into(),
+        }
+    }
+
+    /// Return the negotiated [`AlpnProtocol`].
+    pub fn alpn_protocol(&self) -> Option<AlpnProtocol> {
+        match self
+            .extra
+            .as_ref()
+            .and_then(RequestOptions::enforced_version)
+        {
+            Some(Version::HTTP_11 | Version::HTTP_10 | Version::HTTP_09) => {
+                Some(AlpnProtocol::HTTP1)
+            }
+            Some(Version::HTTP_2) => Some(AlpnProtocol::HTTP2),
+            _ => None,
+        }
+    }
+
+    /// Return a reference to the [`ProxyMacher`].
+    #[inline]
+    pub fn proxy_matcher(&self) -> Option<&ProxyMacher> {
+        self.extra.as_ref().and_then(RequestOptions::proxy_matcher)
+    }
+
+    /// Return a reference to the [`TlsOptions`].
+    #[inline]
+    pub fn tls_options(&self) -> Option<&TlsOptions> {
+        self.extra
+            .as_ref()
+            .map(RequestOptions::transport_opts)
+            .and_then(TransportOptions::tls_options)
+    }
+
+    /// Return a reference to the [`TcpConnectOptions`].
+    #[inline]
+    pub fn tcp_options(&self) -> Option<&TcpConnectOptions> {
+        self.extra.as_ref().map(RequestOptions::tcp_connect_opts)
+    }
+}

data/vendor/wreq/src/client/http/client/lazy.rs

@@ -0,0 +1,79 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{self, Poll},
+};
+
+use pin_project_lite::pin_project;
+
+pub(crate) trait Started: Future {
+    fn started(&self) -> bool;
+}
+
+pub(crate) fn lazy<F, R>(func: F) -> Lazy<F, R>
+where
+    F: FnOnce() -> R,
+    R: Future + Unpin,
+{
+    Lazy {
+        inner: Inner::Init { func },
+    }
+}
+
+// FIXME: allow() required due to `impl Trait` leaking types to this lint
+pin_project! {
+    pub(crate) struct Lazy<F, R> {
+        #[pin]
+        inner: Inner<F, R>,
+    }
+}
+
+pin_project! {
+    #[project = InnerProj]
+    #[project_replace = InnerProjReplace]
+    enum Inner<F, R> {
+        Init { func: F },
+        Fut { #[pin] fut: R },
+        Empty,
+    }
+}
+
+impl<F, R> Started for Lazy<F, R>
+where
+    F: FnOnce() -> R,
+    R: Future,
+{
+    fn started(&self) -> bool {
+        match self.inner {
+            Inner::Init { .. } => false,
+            Inner::Fut { .. } | Inner::Empty => true,
+        }
+    }
+}
+
+impl<F, R> Future for Lazy<F, R>
+where
+    F: FnOnce() -> R,
+    R: Future,
+{
+    type Output = R::Output;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+
+        if let InnerProj::Fut { fut } = this.inner.as_mut().project() {
+            return fut.poll(cx);
+        }
+
+        match this.inner.as_mut().project_replace(Inner::Empty) {
+            InnerProjReplace::Init { func } => {
+                this.inner.set(Inner::Fut { fut: func() });
+                if let InnerProj::Fut { fut } = this.inner.project() {
+                    return fut.poll(cx);
+                }
+                unreachable!()
+            }
+            _ => unreachable!("lazy state wrong"),
+        }
+    }
+}