( )⚙ D11622 dirstate: simplify cat operation

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11622

dirstate: simplify cat operation
AbandonedPublic

Authored by martinvonz on Oct 8 2021, 8:16 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers

Diff Detail

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

Event Timeline

martinvonz created this revision.Oct 8 2021, 8:16 PM
martinvonz added a parent revision: D11616: rhg: stop manifest traversal when no more files are needed.Oct 8 2021, 8:42 PM
martinvonz added a subscriber: aalekseyev.

This is not meant to be queued, it was just meant to show @aalekseyev how I thought we could simplify

rust/hg-core/src/operations/cat.rs
60–61

Oops, I missed a .sorted() here

martinvonz abandoned this revision.Oct 14 2021, 11:04 AM

Revision Contents
Changeset List

Diff 30695

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::HgPathBuf; use crate::utils::hg_path::HgPathBuf;
use itertools::put_back; use std::collections::HashSet;
use itertools::PutBack;
use std::cmp::Ordering;
pub struct CatOutput { pub struct CatOutput {
/// 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 concatenated: Vec<u8>, pub concatenated: 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<HgPathBuf>, pub missing: Vec<HgPathBuf>,
/// 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.
fn find_item<'a, 'b, 'c, D, I: Iterator<Item = (&'a HgPath, D)>>(
i: &mut PutBack<I>,
needle: &'b HgPath,
) -> Option<I::Item> {
loop {
match i.next() {
None => return None,
Some(val) => match needle.as_bytes().cmp(val.0.as_bytes()) {
Ordering::Less => {
i.put_back(val);
return None;
}
Ordering::Greater => continue,
Ordering::Equal => return Some(val),
},
}
}
}
fn find_files_in_manifest<
'a,
'b,
D,
I: Iterator<Item = (&'a HgPath, D)>,
J: Iterator<Item = &'b HgPath>,
>(
manifest: I,
files: J,
) -> (Vec<(&'a HgPath, D)>, Vec<&'b HgPath>) {
let mut manifest = put_back(manifest);
let mut res = vec![];
let mut missing = vec![];
for file in files {
match find_item(&mut manifest, file) {
None => missing.push(file),
Some(item) => res.push(item),
}
}
return (res, missing);
}
/// Output the given revision of files /// Output the given revision of files
/// ///
/// * `root`: Repository root /// * `root`: Repository root
/// * `rev`: The revision to cat the files from. /// * `rev`: The revision to cat the files from.
/// * `files`: The files to output. /// * `files`: The files to output.
pub fn cat<'a>( pub fn cat<'a>(
repo: &Repo, repo: &Repo,
revset: &str, revset: &str,
mut files: Vec<HgPathBuf>, files: &[HgPathBuf],
) -> Result<CatOutput, RevlogError> { ) -> Result<CatOutput, RevlogError> {
let rev = crate::revset::resolve_single(revset, repo)?; let rev = crate::revset::resolve_single(revset, repo)?;
let manifest = repo.manifest_for_rev(rev)?; let manifest = repo.manifest_for_rev(rev)?;
let node = *repo let node = *repo
.changelog()? .changelog()?
.node_from_rev(rev) .node_from_rev(rev)
.expect("should succeed when repo.manifest did"); .expect("should succeed when repo.manifest did");
let mut bytes: Vec<u8> = vec![];
let mut found_any = false;
files.sort_unstable();
let (found, missing) = find_files_in_manifest( let mut missing: HashSet<_> = files.iter().map(|x| x.as_ref()).collect();
manifest.files_with_nodes(), let mut bytes: Vec<u8> = vec![];
files.iter().map(|f| f.as_ref()), if let Some(last_path) = files.iter().max() {
); for (path, node_bytes) in manifest.files_with_nodes() {
if missing.remove(&*path) {
for (manifest_file, node_bytes) in found { let file_log = repo.filelog(path)?;
found_any = true;
let file_log = repo.filelog(manifest_file)?;
let file_node = Node::from_hex_for_repo(node_bytes)?; let file_node = Node::from_hex_for_repo(node_bytes)?;
bytes.extend(file_log.data_for_node(file_node)?.data()?); bytes.extend(file_log.data_for_node(file_node)?.data()?);
} }
if path >= last_path {
// make the order of the [missing] files break;
// match the order they were specified on the command line }
let missing: Vec<_> = files }
.iter() }
.filter(|file| missing.contains(&file.as_ref())) let found_any = missing.len() != files.len();
.map(|file| file.clone()) let missing: Vec<_> =
.collect(); missing.into_iter().map(|path| path.to_owned()).collect();
martinvonzAuthorUnsubmitted
Done

Oops, I missed a .sorted() here

martinvonz: Oops, I missed a `.sorted()` here
Ok(CatOutput { Ok(CatOutput {
found_any, found_any,
concatenated: bytes, concatenated: bytes,
missing, missing,
node, node,
}) })
} }

rust/rhg/src/commands/cat.rs

} }
// TODO probably move this to a util function like `repo.default_rev` or // TODO probably move this to a util function like `repo.default_rev` or
// something when it's used somewhere else // something when it's used somewhere else
let rev = match rev { let rev = match rev {
Some(r) => r.to_string(), Some(r) => r.to_string(),
None => format!("{:x}", repo.dirstate_parents()?.p1), None => format!("{:x}", repo.dirstate_parents()?.p1),
}; };
let output = cat(&repo, &rev, files).map_err(|e| (e, rev.as_str()))?; let output = cat(&repo, &rev, &files).map_err(|e| (e, rev.as_str()))?;
invocation.ui.write_stdout(&output.concatenated)?; invocation.ui.write_stdout(&output.concatenated)?;
if !output.missing.is_empty() { if !output.missing.is_empty() {
let short = format!("{:x}", output.node.short()).into_bytes(); let short = format!("{:x}", output.node.short()).into_bytes();
for path in &output.missing { for path in &output.missing {
invocation.ui.write_stderr(&format_bytes!( invocation.ui.write_stderr(&format_bytes!(
b"{}: no such file in rev {}\n", b"{}: no such file in rev {}\n",
path.as_bytes(), path.as_bytes(),
short short