( )⚙ D11404 rust: Rename Manifest to Manifestlog, ManifestEntry to Manifest

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11404

rust: Rename Manifest to Manifestlog, ManifestEntry to Manifest
ClosedPublic

Authored by SimonSapin on Sep 13 2021, 2:13 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGd44740725b95: rust: Rename Manifest to Manifestlog, ManifestEntry to Manifest
Summary

This appears to match the terminology used in Python code
and on https://www.mercurial-scm.org/wiki/Manifest

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.

Revision Contents
Changeset List

Diff 30232

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

// list_tracked_files.rs // list_tracked_files.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use std::path::PathBuf; use std::path::PathBuf;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::Manifest; use crate::revlog::manifest::Manifestlog;
use crate::revlog::path_encode::path_encode; use crate::revlog::path_encode::path_encode;
use crate::revlog::revlog::Revlog; use crate::revlog::revlog::Revlog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
pub struct CatOutput { pub struct CatOutput {
/// * `files`: The files to output. /// * `files`: The files to output.
pub fn cat<'a>( pub fn cat<'a>(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
files: &'a [HgPathBuf], files: &'a [HgPathBuf],
) -> Result<CatOutput, RevlogError> { ) -> Result<CatOutput, RevlogError> {
let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
let changelog = Changelog::open(repo)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(repo)?; let manifest = Manifestlog::open(repo)?;
let changelog_entry = changelog.get_rev(rev)?; let changelog_entry = changelog.get_rev(rev)?;
let node = *changelog let node = *changelog
.node_from_rev(rev) .node_from_rev(rev)
.expect("should succeed when changelog.get_rev did"); .expect("should succeed when changelog.get_rev did");
let manifest_node = let manifest_node =
Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?; Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
let mut bytes = vec![]; let mut bytes = vec![];

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

// list_tracked_files.rs // list_tracked_files.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::dirstate::parsers::parse_dirstate_entries; use crate::dirstate::parsers::parse_dirstate_entries;
use crate::dirstate_tree::on_disk::{for_each_tracked_path, read_docket}; use crate::dirstate_tree::on_disk::{for_each_tracked_path, read_docket};
use crate::errors::HgError; use crate::errors::HgError;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::{Manifest, ManifestEntry}; use crate::revlog::manifest::{Manifest, Manifestlog};
use crate::revlog::node::Node; use crate::revlog::node::Node;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::DirstateError; use crate::DirstateError;
use rayon::prelude::*; use rayon::prelude::*;
/// List files under Mercurial control in the working directory /// List files under Mercurial control in the working directory
/// by reading the dirstate /// by reading the dirstate
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
pub fn list_rev_tracked_files( pub fn list_rev_tracked_files(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
) -> Result<FilesForRev, RevlogError> { ) -> Result<FilesForRev, RevlogError> {
let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
let changelog = Changelog::open(repo)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(repo)?; let manifest = Manifestlog::open(repo)?;
let changelog_entry = changelog.get_rev(rev)?; let changelog_entry = changelog.get_rev(rev)?;
let manifest_node = let manifest_node =
Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?; Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
Ok(FilesForRev(manifest_entry)) Ok(FilesForRev(manifest_entry))
} }
pub struct FilesForRev(ManifestEntry); pub struct FilesForRev(Manifest);
impl FilesForRev { impl FilesForRev {
pub fn iter(&self) -> impl Iterator<Item = &HgPath> { pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
self.0.files() self.0.files()
} }
} }

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

use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix; use crate::revlog::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
/// A specialized `Revlog` to work with `manifest` data format. /// A specialized `Revlog` to work with `manifest` data format.
pub struct Manifest { pub struct Manifestlog {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, revlog: Revlog,
} }
impl Manifest { 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, RevlogError> { pub fn open(repo: &Repo) -> Result<Self, RevlogError> {
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 `ManifestEntry` of a given node id.
pub fn get_node( pub fn get_node(&self, node: NodePrefix) -> Result<Manifest, RevlogError> {
&self,
node: NodePrefix,
) -> Result<ManifestEntry, RevlogError> {
let rev = self.revlog.get_node_rev(node)?; let rev = self.revlog.get_node_rev(node)?;
self.get_rev(rev) self.get_rev(rev)
} }
/// Return the `ManifestEntry` of a given node revision. /// Return the `ManifestEntry` of a given node revision.
pub fn get_rev( pub fn get_rev(&self, rev: Revision) -> Result<Manifest, RevlogError> {
&self,
rev: Revision,
) -> Result<ManifestEntry, RevlogError> {
let bytes = self.revlog.get_rev_data(rev)?; let bytes = self.revlog.get_rev_data(rev)?;
Ok(ManifestEntry { bytes }) Ok(Manifest { bytes })
} }
} }
/// `Manifest` 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 ManifestEntry { pub struct Manifest {
bytes: Vec<u8>, bytes: Vec<u8>,
} }
impl ManifestEntry { impl Manifest {
/// 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 self.bytes
.split(|b| b == &b'\n') .split(|b| b == &b'\n')
.filter(|line| !line.is_empty()) .filter(|line| !line.is_empty())
} }
/// Return an iterator over the files of the entry. /// Return an iterator over the files of the entry.