( )⚙ D11772 rhg: Also parse flags in the manifest parser

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11772

rhg: Also parse flags in the manifest parser
ClosedPublic

Authored by SimonSapin on Nov 23 2021, 2:10 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGeb428010aad2: rhg: Also parse flags in the manifest parser

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Nov 23 2021, 2:10 PM
Alphare accepted this revision.Nov 24 2021, 6:32 AM
This revision is now accepted and ready to land.Nov 24 2021, 6:32 AM
SimonSapin added a commit: rHGeb428010aad2: rhg: Also parse flags in the manifest parser.Nov 26 2021, 10:03 AM
Closed by commit rHGeb428010aad2: rhg: Also parse flags in the manifest parser (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.
baymax updated this revision to Diff 31163.Nov 26 2021, 10:33 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 31094

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 crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::errors::HgError; use crate::errors::HgError;
use crate::manifest::Manifest;
use crate::manifest::ManifestEntry;
use itertools::put_back; use itertools::put_back;
use itertools::PutBack; use itertools::PutBack;
use std::cmp::Ordering; use std::cmp::Ordering;
pub struct CatOutput<'a> { pub struct CatOutput<'a> {
/// Whether any file in the manifest matched the paths given as CLI /// Whether any file in the manifest matched the paths given as CLI
/// arguments /// arguments
pub found_any: bool, pub found_any: bool,
/// The contents of matching files, in manifest order /// The contents of matching files, in manifest order
pub results: Vec<(&'a HgPath, Vec<u8>)>, pub results: Vec<(&'a HgPath, Vec<u8>)>,
/// Which of the CLI arguments did not match any manifest file /// Which of the CLI arguments did not match any manifest file
pub missing: Vec<&'a HgPath>, pub missing: Vec<&'a HgPath>,
/// The node ID that the given revset was resolved to /// The node ID that the given revset was resolved to
pub node: Node, pub node: Node,
} }
// Find an item in an iterator over a sorted collection. // Find an item in an iterator over a sorted collection.
fn find_item<'a, D, I: Iterator<Item = Result<(&'a HgPath, D), HgError>>>( fn find_item<'a>(
i: &mut PutBack<I>, i: &mut PutBack<impl Iterator<Item = Result<ManifestEntry<'a>, HgError>>>,
needle: &HgPath, needle: &HgPath,
) -> Result<Option<D>, HgError> { ) -> Result<Option<Node>, HgError> {
loop { loop {
match i.next() { match i.next() {
None => return Ok(None), None => return Ok(None),
Some(result) => { Some(result) => {
let (path, value) = result?; let entry = result?;
match needle.as_bytes().cmp(path.as_bytes()) { match needle.as_bytes().cmp(entry.path.as_bytes()) {
Ordering::Less => { Ordering::Less => {
i.put_back(Ok((path, value))); i.put_back(Ok(entry));
return Ok(None); return Ok(None);
} }
Ordering::Greater => continue, Ordering::Greater => continue,
Ordering::Equal => return Ok(Some(value)), Ordering::Equal => return Ok(Some(entry.node_id()?)),
} }
} }
} }
} }
} }
fn find_files_in_manifest< fn find_files_in_manifest<'query>(
'manifest, manifest: &Manifest,
'query, query: impl Iterator<Item = &'query HgPath>,
Data, ) -> Result<(Vec<(&'query HgPath, Node)>, Vec<&'query HgPath>), HgError> {
Manifest: Iterator<Item = Result<(&'manifest HgPath, Data), HgError>>, let mut manifest = put_back(manifest.iter());
Query: Iterator<Item = &'query HgPath>,
>(
manifest: Manifest,
query: Query,
) -> Result<(Vec<(&'query HgPath, Data)>, Vec<&'query HgPath>), HgError> {
let mut manifest = put_back(manifest);
let mut res = vec![]; let mut res = vec![];
let mut missing = vec![]; let mut missing = vec![];
for file in query { for file in query {
match find_item(&mut manifest, file)? { match find_item(&mut manifest, file)? {
None => missing.push(file), None => missing.push(file),
Some(item) => res.push((file, item)), Some(item) => res.push((file, item)),
} }
.node_from_rev(rev) .node_from_rev(rev)
.expect("should succeed when repo.manifest did"); .expect("should succeed when repo.manifest did");
let mut results: Vec<(&'a HgPath, Vec<u8>)> = vec![]; let mut results: Vec<(&'a HgPath, Vec<u8>)> = vec![];
let mut found_any = false; let mut found_any = false;
files.sort_unstable(); files.sort_unstable();
let (found, missing) = find_files_in_manifest( let (found, missing) = find_files_in_manifest(
manifest.files_with_nodes(), &manifest,
files.into_iter().map(|f| f.as_ref()), files.into_iter().map(|f| f.as_ref()),
)?; )?;
for (file_path, node_bytes) in found { for (file_path, file_node) in found {
found_any = true; found_any = true;
let file_log = repo.filelog(file_path)?; let file_log = repo.filelog(file_path)?;
let file_node = Node::from_hex_for_repo(node_bytes)?;
results.push(( results.push((
file_path, file_path,
file_log.data_for_node(file_node)?.into_data()?, file_log.data_for_node(file_node)?.into_data()?,
)); ));
} }
Ok(CatOutput { Ok(CatOutput {
found_any, found_any,
results, results,
missing, missing,
node, node,
}) })
} }

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

let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
Ok(FilesForRev(repo.manifest_for_rev(rev)?)) Ok(FilesForRev(repo.manifest_for_rev(rev)?))
} }
pub struct FilesForRev(Manifest); pub struct FilesForRev(Manifest);
impl FilesForRev { impl FilesForRev {
pub fn iter(&self) -> impl Iterator<Item = Result<&HgPath, HgError>> { pub fn iter(&self) -> impl Iterator<Item = Result<&HgPath, HgError>> {
self.0.files() self.0.iter().map(|entry| Ok(entry?.path))
} }
} }

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

use crate::errors::HgError; use crate::errors::HgError;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::revlog::{Node, NodePrefix}; use crate::revlog::{Node, NodePrefix};
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::utils::SliceExt;
/// A specialized `Revlog` to work with `manifest` data format. /// A specialized `Revlog` to work with `manifest` data format.
pub struct Manifestlog { pub struct Manifestlog {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, revlog: Revlog,
} }
impl Manifestlog { impl Manifestlog {
/// `Manifestlog` 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 Manifest { pub struct Manifest {
bytes: Vec<u8>, bytes: Vec<u8>,
} }
impl Manifest { impl Manifest {
/// Return an iterator over the lines of the entry. pub fn iter(
pub fn lines(&self) -> impl Iterator<Item = &[u8]> { &self,
) -> impl Iterator<Item = Result<ManifestEntry, HgError>> {
self.bytes self.bytes
.split(|b| b == &b'\n') .split(|b| b == &b'\n')
.filter(|line| !line.is_empty()) .filter(|line| !line.is_empty())
} .map(|line| {
let (path, rest) = line.split_2(b'\0').ok_or_else(|| {
/// Return an iterator over the files of the entry.
pub fn files(&self) -> impl Iterator<Item = Result<&HgPath, HgError>> {
self.lines().filter(|line| !line.is_empty()).map(|line| {
let pos =
line.iter().position(|x| x == &b'\0').ok_or_else(|| {
HgError::corrupted("manifest line should contain \\0") HgError::corrupted("manifest line should contain \\0")
})?; })?;
Ok(HgPath::new(&line[..pos])) let path = HgPath::new(path);
let (hex_node_id, flags) = match rest.split_last() {
Some((&b'x', rest)) => (rest, Some(b'x')),
Some((&b'l', rest)) => (rest, Some(b'l')),
Some((&b't', rest)) => (rest, Some(b't')),
_ => (rest, None),
};
Ok(ManifestEntry {
path,
hex_node_id,
flags,
}) })
}
/// Return an iterator over the files of the entry.
pub fn files_with_nodes(
&self,
) -> impl Iterator<Item = Result<(&HgPath, &[u8]), HgError>> {
self.lines().filter(|line| !line.is_empty()).map(|line| {
let pos =
line.iter().position(|x| x == &b'\0').ok_or_else(|| {
HgError::corrupted("manifest line should contain \\0")
})?;
let hash_start = pos + 1;
let hash_end = hash_start + 40;
Ok((HgPath::new(&line[..pos]), &line[hash_start..hash_end]))
}) })
} }
/// If the given path is in this manifest, return its filelog node ID /// If the given path is in this manifest, return its filelog node ID
pub fn find_file(&self, path: &HgPath) -> Result<Option<Node>, HgError> { pub fn find_file(
&self,
path: &HgPath,
) -> Result<Option<ManifestEntry>, HgError> {
// TODO: use binary search instead of linear scan. This may involve // TODO: use binary search instead of linear scan. This may involve
// building (and caching) an index of the byte indicex of each manifest // building (and caching) an index of the byte indicex of each manifest
// line. // line.
for entry in self.files_with_nodes() {
let (manifest_path, node) = entry?; // TODO: use try_find when available (if still using linear scan)
if manifest_path == path { // https://github.com/rust-lang/rust/issues/63178
return Ok(Some(Node::from_hex_for_repo(node)?)); for entry in self.iter() {
let entry = entry?;
if entry.path == path {
return Ok(Some(entry));
} }
} }
Ok(None) Ok(None)
} }
} }
/// `Manifestlog` entry which knows how to interpret the `manifest` data bytes.
#[derive(Debug)]
pub struct ManifestEntry<'manifest> {
pub path: &'manifest HgPath,
pub hex_node_id: &'manifest [u8],
/// `Some` values are b'x', b'l', or 't'
pub flags: Option<u8>,
}
impl ManifestEntry<'_> {
pub fn node_id(&self) -> Result<Node, HgError> {
Node::from_hex_for_repo(self.hex_node_id)
}
}

