Clippy

Author: Zeophlite

crates/bevy_text/src/undo_2/lib.rs

@@ -6,17 +6,17 @@ use core::iter::FusedIterator;
 use core::ops::ControlFlow;
 use core::ops::{Deref, Index};
 use core::option;
-use std::fmt::Debug;
+use core::fmt::Debug;
 use std::hash::{DefaultHasher, Hash, Hasher as _};
-use std::slice::SliceIndex;
-use std::{slice, vec};
+use core::slice::SliceIndex;
+use alloc::{slice, vec};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 /// Action that should be taken on the paired command
 ///
-/// [ActionIter] item type is a pair `(Action, C)` where
+/// [`ActionIter`] item type is a pair `(Action, C)` where
 /// C is the client defined command type. `(Action::Do, t)`
 /// signifies that the command `t` shall be executed. `(Action::Undo,t)`
 /// means it shall be undone.
@@ -50,24 +50,24 @@ pub enum Action<T> {
 /// transition are interlieved with other transitions.
 ///
 /// So the set of all commands can be partitionned in two: the set of transitions affecting
-/// indepent state, and the other transitions. [SetOrTransition] provides such a partition.
+/// indepent state, and the other transitions. [`SetOrTransition`] provides such a partition.
 /// It is supposed to be used as the element of the [Commands]:
 /// `Commands<SetOrTransition::<MyStateCommands,MyTransitions>`.
 ///
-/// [Commands] provides dedicateds methods (see [apply_actions][Commands::apply_actions]) to simplify the use of
+/// [Commands] provides dedicateds methods (see [`apply_actions`][Commands::apply_actions]) to simplify the use of
 /// commands partitionned in independent state and transitions.
 ///
 /// State commands are supposed to represent the setting of an indepent state such as "set the view
 /// port to `x`, `y`, `lx`, `ly`". When a independent state command is undone within the `apply_actions`, the
-/// algorithm will look for the previous application of a command the same key [IndepStateKey::key] and will
+/// algorithm will look for the previous application of a command the same key [`IndepStateKey::key`] and will
 /// command the application of it.
 ///
 /// # Example
 ///
 /// In this example we use commands that set the state `color` and `length`.
 ///
 /// In the commands registered the previous states of `color` and `length` are not stored
-/// but [Commands::apply_actions] will retrieve automatically the value to set for this states.
+/// but [`Commands::apply_actions`] will retrieve automatically the value to set for this states.
 /// ```
 /// use std::mem::{discriminant, Discriminant};
 ///
@@ -200,7 +200,7 @@ pub trait IndepStateKey {
 }
 
 /// The actions asked to be performed by the user
-/// when calling [Commands::apply_actions]
+/// when calling [`Commands::apply_actions`]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum SetTransAction<'a, S: IndepStateKey, T> {
     /// Ask the execution of the transition .0
@@ -320,7 +320,7 @@ pub enum CommandItem<T> {
 ///
 /// # Representation
 ///
-/// `Commands` owns a slice of [CommandItem] that is accesible
+/// `Commands` owns a slice of [`CommandItem`] that is accesible
 /// by dereferencing the command.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Eq)]
@@ -330,7 +330,7 @@ pub struct Commands<T> {
     undo_cache: Vec<IndexedAction>,
 }
 impl<T: Debug> Debug for Commands<T> {
-    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("Commands")
             .field("commands", &self.commands)
             .finish()
@@ -342,7 +342,7 @@ impl<T: PartialEq> PartialEq for Commands<T> {
     }
 }
 impl<T: Hash> Hash for Commands<T> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.commands.hash(state);
     }
 }
@@ -368,11 +368,11 @@ struct IndexedAction {
     index: usize,
 }
 
-/// Specify a merge when calling [Commands::merge](Commands#method.merge)
+/// Specify a merge when calling [`Commands::merge`](Commands#method.merge)
 ///
 /// The [`end`, `start`) bounds the slice of command that will
 /// be removed during the merge. `end` and `start` are in reverse order
