Code and formater fix

Author: Lucas Paixão

src/runtime/context.rs

@@ -4,10 +4,10 @@ use std::cell::{Cell, RefCell};
 /// Owns the driver and resides in thread-local storage.
 pub(crate) struct RuntimeContext {
   driver: RefCell<Option<Handle>>,
-  on_thread_park: Cell<fn()>
+  on_thread_park: Cell<fn()>,
 }
 
-fn noop(){}
+fn noop() {}
 
 impl RuntimeContext {
   /// Construct the context with an uninitialized driver.
@@ -51,7 +51,8 @@ impl RuntimeContext {
   /// Check if driver is initialized
   #[allow(dead_code)]
   pub(crate) fn is_set(&self) -> bool {
-    self.driver
+    self
+      .driver
       .try_borrow()
       .map(|b| b.is_some())
       .unwrap_or(false)

src/runtime/driver/mod.rs

@@ -134,8 +134,7 @@ impl Driver {
       cq.sync();
 
       for cqe in cq {
-        if cqe.user_data() == u64::MAX ||
-           cqe.user_data() == 0 {
+        if cqe.user_data() == u64::MAX || cqe.user_data() == 0 {
           // Result of the cancellation action. There isn't anything we
           // need to do here. We must wait for the CQE for the operation
           // that was canceled.
@@ -425,10 +424,7 @@ impl Drop for Driver {
 
     unsafe {
       let cancel = opcode::AsyncCancel::new(u64::MAX);
-      let sqe = cancel
-        .build()
-        .user_data(0)
-        .flags(any_flags);
+      let sqe = cancel.build().user_data(0).flags(any_flags);
 
       while self.uring.submission().push(&sqe).is_err() {
         self

src/runtime/driver/op/mod.rs

@@ -440,9 +440,9 @@ where
       .upgrade()
       .expect("Not in runtime context")
       .poll_multishot_op(self.get_mut(), cx);
-    
+
     CONTEXT.with(|x| x.call_on_thread_park());
-    
+
     result
   }
 }

src/runtime/mod.rs

@@ -12,8 +12,8 @@ mod context;
 pub(crate) mod driver;
 
 use crate::runtime::driver::Handle;
+use crate::Builder;
 pub(crate) use context::RuntimeContext;
-use crate::{Builder};
 
 type Context = Arc<RuntimeContext>;
 
@@ -43,7 +43,7 @@ pub struct Runtime {
   signal: Arc<Notify>,
 
   /// Builder for runtime contexts
-  builder: Builder
+  builder: Builder,
 }
 
 /// Spawns a new asynchronous task, returning a [`JoinHandle`] for it.
@@ -109,7 +109,7 @@ impl Runtime {
       tokio_rt: MaybeUninit::zeroed(),
       contexts: Default::default(),
       builder: builder.clone(),
-      signal: Arc::new(Notify::new())
+      signal: Arc::new(Notify::new()),
     };
 
     let on_thread_start = runtime.create_on_thread_start_callback();
@@ -128,7 +128,7 @@ impl Runtime {
     runtime.start_uring_wakes_task();
 
     CONTEXT.with(|x| {
-      x.set_handle(Handle::new(&builder).expect("Internal error"));
+      x.set_handle(Handle::new(builder).expect("Internal error"));
       x.set_on_thread_park(Runtime::on_thread_park);
       let mut lock = runtime.contexts.lock().unwrap();
       lock.push_back(x.clone());
@@ -139,12 +139,12 @@ impl Runtime {
     Ok(runtime)
   }
 
-  fn on_thread_park(){
+  fn on_thread_park() {
     CONTEXT.with(|x| {
       let _ = x.handle().flush();
     });
   }
-  
+
   fn create_on_thread_start_callback(&self) -> impl Fn() + Sync + 'static {
     let is_unique = |item: &Context, list: &LinkedList<Context>| {
       let item_fd = item.handle().as_raw_fd();
@@ -182,27 +182,25 @@ impl Runtime {
     //SAFETY: It's always already initialized on Runtime::new method
     let tokio_rt = unsafe { self.tokio_rt.assume_init_ref() };
     let _guard = tokio_rt.enter();
-    self.local.spawn_local(
-      Runtime::drive_uring_wakes(
-        self.contexts.clone(),
-        self.signal.clone(),
-        self.builder.threads
-      )
-    );
+    self.local.spawn_local(Runtime::drive_uring_wakes(
+      self.contexts.clone(),
+      self.signal.clone(),
+      self.builder.threads,
+    ));
   }
 
   async fn drive_uring_wakes(
     contexts: Arc<Mutex<LinkedList<Context>>>,
     signal: Arc<Notify>,
-    threads: usize
+    threads: usize,
   ) {
     let mut total = 0;
 
     while total != threads + 1 {
       signal.notified().await;
 
       let mut guard = contexts.lock().unwrap();
-      
+
       for i in guard.iter() {
         tokio::spawn(Runtime::wait_event(Item::new(i.clone())));
         total += 1;
@@ -262,8 +260,8 @@ impl Drop for Runtime {
 
 #[cfg(test)]
 mod test {
-  use crate::builder;
   use super::*;
+  use crate::builder;
 
   #[test]
   fn block_on() {