From d4a095d75c0c644d0988fb5fbc2c58d6e899421d Mon Sep 17 00:00:00 2001 From: "leonardo.yvens" Date: Sat, 4 Jun 2016 11:21:53 -0300 Subject: [PATCH] refactor(multiple): Clippy run --- src/client/connect.rs | 33 ++++++++++--------------- src/client/mod.rs | 8 +++--- src/header/common/accept_ranges.rs | 2 +- src/header/common/content_range.rs | 2 +- src/header/common/host.rs | 10 +++----- src/header/common/prefer.rs | 14 +++++------ src/header/common/preference_applied.rs | 2 +- src/header/common/range.rs | 4 +-- src/header/mod.rs | 6 ++--- src/header/parsing.rs | 2 +- src/header/shared/charset.rs | 2 +- src/header/shared/entity.rs | 4 +-- src/http/buffer.rs | 8 ++---- src/http/conn.rs | 15 ++++------- src/server/message.rs | 7 +++--- src/server/response.rs | 2 +- 16 files changed, 50 insertions(+), 71 deletions(-) diff --git a/src/client/connect.rs b/src/client/connect.rs index 4c9a36013a..fc34f45fc1 100644 --- a/src/client/connect.rs +++ b/src/client/connect.rs @@ -88,7 +88,7 @@ impl Connect for HttpConnector { if let Some(key) = self.key(url) { let host = url.host_str().expect("http scheme must have a host"); self.dns.as_ref().expect("dns workers lost").resolve(host); - self.resolving.entry(host.to_owned()).or_insert(Vec::new()).push(key.clone()); + self.resolving.entry(host.to_owned()).or_insert_with(Vec::new).push(key.clone()); Ok(key) } else { Err(io::Error::new(io::ErrorKind::InvalidInput, "scheme must be http")) @@ -101,25 +101,18 @@ impl Connect for HttpConnector { Err(_) => return None }; debug!("Http::resolved <- ({:?}, {:?})", host, addr); - match self.resolving.entry(host) { - Entry::Occupied(mut entry) => { - let resolved = entry.get_mut().remove(0); - if entry.get().is_empty() { - entry.remove(); - } - let port = resolved.2; - match addr { - Ok(addr) => { - Some((resolved, TcpStream::connect(&SocketAddr::new(addr, port)) - .map(HttpStream))) - }, - Err(e) => Some((resolved, Err(e))) - } - } - _ => { - trace!("^-- resolved but not in hashmap?"); - return None + if let Entry::Occupied(mut entry) = self.resolving.entry(host) { + let resolved = entry.get_mut().remove(0); + if entry.get().is_empty() { + entry.remove(); } + let port = resolved.2; + Some((resolved, addr.and_then(|addr| TcpStream::connect(&SocketAddr::new(addr, port)) + .map(HttpStream)) + )) + } else { + trace!("^-- resolved but not in hashmap?"); + None } } @@ -167,7 +160,7 @@ impl Connect for HttpsConnector { if let Some(key) = self.key(url) { let host = url.host_str().expect("http scheme must have a host"); self.http.dns.as_ref().expect("dns workers lost").resolve(host); - self.http.resolving.entry(host.to_owned()).or_insert(Vec::new()).push(key.clone()); + self.http.resolving.entry(host.to_owned()).or_insert_with(Vec::new).push(key.clone()); Ok(key) } else { Err(io::Error::new(io::ErrorKind::InvalidInput, "scheme must be http or https")) diff --git a/src/client/mod.rs b/src/client/mod.rs index 7f06504190..65443e78be 100644 --- a/src/client/mod.rs +++ b/src/client/mod.rs @@ -67,11 +67,11 @@ impl Client { /*TODO pub fn http() -> Config { - + } pub fn https() -> Config { - + } */ } @@ -440,7 +440,7 @@ where C: Connect, let now = scope.now(); let mut empty_keys = Vec::new(); { - for (key, mut vec) in scope.queue.iter_mut() { + for (key, mut vec) in &mut scope.queue { while !vec.is_empty() && vec[0].deadline <= now { let mut queued = vec.remove(0); let _ = queued.handler.on_error(::Error::Timeout); @@ -517,7 +517,7 @@ where C: Connect, match connector.connect(&url) { Ok(key) => { let deadline = scope.now() + scope.connect_timeout; - scope.queue.entry(key).or_insert(Vec::new()).push(Queued { + scope.queue.entry(key).or_insert_with(Vec::new).push(Queued { deadline: deadline, handler: handler, url: url diff --git a/src/header/common/accept_ranges.rs b/src/header/common/accept_ranges.rs index 86e847dbd4..dcc0ec9cdc 100644 --- a/src/header/common/accept_ranges.rs +++ b/src/header/common/accept_ranges.rs @@ -95,7 +95,7 @@ impl Display for RangeUnit { match *self { RangeUnit::Bytes => f.write_str("bytes"), RangeUnit::None => f.write_str("none"), - RangeUnit::Unregistered(ref x) => f.write_str(&x), + RangeUnit::Unregistered(ref x) => f.write_str(x), } } } diff --git a/src/header/common/content_range.rs b/src/header/common/content_range.rs index 2d9a965b33..4b24ce9171 100644 --- a/src/header/common/content_range.rs +++ b/src/header/common/content_range.rs @@ -182,7 +182,7 @@ impl Display for ContentRangeSpec { ContentRangeSpec::Unregistered { ref unit, ref resp } => { try!(f.write_str(&unit)); try!(f.write_str(" ")); - f.write_str(&resp) + f.write_str(resp) } } } diff --git a/src/header/common/host.rs b/src/header/common/host.rs index 2d906f0eb7..e59d57ceab 100644 --- a/src/header/common/host.rs +++ b/src/header/common/host.rs @@ -69,14 +69,10 @@ impl Header for Host { } }; - let port = match idx { - Some(idx) => s[idx + 1..].parse().ok(), - None => None - }; + let port = idx.and_then(|idx| s[idx + 1..].parse().ok()); - match idx { - Some(idx) => s.truncate(idx), - None => () + if let Some(idx) = idx { + s.truncate(idx) } Ok(Host { diff --git a/src/header/common/prefer.rs b/src/header/common/prefer.rs index b0e81a9a12..b960bfd6fc 100644 --- a/src/header/common/prefer.rs +++ b/src/header/common/prefer.rs @@ -106,7 +106,7 @@ impl fmt::Display for Preference { Extension(ref name, ref value, ref params) => { try!(write!(f, "{}", name)); if value != "" { try!(write!(f, "={}", value)); } - if params.len() > 0 { + if !params.is_empty() { for &(ref name, ref value) in params { try!(write!(f, "; {}", name)); if value != "" { try!(write!(f, "={}", value)); } @@ -138,12 +138,12 @@ impl FromStr for Preference { Some(param) => { let rest: Vec<(String, String)> = params.map(|(l, r)| (l.to_owned(), r.to_owned())).collect(); match param { - ("respond-async", "") => if rest.len() == 0 { Ok(RespondAsync) } else { Err(None) }, - ("return", "representation") => if rest.len() == 0 { Ok(ReturnRepresentation) } else { Err(None) }, - ("return", "minimal") => if rest.len() == 0 { Ok(ReturnMinimal) } else { Err(None) }, - ("handling", "strict") => if rest.len() == 0 { Ok(HandlingStrict) } else { Err(None) }, - ("handling", "leniant") => if rest.len() == 0 { Ok(HandlingLeniant) } else { Err(None) }, - ("wait", secs) => if rest.len() == 0 { secs.parse().map(Wait).map_err(Some) } else { Err(None) }, + ("respond-async", "") => if rest.is_empty() { Ok(RespondAsync) } else { Err(None) }, + ("return", "representation") => if rest.is_empty() { Ok(ReturnRepresentation) } else { Err(None) }, + ("return", "minimal") => if rest.is_empty() { Ok(ReturnMinimal) } else { Err(None) }, + ("handling", "strict") => if rest.is_empty() { Ok(HandlingStrict) } else { Err(None) }, + ("handling", "leniant") => if rest.is_empty() { Ok(HandlingLeniant) } else { Err(None) }, + ("wait", secs) => if rest.is_empty() { secs.parse().map(Wait).map_err(Some) } else { Err(None) }, (left, right) => Ok(Extension(left.to_owned(), right.to_owned(), rest)) } }, diff --git a/src/header/common/preference_applied.rs b/src/header/common/preference_applied.rs index 385fa46a8d..2d6ef4fdc5 100644 --- a/src/header/common/preference_applied.rs +++ b/src/header/common/preference_applied.rs @@ -71,7 +71,7 @@ impl Header for PreferenceApplied { value.to_owned(), vec![] ), - preference @ _ => preference.clone() + preference => preference.clone() }).collect(); fmt_comma_delimited(f, &preferences) } diff --git a/src/header/common/range.rs b/src/header/common/range.rs index 79edc1a0d2..c18c19a641 100644 --- a/src/header/common/range.rs +++ b/src/header/common/range.rs @@ -126,7 +126,7 @@ impl FromStr for Range { type Err = ::Error; fn from_str(s: &str) -> ::Result { - let mut iter = s.splitn(2, "="); + let mut iter = s.splitn(2, '='); match (iter.next(), iter.next()) { (Some("bytes"), Some(ranges)) => { @@ -153,7 +153,7 @@ impl FromStr for ByteRangeSpec { type Err = ::Error; fn from_str(s: &str) -> ::Result { - let mut parts = s.splitn(2, "-"); + let mut parts = s.splitn(2, '-'); match (parts.next(), parts.next()) { (Some(""), Some(end)) => { diff --git a/src/header/mod.rs b/src/header/mod.rs index f85da69526..d79156dc28 100644 --- a/src/header/mod.rs +++ b/src/header/mod.rs @@ -143,12 +143,12 @@ impl HeaderClone for T { impl Header + Send + Sync { #[inline] unsafe fn downcast_ref_unchecked(&self) -> &T { - mem::transmute(traitobject::data(self)) + &*(traitobject::data(self) as *const T) } #[inline] unsafe fn downcast_mut_unchecked(&mut self) -> &mut T { - mem::transmute(traitobject::data_mut(self)) + &mut *(traitobject::data_mut(self) as *mut T) } } @@ -497,7 +497,7 @@ impl<'a> fmt::Display for &'a (Header + Send + Sync) { } } -/// A wrapper around any Header with a Display impl that calls fmt_header. +/// A wrapper around any Header with a Display impl that calls `fmt_header`. /// /// This can be used like so: `format!("{}", HeaderFormatter(&header))` to /// get the representation of a Header which will be written to an diff --git a/src/header/parsing.rs b/src/header/parsing.rs index 52425a78a4..fc8b96498d 100644 --- a/src/header/parsing.rs +++ b/src/header/parsing.rs @@ -12,7 +12,7 @@ use header::shared::Charset; pub fn from_one_raw_str(raw: &[Vec]) -> ::Result { if raw.len() != 1 || unsafe { raw.get_unchecked(0) } == b"" { return Err(::Error::Header) } // we JUST checked that raw.len() == 1, so raw[0] WILL exist. - from_raw_str(& unsafe { raw.get_unchecked(0) }) + from_raw_str( unsafe { raw.get_unchecked(0) }) } /// Reads a raw string into a value. diff --git a/src/header/shared/charset.rs b/src/header/shared/charset.rs index 070c3bb8e8..f3ed8d86f1 100644 --- a/src/header/shared/charset.rs +++ b/src/header/shared/charset.rs @@ -91,7 +91,7 @@ impl Charset { Gb2312 => "GB2312", Big5 => "5", Koi8_R => "KOI8-R", - Ext(ref s) => &s + Ext(ref s) => s } } } diff --git a/src/header/shared/entity.rs b/src/header/shared/entity.rs index 0d51d5cf93..3c2d9e6c93 100644 --- a/src/header/shared/entity.rs +++ b/src/header/shared/entity.rs @@ -4,10 +4,10 @@ use std::fmt::{self, Display}; // check that each char in the slice is either: // 1. %x21, or // 2. in the range %x23 to %x7E, or -// 3. in the range %x80 to %xFF +// 3. above %x80 fn check_slice_validity(slice: &str) -> bool { slice.bytes().all(|c| - c == b'\x21' || (c >= b'\x23' && c <= b'\x7e') | (c >= b'\x80' && c <= b'\xff')) + c == b'\x21' || (c >= b'\x23' && c <= b'\x7e') | (c >= b'\x80')) } /// An entity tag, defined in [RFC7232](https://tools.ietf.org/html/rfc7232#section-2.3) diff --git a/src/http/buffer.rs b/src/http/buffer.rs index ae46491ac5..8aaf0a7e15 100644 --- a/src/http/buffer.rs +++ b/src/http/buffer.rs @@ -6,7 +6,7 @@ use std::ptr; const INIT_BUFFER_SIZE: usize = 4096; const MAX_BUFFER_SIZE: usize = 8192 + 4096 * 100; -#[derive(Debug)] +#[derive(Debug, Default)] pub struct Buffer { vec: Vec, read_pos: usize, @@ -15,11 +15,7 @@ pub struct Buffer { impl Buffer { pub fn new() -> Buffer { - Buffer { - vec: Vec::new(), - read_pos: 0, - write_pos: 0, - } + Buffer::default() } pub fn reset(&mut self) { diff --git a/src/http/conn.rs b/src/http/conn.rs index 7112cbfda8..dc15e95834 100644 --- a/src/http/conn.rs +++ b/src/http/conn.rs @@ -508,7 +508,7 @@ impl> Conn { }, Err(e) => { trace!("error reregistering: {:?}", e); - let _ = self.on_error(e.into()); + self.on_error(e.into()); None } } @@ -516,14 +516,9 @@ impl> Conn { pub fn wakeup(mut self, scope: &mut Scope) -> Option<(Self, Option)> where F: MessageHandlerFactory { - loop { - match self.ctrl.1.try_recv() { - Ok(next) => { - trace!("woke up with {:?}", next); - self.state.update(next); - }, - Err(_) => break - } + while let Ok(next) = self.ctrl.1.try_recv() { + trace!("woke up with {:?}", next); + self.state.update(next); } self.ready(EventSet::readable() | EventSet::writable(), scope) } @@ -872,7 +867,7 @@ impl<'a, K: Key + 'a> Seed<'a, K> { } pub fn key(&self) -> &K { - &self.0 + self.0 } } diff --git a/src/server/message.rs b/src/server/message.rs index 05fe7a8c9c..81c12a3eb7 100644 --- a/src/server/message.rs +++ b/src/server/message.rs @@ -6,10 +6,10 @@ use net::Transport; use super::{Handler, request, response}; -/// A MessageHandler for a Server. +/// A `MessageHandler` for a Server. /// -/// This should be really thin glue between http::MessageHandler and -/// server::Handler, but largely just providing the proper types one +/// This should be really thin glue between `http::MessageHandler` and +/// `server::Handler`, but largely just providing the proper types one /// would expect in a Server Handler. pub struct Message, T: Transport> { handler: H, @@ -55,4 +55,3 @@ impl, T: Transport> http::MessageHandler for Message { self.handler.on_remove(transport); } } - diff --git a/src/server/response.rs b/src/server/response.rs index 95874781c9..52fe103690 100644 --- a/src/server/response.rs +++ b/src/server/response.rs @@ -43,7 +43,7 @@ impl<'a> Response<'a> { } /// Creates a new Response that can be used to write to a network stream. -pub fn new<'a>(head: &'a mut http::MessageHead) -> Response<'a> { +pub fn new(head: &mut http::MessageHead) -> Response { Response { head: head }