rust/rhg/src/commands/status.rs

/// to time resolution limits. /// to time resolution limits.
/// ///
/// TODO: detect permission bits and similar metadata modifications /// TODO: detect permission bits and similar metadata modifications
fn cat_file_is_modified( fn cat_file_is_modified(
repo: &Repo, repo: &Repo,
manifest: &Manifest, manifest: &Manifest,
hg_path: &HgPath, hg_path: &HgPath,
) -> Result<bool, HgError> { ) -> Result<bool, HgError> {
let file_node = manifest let entry = manifest
.find_file(hg_path)? .find_file(hg_path)?
.expect("ambgious file not in p1"); .expect("ambgious file not in p1");
let filelog = repo.filelog(hg_path)?; let filelog = repo.filelog(hg_path)?;
let filelog_entry = filelog.data_for_node(file_node).map_err(|_| { let filelog_entry =
filelog.data_for_node(entry.node_id()?).map_err(|_| {
HgError::corrupted("filelog missing node from manifest") HgError::corrupted("filelog missing node from manifest")
})?; })?;
let contents_in_p1 = filelog_entry.data()?; let contents_in_p1 = filelog_entry.data()?;
let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion"); let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion");
let fs_contents = repo.working_directory_vfs().read(fs_path)?; let fs_contents = repo.working_directory_vfs().read(fs_path)?;
return Ok(contents_in_p1 != &*fs_contents); return Ok(contents_in_p1 != &*fs_contents);
} }