-/// because [IterRealized] goes backward.
+/// because [`IterRealized`] goes backward.
 ///
 /// If `command` is `None` then the slice will be removed, otherwise if
 /// the `command` is `Some(c)` the slice will be replace by `c`.
@@ -383,11 +383,11 @@ pub struct Merge<'a, T> {
     pub command: Option<T>,
 }
 
-/// Specify a splice when calling [Commands::splice](Commands#method.splice)
+/// Specify a splice when calling [`Commands::splice`](Commands#method.splice)
 ///
 /// The [`end`, `start`) bounds the slice of command that will
 /// be removed during the merge. `end` and `start` are in reverse order
-/// because [IterRealized] goes backward.
+/// because [`IterRealized`] goes backward.
 ///
 /// The removed slice is then replaced by the sequence (not reversed) of
 /// commands denoted by `commands`.
@@ -399,8 +399,8 @@ pub struct Splice<'a, T, I: IntoIterator<Item = T>> {
 }
 
 #[derive(Debug)]
-/// Iterator of actions returned by [Commands::undo](Commands#method.undo) and
-/// [Commands::redo](Commands#method.redo)
+/// Iterator of actions returned by [`Commands::undo`](Commands#method.undo) and
+/// [`Commands::redo`](Commands#method.redo)
 pub struct ActionIter<'a, T> {
     commands: &'a [CommandItem<T>],
     to_do: slice::Iter<'a, IndexedAction>,
@@ -415,7 +415,7 @@ impl<T> Clone for ActionIter<'_, T> {
 }
 
 #[derive(Debug)]
-/// The type of the iterator returned by [Commands::iter_realized](Commands#method.iter_realized).
+/// The type of the iterator returned by [`Commands::iter_realized`](Commands#method.iter_realized).
 pub struct IterRealized<'a, T> {
     commands: &'a [CommandItem<T>],
     current: usize,
