rust: Rename Manifest to Manifestlog, ManifestEntry to Manifest

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

Differential Revision: https://phab.mercurial-scm.org/D11404

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

@@ -1,105 +1,105 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use std::path::PathBuf;
 
 use crate::repo::Repo;
 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::revlog::Revlog;
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Node;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 
 pub struct CatOutput {
     /// Whether any file in the manifest matched the paths given as CLI
     /// arguments
     pub found_any: bool,
     /// The contents of matching files, in manifest order
     pub concatenated: Vec<u8>,
     /// Which of the CLI arguments did not match any manifest file
     pub missing: Vec<HgPathBuf>,
     /// The node ID that the given revset was resolved to
     pub node: Node,
 }
 
 const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
 
 /// Output the given revision of files
 ///
 /// * `root`: Repository root
 /// * `rev`: The revision to cat the files from.
 /// * `files`: The files to output.
 pub fn cat<'a>(
     repo: &Repo,
     revset: &str,
     files: &'a [HgPathBuf],
 ) -> Result<CatOutput, RevlogError> {
     let rev = crate::revset::resolve_single(revset, repo)?;
     let changelog = Changelog::open(repo)?;
-    let manifest = Manifest::open(repo)?;
+    let manifest = Manifestlog::open(repo)?;
     let changelog_entry = changelog.get_rev(rev)?;
     let node = *changelog
         .node_from_rev(rev)
         .expect("should succeed when changelog.get_rev did");
     let manifest_node =
         Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
     let manifest_entry = manifest.get_node(manifest_node.into())?;
     let mut bytes = vec![];
     let mut matched = vec![false; files.len()];
     let mut found_any = false;
 
     for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() {
         for (cat_file, is_matched) in files.iter().zip(&mut matched) {
             if cat_file.as_bytes() == manifest_file.as_bytes() {
                 *is_matched = true;
                 found_any = true;
                 let index_path = store_path(manifest_file, b".i");
                 let data_path = store_path(manifest_file, b".d");
 
                 let file_log =
                     Revlog::open(repo, &index_path, Some(&data_path))?;
                 let file_node = Node::from_hex_for_repo(node_bytes)?;
                 let file_rev = file_log.get_node_rev(file_node.into())?;
                 let data = file_log.get_rev_data(file_rev)?;
                 if data.starts_with(&METADATA_DELIMITER) {
                     let end_delimiter_position = data
                         [METADATA_DELIMITER.len()..]
                         .windows(METADATA_DELIMITER.len())
                         .position(|bytes| bytes == METADATA_DELIMITER);
                     if let Some(position) = end_delimiter_position {
                         let offset = METADATA_DELIMITER.len() * 2;
                         bytes.extend(data[position + offset..].iter());
                     }
                 } else {
                     bytes.extend(data);
                 }
             }
         }
     }
 
     let missing: Vec<_> = files
         .iter()
         .zip(&matched)
         .filter(|pair| !*pair.1)
         .map(|pair| pair.0.clone())
         .collect();
     Ok(CatOutput {
         found_any,
         concatenated: bytes,
         missing,
         node,
     })
 }
 
 fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
     let encoded_bytes =
         path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
     get_path_from_bytes(&encoded_bytes).into()
 }

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

