chore: cargo fmt

alemidev · alemidev · commit 5b54251e59d4 · 2025-07-30T21:06:11.000+02:00
diff --git a/src/api/config.rs b/src/api/config.rs
@@ -68,8 +68,9 @@ impl Config {
 impl std::fmt::Debug for Config {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		if f.alternate() {
-			write!(f,
-r#"""Config {{
+			write!(
+				f,
+				r#"""Config {{
     username: {},
     password: ********,
     host: {:#?},
@@ -79,7 +80,11 @@ r#"""Config {{
 				self.username, self.host, self.port, self.tls
 			)
 		} else {
-			write!(f, "Config {{ username: {}, password: ********, host: {:?}, port: {:?}, tls: {:?} }}", self.username, self.host, self.port, self.tls)
+			write!(
+				f,
+				"Config {{ username: {}, password: ********, host: {:?}, port: {:?}, tls: {:?} }}",
+				self.username, self.host, self.port, self.tls
+			)
 		}
 	}
 }
diff --git a/src/buffer/controller.rs b/src/buffer/controller.rs
@@ -6,9 +6,9 @@ use std::sync::Arc;
 use diamond_types::LocalVersion;
 use tokio::sync::{mpsc, oneshot, watch};
 
-use crate::api::controller::{AsyncReceiver, AsyncSender, Controller, ControllerCallback};
 use crate::api::BufferUpdate;
 use crate::api::TextChange;
+use crate::api::controller::{AsyncReceiver, AsyncSender, Controller, ControllerCallback};
 use crate::errors::ControllerResult;
 use crate::ext::IgnorableError;
 
diff --git a/src/buffer/worker.rs b/src/buffer/worker.rs
@@ -1,15 +1,15 @@
 use std::sync::Arc;
 
+use diamond_types::LocalVersion;
 use diamond_types::list::encoding::ENCODE_PATCH;
 use diamond_types::list::{Branch, OpLog};
-use diamond_types::LocalVersion;
 use tokio::sync::{mpsc, oneshot, watch};
 use tonic::Streaming;
 use uuid::Uuid;
 
-use crate::api::controller::ControllerCallback;
 use crate::api::BufferUpdate;
 use crate::api::TextChange;
+use crate::api::controller::ControllerCallback;
 use crate::ext::IgnorableError;
 
 use codemp_proto::buffer::{BufferEvent, Operation};
diff --git a/src/client.rs b/src/client.rs
@@ -17,9 +17,9 @@ use crate::{
 	workspace::Workspace,
 };
 use codemp_proto::{
-	auth::{auth_client::AuthClient, LoginRequest},
+	auth::{LoginRequest, auth_client::AuthClient},
 	common::{Empty, Token},
-	session::{session_client::SessionClient, InviteRequest, WorkspaceRequest},
+	session::{InviteRequest, WorkspaceRequest, session_client::SessionClient},
 };
 
 #[cfg(feature = "py")]
diff --git a/src/cursor/controller.rs b/src/cursor/controller.rs
@@ -7,8 +7,8 @@ use tokio::sync::{mpsc, oneshot, watch};
 
 use crate::{
 	api::{
-		controller::{AsyncReceiver, AsyncSender, ControllerCallback},
 		Controller, Cursor, Selection,
+		controller::{AsyncReceiver, AsyncSender, ControllerCallback},
 	},
 	errors::ControllerResult,
 };
diff --git a/src/cursor/worker.rs b/src/cursor/worker.rs
@@ -5,7 +5,7 @@ use tonic::Streaming;
 use uuid::Uuid;
 
 use crate::{
-	api::{controller::ControllerCallback, Cursor, Selection, User},
+	api::{Cursor, Selection, User, controller::ControllerCallback},
 	ext::IgnorableError,
 };
 use codemp_proto::cursor::{CursorEvent, CursorPosition};
@@ -27,26 +27,25 @@ struct CursorWorker {
 impl CursorWorker {
 	#[tracing::instrument(skip(self, tx))]
 	fn handle_recv(&mut self, tx: oneshot::Sender<Option<Cursor>>) {
-		tx.send(
-			self.store.pop_front().and_then(|event| {
-				let user_id = Uuid::from(event.user);
-				if let Some(user_name) = self.map.get(&user_id).map(|u| u.name.clone()) {
-					Some(Cursor {
-						user: user_name,
-						sel: Selection {
-							buffer: event.position.buffer.path,
-							start_row: event.position.start.row,
-							start_col: event.position.start.col,
-							end_row: event.position.end.row,
-							end_col: event.position.end.col
-						}
-					})
-				} else {
-					tracing::warn!("received cursor for unknown user {user_id}");
-					None
-				}
-			})
-		).unwrap_or_warn("client gave up receiving!");
+		tx.send(self.store.pop_front().and_then(|event| {
+			let user_id = Uuid::from(event.user);
+			if let Some(user_name) = self.map.get(&user_id).map(|u| u.name.clone()) {
+				Some(Cursor {
+					user: user_name,
+					sel: Selection {
+						buffer: event.position.buffer.path,
+						start_row: event.position.start.row,
+						start_col: event.position.start.col,
+						end_row: event.position.end.row,
+						end_col: event.position.end.col,
+					},
+				})
+			} else {
+				tracing::warn!("received cursor for unknown user {user_id}");
+				None
+			}
+		}))
+		.unwrap_or_warn("client gave up receiving!");
 	}
 }
 
diff --git a/src/ffi/java/buffer.rs b/src/ffi/java/buffer.rs
@@ -1,4 +1,4 @@
-use jni::{objects::JObject, JNIEnv};
+use jni::{JNIEnv, objects::JObject};
 use jni_toolbox::jni;
 
 use crate::{
diff --git a/src/ffi/java/client.rs b/src/ffi/java/client.rs
@@ -1,8 +1,8 @@
 use crate::{
+	Workspace,
 	api::Config,
 	client::Client,
 	errors::{ConnectionError, RemoteError},
-	Workspace,
 };
 use jni_toolbox::jni;
 
diff --git a/src/ffi/java/cursor.rs b/src/ffi/java/cursor.rs
@@ -2,7 +2,7 @@ use crate::{
 	api::{AsyncReceiver, AsyncSender, Cursor, Selection},
 	errors::ControllerError,
 };
-use jni::{objects::JObject, JNIEnv};
+use jni::{JNIEnv, objects::JObject};
 use jni_toolbox::jni;
 
 use super::null_check;
diff --git a/src/ffi/java/workspace.rs b/src/ffi/java/workspace.rs
@@ -1,10 +1,10 @@
 use crate::{
-	api::{controller::AsyncReceiver, User},
+	Workspace,
+	api::{User, controller::AsyncReceiver},
 	errors::{ConnectionError, ControllerError, RemoteError},
 	ffi::java::null_check,
-	Workspace,
 };
-use jni::{objects::JObject, JNIEnv};
+use jni::{JNIEnv, objects::JObject};
 use jni_toolbox::jni;
 
 /// Get the workspace id.
diff --git a/src/ffi/js/workspace.rs b/src/ffi/js/workspace.rs
@@ -1,7 +1,7 @@
+use crate::Workspace;
 use crate::api::controller::AsyncReceiver;
 use crate::buffer::controller::BufferController;
 use crate::cursor::controller::CursorController;
-use crate::Workspace;
 use napi::threadsafe_function::ErrorStrategy::Fatal;
 use napi::threadsafe_function::{
 	ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
@@ -121,7 +121,7 @@ impl Workspace {
 			})?;
 		self.callback(move |controller: Workspace| {
 			tsfn.call(controller.clone(), ThreadsafeFunctionCallMode::Blocking); //check this with tracing also we could use Ok(event) to get the error
-			                                                            // If it blocks the main thread too many time we have to change this
+			// If it blocks the main thread too many time we have to change this
 		});
 
 		Ok(())
diff --git a/src/ffi/lua/buffer.rs b/src/ffi/lua/buffer.rs
@@ -47,6 +47,10 @@ impl LuaUserData for CodempBufferController {
 
 impl CodempBufferController {
 	fn lua_callback_id(&self) -> String {
-		format!("codemp-buffercontroller({}:{})-callback-registry", self.workspace_id(), self.path())
+		format!(
+			"codemp-buffercontroller({}:{})-callback-registry",
+			self.workspace_id(),
+			self.path()
+		)
 	}
 }
diff --git a/src/ffi/lua/cursor.rs b/src/ffi/lua/cursor.rs
@@ -37,6 +37,9 @@ impl LuaUserData for CodempCursorController {
 
 impl CodempCursorController {
 	fn lua_callback_id(&self) -> String {
-		format!("codemp-cursorcontroller({})-callback-registry", self.workspace_id())
+		format!(
+			"codemp-cursorcontroller({})-callback-registry",
+			self.workspace_id()
+		)
 	}
 }
diff --git a/src/ffi/lua/ext/a_sync.rs b/src/ffi/lua/ext/a_sync.rs
@@ -47,12 +47,10 @@ impl LuaUserData for Promise {
 		// TODO: await MUST NOT be used in callbacks!!
 		methods.add_method_mut("await", |_, this, ()| match this.0.take() {
 			None => Err(LuaError::runtime("Promise already awaited")),
-			Some(x) => Ok(
-				tokio()
-					.block_on(x)
-					.map_err(LuaError::runtime)?
-					.map_err(LuaError::runtime)?
-			),
+			Some(x) => Ok(tokio()
+				.block_on(x)
+				.map_err(LuaError::runtime)?
+				.map_err(LuaError::runtime)?),
 		});
 		methods.add_method_mut("cancel", |_, this, ()| match this.0.take() {
 			None => Err(LuaError::runtime("Promise already awaited")),
diff --git a/src/ffi/lua/ext/callback.rs b/src/ffi/lua/ext/callback.rs
@@ -32,7 +32,9 @@ impl CallbackChannel<LuaCallback> {
 
 	pub(crate) fn failure(&self, err: impl std::error::Error) {
 		self.tx
-			.send(LuaCallback::Fail(format!("callback returned error: {err:?}")))
+			.send(LuaCallback::Fail(format!(
+				"callback returned error: {err:?}"
+			)))
 			.unwrap_or_warn("error scheduling callback failure")
 	}
 
@@ -51,22 +53,22 @@ impl CallbackChannel<LuaCallback> {
 				Ok(LuaCallback::Fail(msg)) => {
 					tracing::error!("callback returned error: {msg}");
 					None
-				},
+				}
 				Ok(LuaCallback::Invoke(key, arg, cleanup)) => {
 					let cb = match lua.named_registry_value::<LuaFunction>(&key) {
 						Ok(x) => x,
 						Err(e) => {
 							tracing::error!("could not get callback to invoke: {e}");
 							return None;
-						},
+						}
 					};
 					if cleanup {
 						if let Err(e) = lua.unset_named_registry_value(&key) {
 							tracing::warn!("could not unset callback from registry: {e}");
 						}
 					}
 					Some((cb, arg))
-				},
+				}
 			},
 		}
 	}
diff --git a/src/ffi/lua/ext/log.rs b/src/ffi/lua/ext/log.rs
@@ -72,7 +72,7 @@ pub(crate) fn setup_tracing(
 				});
 			}
 			res
-		},
+		}
 		_ => return Err(LuaError::BindError), // TODO full BadArgument type??
 	};
 
