1 files changed, 32 insertions, 34 deletions

diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index 12066a9..f0eb8fc 100644
--- a/src/http/ratelimiting.rs
+++ b/src/http/ratelimiting.rs
@@ -346,8 +346,7 @@ pub enum Route {
 }
 
 pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
-where
-    F: Fn() -> RequestBuilder<'a>, {
+    where F: Fn() -> RequestBuilder<'a> {
     loop {
         // This will block if another thread already has the global
         // unlocked already (due to receiving an x-ratelimit-global).
@@ -367,10 +366,10 @@ where
             .entry(route)
             .or_insert_with(|| {
                 Arc::new(Mutex::new(RateLimit {
-                                        limit: i64::MAX,
-                                        remaining: i64::MAX,
-                                        reset: i64::MAX,
-                                    }))
+                    limit: i64::MAX,
+                    remaining: i64::MAX,
+                    reset: i64::MAX,
+                }))
             })
             .clone();
 
@@ -398,14 +397,15 @@ where
             let redo = if response.headers.get_raw("x-ratelimit-global").is_some() {
                 let _ = GLOBAL.lock().expect("global route lock poisoned");
 
-                Ok(if let Some(retry_after) = parse_header(&response.headers, "retry-after")? {
-                       debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
-                       thread::sleep(Duration::from_millis(retry_after as u64));
+                Ok(if let Some(retry_after) =
+                    parse_header(&response.headers, "retry-after")? {
+                    debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
+                    thread::sleep(Duration::from_millis(retry_after as u64));
 
-                       true
-                   } else {
-                       false
-                   })
+                    true
+                } else {
+                    false
+                })
             } else {
                 lock.post_hook(&response, &route)
             };
@@ -462,9 +462,11 @@ impl RateLimit {
         if self.remaining == 0 {
             let delay = (diff * 1000) + 500;
 
-            debug!("Pre-emptive ratelimit on route {:?} for {:?}ms",
-                   route,
-                   delay);
+            debug!(
+                "Pre-emptive ratelimit on route {:?} for {:?}ms",
+                route,
+                delay
+            );
             thread::sleep(Duration::from_millis(delay));
 
             return;
@@ -487,30 +489,26 @@ impl RateLimit {
         }
 
         Ok(if response.status != StatusCode::TooManyRequests {
-               false
-           } else if let Some(retry_after) = parse_header(&response.headers, "retry-after")? {
-               debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
-               thread::sleep(Duration::from_millis(retry_after as u64));
+            false
+        } else if let Some(retry_after) = parse_header(&response.headers, "retry-after")? {
+            debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
+            thread::sleep(Duration::from_millis(retry_after as u64));
 
-               true
-           } else {
-               false
-           })
+            true
+        } else {
+            false
+        })
     }
 }
 
 fn parse_header(headers: &Headers, header: &str) -> Result<Option<i64>> {
     match headers.get_raw(header) {
-        Some(header) => {
-            match str::from_utf8(&header[0]) {
-                Ok(v) => {
-                    match v.parse::<i64>() {
-                        Ok(v) => Ok(Some(v)),
-                        Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
-                    }
-                },
-                Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
-            }
+        Some(header) => match str::from_utf8(&header[0]) {
+            Ok(v) => match v.parse::<i64>() {
+                Ok(v) => Ok(Some(v)),
+                Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
+            },
+            Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
         },
         None => Ok(None),
     }