@@ -1,90 +1,90 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::dirstate::parsers::parse_dirstate_entries;
 use crate::dirstate_tree::on_disk::{for_each_tracked_path, read_docket};
 use crate::errors::HgError;
 use crate::repo::Repo;
 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::revlog::RevlogError;
 use crate::utils::hg_path::HgPath;
 use crate::DirstateError;
 use rayon::prelude::*;
 
 /// List files under Mercurial control in the working directory
 /// by reading the dirstate
 pub struct Dirstate {
     /// The `dirstate` content.
     content: Vec<u8>,
     v2_metadata: Option<Vec<u8>>,
 }
 
 impl Dirstate {
     pub fn new(repo: &Repo) -> Result<Self, HgError> {
         let mut content = repo.hg_vfs().read("dirstate")?;
         let v2_metadata = if repo.has_dirstate_v2() {
             let docket = read_docket(&content)?;
             let meta = docket.tree_metadata().to_vec();
             content = repo.hg_vfs().read(docket.data_filename())?;
             Some(meta)
         } else {
             None
         };
         Ok(Self {
             content,
             v2_metadata,
         })
     }
 
     pub fn tracked_files(&self) -> Result<Vec<&HgPath>, DirstateError> {
         let mut files = Vec::new();
         if !self.content.is_empty() {
             if let Some(meta) = &self.v2_metadata {
                 for_each_tracked_path(&self.content, meta, |path| {
                     files.push(path)
                 })?
             } else {
                 let _parents = parse_dirstate_entries(
                     &self.content,
                     |path, entry, _copy_source| {
                         if entry.state.is_tracked() {
                             files.push(path)
                         }
                         Ok(())
                     },
                 )?;
             }
         }
         files.par_sort_unstable();
         Ok(files)
     }
 }
 
 /// List files under Mercurial control at a given revision.
 pub fn list_rev_tracked_files(
     repo: &Repo,
     revset: &str,
 ) -> Result<FilesForRev, RevlogError> {
     let rev = crate::revset::resolve_single(revset, repo)?;
     let changelog = Changelog::open(repo)?;
-    let manifest = Manifest::open(repo)?;
+    let manifest = Manifestlog::open(repo)?;
     let changelog_entry = changelog.get_rev(rev)?;
     let manifest_node =
         Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
     let manifest_entry = manifest.get_node(manifest_node.into())?;
     Ok(FilesForRev(manifest_entry))
 }
 
-pub struct FilesForRev(ManifestEntry);
+pub struct FilesForRev(Manifest);
 
 impl FilesForRev {
     pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
         self.0.files()
     }
 }

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

@@ -1,76 +1,70 b''
 use crate::repo::Repo;
 use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::NodePrefix;
 use crate::revlog::Revision;
 use crate::utils::hg_path::HgPath;
 
 /// A specialized `Revlog` to work with `manifest` data format.
-pub struct Manifest {
+pub struct Manifestlog {
     /// The generic `revlog` format.
     revlog: Revlog,
 }
 
-impl Manifest {
+impl Manifestlog {
     /// Open the `manifest` of a repository given by its root.
     pub fn open(repo: &Repo) -> Result<Self, RevlogError> {
         let revlog = Revlog::open(repo, "00manifest.i", None)?;
         Ok(Self { revlog })
     }
 
     /// Return the `ManifestEntry` of a given node id.
-    pub fn get_node(
-        &self,
-        node: NodePrefix,
-    ) -> Result<ManifestEntry, RevlogError> {
+    pub fn get_node(&self, node: NodePrefix) -> Result<Manifest, RevlogError> {
         let rev = self.revlog.get_node_rev(node)?;
         self.get_rev(rev)
     }
 
     /// Return the `ManifestEntry` of a given node revision.
-    pub fn get_rev(
-        &self,
-        rev: Revision,
-    ) -> Result<ManifestEntry, RevlogError> {
+    pub fn get_rev(&self, rev: Revision) -> Result<Manifest, RevlogError> {
         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)]
-pub struct ManifestEntry {
+pub struct Manifest {
     bytes: Vec<u8>,
 }
 
-impl ManifestEntry {
+impl Manifest {
     /// Return an iterator over the lines of the entry.
     pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
         self.bytes
             .split(|b| b == &b'\n')
             .filter(|line| !line.is_empty())
     }
 
     /// Return an iterator over the files of the entry.
     pub fn files(&self) -> impl Iterator<Item = &HgPath> {
         self.lines().filter(|line| !line.is_empty()).map(|line| {
             let pos = line
                 .iter()
                 .position(|x| x == &b'\0')
                 .expect("manifest line should contain \\0");
             HgPath::new(&line[..pos])
         })
     }
 
     /// Return an iterator over the files of the entry.
     pub fn files_with_nodes(&self) -> impl Iterator<Item = (&HgPath, &[u8])> {
         self.lines().filter(|line| !line.is_empty()).map(|line| {
             let pos = line
                 .iter()
                 .position(|x| x == &b'\0')
                 .expect("manifest line should contain \\0");
             let hash_start = pos + 1;
             let hash_end = hash_start + 40;
             (HgPath::new(&line[..pos]), &line[hash_start..hash_end])
         })
     }
 }