changelog.rs
346 lines
| 11.2 KiB
| application/rls-services+xml
|
RustLexer
|
r47172 | use crate::errors::HgError; | ||
|
r47478 | use crate::revlog::{Node, NodePrefix}; | ||
|
r51268 | use crate::revlog::{Revision, NULL_REVISION}; | ||
|
r50832 | use crate::revlog::{Revlog, RevlogEntry, RevlogError}; | ||
|
r49938 | use crate::utils::hg_path::HgPath; | ||
|
r49981 | use crate::vfs::Vfs; | ||
|
r49938 | use itertools::Itertools; | ||
use std::ascii::escape_default; | ||||
|
r49987 | use std::borrow::Cow; | ||
|
r49938 | use std::fmt::{Debug, Formatter}; | ||
|
r46103 | |||
|
r51266 | /// A specialized `Revlog` to work with changelog data format. | ||
|
r46103 | pub struct Changelog { | ||
/// The generic `revlog` format. | ||||
|
r47162 | pub(crate) revlog: Revlog, | ||
|
r46103 | } | ||
impl Changelog { | ||||
/// Open the `changelog` of a repository given by its root. | ||||
|
r49981 | pub fn open(store_vfs: &Vfs, use_nodemap: bool) -> Result<Self, HgError> { | ||
let revlog = | ||||
Revlog::open(store_vfs, "00changelog.i", None, use_nodemap)?; | ||||
|
r46103 | Ok(Self { revlog }) | ||
} | ||||
|
r51266 | /// Return the `ChangelogRevisionData` for the given node ID. | ||
|
r48783 | pub fn data_for_node( | ||
|
r46103 | &self, | ||
|
r47160 | node: NodePrefix, | ||
|
r49372 | ) -> Result<ChangelogRevisionData, RevlogError> { | ||
|
r48782 | let rev = self.revlog.rev_from_node(node)?; | ||
|
r48783 | self.data_for_rev(rev) | ||
|
r46103 | } | ||
|
r51268 | /// Return the [`ChangelogEntry`] for the given revision number. | ||
|
r49939 | pub fn entry_for_rev( | ||
&self, | ||||
rev: Revision, | ||||
|
r51268 | ) -> Result<ChangelogEntry, RevlogError> { | ||
let revlog_entry = self.revlog.get_entry(rev)?; | ||||
Ok(ChangelogEntry { revlog_entry }) | ||||
|
r49939 | } | ||
|
r51266 | /// Return the [`ChangelogRevisionData`] for the given revision number. | ||
|
r51268 | /// | ||
/// This is a useful shortcut in case the caller does not need the | ||||
/// generic revlog information (parents, hashes etc). Otherwise | ||||
/// consider taking a [`ChangelogEntry`] with | ||||
/// [entry_for_rev](`Self::entry_for_rev`) and doing everything from there. | ||||
|
r48783 | pub fn data_for_rev( | ||
|
r46103 | &self, | ||
rev: Revision, | ||||
|
r49372 | ) -> Result<ChangelogRevisionData, RevlogError> { | ||
|
r51268 | if rev == NULL_REVISION { | ||
return Ok(ChangelogRevisionData::null()); | ||||
|
r49937 | } | ||
|
r51268 | self.entry_for_rev(rev)?.data() | ||
|
r46103 | } | ||
|
r47478 | |||
pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> { | ||||
|
r48781 | self.revlog.node_from_rev(rev) | ||
|
r47478 | } | ||
|
r49939 | |||
pub fn rev_from_node( | ||||
&self, | ||||
node: NodePrefix, | ||||
) -> Result<Revision, RevlogError> { | ||||
self.revlog.rev_from_node(node) | ||||
} | ||||
|
r46103 | } | ||
|
r51268 | /// A specialized `RevlogEntry` for `changelog` data format | ||
/// | ||||
/// This is a `RevlogEntry` with the added semantics that the associated | ||||
/// data should meet the requirements for `changelog`, materialized by | ||||
/// the fact that `data()` constructs a `ChangelogRevisionData`. | ||||
/// In case that promise would be broken, the `data` method returns an error. | ||||
#[derive(Clone)] | ||||
pub struct ChangelogEntry<'changelog> { | ||||
/// Same data, as a generic `RevlogEntry`. | ||||
pub(crate) revlog_entry: RevlogEntry<'changelog>, | ||||
} | ||||
impl<'changelog> ChangelogEntry<'changelog> { | ||||
pub fn data<'a>( | ||||
&'a self, | ||||
) -> Result<ChangelogRevisionData<'changelog>, RevlogError> { | ||||
let bytes = self.revlog_entry.data()?; | ||||
if bytes.is_empty() { | ||||
Ok(ChangelogRevisionData::null()) | ||||
} else { | ||||
Ok(ChangelogRevisionData::new(bytes).map_err(|err| { | ||||
RevlogError::Other(HgError::CorruptedRepository(format!( | ||||
"Invalid changelog data for revision {}: {:?}", | ||||
self.revlog_entry.revision(), | ||||
err | ||||
))) | ||||
})?) | ||||
} | ||||
} | ||||
/// Obtain a reference to the underlying `RevlogEntry`. | ||||
/// | ||||
/// This allows the caller to access the information that is common | ||||
/// to all revlog entries: revision number, node id, parent revisions etc. | ||||
pub fn as_revlog_entry(&self) -> &RevlogEntry { | ||||
&self.revlog_entry | ||||
} | ||||
|
r51271 | |||
pub fn p1_entry(&self) -> Result<Option<ChangelogEntry>, RevlogError> { | ||||
Ok(self | ||||
.revlog_entry | ||||
.p1_entry()? | ||||
.map(|revlog_entry| Self { revlog_entry })) | ||||
} | ||||
pub fn p2_entry(&self) -> Result<Option<ChangelogEntry>, RevlogError> { | ||||
Ok(self | ||||
.revlog_entry | ||||
.p2_entry()? | ||||
.map(|revlog_entry| Self { revlog_entry })) | ||||
} | ||||
|
r51268 | } | ||
|
r46103 | /// `Changelog` entry which knows how to interpret the `changelog` data bytes. | ||
|
r49938 | #[derive(PartialEq)] | ||
|
r49987 | pub struct ChangelogRevisionData<'changelog> { | ||
|
r46103 | /// The data bytes of the `changelog` entry. | ||
|
r49987 | bytes: Cow<'changelog, [u8]>, | ||
|
r49938 | /// The end offset for the hex manifest (not including the newline) | ||
manifest_end: usize, | ||||
/// The end offset for the user+email (not including the newline) | ||||
user_end: usize, | ||||
/// The end offset for the timestamp+timezone+extras (not including the | ||||
/// newline) | ||||
timestamp_end: usize, | ||||
/// The end offset for the file list (not including the newline) | ||||
files_end: usize, | ||||
|
r46103 | } | ||
|
r49987 | impl<'changelog> ChangelogRevisionData<'changelog> { | ||
fn new(bytes: Cow<'changelog, [u8]>) -> Result<Self, HgError> { | ||||
|
r49938 | let mut line_iter = bytes.split(|b| b == &b'\n'); | ||
let manifest_end = line_iter | ||||
.next() | ||||
.expect("Empty iterator from split()?") | ||||
.len(); | ||||
let user_slice = line_iter.next().ok_or_else(|| { | ||||
HgError::corrupted("Changeset data truncated after manifest line") | ||||
})?; | ||||
let user_end = manifest_end + 1 + user_slice.len(); | ||||
let timestamp_slice = line_iter.next().ok_or_else(|| { | ||||
HgError::corrupted("Changeset data truncated after user line") | ||||
})?; | ||||
let timestamp_end = user_end + 1 + timestamp_slice.len(); | ||||
let mut files_end = timestamp_end + 1; | ||||
loop { | ||||
let line = line_iter.next().ok_or_else(|| { | ||||
HgError::corrupted("Changeset data truncated in files list") | ||||
})?; | ||||
if line.is_empty() { | ||||
if files_end == bytes.len() { | ||||
// The list of files ended with a single newline (there | ||||
// should be two) | ||||
return Err(HgError::corrupted( | ||||
"Changeset data truncated after files list", | ||||
)); | ||||
} | ||||
files_end -= 1; | ||||
break; | ||||
} | ||||
files_end += line.len() + 1; | ||||
} | ||||
Ok(Self { | ||||
bytes, | ||||
manifest_end, | ||||
user_end, | ||||
timestamp_end, | ||||
files_end, | ||||
}) | ||||
|
r49937 | } | ||
fn null() -> Self { | ||||
|
r49987 | Self::new(Cow::Borrowed( | ||
b"0000000000000000000000000000000000000000\n\n0 0\n\n", | ||||
)) | ||||
|
r49938 | .unwrap() | ||
|
r49937 | } | ||
|
r46103 | /// Return an iterator over the lines of the entry. | ||
pub fn lines(&self) -> impl Iterator<Item = &[u8]> { | ||||
|
r49936 | self.bytes.split(|b| b == &b'\n') | ||
|
r46103 | } | ||
/// Return the node id of the `manifest` referenced by this `changelog` | ||||
/// entry. | ||||
|
r48778 | pub fn manifest_node(&self) -> Result<Node, HgError> { | ||
|
r49938 | let manifest_node_hex = &self.bytes[..self.manifest_end]; | ||
|
r49937 | Node::from_hex_for_repo(manifest_node_hex) | ||
|
r46103 | } | ||
|
r49938 | |||
/// The full user string (usually a name followed by an email enclosed in | ||||
/// angle brackets) | ||||
pub fn user(&self) -> &[u8] { | ||||
&self.bytes[self.manifest_end + 1..self.user_end] | ||||
} | ||||
/// The full timestamp line (timestamp in seconds, offset in seconds, and | ||||
/// possibly extras) | ||||
// TODO: We should expose this in a more useful way | ||||
pub fn timestamp_line(&self) -> &[u8] { | ||||
&self.bytes[self.user_end + 1..self.timestamp_end] | ||||
} | ||||
/// The files changed in this revision. | ||||
pub fn files(&self) -> impl Iterator<Item = &HgPath> { | ||||
self.bytes[self.timestamp_end + 1..self.files_end] | ||||
.split(|b| b == &b'\n') | ||||
|
r50825 | .map(HgPath::new) | ||
|
r49938 | } | ||
/// The change description. | ||||
pub fn description(&self) -> &[u8] { | ||||
&self.bytes[self.files_end + 2..] | ||||
} | ||||
|
r46103 | } | ||
|
r49938 | |||
|
r49987 | impl Debug for ChangelogRevisionData<'_> { | ||
|
r49938 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { | ||
f.debug_struct("ChangelogRevisionData") | ||||
.field("bytes", &debug_bytes(&self.bytes)) | ||||
.field("manifest", &debug_bytes(&self.bytes[..self.manifest_end])) | ||||
.field( | ||||
"user", | ||||
&debug_bytes( | ||||
&self.bytes[self.manifest_end + 1..self.user_end], | ||||
), | ||||
) | ||||
.field( | ||||
"timestamp", | ||||
&debug_bytes( | ||||
&self.bytes[self.user_end + 1..self.timestamp_end], | ||||
), | ||||
) | ||||
.field( | ||||
"files", | ||||
&debug_bytes( | ||||
&self.bytes[self.timestamp_end + 1..self.files_end], | ||||
), | ||||
) | ||||
.field( | ||||
"description", | ||||
&debug_bytes(&self.bytes[self.files_end + 2..]), | ||||
) | ||||
.finish() | ||||
} | ||||
} | ||||
fn debug_bytes(bytes: &[u8]) -> String { | ||||
String::from_utf8_lossy( | ||||
&bytes.iter().flat_map(|b| escape_default(*b)).collect_vec(), | ||||
) | ||||
.to_string() | ||||
} | ||||
#[cfg(test)] | ||||
mod tests { | ||||
use super::*; | ||||
|
r51267 | use crate::vfs::Vfs; | ||
use crate::NULL_REVISION; | ||||
|
r49938 | use pretty_assertions::assert_eq; | ||
#[test] | ||||
fn test_create_changelogrevisiondata_invalid() { | ||||
// Completely empty | ||||
|
r49987 | assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd")).is_err()); | ||
|
r49938 | // No newline after manifest | ||
|
r49987 | assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd")).is_err()); | ||
|
r49938 | // No newline after user | ||
|
r49987 | assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd\n")).is_err()); | ||
|
r49938 | // No newline after timestamp | ||
|
r49987 | assert!( | ||
ChangelogRevisionData::new(Cow::Borrowed(b"abcd\n\n0 0")).is_err() | ||||
); | ||||
|
r49938 | // Missing newline after files | ||
|
r49987 | assert!(ChangelogRevisionData::new(Cow::Borrowed( | ||
b"abcd\n\n0 0\nfile1\nfile2" | ||||
)) | ||||
|
r49938 | .is_err(),); | ||
// Only one newline after files | ||||
|
r49987 | assert!(ChangelogRevisionData::new(Cow::Borrowed( | ||
b"abcd\n\n0 0\nfile1\nfile2\n" | ||||
)) | ||||
|
r49938 | .is_err(),); | ||
} | ||||
#[test] | ||||
fn test_create_changelogrevisiondata() { | ||||
|
r49987 | let data = ChangelogRevisionData::new(Cow::Borrowed( | ||
|
r49938 | b"0123456789abcdef0123456789abcdef01234567 | ||
Some One <someone@example.com> | ||||
0 0 | ||||
file1 | ||||
file2 | ||||
some | ||||
commit | ||||
|
r49987 | message", | ||
)) | ||||
|
r49938 | .unwrap(); | ||
assert_eq!( | ||||
data.manifest_node().unwrap(), | ||||
Node::from_hex("0123456789abcdef0123456789abcdef01234567") | ||||
.unwrap() | ||||
); | ||||
assert_eq!(data.user(), b"Some One <someone@example.com>"); | ||||
assert_eq!(data.timestamp_line(), b"0 0"); | ||||
assert_eq!( | ||||
data.files().collect_vec(), | ||||
vec![HgPath::new("file1"), HgPath::new("file2")] | ||||
); | ||||
assert_eq!(data.description(), b"some\ncommit\nmessage"); | ||||
} | ||||
|
r51267 | |||
#[test] | ||||
fn test_data_from_rev_null() -> Result<(), RevlogError> { | ||||
// an empty revlog will be enough for this case | ||||
let temp = tempfile::tempdir().unwrap(); | ||||
let vfs = Vfs { base: temp.path() }; | ||||
std::fs::write(temp.path().join("foo.i"), b"").unwrap(); | ||||
let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap(); | ||||
let changelog = Changelog { revlog }; | ||||
assert_eq!( | ||||
changelog.data_for_rev(NULL_REVISION)?, | ||||
ChangelogRevisionData::null() | ||||
); | ||||
|
r51639 | // same with the intermediate entry object | ||
assert_eq!( | ||||
changelog.entry_for_rev(NULL_REVISION)?.data()?, | ||||
ChangelogRevisionData::null() | ||||
); | ||||
|
r51267 | Ok(()) | ||
} | ||||
|
r49938 | } | ||