diff --git a/src/ffi/python/client.rs b/src/ffi/python/client.rs
@@ -1,5 +1,5 @@
-use super::a_sync_allow_threads;
 use super::Client;
+use super::a_sync_allow_threads;
 use crate::api::User;
 use crate::workspace::Workspace;
 use pyo3::prelude::*;
diff --git a/src/ffi/python/controllers.rs b/src/ffi/python/controllers.rs
@@ -1,13 +1,13 @@
-use crate::api::controller::{AsyncReceiver, AsyncSender};
 use crate::api::TextChange;
+use crate::api::controller::{AsyncReceiver, AsyncSender};
 use crate::api::{Cursor, Selection};
 use crate::buffer::Controller as BufferController;
 use crate::cursor::Controller as CursorController;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 
-use super::a_sync_allow_threads;
 use super::Promise;
+use super::a_sync_allow_threads;
 
 // need to do manually since Controller is a trait implementation
 #[pymethods]
diff --git a/src/ffi/python/mod.rs b/src/ffi/python/mod.rs
@@ -3,10 +3,10 @@ pub mod controllers;
 pub mod workspace;
 
 use crate::{
+	Client, Workspace,
 	api::{BufferUpdate, Config, Cursor, Event, Selection, TextChange, User},
 	buffer::Controller as BufferController,
 	cursor::Controller as CursorController,
-	Client, Workspace,
 };
 
 use pyo3::{
diff --git a/src/ffi/python/workspace.rs b/src/ffi/python/workspace.rs
@@ -1,13 +1,13 @@
-use crate::api::controller::AsyncReceiver;
 use crate::api::User;
+use crate::api::controller::AsyncReceiver;
 use crate::buffer::Controller as BufferController;
 use crate::cursor::Controller as CursorController;
 use crate::workspace::Workspace;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 
-use super::a_sync_allow_threads;
 use super::Promise;
+use super::a_sync_allow_threads;
 
 #[pymethods]
 impl Workspace {
diff --git a/src/network.rs b/src/network.rs
@@ -3,7 +3,7 @@ use codemp_proto::{
 	workspace::workspace_client::WorkspaceClient,
 };
 use tonic::{
-	service::{interceptor::InterceptedService, Interceptor},
+	service::{Interceptor, interceptor::InterceptedService},
 	transport::{Channel, Endpoint},
 };
 
diff --git a/src/tests/client.rs b/src/tests/client.rs
@@ -244,9 +244,11 @@ async fn test_buffer_search() {
 
 			async move {
 				workspace_alice.create_buffer(&buffer_name).await?;
-				assert_or_err!(!workspace_alice
-					.search_buffers(Some(&buffer_name[0..4]))
-					.is_empty());
+				assert_or_err!(
+					!workspace_alice
+						.search_buffers(Some(&buffer_name[0..4]))
+						.is_empty()
+				);
 				assert_or_err!(workspace_alice.search_buffers(Some("_")).is_empty());
 				workspace_alice.delete_buffer(&buffer_name).await?;
 				Ok(())
diff --git a/src/tests/server.rs b/src/tests/server.rs
@@ -73,10 +73,12 @@ async fn test_workspace_interactions() {
 			.invite_to_workspace(&workspace_name, &client_bob.current_user().name)
 			.await?;
 		client_bob.attach_workspace(&workspace_name).await?;
-		assert_or_err!(client_bob
-			.fetch_joined_workspaces()
-			.await?
-			.contains(&workspace_name));
+		assert_or_err!(
+			client_bob
+				.fetch_joined_workspaces()
+				.await?
+				.contains(&workspace_name)
+		);
 
 		assert_or_err!(client_bob.leave_workspace(&workspace_name));
 		assert_or_err!(client_alice.leave_workspace(&workspace_name));
diff --git a/src/workspace.rs b/src/workspace.rs

Original file line number	Diff line number	Diff line change
`@@ -68,8 +68,9 @@ impl Config {`
`68`	`68`	`impl std::fmt::Debug for Config {`
`69`	`69`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`70`	`70`	`if f.alternate() {`
`71`		`- write!(f,`
`72`		`-r#"""Config {{`
	`71`	`+ write!(`
	`72`	`+ f,`
	`73`	`+ r#"""Config {{`
`73`	`74`	`username: {},`
`74`	`75`	`password: ********,`
`75`	`76`	`host: {:#?},`
`@@ -79,7 +80,11 @@ r#"""Config {{`
`79`	`80`	`self.username, self.host, self.port, self.tls`
`80`	`81`	`)`
`81`	`82`	`} else {`
`82`		`- write!(f, "Config {{ username: {}, password: ********, host: {:?}, port: {:?}, tls: {:?} }}", self.username, self.host, self.port, self.tls)`
	`83`	`+ write!(`
	`84`	`+ f,`
	`85`	`+ "Config {{ username: {}, password: ********, host: {:?}, port: {:?}, tls: {:?} }}",`
	`86`	`+ self.username, self.host, self.port, self.tls`
	`87`	`+ )`
`83`	`88`	`}`
`84`	`89`	`}`
`85`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use jni::{objects::JObject, JNIEnv};`
	`1`	`+use jni::{JNIEnv, objects::JObject};`
`2`	`2`	`use jni_toolbox::jni;`
`3`	`3`
`4`	`4`	`use crate::{`