refactor: clippy, fmt, shorter naming

Author: Joonas Koivunen

http/src/v0/refs.rs

@@ -8,7 +8,6 @@ use serde::Serialize;
 use std::borrow::Cow;
 use std::collections::VecDeque;
 use std::convert::TryFrom;
-use std::fmt;
 use warp::{Filter, Rejection, Reply};
 
 mod options;
@@ -78,11 +77,11 @@ async fn refs_inner<T: IpfsTypes>(
             }
             Err(e) => serde_json::to_string(&Edge {
                 ok: "".into(),
-                err: e.to_string().into(),
+                err: e.into(),
             }),
         };
 
-        let res = match res {
+        match res {
             Ok(mut s) => {
                 s.push('\n');
                 Ok(s.into_bytes())
@@ -91,9 +90,7 @@ async fn refs_inner<T: IpfsTypes>(
                 log::error!("edge serialization failed: {}", e);
                 Err(HandledErr)
             }
-        };
-
-        res
+        }
     });
 
     // Note: Unshared has the unsafe impl Sync which sadly is needed.
@@ -114,7 +111,7 @@ fn refs_options() -> impl Filter<Extract = (RefsOptions,), Error = Rejection> +
     warp::filters::query::raw().and_then(|q: String| {
         let res = RefsOptions::try_from(q.as_str())
             .map_err(StringError::from)
-            .map_err(|e| warp::reject::custom(e));
+            .map_err(warp::reject::custom);
 
         futures::future::ready(res)
     })
@@ -325,7 +322,7 @@ fn dagpb_links(ipld: Ipld) -> Vec<(Option<String>, Cid)> {
                         ),
                     };
 
-                    return Some((name, link));
+                    Some((name, link))
                 }
                 x => panic!(
                     "Expected dag-pb2ipld \"Links[{}]\" to be a map, got: {:?}",

http/src/v0/refs/options.rs

@@ -38,16 +38,16 @@ impl RefsOptions {
 }
 
 #[derive(Debug)]
-pub enum RefOptionsParseError<'a> {
+pub enum ParseError<'a> {
     DuplicateField(Cow<'a, str>),
     MissingArg,
     InvalidNumber(Cow<'a, str>, Cow<'a, str>),
     InvalidBoolean(Cow<'a, str>, Cow<'a, str>),
 }
 
-impl<'a> fmt::Display for RefOptionsParseError<'a> {
+impl<'a> fmt::Display for ParseError<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        use RefOptionsParseError::*;
+        use ParseError::*;
         match *self {
             DuplicateField(ref s) => write!(fmt, "field {:?} was duplicated", *s),
             MissingArg => write!(fmt, "required field \"arg\" missing"),
@@ -57,13 +57,13 @@ impl<'a> fmt::Display for RefOptionsParseError<'a> {
     }
 }
 
-impl<'a> std::error::Error for RefOptionsParseError<'a> {}
+impl<'a> std::error::Error for ParseError<'a> {}
 
 impl<'a> TryFrom<&'a str> for RefsOptions {
-    type Error = RefOptionsParseError<'a>;
+    type Error = ParseError<'a>;
 
     fn try_from(q: &'a str) -> Result<Self, Self::Error> {
-        use RefOptionsParseError::*;
+        use ParseError::*;
 
         // TODO: check how go-ipfs handles duplicate parameters for non-Vec fields
         //

http/src/v0/refs/path.rs

@@ -66,7 +66,7 @@ impl TryFrom<&str> for IpfsPath {
             }
             Some(x) => {
                 /* maybe didn't start with /ipfs/, need to check second */
-                if let Some(_) = split.next() {
+                if split.next().is_some() {
                     // x/ipfs/_
                     return Err(PathError::InvalidPath);
                 }
@@ -110,7 +110,7 @@ impl IpfsPath {
         if self.len() == 0 {
             return Ok(WalkSuccess::EmptyPath(ipld));
         }
-        while let Some(key) = self.next() {
+        for key in self {
             if current.codec() == cid::Codec::DagProtobuf {
                 return walk_dagpb(ipld, key);
             }
@@ -248,7 +248,7 @@ fn walk_dagpb(ipld: Ipld, key: String) -> Result<WalkSuccess, WalkFailed> {
                 None => panic!("Expected dag-pb2ipld \"Links[{}]/Hash\" to exist", index),
             };
 
-            return Ok(WalkSuccess::Link(key, link));
+            Ok(WalkSuccess::Link(key, link))
         }
         x => panic!(
             "Expected dag-pb2ipld \"Links[{}]\" to be a Map, was: {:?}",