This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12438

rust-changelog: remove special parsing of empty changelog data for null rev
ClosedPublic

Authored by martinvonz on Apr 5 2022, 2:11 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGcc132255261b: rust-changelog: remove special parsing of empty changelog data for null rev
Summary

For the null revision, Revlog::get_rev_data() will return an empty
string (of bytes). We currently handle that case in
ChangelogRevisionData::manifest_node(). However, it's going to be
ugly to have special handling for the null revision for each future
method on ChangelogRevisionData. This patch therefore restructures
the code so we instead initialize the struct with valid data for the
null revision.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Apr 5 2022, 2:11 PM
Alphare accepted this revision.Apr 6 2022, 6:55 AM
This revision is now accepted and ready to land.Apr 6 2022, 6:55 AM
martinvonz retitled this revision from rhg: remove special parsing of empty changelog data for null rev to rust-changelog: remove special parsing of empty changelog data for null rev.Apr 9 2022, 1:35 AM
martinvonz updated this revision to Diff 33150.Apr 13 2022, 9:10 AM

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/revlog/changelog.rs (23 lines)

Diff 33143

rust/hg-core/src/revlog/changelog.rs

use crate::errors::HgError; use crate::errors::HgError;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::node::NULL_NODE;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::revlog::{Node, NodePrefix}; use crate::revlog::{Node, NodePrefix};
/// A specialized `Revlog` to work with `changelog` data format. /// A specialized `Revlog` to work with `changelog` data format.
pub struct Changelog { pub struct Changelog {
/// The generic `revlog` format. /// The generic `revlog` format.
pub(crate) revlog: Revlog, pub(crate) revlog: Revlog,
} }
/// Return the `ChangelogEntry` of the given revision number. /// Return the `ChangelogEntry` of the given revision number.
pub fn data_for_rev( pub fn data_for_rev(
&self, &self,
rev: Revision, rev: Revision,
) -> Result<ChangelogRevisionData, RevlogError> { ) -> Result<ChangelogRevisionData, RevlogError> {
let bytes = self.revlog.get_rev_data(rev)?.into_owned(); let bytes = self.revlog.get_rev_data(rev)?.into_owned();
Ok(ChangelogRevisionData { bytes }) if bytes.is_empty() {
Ok(ChangelogRevisionData::null())
} else {
Ok(ChangelogRevisionData::new(bytes))
}
} }
pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> { pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {
self.revlog.node_from_rev(rev) self.revlog.node_from_rev(rev)
} }
} }
/// `Changelog` entry which knows how to interpret the `changelog` data bytes. /// `Changelog` entry which knows how to interpret the `changelog` data bytes.
#[derive(Debug)] #[derive(Debug)]
pub struct ChangelogRevisionData { pub struct ChangelogRevisionData {
/// The data bytes of the `changelog` entry. /// The data bytes of the `changelog` entry.
bytes: Vec<u8>, bytes: Vec<u8>,
} }
impl ChangelogRevisionData { impl ChangelogRevisionData {
fn new(bytes: Vec<u8>) -> Self {
Self { bytes }
}
fn null() -> Self {
Self::new(
b"0000000000000000000000000000000000000000\n\n0 0\n\n".to_vec(),
)
}
/// Return an iterator over the lines of the entry. /// Return an iterator over the lines of the entry.
pub fn lines(&self) -> impl Iterator<Item = &[u8]> { pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
self.bytes.split(|b| b == &b'\n') self.bytes.split(|b| b == &b'\n')
} }
/// Return the node id of the `manifest` referenced by this `changelog` /// Return the node id of the `manifest` referenced by this `changelog`
/// entry. /// entry.
pub fn manifest_node(&self) -> Result<Node, HgError> { pub fn manifest_node(&self) -> Result<Node, HgError> {
let manifest_node_hex = let manifest_node_hex =
self.lines().next().expect("Empty iterator from split()?"); self.lines().next().expect("Empty iterator from split()?");
if manifest_node_hex.is_empty() {
Ok(NULL_NODE)
} else {
Node::from_hex_for_repo(manifest_node_hex) Node::from_hex_for_repo(manifest_node_hex)
} }
} }
}