@@ -427,17 +427,17 @@ impl<T> Clone for IterRealized<'_, T> {
 }
 
 impl<S: IndepStateKey, T> Commands<SetOrTransition<S, T>> {
-    /// Apply a series of actions represented by the type [SetTransAction] executed
+    /// Apply a series of actions represented by the type [`SetTransAction`] executed
     /// by argument `f`.
     ///
     /// The list of action to be applied are provided by the call of `act` on
     /// this [Commands]. This may be defined, for exemple as, `|c| c.redo()`
     ///
-    /// This command only exist when the commands have the type [SetOrTransition].
+    /// This command only exist when the commands have the type [`SetOrTransition`].
     /// See the documentation of this type for an explanation.
     ///
     /// The function `f` will be called with [Do][SetTransAction::Do] and [Undo][SetTransAction::Undo] of commands that are
-    /// represented as [transitions][SetOrTransition::Transition], and [Set][SetTransAction::Set] or [SetToInitial][SetTransAction::SetToInitial]
+    /// represented as [transitions][SetOrTransition::Transition], and [Set][SetTransAction::Set] or [`SetToInitial`][SetTransAction::SetToInitial]
     /// (most probably only once) per [key][IndepStateKey::key] for commands that represent independent state setting.
     pub fn apply_actions(
         &mut self,
@@ -446,17 +446,17 @@ impl<S: IndepStateKey, T> Commands<SetOrTransition<S, T>> {
     ) {
         let mut state_commands = Vec::new();
         for command in act(self) {
-            Self::apply_action(command, &mut state_commands, &mut f)
+            Self::apply_action(command, &mut state_commands, &mut f);
         }
         self.restore_state(state_commands, f);
     }
     /// Equivalent to `apply_actions(|c| c.undo(),f)`.
     pub fn apply_undo(&mut self, f: impl FnMut(SetTransAction<S, T>)) {
-        self.apply_actions(|s| s.undo(), f)
+        self.apply_actions(Commands::undo, f);
     }
     /// Equivalent to `apply_actions(|c| c.redo(),f)`.
     pub fn apply_redo(&mut self, f: impl FnMut(SetTransAction<S, T>)) {
-        self.apply_actions(|s| s.redo(), f)
+        self.apply_actions(Commands::redo, f);
     }
     fn apply_action(
         action: Action<&SetOrTransition<S, T>>,
@@ -467,7 +467,7 @@ impl<S: IndepStateKey, T> Commands<SetOrTransition<S, T>> {
             Action::Do(SetOrTransition::Transition(tr)) => f(SetTransAction::Do(tr)),
             Action::Undo(SetOrTransition::Transition(tr)) => f(SetTransAction::Undo(tr)),
             Action::Do(SetOrTransition::Set(s)) | Action::Undo(SetOrTransition::Set(s)) => {
-                state_keys.push(Some(s.key()))
+                state_keys.push(Some(s.key()));
             }
         }
     }
@@ -511,7 +511,7 @@ impl<S: IndepStateKey, T> Commands<SetOrTransition<S, T>> {
         }
         if l > 0 {
             for disc in state_keys.into_iter().flatten() {
-                f(SetTransAction::SetToInitial(disc))
+                f(SetTransAction::SetToInitial(disc));
             }
         }
     }
@@ -531,7 +531,7 @@ impl<T> Commands<T> {
     }
     /// Reserve space for new commands
     pub fn reserve(&mut self, additional: usize) {
-        self.commands.reserve(additional)
+        self.commands.reserve(additional);
     }
 
     /// Return a reference to the last command
@@ -691,7 +691,7 @@ impl<T> Commands<T> {
         producer: impl FnOnce() -> T,
     ) {
         if !self.update_last(updater) {
-            self.push(producer())
+            self.push(producer());
         }
     }
 
@@ -1181,7 +1181,7 @@ impl<T> Commands<T> {
     }
 
     /// Repeat undo or redo so that the last realiazed command correspond to
-    /// the [CommandItem] index passed `index`.
+    /// the [`CommandItem`] index passed `index`.
     ///
     /// ```
     /// use crate::undo_2::{Action,Commands, CommandItem};
@@ -1337,7 +1337,7 @@ impl<T> Commands<T> {
             CommandItem::Undo(_) => false,
             CommandItem::Command(c) => stop_pred(c),
         }) {
-            self.remove_first(i)
+            self.remove_first(i);
         }
     }
     /// Try to keep `count` most recent commands by dropping removable commands.
