Small documentation fixes

Small grammar and spelling changes to make the codebase better.

Author: rickprice

gitoxide-core/src/hours/mod.rs

@@ -17,7 +17,7 @@ pub struct Context<W> {
     pub file_stats: bool,
     /// Collect how many lines in files have been added, removed and modified (without rename tracking).
     pub line_stats: bool,
-    /// The amount of threads to use. If unset, use all cores, if 0 use al physical cores.
+    /// The number of threads to use. If unset, use all cores, if 0 use all physical cores.
     pub threads: Option<usize>,
     /// Omit unifying identities by name and email which can lead to the same author appear multiple times
     /// due to using different names or email addresses.

gix-archive/src/lib.rs

@@ -80,7 +80,7 @@ pub struct Options {
     pub format: Format,
     /// Given a `path`, originating in the git tree, to place into the archive, put `<prefix>/path` in front of it.
     ///
-    /// Note that that `/` should be used as separator, and that a prefix directory has to end with `/`.
+    /// Note that `/` should be used as separator, and that a prefix directory has to end with `/`.
     pub tree_prefix: Option<BString>,
     /// The modification time for all entries in the archive as seen since UNIX epoch.
     ///

gix-command/src/lib.rs

@@ -159,7 +159,7 @@ mod prepare {
         /// Set the name or path to the shell `program` to use if a shell is to be used, to avoid
         /// using the default shell which is `sh`.
         ///
-        /// Note that that shells that are not Bourne-style cannot be expected to work correctly,
+        /// Note that shells that are not Bourne-style cannot be expected to work correctly,
         /// because POSIX shell syntax is assumed when searching for and conditionally adding
         /// `"$@"` to receive arguments, where applicable (and in the behaviour of
         /// [`with_quoted_command()`](Self::with_quoted_command()), if called).

gix-features/src/parallel/in_parallel.rs

@@ -38,11 +38,11 @@ pub fn build_thread() -> std::thread::Builder {
 }
 
 /// Read items from `input` and `consume` them in multiple threads,
-/// whose output output is collected by a `reducer`. Its task is to
-/// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.
+/// whose output is collected by a `reducer`. Its task is to
+/// aggregate these outputs into the final result returned by this function, with the benefit of not having to be thread-safe.
 ///
-/// * if `thread_limit` is `Some`, the given amount of threads will be used. If `None`, all logical cores will be used.
-/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`
+/// * if `thread_limit` is `Some`, then the given number of threads will be used. If `None`, all logical cores will be used.
+/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`
 /// * `consume(Item, &mut State) -> Output` produces an output given an input obtained by `input` along with mutable state initially
 ///   created by `new_thread_state(…)`.
 /// * For `reducer`, see the [`Reduce`] trait
@@ -103,12 +103,12 @@ where
 }
 
 /// Read items from `input` and `consume` them in multiple threads,
-/// whose output output is collected by a `reducer`. Its task is to
+/// whose output is collected by a `reducer`. Its task is to
 /// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.
-/// Caall `finalize` to finish the computation, once per thread, if there was no error sending results earlier.
+/// Call `finalize` to finish the computation, once per thread, if there was no error sending results earlier.
 ///
-/// * if `thread_limit` is `Some`, the given amount of threads will be used. If `None`, all logical cores will be used.
-/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`
+/// * if `thread_limit` is `Some`, then the given number of threads will be used. If `None`, all logical cores will be used.
+/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`
 /// * `consume(Item, &mut State) -> Output` produces an output given an input obtained by `input` along with mutable state initially
 ///   created by `new_thread_state(…)`.
 /// * `finalize(State) -> Output` is called to potentially process remaining work that was placed in `State`.

gix-features/src/parallel/reduce.rs

@@ -232,7 +232,7 @@ pub trait Reduce {
     ///
     /// If an `Error` is returned, the entire operation will be stopped.
     fn feed(&mut self, item: Self::Input) -> Result<Self::FeedProduce, Self::Error>;
-    /// Called once once all items where passed to `feed()`, producing the final `Output` of the operation or an `Error`.
+    /// Called once for all items that were passed to `feed()`, producing the final `Output` of the operation or an `Error`.
     fn finalize(self) -> Result<Self::Output, Self::Error>;
 }
 

gix-features/src/parallel/serial.rs

@@ -116,12 +116,12 @@ mod not_parallel {
 pub use not_parallel::{build_thread, in_parallel_with_slice, join, threads, Scope};
 
 /// Read items from `input` and `consume` them in a single thread, producing an output to be collected by a `reducer`,
-/// whose task is to aggregate these outputs into the final result returned by this function.
+/// whose task it is to aggregate these outputs into the final result returned by this function.
 ///
-/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`
+/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`
 /// * `consume(Item, &mut State) -> Output` produces an output given an input along with mutable state.
 /// * For `reducer`, see the [`Reduce`] trait
-/// * if `thread_limit` has no effect as everything is run on the main thread, but is present to keep the signature
+/// * `thread_limit` has no effect as everything is run on the main thread, but is present to keep the signature
 ///   similar to the parallel version.
 ///
 /// **This serial version performing all calculations on the current thread.**
@@ -143,12 +143,12 @@ where
 }
 
 /// Read items from `input` and `consume` them in multiple threads,
-/// whose output output is collected by a `reducer`. Its task is to
+/// whose output is collected by a `reducer`. Its task is to
 /// aggregate these outputs into the final result returned by this function with the benefit of not having to be thread-safe.
-/// Caall `finalize` to finish the computation, once per thread, if there was no error sending results earlier.
+/// Call `finalize` to finish the computation, once per thread, if there was no error sending results earlier.
 ///
-/// * if `thread_limit` is `Some`, the given amount of threads will be used. If `None`, all logical cores will be used.
-/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be based to `consume`
+/// * if `thread_limit` is `Some`, the given number of threads will be used. If `None`, all logical cores will be used.
+/// * `new_thread_state(thread_number) -> State` produces thread-local state once per thread to be passed to `consume`
 /// * `consume(Item, &mut State) -> Output` produces an output given an input obtained by `input` along with mutable state initially
 ///   created by `new_thread_state(…)`.
 /// * `finalize(State) -> Output` is called to potentially process remaining work that was placed in `State`.

gix-filter/src/driver/apply.rs

@@ -72,14 +72,14 @@ impl State {
     /// Each call to this method will cause the corresponding filter to be invoked unless `driver` indicates a `process` filter,
     /// which is only launched once and maintained using this state.
     ///
-    /// Note that it's not an error if there is no filter process for `operation` or if a long-running process doesn't supported
+    /// Note that it's not an error if there is no filter process for `operation` or if a long-running process doesn't support
     /// the desired capability.
     ///
     /// ### Deviation
     ///
-    /// If a long running process returns the 'abort' status after receiving the data, it will be removed similar to how `git` does it.
-    /// However, it delivers an unsuccessful error status later, it will not be removed, but reports the error only.
-    /// If any other non-'error' status is received, the process will be stopped. But that doesn't happen if if such a status is received
+    /// If a long running process returns the 'abort' status after receiving the data, it will be removed similarly to how `git` does it.
+    /// However, if it returns an unsuccessful error status later, it will not be removed, but reports the error only.
+    /// If any other non-'error' status is received, the process will be stopped. But that doesn't happen if such a status is received
     /// after reading the filtered result.
     pub fn apply<'a>(
         &'a mut self,

gix-fs/src/lib.rs

@@ -96,7 +96,7 @@ pub mod io_err {
 }
 
 #[cfg(not(unix))]
-/// Returns whether a a file has the executable permission set.
+/// Returns whether a file has the executable permission set.
 pub fn is_executable(_metadata: &std::fs::Metadata) -> bool {
     false
 }

gix-hash/src/oid.rs

@@ -34,7 +34,7 @@ impl hash::Hash for oid {
     }
 }
 
-/// A utility able to format itself with the given amount of characters in hex.
+/// A utility able to format itself with the given number of characters in hex.
 #[derive(PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct HexDisplay<'a> {
     inner: &'a oid,

gix-object/src/commit/message/mod.rs

@@ -75,7 +75,7 @@ impl<'a> MessageRef<'a> {
         summary(self.title)
     }
 
-    /// Further parse the body into into non-trailer and trailers, which can be iterated from the returned [`BodyRef`].
+    /// Further parse the body into non-trailer and trailers, which can be iterated from the returned [`BodyRef`].
     pub fn body(&self) -> Option<BodyRef<'a>> {
         self.body.map(|b| BodyRef::from_bytes(b))
     }