forked/reqwest-impersonate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

port all optional features to 2018-edition

Browse Source
This commit is contained in:
Daniel Eades
2019-08-08 18:47:12 +01:00
committed by Sean McArthur
parent 4773408ae4
commit 3ba4b6eadf
20 changed files with 103 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/async_impl/body.rs
View File

@@ -13,7 +13,7 @@ pub struct Body {
enum Inner { enum Inner {
Reusable(Bytes), Reusable(Bytes),
Hyper { Hyper {
body: ::hyper::Body, body: hyper::Body,
timeout: Option<Delay>, timeout: Option<Delay>,
} }
} }
@@ -27,7 +27,7 @@ impl Body {
} }
#[inline] #[inline]
pub(crate) fn response(body: ::hyper::Body, timeout: Option<Delay>) -> Body { pub(crate) fn response(body: hyper::Body, timeout: Option<Delay>) -> Body {
Body { Body {
inner: Inner::Hyper { inner: Inner::Hyper {
body, body,
@@ -37,7 +37,7 @@ impl Body {
} }
#[inline] #[inline]
pub(crate) fn wrap(body: ::hyper::Body) -> Body { pub(crate) fn wrap(body: hyper::Body) -> Body {
Body { Body {
inner: Inner::Hyper { inner: Inner::Hyper {
body, body,
@@ -59,7 +59,7 @@ impl Body {
} }
#[inline] #[inline]
pub(crate) fn into_hyper(self) -> (Option<Bytes>, ::hyper::Body) { pub(crate) fn into_hyper(self) -> (Option<Bytes>, hyper::Body) {
match self.inner { match self.inner {
Inner::Reusable(chunk) => (Some(chunk.clone()), chunk.into()), Inner::Reusable(chunk) => (Some(chunk.clone()), chunk.into()),
Inner::Hyper { body, timeout } => { Inner::Hyper { body, timeout } => {
@@ -154,14 +154,14 @@ where
/// A `Chunk` can be treated like `&[u8]`. /// A `Chunk` can be treated like `&[u8]`.
#[derive(Default)] #[derive(Default)]
pub struct Chunk { pub struct Chunk {
inner: ::hyper::Chunk, inner: hyper::Chunk,
} }
impl Chunk { impl Chunk {
#[inline] #[inline]
pub(crate) fn from_chunk(chunk: Bytes) -> Chunk { pub(crate) fn from_chunk(chunk: Bytes) -> Chunk {
Chunk { Chunk {
inner: ::hyper::Chunk::from(chunk) inner: hyper::Chunk::from(chunk)
} }
} }
} }
@@ -186,7 +186,7 @@ impl AsRef<[u8]> for Chunk {
} }
} }
impl ::std::ops::Deref for Chunk { impl std::ops::Deref for Chunk {
type Target = [u8]; type Target = [u8];
#[inline] #[inline]
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {

20
src/async_impl/client.rs
View File

@@ -109,7 +109,7 @@ impl ClientBuilder {
#[cfg(feature = "tls")] #[cfg(feature = "tls")]
certs_verification: true, certs_verification: true,
connect_timeout: None, connect_timeout: None,
max_idle_per_host: ::std::usize::MAX, max_idle_per_host: std::usize::MAX,
proxies: Vec::new(), proxies: Vec::new(),
redirect_policy: RedirectPolicy::default(), redirect_policy: RedirectPolicy::default(),
referer: true, referer: true,
@@ -160,9 +160,9 @@ impl ClientBuilder {
}, },
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
TlsBackend::Rustls => { TlsBackend::Rustls => {
use ::tls::NoVerifier; use crate::tls::NoVerifier;
let mut tls = ::rustls::ClientConfig::new(); let mut tls = rustls::ClientConfig::new();
if config.http2_only { if config.http2_only {
tls.set_protocols(&["h2".into()]); tls.set_protocols(&["h2".into()]);
} else { } else {
@@ -195,7 +195,7 @@ impl ClientBuilder {
connector.set_timeout(config.connect_timeout); connector.set_timeout(config.connect_timeout);
let mut builder = ::hyper::Client::builder(); let mut builder = hyper::Client::builder();
if config.http2_only { if config.http2_only {
builder.http2_only(true); builder.http2_only(true);
} }
@@ -441,7 +441,7 @@ impl ClientBuilder {
} }
} }
type HyperClient = ::hyper::Client<Connector>; type HyperClient = hyper::Client<Connector>;
impl Client { impl Client {
/// Constructs a new `Client`. /// Constructs a new `Client`.
@@ -590,13 +590,13 @@ impl Client {
(Some(reusable), body) (Some(reusable), body)
}, },
None => { None => {
(None, ::hyper::Body::empty()) (None, hyper::Body::empty())
} }
}; };
self.proxy_auth(&uri, &mut headers); self.proxy_auth(&uri, &mut headers);
let mut req = ::hyper::Request::builder() let mut req = hyper::Request::builder()
.method(method.clone()) .method(method.clone())
.uri(uri.clone()) .uri(uri.clone())
.body(body) .body(body)
@@ -826,10 +826,10 @@ impl Future for PendingRequest {
debug!("redirecting to {:?} '{}'", self.method, self.url); debug!("redirecting to {:?} '{}'", self.method, self.url);
let uri = expect_uri(&self.url); let uri = expect_uri(&self.url);
let body = match self.body { let body = match self.body {
Some(Some(ref body)) => ::hyper::Body::from(body.clone()), Some(Some(ref body)) => hyper::Body::from(body.clone()),
_ => ::hyper::Body::empty(), _ => hyper::Body::empty(),
}; };
let mut req = ::hyper::Request::builder() let mut req = hyper::Request::builder()
.method(self.method.clone()) .method(self.method.clone())
.uri(uri.clone()) .uri(uri.clone())
.body(body) .body(body)

6
src/async_impl/multipart.rs
View File

@@ -512,7 +512,7 @@ mod tests {
// These prints are for debug purposes in case the test fails // These prints are for debug purposes in case the test fails
println!( println!(
"START REAL\n{}\nEND REAL", "START REAL\n{}\nEND REAL",
::std::str::from_utf8(&out).unwrap() std::str::from_utf8(&out).unwrap()
); );
println!("START EXPECTED\n{}\nEND EXPECTED", expected); println!("START EXPECTED\n{}\nEND EXPECTED", expected);
assert_eq!(::std::str::from_utf8(&out).unwrap(), expected); assert_eq!(::std::str::from_utf8(&out).unwrap(), expected);
@@ -538,10 +538,10 @@ mod tests {
// These prints are for debug purposes in case the test fails // These prints are for debug purposes in case the test fails
println!( println!(
"START REAL\n{}\nEND REAL", "START REAL\n{}\nEND REAL",
::std::str::from_utf8(&out).unwrap() std::str::from_utf8(&out).unwrap()
); );
println!("START EXPECTED\n{}\nEND EXPECTED", expected); println!("START EXPECTED\n{}\nEND EXPECTED", expected);
assert_eq!(::std::str::from_utf8(&out).unwrap(), expected); assert_eq!(std::str::from_utf8(&out).unwrap(), expected);
} }
#[test] #[test]

10
src/async_impl/request.rs
View File

@@ -142,11 +142,11 @@ impl RequestBuilder {
#[cfg(feature = "hyper-011")] #[cfg(feature = "hyper-011")]
pub fn header_011<H>(self, header: H) -> RequestBuilder pub fn header_011<H>(self, header: H) -> RequestBuilder
where where
H: ::hyper_011::header::Header, H: crate::hyper_011::header::Header,
{ {
let mut headers = ::hyper_011::Headers::new(); let mut headers = crate::hyper_011::Headers::new();
headers.set(header); headers.set(header);
let map = ::header::HeaderMap::from(headers); let map = crate::header::HeaderMap::from(headers);
self.headers(map) self.headers(map)
} }
@@ -155,8 +155,8 @@ impl RequestBuilder {
/// This method is provided to ease migration, and requires the `hyper-011` /// This method is provided to ease migration, and requires the `hyper-011`
/// Cargo feature enabled on `reqwest`. /// Cargo feature enabled on `reqwest`.
#[cfg(feature = "hyper-011")] #[cfg(feature = "hyper-011")]
pub fn headers_011(self, headers: ::hyper_011::Headers) -> RequestBuilder { pub fn headers_011(self, headers: crate::hyper_011::Headers) -> RequestBuilder {
let map = ::header::HeaderMap::from(headers); let map = crate::header::HeaderMap::from(headers);
self.headers(map) self.headers(map)
} }

2
src/async_impl/response.rs
View File

@@ -37,7 +37,7 @@ pub struct Response {
} }
impl Response { impl Response {
pub(super) fn new(res: ::hyper::Response<::hyper::Body>, url: Url, gzip: bool, timeout: Option<Delay>) -> Response { pub(super) fn new(res: hyper::Response<::hyper::Body>, url: Url, gzip: bool, timeout: Option<Delay>) -> Response {
let (parts, body) = res.into_parts(); let (parts, body) = res.into_parts();
let status = parts.status; let status = parts.status;
let version = parts.version; let version = parts.version;

2
src/client.rs
View File

@@ -603,7 +603,7 @@ impl ClientHandle {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
}); });
::tokio::spawn(task); tokio::spawn(task);
Ok(()) Ok(())
}); });

45
src/connect.rs
View File

@@ -1,9 +1,8 @@
use futures::{Future, try_ready}; use futures::Future;
use http::uri::Scheme; use http::uri::Scheme;
use hyper::client::connect::{Connect, Connected, Destination}; use hyper::client::connect::{Connect, Connected, Destination};
use tokio_io::{AsyncRead, AsyncWrite}; use tokio_io::{AsyncRead, AsyncWrite};
use tokio_timer::Timeout; use tokio_timer::Timeout;
use log::{trace, debug};
#[cfg(feature = "default-tls")] #[cfg(feature = "default-tls")]
use native_tls::{TlsConnector, TlsConnectorBuilder}; use native_tls::{TlsConnector, TlsConnectorBuilder};
@@ -18,13 +17,13 @@ use std::net::IpAddr;
use std::time::Duration; use std::time::Duration;
#[cfg(feature = "trust-dns")] #[cfg(feature = "trust-dns")]
use dns::TrustDnsResolver; use crate::dns::TrustDnsResolver;
use crate::proxy::{Proxy, ProxyScheme}; use crate::proxy::{Proxy, ProxyScheme};
#[cfg(feature = "trust-dns")] #[cfg(feature = "trust-dns")]
type HttpConnector = ::hyper::client::HttpConnector<TrustDnsResolver>; type HttpConnector = hyper::client::HttpConnector<TrustDnsResolver>;
#[cfg(not(feature = "trust-dns"))] #[cfg(not(feature = "trust-dns"))]
type HttpConnector = ::hyper::client::HttpConnector; type HttpConnector = hyper::client::HttpConnector;
pub(crate) struct Connector { pub(crate) struct Connector {
@@ -50,7 +49,7 @@ enum Inner {
impl Connector { impl Connector {
#[cfg(not(feature = "tls"))] #[cfg(not(feature = "tls"))]
pub(crate) fn new<T>(proxies: Arc<Vec<Proxy>>, local_addr: T, nodelay: bool) -> ::Result<Connector> pub(crate) fn new<T>(proxies: Arc<Vec<Proxy>>, local_addr: T, nodelay: bool) -> crate::Result<Connector>
where where
T: Into<Option<IpAddr>> T: Into<Option<IpAddr>>
{ {
@@ -93,7 +92,7 @@ impl Connector {
tls: rustls::ClientConfig, tls: rustls::ClientConfig,
proxies: Arc<Vec<Proxy>>, proxies: Arc<Vec<Proxy>>,
local_addr: T, local_addr: T,
nodelay: bool) -> ::Result<Connector> nodelay: bool) -> crate::Result<Connector>
where where
T: Into<Option<IpAddr>>, T: Into<Option<IpAddr>>,
{ {
@@ -197,10 +196,10 @@ impl Connector {
} }
#[cfg(feature = "trust-dns")] #[cfg(feature = "trust-dns")]
fn http_connector() -> ::Result<HttpConnector> { fn http_connector() -> crate::Result<HttpConnector> {
TrustDnsResolver::new() TrustDnsResolver::new()
.map(HttpConnector::new_with_resolver) .map(HttpConnector::new_with_resolver)
.map_err(::error::dns_system_conf) .map_err(crate::error::dns_system_conf)
} }
#[cfg(not(feature = "trust-dns"))] #[cfg(not(feature = "trust-dns"))]
@@ -250,10 +249,10 @@ impl Connect for Connector {
http.set_nodelay(nodelay || ($dst.scheme() == "https")); http.set_nodelay(nodelay || ($dst.scheme() == "https"));
let http = ::hyper_tls::HttpsConnector::from((http, tls.clone())); let http = hyper_tls::HttpsConnector::from((http, tls.clone()));
timeout!(http.connect($dst) timeout!(http.connect($dst)
.and_then(move |(io, connected)| { .and_then(move |(io, connected)| {
if let ::hyper_tls::MaybeHttpsStream::Https(stream) = &io { if let hyper_tls::MaybeHttpsStream::Https(stream) = &io {
if !nodelay { if !nodelay {
stream.get_ref().get_ref().set_nodelay(false)?; stream.get_ref().get_ref().set_nodelay(false)?;
} }
@@ -271,10 +270,10 @@ impl Connect for Connector {
// https://www.openssl.org/docs/man1.1.1/man3/SSL_connect.html#NOTES // https://www.openssl.org/docs/man1.1.1/man3/SSL_connect.html#NOTES
http.set_nodelay(nodelay || ($dst.scheme() == "https")); http.set_nodelay(nodelay || ($dst.scheme() == "https"));
let http = ::hyper_rustls::HttpsConnector::from((http, tls.clone())); let http = hyper_rustls::HttpsConnector::from((http, tls.clone()));
timeout!(http.connect($dst) timeout!(http.connect($dst)
.and_then(move |(io, connected)| { .and_then(move |(io, connected)| {
if let ::hyper_rustls::MaybeHttpsStream::Https(stream) = &io { if let hyper_rustls::MaybeHttpsStream::Https(stream) = &io {
if !nodelay { if !nodelay {
let (io, _) = stream.get_ref(); let (io, _) = stream.get_ref();
io.set_nodelay(false)?; io.set_nodelay(false)?;
@@ -290,7 +289,7 @@ impl Connect for Connector {
for prox in self.proxies.iter() { for prox in self.proxies.iter() {
if let Some(proxy_scheme) = prox.intercept(&dst) { if let Some(proxy_scheme) = prox.intercept(&dst) {
trace!("proxy({:?}) intercepts {:?}", proxy_scheme, dst); log::trace!("proxy({:?}) intercepts {:?}", proxy_scheme, dst);
let (puri, _auth) = match proxy_scheme { let (puri, _auth) = match proxy_scheme {
ProxyScheme::Http { uri, auth, .. } => (uri, auth), ProxyScheme::Http { uri, auth, .. } => (uri, auth),
@@ -324,10 +323,10 @@ impl Connect for Connector {
let port = dst.port().unwrap_or(443); let port = dst.port().unwrap_or(443);
let mut http = http.clone(); let mut http = http.clone();
http.set_nodelay(nodelay); http.set_nodelay(nodelay);
let http = ::hyper_tls::HttpsConnector::from((http, tls.clone())); let http = hyper_tls::HttpsConnector::from((http, tls.clone()));
let tls = tls.clone(); let tls = tls.clone();
return timeout!(http.connect(ndst).and_then(move |(conn, connected)| { return timeout!(http.connect(ndst).and_then(move |(conn, connected)| {
trace!("tunneling HTTPS over proxy"); log::trace!("tunneling HTTPS over proxy");
tunnel(conn, host.clone(), port, auth) tunnel(conn, host.clone(), port, auth)
.and_then(move |tunneled| { .and_then(move |tunneled| {
tls.connect_async(&host, tunneled) tls.connect_async(&host, tunneled)
@@ -346,10 +345,10 @@ impl Connect for Connector {
let port = dst.port().unwrap_or(443); let port = dst.port().unwrap_or(443);
let mut http = http.clone(); let mut http = http.clone();
http.set_nodelay(nodelay); http.set_nodelay(nodelay);
let http = ::hyper_rustls::HttpsConnector::from((http, tls_proxy.clone())); let http = hyper_rustls::HttpsConnector::from((http, tls_proxy.clone()));
let tls = tls.clone(); let tls = tls.clone();
return timeout!(http.connect(ndst).and_then(move |(conn, connected)| { return timeout!(http.connect(ndst).and_then(move |(conn, connected)| {
trace!("tunneling HTTPS over proxy"); log::trace!("tunneling HTTPS over proxy");
let maybe_dnsname = DNSNameRef::try_from_ascii_str(&host) let maybe_dnsname = DNSNameRef::try_from_ascii_str(&host)
.map(|dnsname| dnsname.to_owned()) .map(|dnsname| dnsname.to_owned())
.map_err(|_| io::Error::new(io::ErrorKind::Other, "Invalid DNS Name")); .map_err(|_| io::Error::new(io::ErrorKind::Other, "Invalid DNS Name"));
@@ -395,7 +394,7 @@ fn tunnel<T>(conn: T, host: String, port: u16, auth: Option<::http::header::Head
", host, port).into_bytes(); ", host, port).into_bytes();
if let Some(value) = auth { if let Some(value) = auth {
debug!("tunnel to {}:{} using basic auth", host, port); log::debug!("tunnel to {}:{} using basic auth", host, port);
buf.extend_from_slice(b"Proxy-Authorization: "); buf.extend_from_slice(b"Proxy-Authorization: ");
buf.extend_from_slice(value.as_bytes()); buf.extend_from_slice(value.as_bytes());
buf.extend_from_slice(b"\r\n"); buf.extend_from_slice(b"\r\n");
@@ -435,7 +434,7 @@ where
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop { loop {
if let TunnelState::Writing = self.state { if let TunnelState::Writing = self.state {
let n = try_ready!(self.conn.as_mut().unwrap().write_buf(&mut self.buf)); let n = futures::try_ready!(self.conn.as_mut().unwrap().write_buf(&mut self.buf));
if !self.buf.has_remaining_mut() { if !self.buf.has_remaining_mut() {
self.state = TunnelState::Reading; self.state = TunnelState::Reading;
self.buf.get_mut().truncate(0); self.buf.get_mut().truncate(0);
@@ -443,7 +442,7 @@ where
return Err(tunnel_eof()); return Err(tunnel_eof());
} }
} else { } else {
let n = try_ready!(self.conn.as_mut().unwrap().read_buf(&mut self.buf.get_mut())); let n = futures::try_ready!(self.conn.as_mut().unwrap().read_buf(&mut self.buf.get_mut()));
let read = &self.buf.get_ref()[..]; let read = &self.buf.get_ref()[..];
if n == 0 { if n == 0 {
return Err(tunnel_eof()); return Err(tunnel_eof());
@@ -497,7 +496,7 @@ mod native_tls_async {
/// and both the server and the client are ready for receiving and sending /// and both the server and the client are ready for receiving and sending
/// data. Bytes read from a `TlsStream` are decrypted from `S` and bytes written /// data. Bytes read from a `TlsStream` are decrypted from `S` and bytes written
/// to a `TlsStream` are encrypted when passing through to `S`. /// to a `TlsStream` are encrypted when passing through to `S`.
#[derive(Debug)] #[derive(log::debug)]
pub struct TlsStream<S> { pub struct TlsStream<S> {
inner: native_tls::TlsStream<S>, inner: native_tls::TlsStream<S>,
} }
@@ -628,7 +627,7 @@ mod socks {
use tokio::{net::TcpStream, reactor}; use tokio::{net::TcpStream, reactor};
use super::{Connecting}; use super::{Connecting};
use proxy::{ProxyScheme}; use crate::proxy::{ProxyScheme};
pub(super) enum DnsResolve { pub(super) enum DnsResolve {
Local, Local,

4
src/cookie.rs
View File

@@ -7,7 +7,7 @@ use std::fmt;
use std::time::SystemTime; use std::time::SystemTime;
/// Convert a time::Tm time to SystemTime. /// Convert a time::Tm time to SystemTime.
fn tm_to_systemtime(tm: ::time::Tm) -> SystemTime { fn tm_to_systemtime(tm: time::Tm) -> SystemTime {
let seconds = tm.to_timespec().sec; let seconds = tm.to_timespec().sec;
let duration = std::time::Duration::from_secs(seconds.abs() as u64); let duration = std::time::Duration::from_secs(seconds.abs() as u64);
if seconds > 0 { if seconds > 0 {
@@ -129,7 +129,7 @@ pub(crate) fn extract_response_cookies<'a>(
/// A persistent cookie store that provides session support. /// A persistent cookie store that provides session support.
#[derive(Default)] #[derive(Default)]
pub(crate) struct CookieStore(pub(crate) ::cookie_store::CookieStore); pub(crate) struct CookieStore(pub(crate) cookie_store::CookieStore);
impl<'a> fmt::Debug for CookieStore { impl<'a> fmt::Debug for CookieStore {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

28
src/error.rs
View File

@@ -64,7 +64,7 @@ struct Inner {
/// A `Result` alias where the `Err` case is `reqwest::Error`. /// A `Result` alias where the `Err` case is `reqwest::Error`.
pub type Result<T> = ::std::result::Result<T, Error>; pub type Result<T> = std::result::Result<T, Error>;
impl Error { impl Error {
fn new(kind: Kind, url: Option<Url>) -> Error { fn new(kind: Kind, url: Option<Url>) -> Error {
@@ -416,21 +416,21 @@ pub(crate) enum Kind {
impl From<::http::Error> for Kind { impl From<::http::Error> for Kind {
#[inline] #[inline]
fn from(err: ::http::Error) -> Kind { fn from(err: http::Error) -> Kind {
Kind::Http(err) Kind::Http(err)
} }
} }
impl From<::hyper::Error> for Kind { impl From<::hyper::Error> for Kind {
#[inline] #[inline]
fn from(err: ::hyper::Error) -> Kind { fn from(err: hyper::Error) -> Kind {
Kind::Hyper(err) Kind::Hyper(err)
} }
} }
impl From<::mime::FromStrError> for Kind { impl From<::mime::FromStrError> for Kind {
#[inline] #[inline]
fn from(err: ::mime::FromStrError) -> Kind { fn from(err: mime::FromStrError) -> Kind {
Kind::Mime(err) Kind::Mime(err)
} }
} }
@@ -444,35 +444,35 @@ impl From<io::Error> for Kind {
impl From<::url::ParseError> for Kind { impl From<::url::ParseError> for Kind {
#[inline] #[inline]
fn from(err: ::url::ParseError) -> Kind { fn from(err: url::ParseError) -> Kind {
Kind::Url(err) Kind::Url(err)
} }
} }
impl From<::serde_urlencoded::ser::Error> for Kind { impl From<::serde_urlencoded::ser::Error> for Kind {
#[inline] #[inline]
fn from(err: ::serde_urlencoded::ser::Error) -> Kind { fn from(err: serde_urlencoded::ser::Error) -> Kind {
Kind::UrlEncoded(err) Kind::UrlEncoded(err)
} }
} }
impl From<::serde_json::Error> for Kind { impl From<::serde_json::Error> for Kind {
#[inline] #[inline]
fn from(err: ::serde_json::Error) -> Kind { fn from(err: serde_json::Error) -> Kind {
Kind::Json(err) Kind::Json(err)
} }
} }
#[cfg(feature = "default-tls")] #[cfg(feature = "default-tls")]
impl From<::native_tls::Error> for Kind { impl From<::native_tls::Error> for Kind {
fn from(err: ::native_tls::Error) -> Kind { fn from(err: native_tls::Error) -> Kind {
Kind::NativeTls(err) Kind::NativeTls(err)
} }
} }
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
impl From<::rustls::TLSError> for Kind { impl From<::rustls::TLSError> for Kind {
fn from(err: ::rustls::TLSError) -> Kind { fn from(err: rustls::TLSError) -> Kind {
Kind::Rustls(err) Kind::Rustls(err)
} }
} }
@@ -495,7 +495,7 @@ impl From<EnterError> for Kind {
} }
impl From<::tokio::timer::Error> for Kind { impl From<::tokio::timer::Error> for Kind {
fn from(_err: ::tokio::timer::Error) -> Kind { fn from(_err: tokio::timer::Error) -> Kind {
Kind::Timer Kind::Timer
} }
} }
@@ -576,7 +576,7 @@ macro_rules! try_io {
($e:expr) => ( ($e:expr) => (
match $e { match $e {
Ok(v) => v, Ok(v) => v,
Err(ref err) if err.kind() == ::std::io::ErrorKind::WouldBlock => { Err(ref err) if err.kind() == std::io::ErrorKind::WouldBlock => {
return Ok(::futures::Async::NotReady); return Ok(::futures::Async::NotReady);
} }
Err(err) => { Err(err) => {
@@ -653,15 +653,15 @@ mod tests {
} }
let root = Chain(None::<Error>); let root = Chain(None::<Error>);
let io = ::std::io::Error::new(::std::io::ErrorKind::Other, root); let io = std::io::Error::new(::std::io::ErrorKind::Other, root);
let err = Error::new(Kind::Io(io), None); let err = Error::new(Kind::Io(io), None);
assert!(err.cause().is_none()); assert!(err.cause().is_none());
assert_eq!(err.to_string(), "root"); assert_eq!(err.to_string(), "root");
let root = ::std::io::Error::new(::std::io::ErrorKind::Other, Chain(None::<Error>)); let root = std::io::Error::new(::std::io::ErrorKind::Other, Chain(None::<Error>));
let link = Chain(Some(root)); let link = Chain(Some(root));
let io = ::std::io::Error::new(::std::io::ErrorKind::Other, link); let io = std::io::Error::new(::std::io::ErrorKind::Other, link);
let err = Error::new(Kind::Io(io), None); let err = Error::new(Kind::Io(io), None);
assert!(err.cause().is_some()); assert!(err.cause().is_some());
assert_eq!(err.to_string(), "chain: root"); assert_eq!(err.to_string(), "chain: root");

2
src/into_url.rs
View File

@@ -38,7 +38,7 @@ impl<'a> PolyfillTryInto for &'a String {
} }
} }
pub(crate) fn expect_uri(url: &Url) -> ::hyper::Uri { pub(crate) fn expect_uri(url: &Url) -> hyper::Uri {
url.as_str().parse().expect("a parsed Url should always be a valid Uri") url.as_str().parse().expect("a parsed Url should always be a valid Uri")
} }

8
src/multipart.rs
View File

@@ -95,7 +95,7 @@ impl Form {
/// # Examples /// # Examples
/// ///
/// ```no_run /// ```no_run
/// # fn run() -> ::std::io::Result<()> { /// # fn run() -> std::io::Result<()> {
/// let files = reqwest::multipart::Form::new() /// let files = reqwest::multipart::Form::new()
/// .file("key", "/path/to/file")?; /// .file("key", "/path/to/file")?;
/// # Ok(()) /// # Ok(())
@@ -410,7 +410,7 @@ mod tests {
// These prints are for debug purposes in case the test fails // These prints are for debug purposes in case the test fails
println!( println!(
"START REAL\n{}\nEND REAL", "START REAL\n{}\nEND REAL",
::std::str::from_utf8(&output).unwrap() std::str::from_utf8(&output).unwrap()
); );
println!("START EXPECTED\n{}\nEND EXPECTED", expected); println!("START EXPECTED\n{}\nEND EXPECTED", expected);
assert_eq!(::std::str::from_utf8(&output).unwrap(), expected); assert_eq!(::std::str::from_utf8(&output).unwrap(), expected);
@@ -446,7 +446,7 @@ mod tests {
// These prints are for debug purposes in case the test fails // These prints are for debug purposes in case the test fails
println!( println!(
"START REAL\n{}\nEND REAL", "START REAL\n{}\nEND REAL",
::std::str::from_utf8(&output).unwrap() std::str::from_utf8(&output).unwrap()
); );
println!("START EXPECTED\n{}\nEND EXPECTED", expected); println!("START EXPECTED\n{}\nEND EXPECTED", expected);
assert_eq!(::std::str::from_utf8(&output).unwrap(), expected); assert_eq!(::std::str::from_utf8(&output).unwrap(), expected);
@@ -471,7 +471,7 @@ mod tests {
// These prints are for debug purposes in case the test fails // These prints are for debug purposes in case the test fails
println!( println!(
"START REAL\n{}\nEND REAL", "START REAL\n{}\nEND REAL",
::std::str::from_utf8(&output).unwrap() std::str::from_utf8(&output).unwrap()
); );
println!("START EXPECTED\n{}\nEND EXPECTED", expected); println!("START EXPECTED\n{}\nEND EXPECTED", expected);
assert_eq!(::std::str::from_utf8(&output).unwrap(), expected); assert_eq!(::std::str::from_utf8(&output).unwrap(), expected);

8
src/proxy.rs
View File

@@ -52,7 +52,7 @@ pub struct Proxy {
pub enum ProxyScheme { pub enum ProxyScheme {
Http { Http {
auth: Option<HeaderValue>, auth: Option<HeaderValue>,
uri: ::hyper::Uri, uri: hyper::Uri,
}, },
#[cfg(feature = "socks")] #[cfg(feature = "socks")]
Socks5 { Socks5 {
@@ -279,7 +279,7 @@ impl ProxyScheme {
/// ///
/// Current SOCKS5 support is provided via blocking IO. /// Current SOCKS5 support is provided via blocking IO.
#[cfg(feature = "socks")] #[cfg(feature = "socks")]
fn socks5(addr: SocketAddr) -> ::Result<Self> { fn socks5(addr: SocketAddr) -> crate::Result<Self> {
Ok(ProxyScheme::Socks5 { Ok(ProxyScheme::Socks5 {
addr, addr,
auth: None, auth: None,
@@ -295,7 +295,7 @@ impl ProxyScheme {
/// ///
/// Current SOCKS5 support is provided via blocking IO. /// Current SOCKS5 support is provided via blocking IO.
#[cfg(feature = "socks")] #[cfg(feature = "socks")]
fn socks5h(addr: SocketAddr) -> ::Result<Self> { fn socks5h(addr: SocketAddr) -> crate::Result<Self> {
Ok(ProxyScheme::Socks5 { Ok(ProxyScheme::Socks5 {
addr, addr,
auth: None, auth: None,
@@ -337,7 +337,7 @@ impl ProxyScheme {
let mut addr = try_!(host_and_port.to_socket_addrs()); let mut addr = try_!(host_and_port.to_socket_addrs());
addr addr
.next() .next()
.ok_or_else(::error::unknown_proxy_scheme) .ok_or_else(crate::error::unknown_proxy_scheme)
}; };
let mut scheme = match url.scheme() { let mut scheme = match url.scheme() {

6
src/redirect.rs
View File

@@ -261,12 +261,12 @@ and the compiler could not infer the lifetimes of those references. That means
people would need to annotate the closure's argument types, which is garbase. people would need to annotate the closure's argument types, which is garbase.
pub trait Redirect { pub trait Redirect {
fn redirect(&self, next: &Url, previous: &[Url]) -> ::Result<bool>; fn redirect(&self, next: &Url, previous: &[Url]) -> Result<bool>;
} }
impl<F> Redirect for F impl<F> Redirect for F
where F: Fn(&Url, &[Url]) -> ::Result<bool> { where F: Fn(&Url, &[Url]) -> Result<bool> {
fn redirect(&self, next: &Url, previous: &[Url]) -> ::Result<bool> { fn redirect(&self, next: &Url, previous: &[Url]) -> Result<bool> {
self(next, previous) self(next, previous)
} }
} }

10
src/request.rs
View File

@@ -200,11 +200,11 @@ impl RequestBuilder {
#[cfg(feature = "hyper-011")] #[cfg(feature = "hyper-011")]
pub fn header_011<H>(self, header: H) -> RequestBuilder pub fn header_011<H>(self, header: H) -> RequestBuilder
where where
H: ::hyper_011::header::Header, H: crate::hyper_011::header::Header,
{ {
let mut headers = ::hyper_011::Headers::new(); let mut headers = crate::hyper_011::Headers::new();
headers.set(header); headers.set(header);
let map = ::header::HeaderMap::from(headers); let map = crate::header::HeaderMap::from(headers);
self.headers(map) self.headers(map)
} }
@@ -213,8 +213,8 @@ impl RequestBuilder {
/// This method is provided to ease migration, and requires the `hyper-011` /// This method is provided to ease migration, and requires the `hyper-011`
/// Cargo feature enabled on `reqwest`. /// Cargo feature enabled on `reqwest`.
#[cfg(feature = "hyper-011")] #[cfg(feature = "hyper-011")]
pub fn headers_011(self, headers: ::hyper_011::Headers) -> RequestBuilder { pub fn headers_011(self, headers: crate::hyper_011::Headers) -> RequestBuilder {
let map = ::header::HeaderMap::from(headers); let map = crate::header::HeaderMap::from(headers);
self.headers(map) self.headers(map)
} }

24
src/tls.rs
View File

@@ -8,7 +8,7 @@ use tokio_rustls::webpki::DNSNameRef;
#[derive(Clone)] #[derive(Clone)]
pub struct Certificate { pub struct Certificate {
#[cfg(feature = "default-tls")] #[cfg(feature = "default-tls")]
native: ::native_tls::Certificate, native: native_tls::Certificate,
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
original: Cert, original: Cert,
} }
@@ -30,7 +30,7 @@ enum ClientCert {
Pkcs12(::native_tls::Identity), Pkcs12(::native_tls::Identity),
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
Pem { Pem {
key: ::rustls::PrivateKey, key: rustls::PrivateKey,
certs: Vec<::rustls::Certificate>, certs: Vec<::rustls::Certificate>,
} }
} }
@@ -90,7 +90,7 @@ impl Certificate {
#[cfg(feature = "default-tls")] #[cfg(feature = "default-tls")]
pub(crate) fn add_to_native_tls( pub(crate) fn add_to_native_tls(
self, self,
tls: &mut ::native_tls::TlsConnectorBuilder, tls: &mut native_tls::TlsConnectorBuilder,
) { ) {
tls.add_root_certificate(self.native); tls.add_root_certificate(self.native);
} }
@@ -98,8 +98,8 @@ impl Certificate {
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
pub(crate) fn add_to_rustls( pub(crate) fn add_to_rustls(
self, self,
tls: &mut ::rustls::ClientConfig, tls: &mut rustls::ClientConfig,
) -> ::Result<()> { ) -> crate::Result<()> {
use std::io::Cursor; use std::io::Cursor;
use rustls::internal::pemfile; use rustls::internal::pemfile;
@@ -177,7 +177,7 @@ impl Identity {
/// # } /// # }
/// ``` /// ```
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
pub fn from_pem(buf: &[u8]) -> ::Result<Identity> { pub fn from_pem(buf: &[u8]) -> crate::Result<Identity> {
use std::io::Cursor; use std::io::Cursor;
use rustls::internal::pemfile; use rustls::internal::pemfile;
@@ -202,7 +202,7 @@ impl Identity {
if let (Some(sk), false) = (sk.pop(), certs.is_empty()) { if let (Some(sk), false) = (sk.pop(), certs.is_empty()) {
(sk, certs) (sk, certs)
} else { } else {
return Err(::error::from(TLSError::General(String::from("private key or certificate not found")))); return Err(crate::error::from(TLSError::General(String::from("private key or certificate not found"))));
} }
}; };
@@ -217,7 +217,7 @@ impl Identity {
#[cfg(feature = "default-tls")] #[cfg(feature = "default-tls")]
pub(crate) fn add_to_native_tls( pub(crate) fn add_to_native_tls(
self, self,
tls: &mut ::native_tls::TlsConnectorBuilder, tls: &mut native_tls::TlsConnectorBuilder,
) -> crate::Result<()> { ) -> crate::Result<()> {
match self.inner { match self.inner {
ClientCert::Pkcs12(id) => { ClientCert::Pkcs12(id) => {
@@ -225,22 +225,22 @@ impl Identity {
Ok(()) Ok(())
}, },
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
ClientCert::Pem { .. } => Err(::error::from(::error::Kind::TlsIncompatible)) ClientCert::Pem { .. } => Err(crate::error::from(crate::error::Kind::TlsIncompatible))
} }
} }
#[cfg(feature = "rustls-tls")] #[cfg(feature = "rustls-tls")]
pub(crate) fn add_to_rustls( pub(crate) fn add_to_rustls(
self, self,
tls: &mut ::rustls::ClientConfig, tls: &mut rustls::ClientConfig,
) -> ::Result<()> { ) -> crate::Result<()> {
match self.inner { match self.inner {
ClientCert::Pem { key, certs } => { ClientCert::Pem { key, certs } => {
tls.set_single_client_cert(certs, key); tls.set_single_client_cert(certs, key);
Ok(()) Ok(())
}, },
#[cfg(feature = "default-tls")] #[cfg(feature = "default-tls")]
ClientCert::Pkcs12(..) => return Err(::error::from(::error::Kind::TlsIncompatible)) ClientCert::Pkcs12(..) => Err(crate::error::from(crate::error::Kind::TlsIncompatible))
} }
} }
} }

4
tests/async.rs
View File

@@ -255,7 +255,7 @@ fn response_timeout() {
fn gzip_case(response_size: usize, chunk_size: usize) { fn gzip_case(response_size: usize, chunk_size: usize) {
let content: String = (0..response_size).into_iter().map(|i| format!("test {}", i)).collect(); let content: String = (0..response_size).into_iter().map(|i| format!("test {}", i)).collect();
let mut encoder = ::libflate::gzip::Encoder::new(Vec::new()).unwrap(); let mut encoder = libflate::gzip::Encoder::new(Vec::new()).unwrap();
match encoder.write(content.as_bytes()) { match encoder.write(content.as_bytes()) {
Ok(n) => assert!(n > 0, "Failed to write to encoder."), Ok(n) => assert!(n > 0, "Failed to write to encoder."),
_ => panic!("Failed to gzip encode string."), _ => panic!("Failed to gzip encode string."),
@@ -297,7 +297,7 @@ fn gzip_case(response_size: usize, chunk_size: usize) {
body.concat2() body.concat2()
}) })
.and_then(|buf| { .and_then(|buf| {
let body = ::std::str::from_utf8(&buf).unwrap(); let body = std::str::from_utf8(&buf).unwrap();
assert_eq!(body, &content); assert_eq!(body, &content);

6
tests/gzip.rs
View File

@@ -11,7 +11,7 @@ use std::io::{Read, Write};
fn test_gzip_response() { fn test_gzip_response() {
let content: String = (0..50).into_iter().map(|i| format!("test {}", i)).collect(); let content: String = (0..50).into_iter().map(|i| format!("test {}", i)).collect();
let chunk_size = content.len() / 3; let chunk_size = content.len() / 3;
let mut encoder = ::libflate::gzip::Encoder::new(Vec::new()).unwrap(); let mut encoder = libflate::gzip::Encoder::new(Vec::new()).unwrap();
match encoder.write(content.as_bytes()) { match encoder.write(content.as_bytes()) {
Ok(n) => assert!(n > 0, "Failed to write to encoder."), Ok(n) => assert!(n > 0, "Failed to write to encoder."),
_ => panic!("Failed to gzip encode string."), _ => panic!("Failed to gzip encode string."),
@@ -74,7 +74,7 @@ fn test_gzip_empty_body() {
.send() .send()
.unwrap(); .unwrap();
let mut body = ::std::string::String::new(); let mut body = std::string::String::new();
res.read_to_string(&mut body).unwrap(); res.read_to_string(&mut body).unwrap();
assert_eq!(body, ""); assert_eq!(body, "");
@@ -104,7 +104,7 @@ fn test_gzip_invalid_body() {
// this tests that the request.send() didn't error, but that the error // this tests that the request.send() didn't error, but that the error
// is in reading the body // is in reading the body
let mut body = ::std::string::String::new(); let mut body = std::string::String::new();
res.read_to_string(&mut body).unwrap_err(); res.read_to_string(&mut body).unwrap_err();
} }

2
tests/multipart.rs
View File

@@ -57,7 +57,7 @@ fn file() {
let form = reqwest::multipart::Form::new() let form = reqwest::multipart::Form::new()
.file("foo", "Cargo.lock").unwrap(); .file("foo", "Cargo.lock").unwrap();
let fcontents = ::std::fs::read_to_string("Cargo.lock").unwrap(); let fcontents = std::fs::read_to_string("Cargo.lock").unwrap();
let expected_body = format!("\ let expected_body = format!("\
--{0}\r\n\ --{0}\r\n\

4
tests/support/server.rs
View File

@@ -97,9 +97,9 @@ pub fn spawn(txns: Vec<Txn>) -> Server {
} }
} }
match (::std::str::from_utf8(&expected), ::std::str::from_utf8(&buf[..n])) { match (::std::str::from_utf8(&expected), std::str::from_utf8(&buf[..n])) {
(Ok(expected), Ok(received)) => { (Ok(expected), Ok(received)) => {
if expected.len() > 300 && ::std::env::var("REQWEST_TEST_BODY_FULL").is_err() { if expected.len() > 300 && std::env::var("REQWEST_TEST_BODY_FULL").is_err() {
assert_eq!( assert_eq!(
expected.len(), expected.len(),
received.len(), received.len(),

2
tests/timeouts.rs
View File

@@ -81,7 +81,7 @@ fn write_timeout_large_body() {
read_closes: true read_closes: true
}; };
let cursor = ::std::io::Cursor::new(body.into_bytes()); let cursor = std::io::Cursor::new(body.into_bytes());
let url = format!("http://{}/write-timeout", server.addr()); let url = format!("http://{}/write-timeout", server.addr());
let err = client let err = client
.post(&url) .post(&url)