Typo fixes

gitoxide-core/src/corpus/db.rs

@@ -131,7 +131,7 @@ pub fn create(path: impl AsRef<std::path::Path>) -> anyhow::Result<rusqlite::Con
         task integer,
         gitoxide_version integer,
         insertion_time integer NOT NULL, -- in seconds since UNIX epoch
-        duration real, -- in seconds or NULL if not yet finished (either successfull or with failure)
+        duration real, -- in seconds or NULL if not yet finished (either successful or with failure)
         error text, -- or NULL if there was no error
         spans_json text, -- all spans collecteted while performing the run
         FOREIGN KEY (repository) REFERENCES repository (id),

gitoxide-core/src/repository/commitgraph/list.rs

@@ -27,7 +27,7 @@ pub(crate) mod function {
         let commits = id
             .object()?
             .peel_to_kind(gix::object::Kind::Commit)
-            .context("Need commitish as starting point")?
+            .context("Need committish as starting point")?
             .id()
             .ancestors()
             .sorting(Sorting::ByCommitTimeNewestFirst)

gitoxide-core/src/repository/fsck.rs

@@ -14,7 +14,7 @@ pub fn function(mut repo: gix::Repository, spec: Option<String>, mut out: impl s
     let commits: gix::revision::Walk<'_> = id
         .object()?
         .peel_to_kind(gix::object::Kind::Commit)
-        .context("Need commitish as starting point")?
+        .context("Need committish as starting point")?
         .id()
         .ancestors()
         .all()?;

gitoxide-core/src/repository/revision/list.rs

@@ -49,7 +49,7 @@ pub(crate) mod function {
         let commits = id
             .object()?
             .peel_to_kind(gix::object::Kind::Commit)
-            .context("Need commitish as starting point")?
+            .context("Need committish as starting point")?
             .id()
             .ancestors()
             .sorting(Sorting::ByCommitTimeNewestFirst)

gix-command/src/lib.rs

@@ -86,7 +86,7 @@ mod prepare {
 
     /// Builder
     impl Prepare {
-        /// If called, the command will not be executed directly, but with `sh`, but ony if the
+        /// If called, the command will not be executed directly, but with `sh`, but only if the
         /// command passed to [`prepare`](super::prepare()) requires this.
         ///
         /// This also allows to pass shell scripts as command, or use commands that contain arguments which are subsequently

gix-commitgraph/src/file/access.rs

@@ -16,7 +16,7 @@ impl File {
         self.base_graph_count
     }
 
-    /// Returns the commit data for the commit located at the given lexigraphical position.
+    /// Returns the commit data for the commit located at the given lexicographical position.
     ///
     /// `pos` must range from 0 to `self.num_commits()`.
     ///
@@ -40,7 +40,7 @@ impl File {
     pub fn id_at(&self, pos: file::Position) -> &gix_hash::oid {
         assert!(
             pos.0 < self.num_commits(),
-            "expected lexigraphical position less than {}, got {}",
+            "expected lexicographical position less than {}, got {}",
             self.num_commits(),
             pos.0
         );
@@ -115,7 +115,7 @@ impl File {
     pub(crate) fn commit_data_bytes(&self, pos: file::Position) -> &[u8] {
         assert!(
             pos.0 < self.num_commits(),
-            "expected lexigraphical position less than {}, got {}",
+            "expected lexicographical position less than {}, got {}",
             self.num_commits(),
             pos.0
         );

gix-config-value/fuzz/fuzz_targets/fuzz_value.rs

@@ -47,7 +47,7 @@ fn fuzz(ctx: Ctx) -> Result<()> {
 
 fuzz_target!(|ctx: Ctx| {
     if let Err(e) = fuzz(ctx) {
-        // Excersize display/debug fmt code.
+        // Exercise display/debug fmt code.
         _ = black_box(format!("{e} {e:?}"));
     }
 });

gix-diff/src/blob/platform.rs

@@ -193,7 +193,7 @@ pub mod prepare_diff {
         /// is `false`.
         ///
         /// Use [`Outcome::interned_input()`] to easily obtain an interner for use with [`imara_diff::diff()`], or maintain one yourself
-        /// for greater re-use.
+        /// for greater reuse.
         InternalDiff {
             /// The algorithm we determined should be used, which is one of (in order, first set one wins):
             ///
@@ -349,7 +349,7 @@ impl Platform {
     ///
     /// ### Important
     ///
-    /// If an error occours, the previous resource of `kind` will be cleared, preventing further diffs
+    /// If an error occurs, the previous resource of `kind` will be cleared, preventing further diffs
     /// unless another attempt succeeds.
     pub fn set_resource(
         &mut self,

gix-features/src/interrupt.rs

@@ -89,7 +89,7 @@ where
     }
 }
 
-/// A wrapper for implementors of [`std::io::Read`] or [`std::io::BufRead`] with interrupt support.
+/// A wrapper for implementers of [`std::io::Read`] or [`std::io::BufRead`] with interrupt support.
 ///
 /// It fails a [read][std::io::Read::read] while an interrupt was requested.
 pub struct Read<'a, R> {
@@ -124,7 +124,7 @@ where
     }
 }
 
-/// A wrapper for implementors of [`std::io::Write`] with interrupt checks on each write call.
+/// A wrapper for implementers of [`std::io::Write`] with interrupt checks on each write call.
 ///
 /// It fails a [write][std::io::Write::write] while an interrupt was requested.
 pub struct Write<'a, W> {

gix-filter/src/driver/shutdown.rs

@@ -14,7 +14,7 @@ pub enum Mode {
 
 /// Lifecycle
 impl State {
-    /// Handle long-running processes according to `mode`. If an error occours, all remaining processes will be ignored automatically.
+    /// Handle long-running processes according to `mode`. If an error occurs, all remaining processes will be ignored automatically.
     /// Return a list of `(process, Option<status>)`
     pub fn shutdown(self, mode: Mode) -> Result<Vec<(BString, Option<std::process::ExitStatus>)>, std::io::Error> {
         let mut out = Vec::with_capacity(self.running.len());

gix-filter/src/pipeline/convert.rs

@@ -242,7 +242,7 @@ pub enum ToGitOutcome<'pipeline, R> {
 ///
 /// ### Panics
 ///
-/// If `std::io::Read` is used on it and the output is delayed, a panic will occour. The caller is responsible for either disallowing delayed
+/// If `std::io::Read` is used on it and the output is delayed, a panic will occur. The caller is responsible for either disallowing delayed
 /// results or if allowed, handle them. Use [`is_delayed()][Self::is_delayed()].
 pub enum ToWorktreeOutcome<'input, 'pipeline> {
     /// The original input wasn't changed and the original buffer is present

gix-filter/src/pipeline/mod.rs

@@ -103,7 +103,7 @@ impl Pipeline {
         &mut self.options
     }
 
-    /// Return our double-buffers for re-use by the caller.
+    /// Return our double-buffers for reuse by the caller.
     pub fn buffers_mut(&mut self) -> &mut gix_utils::Buffers {
         &mut self.bufs
     }

gix-filter/tests/eol/convert_to_git.rs

@@ -101,7 +101,7 @@ fn crlf_in_index_prevents_conversion_to_lf() -> crate::Result {
     let mut buf = Vec::new();
     let mut called = false;
     let changed = eol::convert_to_git(
-        b"elligible\n",
+        b"eligible\n",
         AttributesDigest::TextAutoInput,
         &mut buf,
         &mut |buf| {

gix-index/src/extension/mod.rs

@@ -16,7 +16,7 @@ pub struct Iter<'a> {
 
 /// A structure to associate object ids of a tree with sections in the index entries list.
 ///
-/// It allows to more quickly build trees by avoiding as it can quickly re-use portions of the index and its associated tree ids
+/// It allows to more quickly build trees by avoiding as it can quickly reuse portions of the index and its associated tree ids
 /// if there was no change to them. Portions of this tree are invalidated as the index is changed.
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Tree {

gix-index/src/fs.rs

@@ -73,7 +73,7 @@ impl Metadata {
 
     /// Return the time at which the underlying file was created.
     ///
-    /// Note that this differes from [`std::fs::Metadata::created()`] which would return
+    /// Note that this differs from [`std::fs::Metadata::created()`] which would return
     /// the inode birth time, which is notably different to what `git` does.
     pub fn created(&self) -> Option<SystemTime> {
         #[cfg(not(windows))]

gix-index/src/write.rs

@@ -5,7 +5,7 @@ use crate::{entry, extension, write::util::CountBytes, State, Version};
 /// A way to specify which of the optional extensions to write.
 #[derive(Default, Debug, Copy, Clone)]
 pub enum Extensions {
-    /// Writes all available optional extensions to avoid loosing any information.
+    /// Writes all available optional extensions to avoid losing any information.
     #[default]
     All,
     /// Only write the given optional extensions, with each extension being marked by a boolean flag.

gix-odb/src/store_impls/dynamic/verify.rs

@@ -66,7 +66,7 @@ pub mod integrity {
     #[derive(Debug, PartialEq, Eq, Hash, Ord, PartialOrd, Clone)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     pub struct IndexStatistics {
-        /// The path to the index or multi-pack index for which statics were gathered.
+        /// The path to the index or multi-pack index for which statistics were gathered.
         pub path: PathBuf,
         /// The actual statistics for the index at `path`.
         pub statistics: SingleOrMultiStatistics,

gix-pack/src/cache/object.rs

@@ -1,4 +1,4 @@
-//! This module is a bit 'misplaced' if spelled out like '`gix_pack::cache::object::`*' but is best placed here for code re-use and
+//! This module is a bit 'misplaced' if spelled out like '`gix_pack::cache::object::`*' but is best placed here for code reuse and
 //! general usefulness.
 use crate::cache;
 

gix-pathspec/src/search/mod.rs

@@ -31,7 +31,7 @@ impl Search {
     /// there is none. It doesn't have to end at a directory boundary though, nor does it denote a directory.
     ///
     /// Note that the common_prefix is always matched case-sensitively, and it is useful to skip large portions of input.
-    /// Further, excluded pathspecs don't participate which makes this common prefix inclusive. To work correclty though,
+    /// Further, excluded pathspecs don't participate which makes this common prefix inclusive. To work correctly though,
     /// one will have to additionally match paths that have the common prefix with that pathspec itself to assure it is
     /// not excluded.
     pub fn common_prefix(&self) -> &BStr {

gix-sec/src/identity.rs

@@ -133,7 +133,7 @@ mod impl_ {
                             // Admin-group owned folders are considered owned by the current user, if they are in the admin group
                             if !is_owned && IsWellKnownSid(token_owner, WinBuiltinAdministratorsSid).as_bool() {
                                 let mut is_member = BOOL::default();
-                                // TODO: re-use the handle
+                                // TODO: reuse the handle
                                 match CheckTokenMembership(HANDLE::default(), token_owner, &mut is_member) {
                                     Err(e) => {
                                         err_msg = Some(format!("Couldn't check if user is an administrator: {}", e))

gix-status/src/lib.rs

@@ -19,7 +19,7 @@ pub trait Pathspec {
     /// there is none. It doesn't have to end at a directory boundary though, nor does it denote a directory.
     ///
     /// Note that the common_prefix is always matched case-sensitively, and it is useful to skip large portions of input.
-    /// Further, excluded pathspecs don't participate which makes this common prefix inclusive. To work correclty though,
+    /// Further, excluded pathspecs don't participate which makes this common prefix inclusive. To work correctly though,
     /// one will have to additionally match paths that have the common prefix with that pathspec itself to assure it is
     /// not excluded.
     fn common_prefix(&self) -> &BStr;

gix-status/tests/status/index_as_worktree.rs

@@ -68,7 +68,7 @@ fn fixture_filtered_detailed(
     mut prepare_index: impl FnMut(&mut gix_index::State),
     submodule_dirty: bool,
 ) -> Outcome {
-    // This can easily happen in some fixtures, which can cause flakyness. It's time-dependent after all.
+    // This can easily happen in some fixtures, which can cause flakiness. It's time-dependent after all.
     fn ignore_racyclean(mut out: Outcome) -> Outcome {
         out.racy_clean = 0;
         out
@@ -116,7 +116,7 @@ fn fixture_filtered_detailed(
     ignore_racyclean(ignore_updated(ignore_worktree_stats(outcome)))
 }
 
-/// Note that we also reset certain information to assure there is no flakyness - everything regarding race-detection otherwise can cause failures.
+/// Note that we also reset certain information to assure there is no flakiness - everything regarding race-detection otherwise can cause failures.
 fn records_to_tuple<'index>(records: impl IntoIterator<Item = Record<'index, (), ()>>) -> Vec<Expectation<'index>> {
     records
         .into_iter()

gix-trace/src/enabled.rs

@@ -264,7 +264,7 @@ macro_rules! fieldset {
         $crate::fieldset!(@ { $($out),*, $k } $($rest)*)
     };
 
-    // Remainder is unparseable, but exists --- must be format args!
+    // Remainder is unparsable, but exists --- must be format args!
     (@ { $(,)* $($out:expr),* } $($rest:tt)+) => {
         $crate::fieldset!(@ { "message", $($out),*, })
     };

gix-trace/src/lib.rs

@@ -1,4 +1,4 @@
-//! A crate providing macros for creating spans in various detail levels. `coarse!` shoudl be used for top-level operations, whereas
+//! A crate providing macros for creating spans in various detail levels. `coarse!` should be used for top-level operations, whereas
 //! `detail!` should be used in plumbing crates unless their operations are likely to cost a lot of time.
 //!
 //! The application is supposed to explicitly turn on tracing via `gix-features`.

gix-traverse/src/tree/mod.rs

@@ -47,7 +47,7 @@ pub mod visit {
     pub enum Action {
         /// Continue the traversal of entries.
         Continue,
-        /// Stop the traversal of entries, making this te last call to [`visit_(tree|nontree)(…)`][super::Visit::visit_nontree()].
+        /// Stop the traversal of entries, making this the last call to [`visit_(tree|nontree)(…)`][super::Visit::visit_nontree()].
         Cancel,
         /// Don't dive into the entry, skipping children effectively. Only useful in [`visit_tree(…)`][super::Visit::visit_tree()].
         Skip,

gix-url/tests/baseline.rs

@@ -50,7 +50,7 @@ fn run() {
 
     assert_ne!(test_count, 0, "the baseline is never empty");
     if failures.is_empty() {
-        todo!("The baseline is currently meddling with hooks, thats not needed anymore since the failure rate is 0: move this into a module of the normal tests");
+        todo!("The baseline is currently meddling with hooks, that's not needed anymore since the failure rate is 0: move this into a module of the normal tests");
     }
 
     let failure_count = failures.len();

gix-url/tests/parse/file.rs

@@ -102,7 +102,7 @@ fn no_relative_paths_if_protocol() -> crate::Result {
         assert_matches::assert_matches!(
             gix_url::parse("file://.\\".into()),
             Err(gix_url::parse::Error::MissingRepositoryPath { .. }),
-            "DEVIATION: on windows, this parses with git into something nonesensical Diag: url=file://./ Diag: protocol=file Diag: hostandport=./ Diag: path=//./"
+            "DEVIATION: on windows, this parses with git into something nonsensical Diag: url=file://./ Diag: protocol=file Diag: hostandport=./ Diag: path=//./"
         );
     }
     Ok(())

gix/Cargo.toml

@@ -26,7 +26,7 @@ default = ["max-performance-safe", "comfort", "basic", "extras"]
 #! enabled as long as it doesn't sacrifice compatibility. Most users will be fine with that but will pay with higher compile times than necessary as they
 #! probably don't use all of these features.
 #!
-#! **Thus it's recommended to take a moment and optimize build times by chosing only those 'Components' that you require.** *'Performance' relevant features should
+#! **Thus it's recommended to take a moment and optimize build times by choosing only those 'Components' that you require.** *'Performance' relevant features should
 #! be chosen next to maximize efficiency.*
 #!
 #! #### Application Developers
@@ -121,11 +121,11 @@ async-network-client = ["gix-protocol/async-client", "gix-pack/streaming-input",
 async-network-client-async-std = ["async-std", "async-network-client", "gix-transport/async-std"]
 ## Make `gix-protocol` available along with a blocking client, providing access to the `file://`, git://` and `ssh://` transports.
 blocking-network-client = ["gix-protocol/blocking-client", "gix-pack/streaming-input", "attributes", "credentials"]
-## Stacks with `blocking-network-client` to provide support for HTTP/S using **curl**, and implies blocking networking as a whole, making the `https://` transport avaialble.
+## Stacks with `blocking-network-client` to provide support for HTTP/S using **curl**, and implies blocking networking as a whole, making the `https://` transport available.
 blocking-http-transport-curl = ["blocking-network-client", "gix-transport/http-client-curl"]
 ## Stacks with `blocking-http-transport-curl` and also enables the `rustls` backend to avoid `openssl`.
 blocking-http-transport-curl-rustls = ["blocking-http-transport-curl", "dep:curl-for-configuration-only", "curl-for-configuration-only?/rustls"]
-## Stacks with `blocking-network-client` to provide support for HTTP/S using **reqwest**, and implies blocking networking as a whole, making the `https://` transport avaialble.
+## Stacks with `blocking-network-client` to provide support for HTTP/S using **reqwest**, and implies blocking networking as a whole, making the `https://` transport available.
 blocking-http-transport-reqwest = ["blocking-network-client", "gix-transport/http-client-reqwest"]
 ## Stacks with `blocking-http-transport-reqwest` and enables `https://` via the `rustls` crate.
 blocking-http-transport-reqwest-rust-tls = ["blocking-http-transport-reqwest", "reqwest-for-configuration-only/rustls-tls" ]
@@ -139,7 +139,7 @@ blocking-http-transport-reqwest-native-tls = ["blocking-http-transport-reqwest",
 #! #### Performance
 #!
 #! The reason these features exist is to allow optimization for compile time and optimize for compatibility by default. This means that some performance options around
-#! SHA1 and ZIP might not compile on all platforms, so it depeneds on the end-user who compiles the application to chose these based on their needs.
+#! SHA1 and ZIP might not compile on all platforms, so it depends on the end-user who compiles the application to chose these based on their needs.
 
 ## Activate features that maximize performance, like usage of threads, `zlib-ng` and access to caching in object databases, skipping the ones known to cause compile failures
 ## on some platforms.

gix/src/assets/init/info/exclude

@@ -1,4 +1,4 @@
-# Thise file contains repository-wide exclude patterns that git will ignore.
+# This file contains repository-wide exclude patterns that git will ignore.
 # They are local and will not be shared when pushing or pulling.
 # When using Rust the following would be typical exclude patterns.
 # Remove the '# ' prefix to let them take effect.

gix/src/config/mod.rs

@@ -144,7 +144,7 @@ pub mod diff {
         #[derive(Debug, thiserror::Error)]
         #[error("Failed to parse value of 'diff.{name}.{attribute}'")]
         pub struct Error {
-            /// The name fo the driver.
+            /// The name of the driver.
             pub name: BString,
             /// The name of the attribute we tried to parse.
             pub attribute: &'static str,
@@ -604,7 +604,7 @@ pub(crate) struct Cache {
     // TODO: make core.precomposeUnicode available as well.
 }
 
-/// Utillities shared privately across the crate, for lack of a better place.
+/// Utilities shared privately across the crate, for lack of a better place.
 pub(crate) mod shared {
     use crate::{
         config,

gix/src/interrupt.rs

@@ -193,7 +193,7 @@ where
     }
 }
 
-/// A wrapper for implementors of [`std::io::Read`] or [`std::io::BufRead`] with interrupt support.
+/// A wrapper for implementers of [`std::io::Read`] or [`std::io::BufRead`] with interrupt support.
 ///
 /// It fails a [read][`std::io::Read::read`] while an interrupt was requested.
 pub struct Read<R> {