Apply suggestions from code review

Co-authored-by: Blaž Hrastnik <[email protected]>
Co-authored-by: Michael Davis <[email protected]>

Author: 3 people

helix-vcs/Cargo.toml

@@ -11,7 +11,6 @@ homepage = "https://helix-editor.com"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-
 helix-core = { version = "0.6", path = "../helix-core" }
 
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "parking_lot", "macros"] }

helix-vcs/src/diff.rs

@@ -100,8 +100,8 @@ impl DiffHandle {
 }
 
 // TODO configuration
-/// synchronus debounce value should be low
-/// so we can update synchrously most of the time
+/// synchronous debounce value should be low
+/// so we can update synchronously most of the time
 const DIFF_DEBOUNCE_TIME_SYNC: u64 = 1;
 /// maximum time that rendering should be blocked until the diff finishes
 const SYNC_DIFF_TIMEOUT: u64 = 50;
@@ -111,7 +111,7 @@ const MAX_DIFF_LINES: usize = 64 * u16::MAX as usize;
 // cap average line length to 128 for files with MAX_DIFF_LINES
 const MAX_DIFF_BYTES: usize = MAX_DIFF_LINES * 128;
 
-/// A single change in a file potentially sppaning multiple lines
+/// A single change in a file potentially spanning multiple lines
 /// Hunks produced by the differs are always ordered by their position
 /// in the file and non-overlapping.
 /// Specifically for any two hunks `x` and `y` the following properties hold:
@@ -128,15 +128,15 @@ pub struct Hunk {
 
 impl Hunk {
     /// Can be used instead of `Option::None` for better performance
-    /// because lines larger then `i32::MAX` are not supported by imara-diff anways.
+    /// because lines larger than `i32::MAX` are not supported by imara-diff anways.
     /// Has some nice properties where it usually is not necessary to check for `None` seperatly:
-    /// Empty ranges fail contains checks and also faills smaller then checks.
+    /// Empty ranges fail contains checks and also fails smaller than checks.
     pub const NONE: Hunk = Hunk {
         before: u32::MAX..u32::MAX,
         after: u32::MAX..u32::MAX,
     };
 
-    /// Inverts a change so that `before`
+    /// Inverts a change so that `before` becomes `after` and `after` becomes `before`
     pub fn invert(&self) -> Hunk {
         Hunk {
             before: self.after.clone(),

helix-vcs/src/diff/line_cache.rs

@@ -55,8 +55,8 @@ impl InternedRopeLines {
         }
     }
 
-    /// Updates the `doc` without reintering the `diff_base`, this funciton
-    /// is therefore significantly faster then `update_diff_base` when only the document changes.
+    /// Updates the `doc` without reinterning the `diff_base`, this function
+    /// is therefore significantly faster than `update_diff_base` when only the document changes.
     pub fn update_doc(&mut self, doc: Rope) {
         // Safety: we clear any tokens that were added after
         // the interning of `self.diff_base` finished so
@@ -75,7 +75,7 @@ impl InternedRopeLines {
     }
 
     fn update_diff_base_impl(&mut self) {
-        // Safety: This transmute is save because it only transmutes a lifetime, which has no effect.
+        // Safety: This transmute is safe because it only transmutes a lifetime, which has no effect.
         // The backing storage for the RopeSlices referred to by the lifetime is stored in `self.diff_base`.
         // Therefore as long as `self.diff_base` is not dropped/replaced this memory remains valid.
         // `self.diff_base` is only changed in `self.update_diff_base`, which clears the interner.

helix-vcs/src/diff/worker.rs

@@ -121,7 +121,7 @@ impl<'a> EventAccumulator<'a> {
 
         *dst = Some(event.text);
 
-        // always prefer the most synchronus requested render mode
+        // always prefer the most synchronous requested render mode
         if event.render_strategy > self.render_stratagey {
             if self.render_lock.is_none() {
                 self.timeout = Instant::now() + Duration::from_millis(SYNC_DIFF_TIMEOUT);
@@ -154,7 +154,7 @@ impl<'a> EventAccumulator<'a> {
         }
 
         // setup task to trigger the rendering
-        // with the choosen render stragey
+        // with the chosen render stragey
         match self.render_stratagey {
             RenderStrategy::Async => {
                 tokio::spawn(async move {
@@ -166,8 +166,8 @@ impl<'a> EventAccumulator<'a> {
                 let timeout = self.timeout;
                 tokio::spawn(async move {
                     let res = {
-                        // Aquire a lock on the redraw handle.
-                        // The lock will block the rendering from occuring while held.
+                        // Acquire a lock on the redraw handle.
+                        // The lock will block the rendering from occurring while held.
                         // The rendering waits for the diff if it doesn't time out
                         let _render_guard = redraw_handle.1.read();
                         timeout_at(timeout, diff_finished_notify.notified()).await

helix-view/src/editor.rs

@@ -154,7 +154,7 @@ pub struct Config {
     )]
     pub idle_timeout: Duration,
     /// Time in milliseconds since last keypress before a redraws trigger.
-    /// Used for redrawing asynchronsouly computed UI compoenents, set to 0 for instant.
+    /// Used for redrawing asynchronsouly computed UI components, set to 0 for instant.
     /// Defaults to 100ms.
     #[serde(
         serialize_with = "serialize_duration_millis",

helix-view/src/gutter.rs

@@ -101,10 +101,10 @@ pub fn diff<'doc>(
         let mut hunk = hunks.nth_hunk(hunk_i);
         Box::new(move |line: usize, _selected: bool, out: &mut String| {
             // truncating the line is fine here because we don't compute diffs
-            // for files with more lines then i32::MAX anyways
+            // for files with more lines than i32::MAX anyways
             // we need to special case removals here
             // these technically do not have a range of lines to highlight (`hunk.after.start == hunk.after.end`).
-            // However we still want to display these hunks correctly we must not yet scipe to the next hunk here
+            // However we still want to display these hunks correctly we must not yet skip to the next hunk here
             while hunk.after.end < line as u32
                 || !hunk.is_pure_removal() && line as u32 == hunk.after.end
             {