More doc work

Author: Zeophlite

crates/bevy_text/src/lib.rs

@@ -42,7 +42,7 @@ mod pipeline;
 mod text;
 mod text2d;
 mod text_access;
-mod undo_2;
+pub mod undo_2;
 
 use bevy_camera::{visibility::VisibilitySystems, CameraUpdateSystems};
 pub use bounds::*;
@@ -56,7 +56,6 @@ pub use pipeline::*;
 pub use text::*;
 pub use text2d::*;
 pub use text_access::*;
-pub use undo_2::*;
 
 /// The text prelude.
 ///

crates/bevy_text/src/undo_2/README.md

@@ -1,6 +1,6 @@
 # Undo done the right way
 
-Via [](https://gitlab.com/okannen/undo_2/-/tree/b32c34edb2c15c266b946f0d82188624f3aa3fdc)
+Via [original](https://gitlab.com/okannen/undo_2/-/tree/b32c34edb2c15c266b946f0d82188624f3aa3fdc)
 
 ## Introduction
 
@@ -56,7 +56,7 @@ and it is similar to vim :earlier.
 
 Add the dependency to the cargo file:
 
-```[toml]
+```toml
 [dependencies]
 undo_2 = "0.1"
 ```

crates/bevy_text/src/undo_2/lib.rs

@@ -1,5 +1,8 @@
+//! AA
 #![doc = include_str!("./README.md")]
-#![doc = document_features::document_features!()]
+//! BB
+// #![doc = document_features::document_features!()]
+//! CC
 use alloc::{slice, vec};
 use core::borrow::Borrow;
 use core::cmp::min;
@@ -72,7 +75,6 @@ pub enum Action<T> {
 /// use std::mem::{discriminant, Discriminant};
 ///
 /// use bevy_text::undo_2::{Commands, IndepStateKey, SetOrTransition, SetTransAction};
-/// use bevy_text::undo_2::SetTransAction::Transition;
 ///
 /// #[derive(Copy, Clone, Debug)]
 /// struct State {
@@ -137,24 +139,23 @@ pub enum Action<T> {
 ///     B,
 /// }
 ///
-/// use bevy_text::undo_2::SetTransAction::*;
 /// let mut commands = Commands::new();
 /// let mut state = State::new();
 ///
 /// let c = SetCommands::Color(1.);
 /// state.apply_set(&c);
-/// commands.push(Set(c));
+/// commands.push(SetOrTransition::Set(c));
 ///
-/// commands.push(Transition(TransitionCommand::A));
-/// commands.push(Transition(TransitionCommand::B));
+/// commands.push(SetOrTransition::Transition(TransitionCommand::A));
+/// commands.push(SetOrTransition::Transition(TransitionCommand::B));
 ///
 /// let c = SetCommands::Length(10.);
 /// state.apply_set(&c);
-/// commands.push(Set(c));
+/// commands.push(SetOrTransition::Set(c));
 ///
 /// let c = SetCommands::Color(2.);
 /// state.apply_set(&c);
-/// commands.push(Set(c));
+/// commands.push(SetOrTransition::Set(c));
 ///
 /// commands.apply_undo(|c| {
 ///     assert_eq!(c, SetTransAction::Set(&SetCommands::Color(1.)));
@@ -196,7 +197,9 @@ pub enum SetOrTransition<S, T> {
 /// }
 /// ```
 pub trait IndepStateKey {
+    /// KeyType
     type KeyType: PartialEq + Hash;
+    /// key
     fn key(&self) -> Self::KeyType;
 }
 
@@ -217,22 +220,22 @@ pub enum SetTransAction<'a, S: IndepStateKey, T> {
 }
 
 impl<T> Action<T> {
+    /// as_inner
     pub fn as_inner(&self) -> &T {
         match self {
-            Action::Do(a) => a,
-            Action::Undo(a) => a,
+            Action::Do(a) | Action::Undo(a) => a,
         }
     }
+    /// as_inner_mut
     pub fn as_inner_mut(&mut self) -> &mut T {
         match self {
-            Action::Do(a) => a,
-            Action::Undo(a) => a,
+            Action::Do(a) | Action::Undo(a) => a,
         }
     }
+    /// into_inner
     pub fn into_inner(self) -> T {
         match self {
-            Action::Do(a) => a,
-            Action::Undo(a) => a,
+            Action::Do(a) | Action::Undo(a) => a,
         }
     }
 }
@@ -271,11 +274,11 @@ impl<T> Action<T> {
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum CommandItem<T> {
-    // A command typically created by [Commands::push](Commands#method.push)
+    /// A command typically created by [Commands::push](Commands#method.push)
     Command(T),
-    // Signify that `count` CommandItem previous to this item are undone.
-    //
-    // Where `count` refers to this variant field.
+    /// Signify that `count` CommandItem previous to this item are undone.
+    ///
+    /// Where `count` refers to this variant field.
     Undo(usize),
 }
 
@@ -379,8 +382,11 @@ struct IndexedAction {
 /// the `command` is `Some(c)` the slice will be replace by `c`.
 #[derive(Debug)]
 pub struct Merge<'a, T> {
+    /// start
     pub start: IterRealized<'a, T>,
+    /// end
     pub end: IterRealized<'a, T>,
+    /// command
     pub command: Option<T>,
 }
 
@@ -394,8 +400,11 @@ pub struct Merge<'a, T> {
 /// commands denoted by `commands`.
 #[derive(Debug)]
 pub struct Splice<'a, T, I: IntoIterator<Item = T>> {
+    /// start
     pub start: IterRealized<'a, T>,
+    /// end
     pub end: IterRealized<'a, T>,
+    /// commands
     pub commands: I,
 }
 
@@ -798,9 +807,7 @@ impl<T> Commands<T> {
     /// ```
     #[must_use = "the returned actions should be realized"]
     pub fn undo_repeat(&mut self, repeat: usize) -> ActionIter<'_, T> {
-        let repeat = if let Some(v) = repeat.checked_sub(1) {
-            v
-        } else {
+        let Some(repeat) = repeat.checked_sub(1) else {
             return ActionIter::new();
         };
         let l = self.len();
@@ -878,6 +885,7 @@ impl<T> Commands<T> {
         };
         self.undo_repeat(to_undo)
     }
+    /// rebuild
     #[must_use = "the returned command should be undone"]
     pub fn rebuild(&mut self) -> ActionIter<'_, T> {
         if !self.is_undoing() {
@@ -963,9 +971,7 @@ impl<T> Commands<T> {
     /// ```
     #[must_use = "the returned actions should be realized"]
     pub fn redo_repeat(&mut self, repeat: usize) -> ActionIter<'_, T> {
-        let repeat = if let Some(v) = repeat.checked_sub(1) {
-            v
-        } else {
+        let Some(repeat) = repeat.checked_sub(1) else {
             return ActionIter::new();
         };
         let l = self.len();
@@ -1908,13 +1914,13 @@ impl<'a, T> From<Merge<'a, T>> for Splice<'a, T, option::IntoIter<T>> {
 }
 
 impl<T> IterRealized<'_, T> {
-    // Returned the index of the command refered by the previous non `None` result of call to
-    // `next`.
-    //
-    // This same command is accessible by indexing [Commands] at this returned index.
-    //
-    // This index can be used to set the first realized command with
-    // [Commands::undo_or_redo_to_index](Commands#method.undo_or_redo_to_index).
+    /// Returned the index of the command refered by the previous non `None` result of call to
+    /// `next`.
+    ///
+    /// This same command is accessible by indexing [Commands] at this returned index.
+    ///
+    /// This index can be used to set the first realized command with
+    /// [Commands::undo_or_redo_to_index](Commands#method.undo_or_redo_to_index).
     pub fn index(&self) -> usize {
         self.current
     }

crates/bevy_text/src/undo_2/mod.rs

@@ -1,3 +1,5 @@
+//! Support for undo
+
 mod lib;
 mod tests;