// Copyright 2020 The Jujutsu Authors//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//// https://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License. //! Defines the commit backend trait and related types. This is the lowest-level//! trait for reading and writing commits, trees, files, etc. use std::any::Any;use std::borrow::Borrow;use std::fmt::Debug;use std::fmt::Write as _;use std::iter::zip;use std::pin::Pin;use std::slice;use std::time::SystemTime; use async_trait::async_trait;use chrono::TimeZone as _;use futures::AsyncRead;use futures::stream::BoxStream;use smallvec::SmallVec;use thiserror::Error; use crate::conflict_labels::ConflictLabels;use crate::content_hash::ContentHash;use crate::hex_util;use crate::index::Index;use crate::merge::Merge;use crate::object_id::ObjectId as _;use crate::object_id::id_type;use crate::repo_path::RepoPath;use crate::repo_path::RepoPathBuf;use crate::repo_path::RepoPathComponent;use crate::repo_path::RepoPathComponentBuf;use crate::signing::SignResult; id_type!( /// Identifier for a [`Commit`] based on its content. When a commit is /// rewritten, its `CommitId` changes. pub CommitId { hex() });id_type!( /// Stable identifier for a [`Commit`]. Unlike the `CommitId`, the `ChangeId` /// follows the commit and is not updated when the commit is rewritten. pub ChangeId { reverse_hex() });id_type!( /// Identifier for a tree object. pub TreeId { hex() });id_type!( /// Identifier for a file content. pub FileId { hex() });id_type!( /// Identifier for a symlink. pub SymlinkId { hex() });id_type!( /// Identifier for a copy history. pub CopyId { hex() }); impl ChangeId { /// Parses the given "reverse" hex string into a `ChangeId`. pub fn try_from_reverse_hex(hex: impl AsRef<[u8]>) -> Option<Self> { hex_util::decode_reverse_hex(hex).map(Self) } /// Returns the hex string representation of this ID, which uses `z-k` /// "digits" instead of `0-9a-f`. pub fn reverse_hex(&self) -> String { hex_util::encode_reverse_hex(&self.0) }} impl CopyId { /// Returns a placeholder copy id to be used when we don't have a real copy /// id yet. // TODO: Delete this pub fn placeholder() -> Self { Self::new(vec![]) }} /// Error that may occur when converting a `Timestamp` to a `Datetime``.#[derive(Debug, Error)]#[error("Out-of-range date")]pub struct TimestampOutOfRange; /// The number of milliseconds since the Unix epoch.#[derive(ContentHash, Hash, Debug, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]pub struct MillisSinceEpoch(pub i64); /// A timestamp with millisecond precision and a time zone offset.#[derive(ContentHash, Hash, Debug, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]pub struct Timestamp { /// The number of milliseconds since the Unix epoch. pub timestamp: MillisSinceEpoch, /// Timezone offset in minutes pub tz_offset: i32,} impl Timestamp { /// Returns the current local time as a `Timestamp`. pub fn now() -> Self { Self::from_datetime(chrono::offset::Local::now()) } /// Creates a `Timestamp` from the given `DateTime`. pub fn from_datetime<Tz: chrono::TimeZone<Offset = chrono::offset::FixedOffset>>( datetime: chrono::DateTime<Tz>, ) -> Self { Self { timestamp: MillisSinceEpoch(datetime.timestamp_millis()), tz_offset: datetime.offset().local_minus_utc() / 60, } } /// Converts this `Timestamp` to a `DateTime`. pub fn to_datetime( &self, ) -> Result<chrono::DateTime<chrono::FixedOffset>, TimestampOutOfRange> { let utc = match chrono::Utc.timestamp_opt( self.timestamp.0.div_euclid(1000), (self.timestamp.0.rem_euclid(1000)) as u32 * 1000000, ) { chrono::LocalResult::None => { return Err(TimestampOutOfRange); } chrono::LocalResult::Single(x) => x, chrono::LocalResult::Ambiguous(y, _z) => y, }; Ok(utc.with_timezone( &chrono::FixedOffset::east_opt(self.tz_offset * 60) .unwrap_or_else(|| chrono::FixedOffset::east_opt(0).unwrap()), )) }} impl serde::Serialize for Timestamp { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer, { // TODO: test is_human_readable() to use raw format? let t = self.to_datetime().map_err(serde::ser::Error::custom)?; t.serialize(serializer) }} /// Represents a person/entity and a timestamp for when they authored or/// committed a commit.#[derive(ContentHash, Hash, Debug, PartialEq, Eq, Clone, serde::Serialize)]pub struct Signature { /// The name of the person/entity. pub name: String, /// The email address of the person/entity. pub email: String, /// The timestamp for when the person/entity authored or committed the /// commit. pub timestamp: Timestamp,} /// Represents a cryptographically signed [`Commit`] signature.#[derive(ContentHash, Debug, PartialEq, Eq, Clone)]pub struct SecureSig { /// The raw data that was signed to produce this signature. pub data: Vec<u8>, /// The signature itself. pub sig: Vec<u8>,} /// Function called to sign a commit. The input is the raw data to sign, and the/// output is the signature.pub type SigningFn<'a> = dyn FnMut(&[u8]) -> SignResult<Vec<u8>> + Send + 'a; /// Represents a commit object, which contains a reference to the contents a/// that point in time, along with metadata about the commit.#[derive(ContentHash, Debug, PartialEq, Eq, Clone, serde::Serialize)]pub struct Commit { /// The parent commits of this commit. Commits typically have one parents, /// but they can have any number of parents. Only the root commit has no /// parents. pub parents: Vec<CommitId>, /// The predecessor commits of this commit, i.e. commits that were rewritten /// to create this commit. // // TODO: delete commit.predecessors when we can assume that most commits are // tracked by op.commit_predecessors. (in jj 0.42 or so?) #[serde(skip)] // deprecated pub predecessors: Vec<CommitId>, /// The tree at the root directory in this commit. #[serde(skip)] // TODO: should be exposed? pub root_tree: Merge<TreeId>, /// If resolved, must be empty string. Otherwise, must have same number of /// terms as `root_tree`. #[serde(skip)] pub conflict_labels: Merge<String>, /// The change ID of this commit. This is a stable identifier that follows /// the commit when it's rewritten. pub change_id: ChangeId, /// The description (commit message). pub description: String, /// The person/entity that authored this commit. pub author: Signature, /// The person/entity that committed this commit. pub committer: Signature, /// A cryptographic signature of this commit. #[serde(skip)] // raw data wouldn't be useful pub secure_sig: Option<SecureSig>,} /// An individual copy event, from file A -> B.#[derive(Debug, PartialEq, Eq, Clone)]pub struct CopyRecord { /// The destination of the copy, B. pub target: RepoPathBuf, /// The CommitId where the copy took place. pub target_commit: CommitId, /// The source path a target was copied from. /// /// It is not required that the source path is different than the target /// path. A custom backend may choose to represent 'rollbacks' as copies /// from a file unto itself, from a specific prior commit. pub source: RepoPathBuf, /// The file id of the source file. pub source_file: FileId, /// The source commit the target was copied from. Backends may use this /// field to implement 'integration' logic, where a source may be /// periodically merged into a target, similar to a branch, but the /// branching occurs at the file level rather than the repository level. It /// also follows naturally that any copy source targeted to a specific /// commit should avoid copy propagation on rebasing, which is desirable /// for 'fork' style copies. /// /// It is required that the commit id is an ancestor of the commit with /// which this copy source is associated. pub source_commit: CommitId,} /// Describes the copy history of a file. The copy object is unchanged when a/// file is modified.#[derive(ContentHash, Debug, PartialEq, Eq, Clone, PartialOrd, Ord)]pub struct CopyHistory { /// The file's current path. pub current_path: RepoPathBuf, /// IDs of the files that became the current incarnation of this file. /// /// A newly created file has no parents. A regular copy or rename has one /// parent. A merge of multiple files has multiple parents. pub parents: Vec<CopyId>, /// An optional piece of data to give the Copy object a different ID. May be /// randomly generated. This allows a commit to say that a file was replaced /// by a new incarnation of it, indicating a logically distinct file /// taking the place of the previous file at the path. pub salt: Vec<u8>,} /// A `CopyHistory` along with its `CopyId`.#[derive(Debug, Eq, PartialEq)]pub struct RelatedCopy { /// The copy id. pub id: CopyId, /// The copy history. pub history: CopyHistory,} /// Error that may occur during backend initialization.#[derive(Debug, Error)]#[error(transparent)]pub struct BackendInitError(pub Box<dyn std::error::Error + Send + Sync>); /// Error that may occur during backend loading.#[derive(Debug, Error)]#[error(transparent)]pub struct BackendLoadError(pub Box<dyn std::error::Error + Send + Sync>); /// Commit-backend error that may occur after the backend is loaded.#[derive(Debug, Error)]pub enum BackendError { /// The caller attempted to read an object by specifying an ID with an /// invalid hash length for this backend. #[error( "Invalid hash length for object of type {object_type} (expected {expected} bytes, got \ {actual} bytes): {hash}" )] InvalidHashLength { /// The expected length of the hash in bytes for this backend. expected: usize, /// The actual length of the hash in bytes that was provided. actual: usize, /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash that had an invalid length. hash: String, }, /// The caller attempted to read an object that internally stored as invalid /// UTF-8, such as a symlink target with invalid UTF-8 stored in the Git /// backend. #[error("Invalid UTF-8 for object {hash} of type {object_type}")] InvalidUtf8 { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that had invalid UTF-8. hash: String, /// The source error. source: std::str::Utf8Error, }, /// The caller attempted to read an object that doesn't exist. #[error("Object {hash} of type {object_type} not found")] ObjectNotFound { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that was not found. hash: String, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Failed to read an object due to an I/O error or other unexpected error. #[error("Error when reading object {hash} of type {object_type}")] ReadObject { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that we failed to read. hash: String, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// The caller attempted to read an object but doesn't have permission to /// read it. #[error("Access denied to read object {hash} of type {object_type}")] ReadAccessDenied { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that the caller doesn't have permission /// to read. hash: String, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Failed to read a file's content due to an I/O error or other unexpected /// error. #[error( "Error when reading file content for file {path} with id {id}", path = path.as_internal_file_string() )] ReadFile { /// The path of the file we failed to read. path: RepoPathBuf, /// The ID of the file we failed to read. id: FileId, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Failed to write an object due to an I/O error or other unexpected error. #[error("Could not write object of type {object_type}")] WriteObject { /// The type of the object that we attempted to write, e.g. "commit" or /// "tree". object_type: &'static str, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Some other error that doesn't fit into the above categories. #[error(transparent)] Other(Box<dyn std::error::Error + Send + Sync>), /// A valid operation was attempted, but it failed because it isn't /// supported by the particular backend. #[error("{0}")] Unsupported(String),} /// A specialized [`Result`] type for commit backend errors.pub type BackendResult<T> = Result<T, BackendError>; /// Identifies the content at a given path in a tree.#[derive(ContentHash, Debug, PartialEq, Eq, Clone, Hash)]pub enum TreeValue { // TODO: When there's a CopyId here, the copy object's path must match // the path identified by the tree. /// This path is a regular file, possibly executable. File { /// The file's content ID. id: FileId, /// Whether the file is executable. executable: bool, /// The copy id. copy_id: CopyId, }, /// This path is a symbolic link. Symlink(SymlinkId), /// This path is a directory. Tree(TreeId), /// This path is a Git submodule. GitSubmodule(CommitId),} impl TreeValue { /// The copy id if this value represents a file. pub fn copy_id(&self) -> Option<&CopyId> { match self { Self::File { copy_id, .. } => Some(copy_id), _ => None, } }} /// Borrowed `MergedTreeValue`.pub type MergedTreeVal<'a> = Merge<Option<&'a TreeValue>>; /// The value at a given path in a commit.////// It depends on the context whether it can be absent/// (`Merge::is_absent()`). For example, when getting the value at a/// specific path, it may be, but when iterating over entries in a/// tree, it shouldn't be.pub type MergedTreeValue = Merge<Option<TreeValue>>; /// Extension methods for tree-value merges such as [`MergedTreeValue`] and/// [`MergedTreeVal`].pub trait MergedTreeValueExt { /// Whether this merge should be recursed into when doing directory walks. fn is_tree(&self) -> bool; /// Whether this merge is present and not a tree fn is_file_like(&self) -> bool; /// If this merge contains only files or absent entries, returns a merge of /// the `FileId`s. The executable bits and copy IDs will be ignored. Use /// `Merge::with_new_file_ids()` to produce a new merge with the original /// executable bits preserved. fn to_file_merge(&self) -> Option<Merge<Option<FileId>>>; /// If this merge contains only files or absent entries, returns a merge of /// the files' executable bits. fn to_executable_merge(&self) -> Option<Merge<Option<bool>>>; /// If this merge contains only files or absent entries, returns a merge of /// the files' copy IDs. fn to_copy_id_merge(&self) -> Option<Merge<Option<CopyId>>>; /// Creates a new merge with the file ids from the given merge. In other /// words, the executable bits and copy IDs from `self` will be preserved. /// /// The given `file_ids` should have the same shape as `self`. Only the /// `FileId` values may differ. fn with_new_file_ids(&self, file_ids: &Merge<Option<FileId>>) -> Merge<Option<TreeValue>>; /// Give a summary description of the conflict's "removes" and "adds" fn describe(&self, labels: &ConflictLabels) -> String;} impl<T> MergedTreeValueExt for Merge<Option<T>>where T: Borrow<TreeValue>,{ fn is_tree(&self) -> bool { self.is_present() && self.iter().all(|value| { matches!( borrow_tree_value(value.as_ref()), Some(TreeValue::Tree(_)) | None ) }) } fn is_file_like(&self) -> bool { self.is_present() && !self.is_tree() } fn to_file_merge(&self) -> Option<Merge<Option<FileId>>> { let file_ids = self .try_map(|term| match borrow_tree_value(term.as_ref()) { None => Ok(None), Some(TreeValue::File { id, executable: _, copy_id: _, }) => Ok(Some(id.clone())), _ => Err(()), }) .ok()?; Lines 1–500 of 907. Load more
// Copyright 2020 The Jujutsu Authors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //! Defines the commit backend trait and related types. This is the lowest-level //! trait for reading and writing commits, trees, files, etc. use std::any::Any; use std::borrow::Borrow; use std::fmt::Debug; use std::fmt::Write as _; use std::iter::zip; use std::pin::Pin; use std::slice; use std::time::SystemTime; use async_trait::async_trait; use chrono::TimeZone as _; use futures::AsyncRead; use futures::stream::BoxStream; use smallvec::SmallVec; use thiserror::Error; use crate::conflict_labels::ConflictLabels; use crate::content_hash::ContentHash; use crate::hex_util; use crate::index::Index; use crate::merge::Merge; use crate::object_id::ObjectId as _; use crate::object_id::id_type; use crate::repo_path::RepoPath; use crate::repo_path::RepoPathBuf; use crate::repo_path::RepoPathComponent; use crate::repo_path::RepoPathComponentBuf; use crate::signing::SignResult; id_type!( /// Identifier for a [`Commit`] based on its content. When a commit is /// rewritten, its `CommitId` changes. pub CommitId { hex() } ); id_type!( /// Stable identifier for a [`Commit`]. Unlike the `CommitId`, the `ChangeId` /// follows the commit and is not updated when the commit is rewritten. pub ChangeId { reverse_hex() } ); id_type!( /// Identifier for a tree object. pub TreeId { hex() } ); id_type!( /// Identifier for a file content. pub FileId { hex() } ); id_type!( /// Identifier for a symlink. pub SymlinkId { hex() } ); id_type!( /// Identifier for a copy history. pub CopyId { hex() } ); impl ChangeId { /// Parses the given "reverse" hex string into a `ChangeId`. pub fn try_from_reverse_hex(hex: impl AsRef<[u8]>) -> Option<Self> { hex_util::decode_reverse_hex(hex).map(Self) } /// Returns the hex string representation of this ID, which uses `z-k` /// "digits" instead of `0-9a-f`. pub fn reverse_hex(&self) -> String { hex_util::encode_reverse_hex(&self.0) } } impl CopyId { /// Returns a placeholder copy id to be used when we don't have a real copy /// id yet. // TODO: Delete this pub fn placeholder() -> Self { Self::new(vec![]) } } /// Error that may occur when converting a `Timestamp` to a `Datetime``. #[derive(Debug, Error)] #[error("Out-of-range date")] pub struct TimestampOutOfRange; /// The number of milliseconds since the Unix epoch. #[derive(ContentHash, Hash, Debug, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)] pub struct MillisSinceEpoch(pub i64); /// A timestamp with millisecond precision and a time zone offset. #[derive(ContentHash, Hash, Debug, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)] pub struct Timestamp { /// The number of milliseconds since the Unix epoch. pub timestamp: MillisSinceEpoch, /// Timezone offset in minutes pub tz_offset: i32, } impl Timestamp { /// Returns the current local time as a `Timestamp`. pub fn now() -> Self { Self::from_datetime(chrono::offset::Local::now()) } /// Creates a `Timestamp` from the given `DateTime`. pub fn from_datetime<Tz: chrono::TimeZone<Offset = chrono::offset::FixedOffset>>( datetime: chrono::DateTime<Tz>, ) -> Self { Self { timestamp: MillisSinceEpoch(datetime.timestamp_millis()), tz_offset: datetime.offset().local_minus_utc() / 60, } } /// Converts this `Timestamp` to a `DateTime`. pub fn to_datetime( &self, ) -> Result<chrono::DateTime<chrono::FixedOffset>, TimestampOutOfRange> { let utc = match chrono::Utc.timestamp_opt( self.timestamp.0.div_euclid(1000), (self.timestamp.0.rem_euclid(1000)) as u32 * 1000000, ) { chrono::LocalResult::None => { return Err(TimestampOutOfRange); } chrono::LocalResult::Single(x) => x, chrono::LocalResult::Ambiguous(y, _z) => y, }; Ok(utc.with_timezone( &chrono::FixedOffset::east_opt(self.tz_offset * 60) .unwrap_or_else(|| chrono::FixedOffset::east_opt(0).unwrap()), )) } } impl serde::Serialize for Timestamp { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer, { // TODO: test is_human_readable() to use raw format? let t = self.to_datetime().map_err(serde::ser::Error::custom)?; t.serialize(serializer) } } /// Represents a person/entity and a timestamp for when they authored or /// committed a commit. #[derive(ContentHash, Hash, Debug, PartialEq, Eq, Clone, serde::Serialize)] pub struct Signature { /// The name of the person/entity. pub name: String, /// The email address of the person/entity. pub email: String, /// The timestamp for when the person/entity authored or committed the /// commit. pub timestamp: Timestamp, } /// Represents a cryptographically signed [`Commit`] signature. #[derive(ContentHash, Debug, PartialEq, Eq, Clone)] pub struct SecureSig { /// The raw data that was signed to produce this signature. pub data: Vec<u8>, /// The signature itself. pub sig: Vec<u8>, } /// Function called to sign a commit. The input is the raw data to sign, and the /// output is the signature. pub type SigningFn<'a> = dyn FnMut(&[u8]) -> SignResult<Vec<u8>> + Send + 'a; /// Represents a commit object, which contains a reference to the contents a /// that point in time, along with metadata about the commit. #[derive(ContentHash, Debug, PartialEq, Eq, Clone, serde::Serialize)] pub struct Commit { /// The parent commits of this commit. Commits typically have one parents, /// but they can have any number of parents. Only the root commit has no /// parents. pub parents: Vec<CommitId>, /// The predecessor commits of this commit, i.e. commits that were rewritten /// to create this commit. // // TODO: delete commit.predecessors when we can assume that most commits are // tracked by op.commit_predecessors. (in jj 0.42 or so?) #[serde(skip)] // deprecated pub predecessors: Vec<CommitId>, /// The tree at the root directory in this commit. #[serde(skip)] // TODO: should be exposed? pub root_tree: Merge<TreeId>, /// If resolved, must be empty string. Otherwise, must have same number of /// terms as `root_tree`. #[serde(skip)] pub conflict_labels: Merge<String>, /// The change ID of this commit. This is a stable identifier that follows /// the commit when it's rewritten. pub change_id: ChangeId, /// The description (commit message). pub description: String, /// The person/entity that authored this commit. pub author: Signature, /// The person/entity that committed this commit. pub committer: Signature, /// A cryptographic signature of this commit. #[serde(skip)] // raw data wouldn't be useful pub secure_sig: Option<SecureSig>, } /// An individual copy event, from file A -> B. #[derive(Debug, PartialEq, Eq, Clone)] pub struct CopyRecord { /// The destination of the copy, B. pub target: RepoPathBuf, /// The CommitId where the copy took place. pub target_commit: CommitId, /// The source path a target was copied from. /// /// It is not required that the source path is different than the target /// path. A custom backend may choose to represent 'rollbacks' as copies /// from a file unto itself, from a specific prior commit. pub source: RepoPathBuf, /// The file id of the source file. pub source_file: FileId, /// The source commit the target was copied from. Backends may use this /// field to implement 'integration' logic, where a source may be /// periodically merged into a target, similar to a branch, but the /// branching occurs at the file level rather than the repository level. It /// also follows naturally that any copy source targeted to a specific /// commit should avoid copy propagation on rebasing, which is desirable /// for 'fork' style copies. /// /// It is required that the commit id is an ancestor of the commit with /// which this copy source is associated. pub source_commit: CommitId, } /// Describes the copy history of a file. The copy object is unchanged when a /// file is modified. #[derive(ContentHash, Debug, PartialEq, Eq, Clone, PartialOrd, Ord)] pub struct CopyHistory { /// The file's current path. pub current_path: RepoPathBuf, /// IDs of the files that became the current incarnation of this file. /// /// A newly created file has no parents. A regular copy or rename has one /// parent. A merge of multiple files has multiple parents. pub parents: Vec<CopyId>, /// An optional piece of data to give the Copy object a different ID. May be /// randomly generated. This allows a commit to say that a file was replaced /// by a new incarnation of it, indicating a logically distinct file /// taking the place of the previous file at the path. pub salt: Vec<u8>, } /// A `CopyHistory` along with its `CopyId`. #[derive(Debug, Eq, PartialEq)] pub struct RelatedCopy { /// The copy id. pub id: CopyId, /// The copy history. pub history: CopyHistory, } /// Error that may occur during backend initialization. #[derive(Debug, Error)] #[error(transparent)] pub struct BackendInitError(pub Box<dyn std::error::Error + Send + Sync>); /// Error that may occur during backend loading. #[derive(Debug, Error)] #[error(transparent)] pub struct BackendLoadError(pub Box<dyn std::error::Error + Send + Sync>); /// Commit-backend error that may occur after the backend is loaded. #[derive(Debug, Error)] pub enum BackendError { /// The caller attempted to read an object by specifying an ID with an /// invalid hash length for this backend. #[error( "Invalid hash length for object of type {object_type} (expected {expected} bytes, got \ {actual} bytes): {hash}" )] InvalidHashLength { /// The expected length of the hash in bytes for this backend. expected: usize, /// The actual length of the hash in bytes that was provided. actual: usize, /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash that had an invalid length. hash: String, }, /// The caller attempted to read an object that internally stored as invalid /// UTF-8, such as a symlink target with invalid UTF-8 stored in the Git /// backend. #[error("Invalid UTF-8 for object {hash} of type {object_type}")] InvalidUtf8 { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that had invalid UTF-8. hash: String, /// The source error. source: std::str::Utf8Error, }, /// The caller attempted to read an object that doesn't exist. #[error("Object {hash} of type {object_type} not found")] ObjectNotFound { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that was not found. hash: String, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Failed to read an object due to an I/O error or other unexpected error. #[error("Error when reading object {hash} of type {object_type}")] ReadObject { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that we failed to read. hash: String, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// The caller attempted to read an object but doesn't have permission to /// read it. #[error("Access denied to read object {hash} of type {object_type}")] ReadAccessDenied { /// The type of the object that we attempted to read, e.g. "commit" or /// "tree". object_type: String, /// The hex hash of the object that the caller doesn't have permission /// to read. hash: String, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Failed to read a file's content due to an I/O error or other unexpected /// error. #[error( "Error when reading file content for file {path} with id {id}", path = path.as_internal_file_string() )] ReadFile { /// The path of the file we failed to read. path: RepoPathBuf, /// The ID of the file we failed to read. id: FileId, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Failed to write an object due to an I/O error or other unexpected error. #[error("Could not write object of type {object_type}")] WriteObject { /// The type of the object that we attempted to write, e.g. "commit" or /// "tree". object_type: &'static str, /// The source error. source: Box<dyn std::error::Error + Send + Sync>, }, /// Some other error that doesn't fit into the above categories. #[error(transparent)] Other(Box<dyn std::error::Error + Send + Sync>), /// A valid operation was attempted, but it failed because it isn't /// supported by the particular backend. #[error("{0}")] Unsupported(String), } /// A specialized [`Result`] type for commit backend errors. pub type BackendResult<T> = Result<T, BackendError>; /// Identifies the content at a given path in a tree. #[derive(ContentHash, Debug, PartialEq, Eq, Clone, Hash)] pub enum TreeValue { // TODO: When there's a CopyId here, the copy object's path must match // the path identified by the tree. /// This path is a regular file, possibly executable. File { /// The file's content ID. id: FileId, /// Whether the file is executable. executable: bool, /// The copy id. copy_id: CopyId, }, /// This path is a symbolic link. Symlink(SymlinkId), /// This path is a directory. Tree(TreeId), /// This path is a Git submodule. GitSubmodule(CommitId), } impl TreeValue { /// The copy id if this value represents a file. pub fn copy_id(&self) -> Option<&CopyId> { match self { Self::File { copy_id, .. } => Some(copy_id), _ => None, } } } /// Borrowed `MergedTreeValue`. pub type MergedTreeVal<'a> = Merge<Option<&'a TreeValue>>; /// The value at a given path in a commit. /// /// It depends on the context whether it can be absent /// (`Merge::is_absent()`). For example, when getting the value at a /// specific path, it may be, but when iterating over entries in a /// tree, it shouldn't be. pub type MergedTreeValue = Merge<Option<TreeValue>>; /// Extension methods for tree-value merges such as [`MergedTreeValue`] and /// [`MergedTreeVal`]. pub trait MergedTreeValueExt { /// Whether this merge should be recursed into when doing directory walks. fn is_tree(&self) -> bool; /// Whether this merge is present and not a tree fn is_file_like(&self) -> bool; /// If this merge contains only files or absent entries, returns a merge of /// the `FileId`s. The executable bits and copy IDs will be ignored. Use /// `Merge::with_new_file_ids()` to produce a new merge with the original /// executable bits preserved. fn to_file_merge(&self) -> Option<Merge<Option<FileId>>>; /// If this merge contains only files or absent entries, returns a merge of /// the files' executable bits. fn to_executable_merge(&self) -> Option<Merge<Option<bool>>>; /// If this merge contains only files or absent entries, returns a merge of /// the files' copy IDs. fn to_copy_id_merge(&self) -> Option<Merge<Option<CopyId>>>; /// Creates a new merge with the file ids from the given merge. In other /// words, the executable bits and copy IDs from `self` will be preserved. /// /// The given `file_ids` should have the same shape as `self`. Only the /// `FileId` values may differ. fn with_new_file_ids(&self, file_ids: &Merge<Option<FileId>>) -> Merge<Option<TreeValue>>; /// Give a summary description of the conflict's "removes" and "adds" fn describe(&self, labels: &ConflictLabels) -> String; } impl<T> MergedTreeValueExt for Merge<Option<T>> where T: Borrow<TreeValue>, { fn is_tree(&self) -> bool { self.is_present() && self.iter().all(|value| { matches!( borrow_tree_value(value.as_ref()), Some(TreeValue::Tree(_)) | None ) }) } fn is_file_like(&self) -> bool { self.is_present() && !self.is_tree() } fn to_file_merge(&self) -> Option<Merge<Option<FileId>>> { let file_ids = self .try_map(|term| match borrow_tree_value(term.as_ref()) { None => Ok(None), Some(TreeValue::File { id, executable: _, copy_id: _, }) => Ok(Some(id.clone())), _ => Err(()), }) .ok()?;