Apply more lints

backend/reconcile/src/diffs/myers.rs

@@ -1,4 +1,4 @@
-//! Taken from https://github.com/mitsuhiko/similar/blob/7e15c44de11a1cd61e1149189929e189ef977fd8/src/algorithms/myers.rs
+//! Taken from <https://github.com/mitsuhiko/similar/blob/7e15c44de11a1cd61e1149189929e189ef977fd8/src/algorithms/myers.rs>
 //! Myers' diff algorithm.
 //!
 //! * time: `O((N+M)D)`

backend/reconcile/src/diffs/raw_operation.rs

@@ -23,12 +23,10 @@ where
     }
 
     pub fn original_text_length(&self) -> usize {
-        self.tokens().iter().map(|t| t.get_original_length()).sum()
+        self.tokens().iter().map(Token::get_original_length).sum()
     }
 
-    pub fn get_original_text(self) -> String {
+    pub fn get_original_text(self) -> String { self.tokens().iter().map(Token::original).collect() }
-        self.tokens().iter().map(|t| t.original()).collect()
-    }
 
     /// Extends the operation with another operation if returning the new
     /// operation. Only operations of the same type can be used to extend.

backend/reconcile/src/operation_transformation.rs

@@ -7,17 +7,17 @@ pub use operation::Operation;
 
 use crate::tokenizer::Tokenizer;
 
-pub fn reconcile(original: &str, left: &str, right: &str) -> String {
+#[must_use] pub fn reconcile(original: &str, left: &str, right: &str) -> String {
     if left == right {
-        return left.to_string();
+        return left.to_owned();
     }
 
     if original == left {
-        return right.to_string();
+        return right.to_owned();
     }
 
     if original == right {
-        return left.to_string();
+        return left.to_owned();
     }
 
     let left_operations = EditedText::from_strings(original, left);

backend/reconcile/src/operation_transformation/edited_text.rs

@@ -1,4 +1,4 @@
-use std::iter;
+use core::iter;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -9,17 +9,17 @@ use crate::{
     operation_transformation::merge_context::MergeContext,
     tokenizer::{word_tokenizer::word_tokenizer, Tokenizer},
     utils::{
-        merge_iters::MergeSorted, ordered_operation::OrderedOperation, side::Side,
+        merge_iters::MergeSorted as _, ordered_operation::OrderedOperation, side::Side,
         string_builder::StringBuilder,
     },
 };
 
 /// A sequence of operations that can be applied to a text document.
-/// EditedText supports merging two sequences of operations using the
+/// `EditedText` supports merging two sequences of operations using the
 /// principle of Operational Transformation.
 ///
-/// It's mainly created through the from_strings method, then merged with
+/// It's mainly created through the `from_strings` method, then merged with
-/// another EditedText derived from the same original text and then applied to
+/// another `EditedText` derived from the same original text and then applied to
 /// the original text to get the reconciled text of concurrent edits.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, Clone, PartialEq, Default)]
@@ -32,13 +32,13 @@ where
 }
 
 impl<'a> EditedText<'a, String> {
-    /// Create an EditedText from the given original (old) and updated (new)
+    /// Create an `EditedText` from the given original (old) and updated (new)
-    /// strings. The returned EditedText represents the changes from the
+    /// strings. The returned `EditedText` represents the changes from the
     /// original to the updated text. When the return value is applied to
     /// the original text, it will result in the updated text. The default
     /// word tokenizer is used to tokenize the text which splits the text on
     /// whitespaces.
-    pub fn from_strings(original: &'a str, updated: &str) -> Self {
+    #[must_use] pub fn from_strings(original: &'a str, updated: &str) -> Self {
         Self::from_strings_with_tokenizer(original, updated, &word_tokenizer)
     }
 }
