This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9873

rhg: centralize parsing of `--rev` CLI arguments
ClosedPublic

Authored by SimonSapin on Jan 26 2021, 12:44 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG4b381dbbf8b7: rhg: centralize parsing of `--rev` CLI arguments
Summary

This new module will be the place to implement more of the revset language
when we do so.

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

SimonSapin created this revision.Jan 26 2021, 12:44 PM
SimonSapin updated this revision to Diff 25294.Jan 27 2021, 4:57 AM
SimonSapin updated this revision to Diff 25353.Jan 28 2021, 2:39 PM
Alphare accepted this revision.Jan 29 2021, 7:02 AM
pulkit accepted this revision.Jan 31 2021, 2:40 PM
This revision is now accepted and ready to land.Jan 31 2021, 2:40 PM
SimonSapin added a commit: rHG4b381dbbf8b7: rhg: centralize parsing of `--rev` CLI arguments.Feb 1 2021, 12:34 PM
Closed by commit rHG4b381dbbf8b7: rhg: centralize parsing of `--rev` CLI arguments (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25427

rust/hg-core/src/lib.rs

pub mod copy_tracing; pub mod copy_tracing;
mod filepatterns; mod filepatterns;
pub mod matchers; pub mod matchers;
pub mod repo; pub mod repo;
pub mod revlog; pub mod revlog;
pub use revlog::*; pub use revlog::*;
pub mod config; pub mod config;
pub mod operations; pub mod operations;
pub mod revset;
pub mod utils; pub mod utils;
use crate::utils::hg_path::{HgPathBuf, HgPathError}; use crate::utils::hg_path::{HgPathBuf, HgPathError};
pub use filepatterns::{ pub use filepatterns::{
parse_pattern_syntax, read_pattern_file, IgnorePattern, parse_pattern_syntax, read_pattern_file, IgnorePattern,
PatternFileWarning, PatternSyntax, PatternFileWarning, PatternSyntax,
}; };
use std::collections::HashMap; use std::collections::HashMap;

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

use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::Manifest; use crate::revlog::manifest::Manifest;
use crate::revlog::path_encode::path_encode; use crate::revlog::path_encode::path_encode;
use crate::revlog::revlog::Revlog; use crate::revlog::revlog::Revlog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::revlog::NodePrefix;
use crate::revlog::Revision;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n']; const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
/// Kind of error encountered by `CatRev` /// Kind of error encountered by `CatRev`
#[derive(Debug)] #[derive(Debug)]
pub enum CatRevErrorKind { pub enum CatRevErrorKind {
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
/// ///
/// * `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( pub fn cat(
repo: &Repo, repo: &Repo,
rev: &str, revset: &str,
files: &[HgPathBuf], files: &[HgPathBuf],
) -> Result<Vec<u8>, CatRevError> { ) -> Result<Vec<u8>, CatRevError> {
let rev = crate::revset::resolve_single(revset, repo)?;
let changelog = Changelog::open(repo)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(repo)?; let manifest = Manifest::open(repo)?;
let changelog_entry = changelog.get_rev(rev)?;
let changelog_entry = match rev.parse::<Revision>() {
Ok(rev) => changelog.get_rev(rev)?,
_ => {
let changelog_node = NodePrefix::from_hex(&rev)
.map_err(|_| CatRevErrorKind::InvalidRevision)?;
changelog.get_node(changelog_node)?
}
};
let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
let mut bytes = vec![]; let mut bytes = vec![];
for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() { for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() {
for cat_file in files.iter() { for cat_file in files.iter() {
if cat_file.as_bytes() == manifest_file.as_bytes() { if cat_file.as_bytes() == manifest_file.as_bytes() {
let index_path = store_path(manifest_file, b".i"); let index_path = store_path(manifest_file, b".i");
let data_path = store_path(manifest_file, b".d"); let data_path = store_path(manifest_file, b".d");

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

// debugdata.rs // debugdata.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::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix;
use crate::revlog::Revision;
/// Kind of data to debug /// Kind of data to debug
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub enum DebugDataKind { pub enum DebugDataKind {
Changelog, Changelog,
Manifest, Manifest,
} }
} }
.into() .into()
} }
} }
/// Dump the contents data of a revision. /// Dump the contents data of a revision.
pub fn debug_data( pub fn debug_data(
repo: &Repo, repo: &Repo,
rev: &str, revset: &str,
kind: DebugDataKind, kind: DebugDataKind,
) -> Result<Vec<u8>, DebugDataError> { ) -> Result<Vec<u8>, DebugDataError> {
let index_file = match kind { let index_file = match kind {
DebugDataKind::Changelog => "00changelog.i", DebugDataKind::Changelog => "00changelog.i",
DebugDataKind::Manifest => "00manifest.i", DebugDataKind::Manifest => "00manifest.i",
}; };
let revlog = Revlog::open(repo, index_file, None)?; let revlog = Revlog::open(repo, index_file, None)?;
let rev =
let data = match rev.parse::<Revision>() { crate::revset::resolve_rev_number_or_hex_prefix(revset, &revlog)?;
Ok(rev) => revlog.get_rev_data(rev)?, let data = revlog.get_rev_data(rev)?;
_ => {
let node = NodePrefix::from_hex(&rev)
.map_err(|_| DebugDataErrorKind::InvalidRevision)?;
let rev = revlog.get_node_rev(node)?;
revlog.get_rev_data(rev)?
}
};
Ok(data) Ok(data)
} }

rust/hg-core/src/operations/list_tracked_files.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::dirstate::parsers::parse_dirstate; use crate::dirstate::parsers::parse_dirstate;
use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::{Manifest, ManifestEntry}; use crate::revlog::manifest::{Manifest, ManifestEntry};
use crate::revlog::node::{Node, NodePrefix}; use crate::revlog::node::Node;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Revision;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::{DirstateParseError, EntryState}; use crate::{DirstateParseError, EntryState};
use rayon::prelude::*; use rayon::prelude::*;
use std::convert::From; use std::convert::From;
/// Kind of error encountered by `ListDirstateTrackedFiles` /// Kind of error encountered by `ListDirstateTrackedFiles`
#[derive(Debug)] #[derive(Debug)]
pub enum ListDirstateTrackedFilesErrorKind { pub enum ListDirstateTrackedFilesErrorKind {
} }
.into() .into()
} }
} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
pub fn list_rev_tracked_files( pub fn list_rev_tracked_files(
repo: &Repo, repo: &Repo,
rev: &str, revset: &str,
) -> Result<FilesForRev, ListRevTrackedFilesError> { ) -> Result<FilesForRev, ListRevTrackedFilesError> {
let rev = crate::revset::resolve_single(revset, repo)?;
let changelog = Changelog::open(repo)?; let changelog = Changelog::open(repo)?;
let manifest = Manifest::open(repo)?; let manifest = Manifest::open(repo)?;
let changelog_entry = changelog.get_rev(rev)?;
let changelog_entry = match rev.parse::<Revision>() {
Ok(rev) => changelog.get_rev(rev)?,
_ => {
let changelog_node = NodePrefix::from_hex(&rev)
.or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?;
changelog.get_node(changelog_node)?
}
};
let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?; .or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?;
let manifest_entry = manifest.get_node(manifest_node.into())?; let manifest_entry = manifest.get_node(manifest_node.into())?;
Ok(FilesForRev(manifest_entry)) Ok(FilesForRev(manifest_entry))
} }
pub struct FilesForRev(ManifestEntry); pub struct FilesForRev(ManifestEntry);
impl FilesForRev { impl FilesForRev {
pub fn iter(&self) -> impl Iterator<Item = &HgPath> { pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
self.0.files() self.0.files()
} }
} }

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

