Lints

Author: Zeophlite

crates/bevy_ecs/src/system/builder.rs

@@ -106,7 +106,7 @@ use super::{Res, ResMut, SystemState};
 ///
 /// The implementor must ensure that the state returned
 /// from [`SystemParamBuilder::build`] is valid for `P`.
-/// Note that the exact safety requiremensts depend on the implementation of [`SystemParam`],
+/// Note that the exact safety requirements depend on the implementation of [`SystemParam`],
 /// so if `Self` is not a local type then you must call [`SystemParam::init_state`]
 /// or another [`SystemParamBuilder::build`].
 pub unsafe trait SystemParamBuilder<P: SystemParam>: Sized {

crates/bevy_text/src/undo_2/README.md

@@ -1,6 +1,6 @@
-# Undo done the right way!
+# Undo done the right way
 
-Via https://gitlab.com/okannen/undo_2/-/tree/b32c34edb2c15c266b946f0d82188624f3aa3fdc
+Via [](https://gitlab.com/okannen/undo_2/-/tree/b32c34edb2c15c266b946f0d82188624f3aa3fdc)
 
 ## Introduction
 
@@ -10,34 +10,33 @@ end of the Undo history as a precursor to your new change. I found the idea in
 [zaboople/klong][zaboople]. This crate is an implementation
 of this idea with a minor variation explained below.
 
-As an example consider the following sequence of commands: 
+As an example consider the following sequence of commands:
 
 | Command | State |
 | ------- | ----- |
-| Init    |       | 
+| Init    |       |
 | Do A    | A     |
 | Do B    | A, B  |
-| Undo    | A     | 
-| Do C    | A, C  | 
+| Undo    | A     |
+| Do C    | A, C  |
 
-With the **classical undo**, repeated undo would lead to the sequence: 
+With the **classical undo**, repeated undo would lead to the sequence:
 
 | Command | State |
 |---------|-------|
 |         | A, C  |
 | Undo    | A     |
-| Undo    |       | 
-
+| Undo    |       |
 
-Starting from 5, with **undo_2**, repeating undo would lead to the sequence: 
+Starting from 5, with **undo_2**, repeating undo would lead to the sequence:
 
 | Command | State |
 |---------|-------|
 |         | A, C  |
 | Undo    | A     |
-| Undo    | A,B   | 
-| Undo    | A     | 
-| Undo    |       | 
+| Undo    | A,B   |
+| Undo    | A     |
+| Undo    |       |
 
 **undo_2**'s undo navigates back in history, while classical undo navigates back
 through the sequence of command that builds the state.
@@ -53,7 +52,7 @@ and it is similar to vim :earlier.
   4. very lightweight, dumb and simple.
   5. possibility to merge and splice commands.
 
-## How to use it 
+## How to use it
 
 Add the dependency to the cargo file:
 
@@ -74,7 +73,7 @@ be interpreted by the application. This design pattern makes implementation
 easier because it is not necessary to borrow data within the stored list of
 commands.
 
-```
+```rs
 use undo_2::{Commands,Action};
 use Action::{Do,Undo};
 
@@ -156,22 +155,22 @@ assert_eq!(editor.text, "a");
    forming the sequence are merged. This makes the traversal of the undo
    sequence more concise by avoiding state duplication.
 
-| Command | State   | Comment              | 
+| Command | State   | Comment              |
 |---------|-------  |----------------------|
-| Init    |         |                      | 
+| Init    |         |                      |
 | Do A    | A       |                      |
 | Do B    | A,B     |                      |
 | Do C    | A, B, C |                      |
-| Undo    | A, B    |Merged                | 
-| Undo    | A       |Merged                | 
-| Do D    | A, D    |                      | 
+| Undo    | A, B    |Merged                |
+| Undo    | A       |Merged                |
+| Do D    | A, D    |                      |
 | Undo    | A       |Redo the 2 Merged Undo|
-| Undo    | A, B, C |                      | 
-| Undo    | A, B    |                      | 
-| Undo    | A       |                      | 
-| Undo    |         |                      | 
+| Undo    | A, B, C |                      |
+| Undo    | A, B    |                      |
+| Undo    | A       |                      |
+| Undo    |         |                      |
 
-2. Each execution of an undos or redo may lead to the execution of a sequence of
+1. Each execution of an undos or redo may lead to the execution of a sequence of
    actions in the form `Undo(a)+Do(b)+Do(c)`. Basic arithmetic is implemented
    assuming that `Do(a)+Undo(a)` is equivalent to not doing anything (here the
    2 `a`'s designate the same entity, not to equal objects).
@@ -249,13 +248,15 @@ assert_eq!(editor.text, "az12");
 ```
 
 ## Release note
+
 ### Version 0.3
-  - [Action] is now an enum taking commands, the list of command to be
-  executed is of the form [Action<T>];
-  - added [Commands::can_undo] and [Commands::can_redo];
-  - added [Commands::rebuild], which correspond to the classical redo;
-  - fixed a bug in [Commands::undo_or_redo_to_index]
-  - Added support for special commands that represent a state setting. See [SetOrTransition].
+
+- [`Action`] is now an enum taking commands, the list of command to be
+executed is of the form [`Action<T>`];
+- added [`Commands::can_undo`] and [`Commands::can_redo`];
+- added [`Commands::rebuild`], which correspond to the classical redo;
+- fixed a bug in [`Commands::undo_or_redo_to_index`]
+- Added support for special commands that represent a state setting. See [`SetOrTransition`].
 
 [zaboople]: https://github.com/zaboople/klonk/blob/master/TheGURQ.md
 

crates/bevy_text/src/undo_2/mod.rs

@@ -1,4 +1,3 @@
-
 mod lib;
 mod tests;
 

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

@@ -1,11 +1,10 @@
-use crate::undo_2::*;
-
 #[test]
 fn merge() {
-    use std::ops::ControlFlow;
     use crate::undo_2::CommandItem;
+    use crate::undo_2::Commands;
     use crate::undo_2::IterRealized;
     use crate::undo_2::Merge;
+    use std::ops::ControlFlow;
     #[derive(Eq, PartialEq, Debug)]
     enum Command {
         A,
@@ -15,7 +14,7 @@ fn merge() {
     }
     use Command::*;
     fn is_ab(mut it: IterRealized<'_, Command>) -> (bool, IterRealized<'_, Command>) {
-        let cond = it.next() == Some(&Command::B) && it.next() == Some(&Command::A);
+        let cond = it.next() == Some(&B) && it.next() == Some(&A);
         (cond, it)
     }
     fn parse(
@@ -25,27 +24,27 @@ fn merge() {
             ControlFlow::Continue(Some(Merge {
                 start,
                 end,
-                command: Some(Command::AB),
+                command: Some(AB),
             }))
         } else {
             ControlFlow::Continue(None)
         }
     }
     {
         let mut commands = Commands::new();
-        commands.push(Command::A);
-        commands.push(Command::B);
+        commands.push(A);
+        commands.push(B);
 
         commands.merge(parse);
-        assert_eq!(*commands, [CommandItem::Command(Command::AB)]);
+        assert_eq!(*commands, [CommandItem::Command(AB)]);
     }
     {
         let mut commands = Commands::new();
-        commands.push(Command::A);
-        commands.push(Command::C);
-        commands.push(Command::B);
-        commands.push(Command::A);
-        commands.push(Command::B);
+        commands.push(A);
+        commands.push(C);
+        commands.push(B);
+        commands.push(A);
+        commands.push(B);
 
         commands.merge(parse);
         assert_eq!(
@@ -60,13 +59,13 @@ fn merge() {
     }
     {
         let mut commands = Commands::new();
-        commands.push(Command::A);
-        commands.push(Command::C);
-        commands.push(Command::A);
-        commands.push(Command::B);
-        commands.push(Command::B);
-        commands.push(Command::A);
-        commands.push(Command::B);
+        commands.push(A);
+        commands.push(C);
+        commands.push(A);
+        commands.push(B);
+        commands.push(B);
+        commands.push(A);
+        commands.push(B);
 
         commands.merge(parse);
         assert_eq!(
@@ -82,10 +81,10 @@ fn merge() {
     }
     {
         let mut commands = Commands::new();
-        commands.push(Command::A);
-        commands.push(Command::B);
-        commands.push(Command::A);
-        commands.push(Command::B);
+        commands.push(A);
+        commands.push(B);
+        commands.push(A);
+        commands.push(B);
 
         commands.merge(parse);
         assert_eq!(

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

@@ -1,4 +1,3 @@
-
 mod iter_realized;
 mod merge;
 mod redo;

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

@@ -1,6 +1,6 @@
 use std::mem::{discriminant, Discriminant};
 
-use crate::undo_2::{Commands, IndepStateKey, SetOrTransition, SetTransAction};
+use crate::undo_2::{IndepStateKey, SetTransAction};
 
 #[derive(Copy, Clone, Debug)]
 struct State {
@@ -67,7 +67,7 @@ enum TransitionCommand {
 
 #[test]
 fn set_and_transition() {
-    use SetOrTransition::*;
+    use crate::undo_2::{Commands, SetOrTransition::*};
     let mut commands = Commands::new();
     let mut state = State::new();
 

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

@@ -1,7 +1,7 @@
 #![allow(unused)]
 
-use std::ops::ControlFlow;
 use crate::undo_2::*;
+use std::ops::ControlFlow;
 
 #[derive(PartialEq, Debug)]
 enum Command {

typos.toml

@@ -1,9 +1,10 @@
 [files]
 extend-exclude = [
-  "*.pbxproj", # metadata file
-  "*.patch",   # Automatically generated files that should not be manually modified.
-  "*.bin",     # Binary files
-  ".git/",     # Version control files
+  "*.pbxproj",                    # metadata file
+  "*.patch",                      # Automatically generated files that should not be manually modified.
+  "*.bin",                        # Binary files
+  ".git/",                        # Version control files
+  "crates/bevy_text/src/undo_2/", # undo_2
 ]
 ignore-hidden = false