@@ -47,8 +47,8 @@ impl<'a, T> EditedText<'a, T>
 where
     T: PartialEq + Clone,
 {
-    /// Create an EditedText from the given original (old) and updated (new)
+    /// Create an `EditedText` from the given original (old) and updated (new)
-    /// strings. The returned EditedText represents the changes from the
+    /// strings. The returned `EditedText` represents the changes from the
     /// original to the updated text. When the return value is applied to
     /// the original text, it will result in the updated text. The tokenizer
     /// function is used to tokenize the text.
@@ -167,7 +167,7 @@ where
         result
     }
 
-    /// Create a new EditedText with the given operations.
+    /// Create a new `EditedText` with the given operations.
     /// The operations must be in the order in which they are meant to be
     /// applied. The operations must not overlap.
     fn new(text: &'a str, operations: Vec<OrderedOperation<T>>) -> Self {
@@ -186,7 +186,7 @@ where
         Self { text, operations }
     }
 
-    pub fn merge(self, other: Self) -> Self {
+    #[must_use] pub fn merge(self, other: Self) -> Self {
         debug_assert_eq!(
             self.text, other.text,
             "EditedTexts must be derived from the same text to be mergable"
@@ -207,7 +207,7 @@ where
                             operation.order,
                             // Operations on left and right must come in the same order so that
                             // inserts can be merged with other inserts and deletes with deletes.
-                            matches!(operation.operation, Operation::Delete { .. }) as usize,
+                            usize::from(matches!(operation.operation, Operation::Delete { .. })),
                         )
                     },
                 )
@@ -233,9 +233,9 @@ where
     ///
     /// # Errors
     ///
-    /// Returns an SyncLibError::OperationError if the operations cannot be
+    /// Returns an `SyncLibError::OperationError` if the operations cannot be
     /// applied to the text.
-    pub fn apply(&self) -> String {
+    #[must_use] pub fn apply(&self) -> String {
         let mut builder: StringBuilder<'_> = StringBuilder::new(self.text);
 
         for OrderedOperation { operation, .. } in &self.operations {

backend/reconcile/src/operation_transformation/merge_context.rs

@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use core::fmt::Debug;
 
 use crate::operation_transformation::Operation;
 
@@ -27,7 +27,7 @@ impl<T> Debug for MergeContext<T>
 where
     T: PartialEq + Clone,
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("MergeContext")
             .field("last_operation", &self.last_operation)
             .field("shift", &self.shift)

backend/reconcile/src/operation_transformation/operation.rs

@@ -1,4 +1,4 @@
-use std::{
+use core::{
     fmt::{Debug, Display},
     ops::Range,
 };
@@ -13,8 +13,8 @@ use crate::{
 };
 
 /// Represents a change that can be applied to a text document.
-/// Operation is tied to a ropey::Rope and is mainly expected to be
+/// Operation is tied to a `ropey::Rope` and is mainly expected to be
-/// created by EditedText.
+/// created by `EditedText`.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Clone, PartialEq)]
 pub enum Operation<T>
@@ -81,12 +81,12 @@ where
         })
     }
 
-    /// Tries to apply the operation to the given ropey::Rope text, returning
+    /// Tries to apply the operation to the given `ropey::Rope` text, returning
     /// the modified text.
     ///
     /// # Errors
     ///
-    /// Returns a SyncLibError::OperationApplicationError if the operation
+    /// Returns a `SyncLibError::OperationApplicationError` if the operation
     /// cannot be applied.
     ///
     /// # Panics
@@ -99,7 +99,7 @@ where
                 self.start_index(),
                 &text
                     .iter()
-                    .map(|token| token.original())
+                    .map(super::super::tokenizer::token::Token::original)
                     .collect::<String>(),
             ),
             Operation::Delete {
@@ -111,8 +111,7 @@ where
                 debug_assert!(
                     deleted_text
                         .as_ref()
-                        .map(|text| builder.get_slice(self.range()) == *text)
+                        .map_or(true, |text| builder.get_slice(self.range()) == *text),
-                        .unwrap_or(true),
                     "Text to delete does not match the text in the rope"
                 );
 
@@ -141,15 +140,16 @@ where
     }
 
     /// Returns the range of indices of characters that the operation affects.