use crate::repo::Repo; use crate::repo::Repo;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix; use crate::revlog::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
/// A specialized `Revlog` to work with `changelog` data format. /// A specialized `Revlog` to work with `changelog` data format.
pub struct Changelog { pub struct Changelog {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, pub(crate) revlog: Revlog,
} }
impl Changelog { impl Changelog {
/// Open the `changelog` of a repository given by its root. /// Open the `changelog` of a repository given by its root.
pub fn open(repo: &Repo) -> Result<Self, RevlogError> { pub fn open(repo: &Repo) -> Result<Self, RevlogError> {
let revlog = Revlog::open(repo, "00changelog.i", None)?; let revlog = Revlog::open(repo, "00changelog.i", None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }

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

return Err(RevlogError::AmbiguousPrefix); return Err(RevlogError::AmbiguousPrefix);
} }
found_by_prefix = Some(rev) found_by_prefix = Some(rev)
} }
} }
found_by_prefix.ok_or(RevlogError::InvalidRevision) found_by_prefix.ok_or(RevlogError::InvalidRevision)
} }
/// Returns whether the given revision exists in this revlog.
pub fn has_rev(&self, rev: Revision) -> bool {
self.index.get_entry(rev).is_some()
}
/// Return the full data associated to a revision. /// Return the full data associated to a revision.
/// ///
/// All entries required to build the final data out of deltas will be /// All entries required to build the final data out of deltas will be
/// retrieved as needed, and the deltas will be applied to the inital /// retrieved as needed, and the deltas will be applied to the inital
/// snapshot to rebuild the final data. /// snapshot to rebuild the final data.
#[timed] #[timed]
pub fn get_rev_data(&self, rev: Revision) -> Result<Vec<u8>, RevlogError> { pub fn get_rev_data(&self, rev: Revision) -> Result<Vec<u8>, RevlogError> {
// Todo return -> Cow // Todo return -> Cow

rust/hg-core/src/revset.rs

  • This file was added.
//! The revset query language
//!
//! <https://www.mercurial-scm.org/repo/hg/help/revsets>
use crate::repo::Repo;
use crate::revlog::changelog::Changelog;
use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix;
use crate::revlog::{Revision, NULL_REVISION};
/// Resolve a query string into a single revision.
///
/// Only some of the revset language is implemented yet.
pub fn resolve_single(
input: &str,
repo: &Repo,
) -> Result<Revision, RevlogError> {
let changelog = Changelog::open(repo)?;
match resolve_rev_number_or_hex_prefix(input, &changelog.revlog) {
Err(RevlogError::InvalidRevision) => {} // Try other syntax
result => return result,
}
if input == "null" {
return Ok(NULL_REVISION);
}
// TODO: support for the rest of the language here.
Err(RevlogError::InvalidRevision)
}
/// Resolve the small subset of the language suitable for revlogs other than
/// the changelog, such as in `hg debugdata --manifest` CLI argument.
///
/// * A non-negative decimal integer for a revision number, or
/// * An hexadecimal string, for the unique node ID that starts with this
/// prefix
pub fn resolve_rev_number_or_hex_prefix(
input: &str,
revlog: &Revlog,
) -> Result<Revision, RevlogError> {
if let Ok(integer) = input.parse::<i32>() {
if integer >= 0 && revlog.has_rev(integer) {
return Ok(integer);
}
}
if let Ok(prefix) = NodePrefix::from_hex(input) {
return revlog.get_node_rev(prefix);
}
Err(RevlogError::InvalidRevision)
}