hg-core: add `Manifest` a specialized `Revlog`

A facade to `Revlog` to provide a `manifest` specific interface.

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

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

@@ -0,0 +1,60 b''
+use crate::revlog::revlog::{Revlog, RevlogError};
+use crate::revlog::Revision;
+use crate::utils::hg_path::HgPath;
+use std::path::PathBuf;
+
+/// A specialized `Revlog` to work with `manifest` data format.
+pub struct Manifest {
+    /// The generic `revlog` format.
+    revlog: Revlog,
+}
+
+impl Manifest {
+    /// Open the `manifest` of a repository given by its root.
+    pub fn open(root: &PathBuf) -> Result<Self, RevlogError> {
+        let index_file = root.join(".hg/store/00manifest.i");
+        let revlog = Revlog::open(&index_file)?;
+        Ok(Self { revlog })
+    }
+
+    /// Return the `ManifestEntry` of a given node id.
+    pub fn get_node(&self, node: &[u8]) -> Result<ManifestEntry, 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> {
+        let bytes = self.revlog.get_rev_data(rev)?;
+        Ok(ManifestEntry { bytes })
+    }
+}
+
+/// `Manifest` entry which knows how to interpret the `manifest` data bytes.
+#[derive(Debug)]
+pub struct ManifestEntry {
+    bytes: Vec<u8>,
+}
+
+impl ManifestEntry {
+    /// 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])
+        })
+    }
+}

rust/hg-core/src/revlog.rs

@@ -1,65 +1,66 b''
 // Copyright 2018-2020 Georges Racinet <[e-mail]>
 //           and Mercurial contributors
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 //! Mercurial concepts for handling revision history
 
 pub mod node;
 pub mod nodemap;
 pub use node::{Node, NodeError, NodePrefix, NodePrefixRef};
 pub mod changelog;
 pub mod index;
+pub mod manifest;
 pub mod patch;
 pub mod revlog;
 
 /// Mercurial revision numbers
 ///
 /// As noted in revlog.c, revision numbers are actually encoded in
 /// 4 bytes, and are liberally converted to ints, whence the i32
 pub type Revision = i32;
 
 /// Marker expressing the absence of a parent
 ///
 /// Independently of the actual representation, `NULL_REVISION` is guaranteed
 /// to be smaller than all existing revisions.
 pub const NULL_REVISION: Revision = -1;
 
 /// Same as `mercurial.node.wdirrev`
 ///
 /// This is also equal to `i32::max_value()`, but it's better to spell
 /// it out explicitely, same as in `mercurial.node`
 #[allow(clippy::unreadable_literal)]
 pub const WORKING_DIRECTORY_REVISION: Revision = 0x7fffffff;
 
 /// The simplest expression of what we need of Mercurial DAGs.
 pub trait Graph {
     /// Return the two parents of the given `Revision`.
     ///
     /// Each of the parents can be independently `NULL_REVISION`
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError>;
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum GraphError {
     ParentOutOfRange(Revision),
     WorkingDirectoryUnsupported,
 }
 
 /// The Mercurial Revlog Index
 ///
 /// This is currently limited to the minimal interface that is needed for
 /// the [`nodemap`](nodemap/index.html) module
 pub trait RevlogIndex {
     /// Total number of Revisions referenced in this index
     fn len(&self) -> usize;
 
     fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     /// Return a reference to the Node or `None` if rev is out of bounds
     ///
     /// `NULL_REVISION` is not considered to be out of bounds.
     fn node(&self, rev: Revision) -> Option<&Node>;
 }