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

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

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

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

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

rust/hg-core/src/revlog.rs

@@ -1,64 +1,65 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 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>;
 }