This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11416

rust: Rename get_node methods to data_for_node, get_rev to data_for_rev
ClosedPublic

Authored by SimonSapin on Sep 14 2021, 12:45 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG87e3f878e65f: rust: Rename get_node methods to data_for_node, get_rev to data_for_rev
Summary

These are respective methods of Changelog, Manifestlog, and Filelog;
three Rust structs that that wrap a Revlog struct.

This rename clarifies that node IDs or revision numbers are parameters,
not return values.

Also reword doc-comments in Manifestlog and Filelog to separate node IDs
and revision numbers that are local to a given (non-changelog) revlog
from those of a changeset.

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

SimonSapin created this revision.Sep 14 2021, 12:45 PM
Alphare accepted this revision.Sep 15 2021, 3:48 AM
This revision is now accepted and ready to land.Sep 15 2021, 3:48 AM

Revision Contents
Changeset List

Diff 30254

rust/hg-core/src/operations/cat.rs

for (manifest_file, node_bytes) in manifest.files_with_nodes() { for (manifest_file, node_bytes) in manifest.files_with_nodes() {
for (cat_file, is_matched) in files.iter().zip(&mut matched) { for (cat_file, is_matched) in files.iter().zip(&mut matched) {
if cat_file.as_bytes() == manifest_file.as_bytes() { if cat_file.as_bytes() == manifest_file.as_bytes() {
*is_matched = true; *is_matched = true;
found_any = true; found_any = true;
let file_log = repo.filelog(manifest_file)?; let file_log = repo.filelog(manifest_file)?;
let file_node = Node::from_hex_for_repo(node_bytes)?; let file_node = Node::from_hex_for_repo(node_bytes)?;
let entry = file_log.get_node(file_node)?; let entry = file_log.data_for_node(file_node)?;
bytes.extend(entry.data()?) bytes.extend(entry.data()?)
} }
} }
} }
let missing: Vec<_> = files let missing: Vec<_> = files
.iter() .iter()
.zip(&matched) .zip(&matched)

rust/hg-core/src/repo.rs

pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, HgError> { pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, HgError> {
self.manifestlog.get_or_init(self) self.manifestlog.get_or_init(self)
} }
pub fn manifestlog_mut(&self) -> Result<RefMut<Manifestlog>, HgError> { pub fn manifestlog_mut(&self) -> Result<RefMut<Manifestlog>, HgError> {
self.manifestlog.get_mut_or_init(self) self.manifestlog.get_mut_or_init(self)
} }
/// Returns the manifest of the given node ID /// Returns the manifest of the *changeset* with the given node ID
pub fn manifest_for_node( pub fn manifest_for_node(
&self, &self,
node: impl Into<NodePrefix>, node: impl Into<NodePrefix>,
) -> Result<Manifest, RevlogError> { ) -> Result<Manifest, RevlogError> {
self.manifestlog()?.get_node( self.manifestlog()?.data_for_node(
self.changelog()? self.changelog()?
.get_node(node.into())? .data_for_node(node.into())?
.manifest_node()? .manifest_node()?
.into(), .into(),
) )
} }
/// Returns the manifest of the given revision /// Returns the manifest of the *changeset* with the given revision number
pub fn manifest_for_rev( pub fn manifest_for_rev(
&self, &self,
revision: Revision, revision: Revision,
) -> Result<Manifest, RevlogError> { ) -> Result<Manifest, RevlogError> {
self.manifestlog()?.get_node( self.manifestlog()?.data_for_node(
self.changelog()?.get_rev(revision)?.manifest_node()?.into(), self.changelog()?
.data_for_rev(revision)?
.manifest_node()?
.into(),
) )
} }
pub fn filelog(&self, path: &HgPath) -> Result<Filelog, HgError> { pub fn filelog(&self, path: &HgPath) -> Result<Filelog, HgError> {
Filelog::open(self, path) Filelog::open(self, path)
} }
} }

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