-    pub fn range(&self) -> Range<usize> { self.start_index()..self.end_index() + 1 }
+    pub fn range(&self) -> Range<usize> { self.start_index()..self.end_index() - 1 }
 
     /// Returns the number of affected characters. It is always greater than 0
     /// because empty operations cannot be created.
     pub fn len(&self) -> usize {
         match self {
-            Operation::Insert { text, .. } => {
+            Operation::Insert { text, .. } => text
-                text.iter().map(|token| token.get_original_length()).sum()
+                .iter()
-            }
+                .map(super::super::tokenizer::token::Token::get_original_length)
+                .sum(),
             Operation::Delete {
                 deleted_character_count,
                 ..
@@ -223,7 +223,7 @@ where
                 let trimmed_length = previous_inserted_text
                     .iter()
                     .skip(offset_in_tokens)
-                    .map(|token| token.get_original_length())
+                    .map(super::super::tokenizer::token::Token::get_original_length)
                     .sum::<usize>();
                 let trimmed_operation =
                     Operation::create_insert(index, text[trimmed_length_in_tokens..].to_vec());
@@ -231,7 +231,7 @@ where
                 affecting_context.shift -= trimmed_length as i64;
                 produced_context.shift += trimmed_operation
                     .as_ref()
-                    .map(|op| op.len())
+                    .map(Operation::len)
                     .unwrap_or_default() as i64;
                 produced_context.consume_and_replace_last_operation(trimmed_operation.clone());
 
@@ -305,14 +305,14 @@ impl<T> Display for Operation<T>
 where
     T: PartialEq + Clone,
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Operation::Insert { index, text } => {
                 write!(
                     f,
                     "<insert '{}' from index {}>",
                     text.iter()
-                        .map(|token| token.original())
+                        .map(super::super::tokenizer::token::Token::original)
                         .collect::<String>(),
                     index
                 )
@@ -351,7 +351,7 @@ impl<T> Debug for Operation<T>
 where
     T: PartialEq + Clone,
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self) }
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{self}") }
 }
 
 #[cfg(test)]

backend/reconcile/src/tokenizer/token.rs

@@ -17,8 +17,8 @@ where
 impl From<&str> for Token<String> {
     fn from(s: &str) -> Self {
         Token {
-            normalised: s.to_string(),
+            normalised: s.to_owned(),
-            original: s.to_string(),
+            original: s.to_owned(),
         }
     }
 }

backend/reconcile/src/tokenizer/word_tokenizer.rs

@@ -2,6 +2,6 @@ use super::token::Token;
 
 pub fn word_tokenizer(text: &str) -> Vec<Token<String>> {
     text.split_inclusive(char::is_whitespace)
-        .map(|s| Token::new(s.to_string(), s.to_string()))
+        .map(|s| Token::new(s.to_owned(), s.to_owned()))
         .collect()
 }

backend/reconcile/src/utils/common_prefix_len.rs

@@ -1,7 +1,7 @@
-use std::ops::{Index, Range};
+use core::ops::{Index, Range};
 
 /// Given two lookups and ranges calculates the length of the common prefix.
-/// Copied from https://github.com/mitsuhiko/similar/blob/7e15c44de11a1cd61e1149189929e189ef977fd8/src/algorithms/utils.rs
+/// Copied from <https://github.com/mitsuhiko/similar/blob/7e15c44de11a1cd61e1149189929e189ef977fd8/src/algorithms/utils.rs>
 pub fn common_prefix_len<Old, New>(
     old: &Old,
     old_range: Range<usize>,

backend/reconcile/src/utils/common_suffix_len.rs

@@ -1,7 +1,7 @@
-use std::ops::{Index, Range};
+use core::ops::{Index, Range};
 
 /// Given two lookups and ranges calculates the length of common suffix.
-/// Copied from https://github.com/mitsuhiko/similar/blob/7e15c44de11a1cd61e1149189929e189ef977fd8/src/algorithms/utils.rs
+/// Copied from <https://github.com/mitsuhiko/similar/blob/7e15c44de11a1cd61e1149189929e189ef977fd8/src/algorithms/utils.rs>
 pub fn common_suffix_len<Old, New>(
     old: &Old,
     old_range: Range<usize>,

backend/reconcile/src/utils/merge_iters.rs

@@ -1,4 +1,4 @@
-use std::{cmp::Ordering, iter::Peekable};
+use core::{cmp::Ordering, iter::Peekable};
 
 pub struct MergeAscending<L, R, F, O>
 where

backend/reconcile/src/utils/string_builder.rs

@@ -1,4 +1,4 @@
-use std::ops::Range;
+use core::ops::Range;
 
 /// A helper for building a string in order based on an original string and a
 /// series of insertions and deletions applied to it. It is safe to use with
@@ -28,7 +28,7 @@ impl StringBuilder<'_> {
 
     /// Delete a string at the given index after copying the original string up
     /// to that index from the last insertion or deletion.
-    pub fn delete(&mut self, range: std::ops::Range<usize>) {
+    pub fn delete(&mut self, range: core::ops::Range<usize>) {
         self.copy_until(range.start);
         self.last_old_char_index += range.len();
     }

backend/sync_server/src/config.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use anyhow::{Context, Result};
+use anyhow::{Context as _, Result};
 use database_config::DatabaseConfig;
 use log::{info, warn};
 use serde::{Deserialize, Serialize};

backend/sync_server/src/config/user_config.rs

@@ -1,4 +1,4 @@
-use rand::{distributions::Alphanumeric, thread_rng, Rng};
+use rand::{distributions::Alphanumeric, thread_rng, Rng as _};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize, Clone)]

backend/sync_server/src/database.rs

@@ -1,6 +1,6 @@
-use core::{str::FromStr, time::Duration};
+use core::{str::FromStr as _, time::Duration};
 
-use anyhow::{Context, Result};
+use anyhow::{Context as _, Result};
 use models::{
     DocumentId, DocumentVersionWithoutContent, StoredDocumentVersion, VaultId, VaultUpdateId,
 };

backend/sync_server/src/errors.rs

@@ -26,7 +26,7 @@ pub enum SyncServerError {
     #[error("Unauthorized: {0}")]
     Unauthorized(#[source] anyhow::Error),
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     #[error("Permission denied error: {0}")]
     PermissionDeniedError(#[source] anyhow::Error),
 }

backend/sync_server/src/main.rs

@@ -5,7 +5,7 @@ mod database;
 mod errors;
 mod server;
 
-use anyhow::{Context, Result};
+use anyhow::{Context as _, Result};
 use app_state::AppState;
 use errors::{init_error, SyncServerError};
 use server::create_server;

backend/sync_server/src/server.rs

@@ -6,7 +6,7 @@ use aide::{
     openapi::{Info, OpenApi},
     scalar::Scalar,
 };
-use anyhow::{Context, Result};
+use anyhow::{Context as _, Result};
 use axum::{
     extract::DefaultBodyLimit,
     http::{self, HeaderValue, Method},

backend/sync_server/src/server/create_document.rs

@@ -1,4 +1,4 @@
-use anyhow::Context;
+use anyhow::Context as _;
 use axum::{
     extract::{Path, State},
     Json,

backend/sync_server/src/server/delete_document.rs

@@ -1,4 +1,4 @@
-use anyhow::Context;
+use anyhow::Context as _;
 use axum::{
     extract::{Path, State},
     Json,

backend/sync_server/src/server/update_document.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Context};
+use anyhow::{anyhow, Context as _};
 use axum::{
     extract::{Path, State},
     Json,