fix docs

Author: Byron

gix-commitgraph/src/lib.rs

@@ -20,7 +20,7 @@ use std::path::Path;
 /// A single commit-graph file.
 ///
 /// All operations on a `File` are local to that graph file. Since a commit graph can span multiple
-/// files, all interesting graph operations belong on [`Graph`][crate::Graph].
+/// files, all interesting graph operations belong on [`Graph`].
 pub struct File {
     base_graph_count: u8,
     base_graphs_list_offset: Option<usize>,

gix-diff/src/tree/mod.rs

@@ -41,7 +41,7 @@ pub mod visit;
 #[doc(inline)]
 pub use visit::Visit;
 
-/// A [Visit][visit::Visit] implementation to record every observed change and keep track of the changed paths.
+/// A [Visit] implementation to record every observed change and keep track of the changed paths.
 #[derive(Clone, Debug)]
 pub struct Recorder {
     path_deque: VecDeque<BString>,

gix-filter/src/pipeline/convert.rs

@@ -258,7 +258,7 @@ pub enum ToWorktreeOutcome<'input, 'pipeline> {
 }
 
 impl<'input, 'pipeline> ToWorktreeOutcome<'input, 'pipeline> {
-    /// Return true if this outcome is delayed. In that case, one isn't allowed to use [`Read`][std::io::Read] or cause a panic.
+    /// Return true if this outcome is delayed. In that case, one isn't allowed to use [`Read`] or cause a panic.
     pub fn is_delayed(&self) -> bool {
         matches!(
             self,

gix-index/src/init.rs

@@ -31,7 +31,7 @@ mod from_tree {
                 fs_monitor: None,
             }
         }
-        /// Create an index [`State`][crate::State] by traversing `tree` recursively, accessing sub-trees
+        /// Create an index [`State`] by traversing `tree` recursively, accessing sub-trees
         /// with `find`.
         ///
         /// **No extension data is currently produced**.

gix-object/src/lib.rs

@@ -98,7 +98,7 @@ pub struct CommitRef<'a> {
     pub extra_headers: Vec<(&'a BStr, Cow<'a, BStr>)>,
 }
 
-/// Like [`CommitRef`][crate::CommitRef], but as `Iterator` to support (up to) entirely allocation free parsing.
+/// Like [`CommitRef`], but as `Iterator` to support (up to) entirely allocation free parsing.
 /// It's particularly useful to traverse the commit graph without ever allocating arrays for parents.
 #[derive(Copy, Clone)]
 pub struct CommitRefIter<'a> {

gix-object/src/object/mod.rs

@@ -66,66 +66,66 @@ mod write {
 
 /// Convenient extraction of typed object.
 impl Object {
-    /// Turns this instance into a [`Blob`][Blob], panic otherwise.
+    /// Turns this instance into a [`Blob`], panic otherwise.
     pub fn into_blob(self) -> Blob {
         match self {
             Object::Blob(v) => v,
             _ => panic!("BUG: not a blob"),
         }
     }
-    /// Turns this instance into a [`Commit`][Commit] panic otherwise.
+    /// Turns this instance into a [`Commit`] panic otherwise.
     pub fn into_commit(self) -> Commit {
         match self {
             Object::Commit(v) => v,
             _ => panic!("BUG: not a commit"),
         }
     }
-    /// Turns this instance into a [`Tree`][Tree] panic otherwise.
+    /// Turns this instance into a [`Tree`] panic otherwise.
     pub fn into_tree(self) -> Tree {
         match self {
             Object::Tree(v) => v,
             _ => panic!("BUG: not a tree"),
         }
     }
-    /// Turns this instance into a [`Tag`][Tag] panic otherwise.
+    /// Turns this instance into a [`Tag`] panic otherwise.
     pub fn into_tag(self) -> Tag {
         match self {
             Object::Tag(v) => v,
             _ => panic!("BUG: not a tag"),
         }
     }
-    /// Turns this instance into a [`Blob`][Blob] if it is one.
+    /// Turns this instance into a [`Blob`] if it is one.
     #[allow(clippy::result_large_err)]
     pub fn try_into_blob(self) -> Result<Blob, Self> {
         match self {
             Object::Blob(v) => Ok(v),
             _ => Err(self),
         }
     }
-    /// Turns this instance into a [`BlobRef`][BlobRef] if it is a blob.
+    /// Turns this instance into a [`BlobRef`] if it is a blob.
     pub fn try_into_blob_ref(&self) -> Option<BlobRef<'_>> {
         match self {
             Object::Blob(v) => Some(v.to_ref()),
             _ => None,
         }
     }
-    /// Turns this instance into a [`Commit`][Commit] if it is one.
+    /// Turns this instance into a [`Commit`] if it is one.
     #[allow(clippy::result_large_err)]
     pub fn try_into_commit(self) -> Result<Commit, Self> {
         match self {
             Object::Commit(v) => Ok(v),
             _ => Err(self),
         }
     }
-    /// Turns this instance into a [`Tree`][Tree] if it is one.
+    /// Turns this instance into a [`Tree`] if it is one.
     #[allow(clippy::result_large_err)]
     pub fn try_into_tree(self) -> Result<Tree, Self> {
         match self {
             Object::Tree(v) => Ok(v),
             _ => Err(self),
         }
     }
-    /// Turns this instance into a [`Tag`][Tag] if it is one.
+    /// Turns this instance into a [`Tag`] if it is one.
     #[allow(clippy::result_large_err)]
     pub fn try_into_tag(self) -> Result<Tag, Self> {
         match self {
@@ -134,28 +134,28 @@ impl Object {
         }
     }
 
-    /// Returns a [`Blob`][Blob] if it is one.
+    /// Returns a [`Blob`] if it is one.
     pub fn as_blob(&self) -> Option<&Blob> {
         match self {
             Object::Blob(v) => Some(v),
             _ => None,
         }
     }
-    /// Returns a [`Commit`][Commit] if it is one.
+    /// Returns a [`Commit`] if it is one.
     pub fn as_commit(&self) -> Option<&Commit> {
         match self {
             Object::Commit(v) => Some(v),
             _ => None,
         }
     }
-    /// Returns a [`Tree`][Tree] if it is one.
+    /// Returns a [`Tree`] if it is one.
     pub fn as_tree(&self) -> Option<&Tree> {
         match self {
             Object::Tree(v) => Some(v),
             _ => None,
         }
     }
-    /// Returns a [`Tag`][Tag] if it is one.
+    /// Returns a [`Tag`] if it is one.
     pub fn as_tag(&self) -> Option<&Tag> {
         match self {
             Object::Tag(v) => Some(v),

gix-odb/src/lib.rs

@@ -50,7 +50,7 @@ pub struct Cache<S> {
 pub mod cache;
 
 ///
-/// It can optionally compress the content, similarly to what would happen when using a [`loose::Store`][crate::loose::Store].
+/// It can optionally compress the content, similarly to what would happen when using a [`loose::Store`].
 ///
 #[derive(Clone)]
 pub struct Sink {

gix-pathspec/src/lib.rs

@@ -134,7 +134,7 @@ pub enum SearchMode {
     PathAwareGlob,
 }
 
-/// Parse a git-style pathspec into a [`Pattern`][Pattern],
+/// Parse a git-style pathspec into a [`Pattern`],
 /// setting the given `default` values in case these aren't specified in `input`.
 ///
 /// Note that empty [paths](Pattern::path) are allowed here, and generally some processing has to be performed.

gix-ref/src/lib.rs

@@ -5,7 +5,7 @@
 //! Refs are the way to keep track of objects and come in two flavors.
 //!
 //! * symbolic refs are pointing to another reference
-//! * peeled refs point to the an object by its [`ObjectId`][gix_hash::ObjectId]
+//! * peeled refs point to the an object by its [`ObjectId`]
 //!
 //! They can be identified by a relative path and stored in various flavors.
 //!

gix-ref/src/name.rs

@@ -4,7 +4,7 @@ use gix_object::bstr::{BStr, BString, ByteSlice, ByteVec};
 
 use crate::{Category, FullName, FullNameRef, PartialName, PartialNameRef};
 
-/// The error used in the [`PartialNameRef`][super::PartialNameRef]`::try_from`(…) implementations.
+/// The error used in the [`PartialNameRef`]`::try_from`(…) implementations.
 pub type Error = gix_validate::reference::name::Error;
 
 impl<'a> Category<'a> {

gix-traverse/src/tree/mod.rs

@@ -27,7 +27,7 @@ pub trait Visit {
     fn visit_nontree(&mut self, entry: &gix_object::tree::EntryRef<'_>) -> visit::Action;
 }
 
-/// A [Visit][Visit] implementation to record every observed change and keep track of the changed paths.
+/// A [Visit] implementation to record every observed change and keep track of the changed paths.
 ///
 /// Recorders can also be instructed to track the filename only, or no location at all.
 #[derive(Clone, Debug)]