This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9011

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

Authored by acezar on Sep 11 2020, 3:53 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG89ac95bd4993: hg-core: add `Manifest` a specialized `Revlog`
Summary

A facade to Revlog to provide a manifest specific interface.

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

acezar created this revision.Sep 11 2020, 3:53 AM
Alphare accepted this revision.Sep 17 2020, 6:02 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/hg-core/src/revlog/manifest.rs
37

Same nit: s/know/knows/

acezar updated this revision to Diff 22722.Sep 18 2020, 10:48 AM
acezar updated this revision to Diff 22727.Sep 18 2020, 10:54 AM
acezar marked an inline comment as done.Sep 18 2020, 10:55 AM
acezar added a commit: rHG89ac95bd4993: hg-core: add `Manifest` a specialized `Revlog`.Sep 23 2020, 10:57 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG89ac95bd4993: hg-core: add `Manifest` a specialized `Revlog` (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22792

rust/hg-core/src/revlog.rs

// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
// and Mercurial contributors // and Mercurial contributors
// //
// 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.
//! Mercurial concepts for handling revision history //! Mercurial concepts for handling revision history
pub mod node; pub mod node;
pub mod nodemap; pub mod nodemap;
pub use node::{Node, NodeError, NodePrefix, NodePrefixRef}; pub use node::{Node, NodeError, NodePrefix, NodePrefixRef};
pub mod changelog; pub mod changelog;
pub mod index; pub mod index;
pub mod manifest;
pub mod patch; pub mod patch;
pub mod revlog; pub mod revlog;
/// Mercurial revision numbers /// Mercurial revision numbers
/// ///
/// As noted in revlog.c, revision numbers are actually encoded in /// As noted in revlog.c, revision numbers are actually encoded in
/// 4 bytes, and are liberally converted to ints, whence the i32 /// 4 bytes, and are liberally converted to ints, whence the i32
pub type Revision = i32; pub type Revision = i32;

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

  • This file was added.
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)]
AlphareUnsubmitted
Done

Same nit: s/know/knows/

Alphare: Same nit: s/know/knows/
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])
})
}
}