@@ -1404,7 +1404,7 @@ impl<T> Commands<T> {
     /// ```
     pub fn keep_last(&mut self, count: usize) {
         let i = self.len().saturating_sub(count);
-        self.remove_first(i)
+        self.remove_first(i);
     }
     /// Remove `count` or less of the oldest command.
     ///
@@ -1479,11 +1479,10 @@ impl<T> Commands<T> {
     fn remove_i(&self, mut i: usize, end: usize) -> usize {
         let i0 = i;
         for j in i0..end {
-            if let CommandItem::Undo(count) = self.commands[j] {
-                if j - count - 1 < i {
-                    i = self.remove_i(j - count - 1, i)
+            if let CommandItem::Undo(count) = self.commands[j]
+                && j - count - 1 < i {
+                    i = self.remove_i(j - count - 1, i);
                 }
-            }
         }
         i
     }
@@ -1538,7 +1537,7 @@ impl<T> Commands<T> {
     /// Merge a sequence of [*realized commands*](Commands#method.iter_realized) into a single new
     /// command or remove the sequence.
     ///
-    /// The parameter `f` takes as an input a [IterRealized], and returns a
+    /// The parameter `f` takes as an input a [`IterRealized`], and returns a
     /// [`std::ops::ControlFlow<Option<Merge>, Option<Merge>>`](std::ops::ControlFlow). If the
     /// returned value contain a `Some(merge)`[Merge], the action specified by `merge` is then
     /// inserted in place.
@@ -1598,15 +1597,15 @@ impl<T> Commands<T> {
     {
         use ControlFlow::*;
         self.splice(|it| match f(it) {
-            Continue(c) => Continue(c.map(|m| m.into())),
-            Break(c) => Break(c.map(|m| m.into())),
-        })
+            Continue(c) => Continue(c.map(Into::into)),
+            Break(c) => Break(c.map(Into::into)),
+        });
     }
 
     /// Replace a sequence of command by an other. This is a generalization of
-    /// [Commands::merge](Commands#method.merge)
+    /// [`Commands::merge`](Commands#method.merge)
     ///
-    /// The parameter `f` takes as an input a [IterRealized], and returns a
+    /// The parameter `f` takes as an input a [`IterRealized`], and returns a
     /// [`std::ops::ControlFlow<Option<Splice>, Option<Splice>>`](std::ops::ControlFlow). If the returned value
     /// contain a `Some(splice)`[Splice], the actions specified by `splice` are then inserted in
     /// place.
@@ -1705,7 +1704,7 @@ impl<T> Commands<T> {
         let end_i = rev_start;
         let start_i = rev_end;
         self.commands
-            .splice(start_i..end_i, commands.into_iter().map(|c| c.into()));
+            .splice(start_i..end_i, commands.into_iter().map(Into::into));
     }
 
     /// Clean up the history of all the undone commands.
@@ -1736,7 +1735,7 @@ impl<T> Commands<T> {
     /// assert_eq!(*c, [A.into(), C.into()]);
     /// ```
     pub fn remove_all_undone(&mut self) {
-        self.remove_undone(|i| i)
+        self.remove_undone(|i| i);
     }
     /// Clean up the history of all undone commands before a given
     /// [realized iterator](Commands#method.iter_realized).
@@ -1833,7 +1832,7 @@ impl<T: Clone> Clone for Commands<T> {
         }
     }
     fn clone_from(&mut self, source: &Self) {
-        self.commands.clone_from(&source.commands)
+        self.commands.clone_from(&source.commands);
     }
 }
 
@@ -1855,13 +1854,13 @@ impl<T> Borrow<[CommandItem<T>]> for Commands<T> {
 }
 impl<T> Extend<T> for Commands<T> {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        self.commands.extend(iter.into_iter().map(|c| c.into()))
+        self.commands.extend(iter.into_iter().map(Into::into));
     }
 }
 impl<T> FromIterator<T> for Commands<T> {
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
         Self {
-            commands: iter.into_iter().map(|c| c.into()).collect(),
+            commands: iter.into_iter().map(Into::into).collect(),
             undo_cache: vec![],
         }
     }
@@ -2066,14 +2065,14 @@ fn do_simplify(to_do: &mut [IndexedAction]) {
             if to_do[cursor].is_reverse_of(action) {
                 cursor += 1;
                 while cursor < l && to_do[cursor].action == Skip {
-                    cursor += 1
+                    cursor += 1;
                 }
             } else {
                 to_do[analyzed + 1..cursor]
                     .iter_mut()
                     .for_each(|a| a.action = Skip);
                 if cursor == analyzed + 1 {
-                    cursor = analyzed
+                    cursor = analyzed;
                 } else {
                     cursor = analyzed + 1;
                     analyzed += 1;

crates/bevy_text/src/undo_2/tests/mod.rs

@@ -1,3 +1,5 @@
+#[expect(clippy::allow_attributes_without_reason)]
+
 mod iter_realized;
 mod merge;
 mod redo;

crates/bevy_text/src/undo_2/tests/set_and_transition.rs

@@ -1,4 +1,4 @@
-use std::mem::{discriminant, Discriminant};
+use core::mem::{discriminant, Discriminant};
 
 use crate::undo_2::{IndepStateKey, SetTransAction};
 

crates/bevy_text/src/undo_2/tests/splice.rs

@@ -1,7 +1,7 @@
 #![allow(unused)]
 
 use crate::undo_2::*;
-use std::ops::ControlFlow;
+use core::ops::ControlFlow;
 
 #[derive(PartialEq, Debug)]
 enum Command {
@@ -29,7 +29,7 @@ fn do_splice(c: &mut Commands<Command>) {
         } else {
             ControlFlow::Continue(None)
         }
-    })
+    });
 }
 
 #[test]