diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-04 12:41:35 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-04 12:41:35 +0000 |
commit | 7e5d7eea9c580ef4b41a765bde624af431942b96 (patch) | |
tree | 2c0d9ca12878fc4525650aa4e54d77a81a07cc09 /vendor/gix-ref/src/lib.rs | |
parent | Adding debian version 1.70.0+dfsg1-9. (diff) | |
download | rustc-7e5d7eea9c580ef4b41a765bde624af431942b96.tar.xz rustc-7e5d7eea9c580ef4b41a765bde624af431942b96.zip |
Merging upstream version 1.70.0+dfsg2.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/gix-ref/src/lib.rs')
-rw-r--r-- | vendor/gix-ref/src/lib.rs | 205 |
1 files changed, 205 insertions, 0 deletions
diff --git a/vendor/gix-ref/src/lib.rs b/vendor/gix-ref/src/lib.rs new file mode 100644 index 000000000..b18d67c4a --- /dev/null +++ b/vendor/gix-ref/src/lib.rs @@ -0,0 +1,205 @@ +//! A crate for handling the references stored in various formats in a git repository. +//! +//! References are also called _refs_ which are used interchangeably. +//! +//! 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] +//! +//! They can be identified by a relative path and stored in various flavors. +//! +//! * **files** +//! * **[loose][file::Store]** +//! * one reference maps to a file on disk +//! * **packed** +//! * references are stored in a single human-readable file, along with their targets if they are symbolic. +//! +//! ## Feature Flags +#![cfg_attr( + feature = "document-features", + cfg_attr(doc, doc = ::document_features::document_features!()) +)] +#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))] +#![deny(missing_docs, rust_2018_idioms, unsafe_code)] + +use std::borrow::Cow; + +use gix_hash::{oid, ObjectId}; +pub use gix_object::bstr; +use gix_object::bstr::{BStr, BString}; + +#[path = "store/mod.rs"] +mod store_impl; +pub use store_impl::{file, packed}; + +mod fullname; +/// +pub mod name; +/// +pub mod namespace; +/// +pub mod transaction; + +mod parse; +mod raw; + +pub use raw::Reference; + +mod target; + +/// +pub mod log; + +/// +pub mod peel; + +/// +pub mod store { + /// The way a file store handles the reflog + #[derive(Debug, PartialOrd, PartialEq, Ord, Eq, Hash, Clone, Copy)] + pub enum WriteReflog { + /// Always write the reflog for all references for ref edits, unconditionally. + Always, + /// Write a ref log for ref edits according to the standard rules. + Normal, + /// Never write a ref log. + Disable, + } + + impl Default for WriteReflog { + fn default() -> Self { + WriteReflog::Normal + } + } + + /// A thread-local handle for interacting with a [`Store`][crate::Store] to find and iterate references. + #[derive(Clone)] + #[allow(dead_code)] + pub(crate) struct Handle { + /// A way to access shared state with the requirement that interior mutability doesn't leak or is incorporated into error types + /// if it could. The latter can't happen if references to said internal aren't ever returned. + state: handle::State, + } + + #[allow(dead_code)] + pub(crate) enum State { + Loose { store: file::Store }, + } + + pub(crate) mod general; + + /// + #[path = "general/handle/mod.rs"] + mod handle; + pub use handle::find; + + use crate::file; +} + +/// The git reference store. +/// TODO: Figure out if handles are needed at all, which depends on the ref-table implementation. +#[allow(dead_code)] +pub(crate) struct Store { + inner: store::State, +} + +/// Indicate that the given BString is a validate reference name or path that can be used as path on disk or written as target +/// of a symbolic reference +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)] +#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))] +pub struct FullName(pub(crate) BString); + +/// A validated and potentially partial reference name - it can safely be used for common operations. +#[derive(Hash, Debug, PartialEq, Eq, Ord, PartialOrd)] +#[repr(transparent)] +pub struct FullNameRef(BStr); + +/// A validated complete and fully qualified reference name, safe to use for all operations. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)] +pub struct PartialNameCow<'a>(Cow<'a, BStr>); + +/// A validated complete and fully qualified referenced reference name, safe to use for all operations. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd)] +#[repr(transparent)] +pub struct PartialNameRef(BStr); + +/// A validated complete and fully qualified owned reference name, safe to use for all operations. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd)] +pub struct PartialName(BString); + +/// A _validated_ prefix for references to act as a namespace. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)] +pub struct Namespace(BString); + +/// Denotes the kind of reference. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)] +#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))] +pub enum Kind { + /// A ref that points to an object id + Peeled, + /// A ref that points to another reference, adding a level of indirection. + /// + /// It can be resolved to an id using the [`peel_in_place_to_id()`][`crate::file::ReferenceExt::peel_to_id_in_place()`] method. + Symbolic, +} + +/// The various known categories of references. +/// +/// This translates into a prefix containing all references of a given category. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)] +pub enum Category<'a> { + /// A tag in `refs/tags` + Tag, + /// A branch in `refs/heads` + LocalBranch, + /// A branch in `refs/remotes` + RemoteBranch, + /// A tag in `refs/notes` + Note, + /// Something outside of `ref/` in the current worktree, typically `HEAD`. + PseudoRef, + /// A `PseudoRef`, but referenced so that it will always refer to the main worktree by + /// prefixing it with `main-worktree/`. + MainPseudoRef, + /// Any reference that is prefixed with `main-worktree/refs/` + MainRef, + /// A `PseudoRef` in another _linked_ worktree, never in the main one, like `worktrees/<id>/HEAD`. + LinkedPseudoRef { + /// The name of the worktree. + name: &'a BStr, + }, + /// Any reference that is prefixed with `worktrees/<id>/refs/`. + LinkedRef { + /// The name of the worktree. + name: &'a BStr, + }, + /// A ref that is private to each worktree (_linked_ or _main_), with `refs/bisect/` prefix + Bisect, + /// A ref that is private to each worktree (_linked_ or _main_), with `refs/rewritten/` prefix + Rewritten, + /// A ref that is private to each worktree (_linked_ or _main_), with `refs/worktree/` prefix + WorktreePrivate, + // REF_TYPE_NORMAL, /* normal/shared refs inside refs/ */ +} + +/// Denotes a ref target, equivalent to [`Kind`], but with mutable data. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)] +#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))] +pub enum Target { + /// A ref that points to an object id + Peeled(ObjectId), + /// A ref that points to another reference by its validated name, adding a level of indirection. + /// + /// Note that this is an extension of gitoxide which will be helpful in logging all reference changes. + Symbolic(FullName), +} + +/// Denotes a ref target, equivalent to [`Kind`], but with immutable data. +#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)] +pub enum TargetRef<'a> { + /// A ref that points to an object id + Peeled(&'a oid), + /// A ref that points to another reference by its validated name, adding a level of indirection. + Symbolic(&'a FullNameRef), +} |