impl Changelog { impl Changelog {
/// Open the `changelog` of a repository given by its root. /// Open the `changelog` of a repository given by its root.
pub fn open(repo: &Repo) -> Result<Self, HgError> { pub fn open(repo: &Repo) -> Result<Self, HgError> {
let revlog = Revlog::open(repo, "00changelog.i", None)?; let revlog = Revlog::open(repo, "00changelog.i", None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// Return the `ChangelogEntry` a given node id. /// Return the `ChangelogEntry` for the given node ID.
pub fn get_node( pub fn data_for_node(
&self, &self,
node: NodePrefix, node: NodePrefix,
) -> Result<ChangelogEntry, RevlogError> { ) -> Result<ChangelogEntry, RevlogError> {
let rev = self.revlog.rev_from_node(node)?; let rev = self.revlog.rev_from_node(node)?;
self.get_rev(rev) self.data_for_rev(rev)
} }
/// Return the `ChangelogEntry` of a given node revision. /// Return the `ChangelogEntry` of the given revision number.
pub fn get_rev( pub fn data_for_rev(
&self, &self,
rev: Revision, rev: Revision,
) -> Result<ChangelogEntry, RevlogError> { ) -> Result<ChangelogEntry, RevlogError> {
let bytes = self.revlog.get_rev_data(rev)?; let bytes = self.revlog.get_rev_data(rev)?;
Ok(ChangelogEntry { bytes }) Ok(ChangelogEntry { bytes })
} }
pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> { pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {

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

let index_path = store_path(file_path, b".i"); let index_path = store_path(file_path, b".i");
let data_path = store_path(file_path, b".d"); let data_path = store_path(file_path, b".d");
let revlog = Revlog::open(repo, index_path, Some(&data_path))?; let revlog = Revlog::open(repo, index_path, Some(&data_path))?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// The given node ID is that of the file as found in a manifest, not of a /// The given node ID is that of the file as found in a manifest, not of a
/// changeset. /// changeset.
pub fn get_node( pub fn data_for_node(
&self, &self,
file_node: impl Into<NodePrefix>, file_node: impl Into<NodePrefix>,
) -> Result<FilelogEntry, RevlogError> { ) -> Result<FilelogEntry, RevlogError> {
let file_rev = self.revlog.rev_from_node(file_node.into())?; let file_rev = self.revlog.rev_from_node(file_node.into())?;
self.get_rev(file_rev) self.data_for_rev(file_rev)
} }
/// The given revision is that of the file as found in a manifest, not of a /// The given revision is that of the file as found in a manifest, not of a
/// changeset. /// changeset.
pub fn get_rev( pub fn data_for_rev(
&self, &self,
file_rev: Revision, file_rev: Revision,
) -> Result<FilelogEntry, RevlogError> { ) -> Result<FilelogEntry, RevlogError> {
let data = self.revlog.get_rev_data(file_rev)?; let data = self.revlog.get_rev_data(file_rev)?;
Ok(FilelogEntry(data.into())) Ok(FilelogEntry(data.into()))
} }
} }

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

impl Manifestlog { impl Manifestlog {
/// Open the `manifest` of a repository given by its root. /// Open the `manifest` of a repository given by its root.
pub fn open(repo: &Repo) -> Result<Self, HgError> { pub fn open(repo: &Repo) -> Result<Self, HgError> {
let revlog = Revlog::open(repo, "00manifest.i", None)?; let revlog = Revlog::open(repo, "00manifest.i", None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// Return the `ManifestEntry` of a given node id. /// Return the `Manifest` for the given node ID.
pub fn get_node(&self, node: NodePrefix) -> Result<Manifest, RevlogError> { ///
/// Note: this is a node ID in the manifestlog, typically found through
/// `ChangelogEntry::manifest_node`. It is *not* the node ID of any
/// changeset.
///
/// See also `Repo::manifest_for_node`
pub fn data_for_node(
&self,
node: NodePrefix,
) -> Result<Manifest, RevlogError> {
let rev = self.revlog.rev_from_node(node)?; let rev = self.revlog.rev_from_node(node)?;
self.get_rev(rev) self.data_for_rev(rev)
} }
/// Return the `ManifestEntry` of a given node revision. /// Return the `Manifest` of a given revision number.
pub fn get_rev(&self, rev: Revision) -> Result<Manifest, RevlogError> { ///
/// Note: this is a revision number in the manifestlog, *not* of any
/// changeset.
///
/// See also `Repo::manifest_for_rev`
pub fn data_for_rev(
&self,
rev: Revision,
) -> Result<Manifest, RevlogError> {
let bytes = self.revlog.get_rev_data(rev)?; let bytes = self.revlog.get_rev_data(rev)?;
Ok(Manifest { bytes }) Ok(Manifest { bytes })
} }
} }
/// `Manifestlog` entry which knows how to interpret the `manifest` data bytes. /// `Manifestlog` entry which knows how to interpret the `manifest` data bytes.
#[derive(Debug)] #[derive(Debug)]
pub struct Manifest { pub struct Manifest {

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

self.index.len() self.index.len()
} }
/// Returns `true` if the `Revlog` has zero `entries`. /// Returns `true` if the `Revlog` has zero `entries`.
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.index.is_empty() self.index.is_empty()
} }
/// Returns the node ID for the given revision number, if it exists in this revlog /// Returns the node ID for the given revision number, if it exists in this
/// revlog
pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> { pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {
Some(self.index.get_entry(rev)?.hash()) Some(self.index.get_entry(rev)?.hash())
} }
/// Return the revision number for the given node ID, if it exists in this revlog /// Return the revision number for the given node ID, if it exists in this
/// revlog
#[timed] #[timed]
pub fn rev_from_node( pub fn rev_from_node(
&self, &self,
node: NodePrefix, node: NodePrefix,
) -> Result<Revision, RevlogError> { ) -> Result<Revision, RevlogError> {
if node.is_prefix_of(&NULL_NODE) { if node.is_prefix_of(&NULL_NODE) {
return Ok(NULL_REVISION); return Ok(NULL_REVISION);
} }

rust/rhg/src/commands/status.rs

repo: &Repo, repo: &Repo,
manifest: &Manifest, manifest: &Manifest,
hg_path: &HgPath, hg_path: &HgPath,
) -> Result<bool, HgError> { ) -> Result<bool, HgError> {
let file_node = manifest let file_node = manifest
.find_file(hg_path)? .find_file(hg_path)?
.expect("ambgious file not in p1"); .expect("ambgious file not in p1");
let filelog = repo.filelog(hg_path)?; let filelog = repo.filelog(hg_path)?;
let filelog_entry = filelog.get_node(file_node).map_err(|_| { let filelog_entry = filelog.data_for_node(file_node).map_err(|_| {
HgError::corrupted("filelog missing node from manifest") HgError::corrupted("filelog missing node from manifest")
})?; })?;
let contents_in_p1 = filelog_entry.data()?; let contents_in_p1 = filelog_entry.data()?;
let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion"); let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion");
let fs_contents = repo.working_directory_vfs().read(fs_path)?; let fs_contents = repo.working_directory_vfs().read(fs_path)?;
return Ok(contents_in_p1 == &*fs_contents); return Ok(contents_in_p1 == &*fs_contents);
} }