This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9015

rhg: add `--revision` argument to `rhg files`
ClosedPublic

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

Download Raw Diff

Details

Reviewers

Alphare

Group Reviewers

hg-reviewers

Commits

rHG2f8227a12592: rhg: add `--revision` argument to `rhg files`

Summary

Add the option to list the tracked files of a revision given its number
or full node id.

Benched on a clone of moz-central
where tip is 1671467:81deaa1a68ebb28db0490954034ab38ab269409d

files -r 81deaa1a68ebb28db0490954034ab38ab269409d > out.txt
hg 0m1.633s
rhg 0m0.157s

files -r 81deaa1a68ebb28db0490954034ab38ab269409d > /dev/null
hg 0m0.415s
rhg 0m0.143s

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

Herald added a reviewer: hg-reviewers. · View Herald TranscriptSep 11 2020, 3:53 AM

Herald added a subscriber: mercurial-patches. · View Herald Transcript

Maybe adding some performance numbers in the commit message would be useful and motivating, seeing as it is very fast.

acezar updated this revision to Diff 22726.Sep 18 2020, 10:49 AM

acezar edited the summary of this revision. (Show Details)Sep 18 2020, 11:30 AM

acezar added a child revision: D9048: hg-core: impl TryFrom<PathBuff> for HgPathBuf.Sep 21 2020, 5:12 AM

acezar added a commit: rHG2f8227a12592: rhg: add `--revision` argument to `rhg files`.Sep 23 2020, 10:57 AM

This revision was not accepted when it landed; it landed in state Needs Review.

Closed by commit rHG2f8227a12592: rhg: add `--revision` argument to `rhg files` (authored by acezar). · Explain Why

This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

			Path	Packages
M			rust/rhg/src/commands/files.rs (95 lines)
M			rust/rhg/src/main.rs (24 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	22618		Sep 11 2020, 3:53 AM	★	★
Diff 2	22726		Sep 18 2020, 10:49 AM	★	★
Diff 3	22796	rHG2f8227a125928a6f1670adb74c7bd117d7e5d958	Sep 9 2020, 8:53 AM	★	★

Status	Author	Revision
Closed	acezar	D9052 rhg: add a limited `rhg cat -r` subcommand
Closed	acezar	D9051 hg-core: add a `CatRev` operation
Closed	acezar	D9050 hg-core: add `files_with_nodes` to `Manifest`
Closed	acezar	D9049 hg-core: add path_encode
Closed	acezar	D9048 hg-core: impl TryFrom<PathBuff> for HgPathBuf
Closed	acezar	D9015 rhg: add `--revision` argument to `rhg files`
Closed	acezar	D9014 hg-core: add a `ListRevTrackedFiles` operation
Closed	acezar	D9013 hg-core: simplify `list_tracked_files` operation
Closed	acezar	D9012 hg-core: add `Revlog.get_node_rev`
Closed	acezar	D9011 hg-core: add `Manifest` a specialized `Revlog`
Closed	acezar	D9010 hg-core: add `Changlog` a specialized `Revlog`
Closed	acezar	D9005 hg-core: check data integrity in `Revlog`
Closed	acezar	D8962 rhg: Add debug timing
Closed	acezar	D8961 rhg: add a limited `rhg debugdata` subcommand
Closed	acezar	D8960 rhg: add a `DebugData` `Command` to prepare the `rhg debugdata` subcommand
Closed	acezar	D8959 hg-core: define a `DebugData` `Operation`
Closed	acezar	D8958 hg-core: Add a limited read only `revlog` implementation
Closed	acezar	D8957 hg-core: fix some `clippy` warnings
Closed	acezar	D8956 rhg: print error message when argument parsing fails
Closed	acezar	D8955 rhg: fix `clippy` warnings
Closed	acezar	D8954 rhg: pass `ui` to `Command` `run`
Closed	acezar	D8953 documentation: add `zstd` compression to the internal `revlogs` documentation
Closed	acezar	D8873 rhg: add harness tests for rhg files
Closed	acezar	D8872 rhg: make output of `files` relative to the current directory and the root
Closed	acezar	D8871 rhg: handle broken pipe error for stderr
Closed	acezar	D8870 rhg: extract function handle_stdout_error
Closed	acezar	D8869 rhg: add a limited `rhg files` subcommand
Closed	acezar	D8868 rhg: add a `Files` `Command` to prepare the `rhg files` subcommand
Closed	acezar	D8867 rhg: simplify `FindRootError` handling
Closed	acezar	D8866 rhg: add buffered stdout writing possibility
Closed	acezar	D8865 rhg: ask the error message from `CommandError`
Closed	acezar	D8864 rhg: Do not return error when when we really mean ok in commands
Closed	acezar	D8863 hg-core: define a `ListTrackedFiles` `Operation`
Closed	acezar	D8862 hg-core: remove the `Operation` trait
Closed	acezar	D8861 hg-core: make parse_dirstate return references rather than update hashmaps

Diff 22796

rust/rhg/src/commands/files.rs

	use crate::commands::Command;			use crate::commands::Command;
	use crate::error::{CommandError, CommandErrorKind};			use crate::error::{CommandError, CommandErrorKind};
	use crate::ui::utf8_to_local;			use crate::ui::utf8_to_local;
	use crate::ui::Ui;			use crate::ui::Ui;
	use hg::operations::FindRoot;			use hg::operations::FindRoot;
	use hg::operations::{			use hg::operations::{
	ListDirstateTrackedFiles, ListDirstateTrackedFilesError,			ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
	ListDirstateTrackedFilesErrorKind,			ListDirstateTrackedFilesErrorKind,
	};			};
				use hg::operations::{
				ListRevTrackedFiles, ListRevTrackedFilesError,
				ListRevTrackedFilesErrorKind,
				};
	use hg::utils::files::{get_bytes_from_path, relativize_path};			use hg::utils::files::{get_bytes_from_path, relativize_path};
	use hg::utils::hg_path::HgPathBuf;			use hg::utils::hg_path::{HgPath, HgPathBuf};
				use std::path::PathBuf;

	pub const HELP_TEXT: &str = "			pub const HELP_TEXT: &str = "
	List tracked files.			List tracked files.

	Returns 0 on success.			Returns 0 on success.
	";			";

	pub struct FilesCommand {}			pub struct FilesCommand<'a> {
				rev: Option<&'a str>,
	impl FilesCommand {
	pub fn new() -> Self {
	FilesCommand {}
	}
	}			}

	impl Command for FilesCommand {			impl<'a> FilesCommand<'a> {
	fn run(&self, ui: &Ui) -> Result<(), CommandError> {			pub fn new(rev: Option<&'a str>) -> Self {
	let root = FindRoot::new().run()?;			FilesCommand { rev }
	let mut operation = ListDirstateTrackedFiles::new(&root)			}
	.map_err(map_dirstate_error)?;
	let files = operation.run().map_err(map_dirstate_error)?;

				fn display_files(
				&self,
				ui: &Ui,
				root: &PathBuf,
				files: impl IntoIterator<Item = &'a HgPath>,
				) -> Result<(), CommandError> {
	let cwd = std::env::current_dir()			let cwd = std::env::current_dir()
	.or_else(\|e\| Err(CommandErrorKind::CurrentDirNotFound(e)))?;			.or_else(\|e\| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
	let rooted_cwd = cwd			let rooted_cwd = cwd
	.strip_prefix(&root)			.strip_prefix(&root)
	.expect("cwd was already checked within the repository");			.expect("cwd was already checked within the repository");
	let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));			let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));

	let mut stdout = ui.stdout_buffer();			let mut stdout = ui.stdout_buffer();

	for file in files {			for file in files {
	stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;			stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
	stdout.write_all(b"\n")?;			stdout.write_all(b"\n")?;
	}			}
	stdout.flush()?;			stdout.flush()?;
	Ok(())			Ok(())
	}			}
	}			}

	/// Convert operation errors to command errors			impl<'a> Command for FilesCommand<'a> {
				fn run(&self, ui: &Ui) -> Result<(), CommandError> {
				let root = FindRoot::new().run()?;
				if let Some(rev) = self.rev {
				let mut operation = ListRevTrackedFiles::new(&root, rev)
				.map_err(\|e\| map_rev_error(rev, e))?;
				let files = operation.run().map_err(\|e\| map_rev_error(rev, e))?;
				self.display_files(ui, &root, files)
				} else {
				let mut operation = ListDirstateTrackedFiles::new(&root)
				.map_err(map_dirstate_error)?;
				let files = operation.run().map_err(map_dirstate_error)?;
				self.display_files(ui, &root, files)
				}
				}
				}

				/// Convert `ListRevTrackedFilesErrorKind` to `CommandError`
				fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
				CommandError {
				kind: match err.kind {
				ListRevTrackedFilesErrorKind::IoError(err) => {
				CommandErrorKind::Abort(Some(
				utf8_to_local(&format!("abort: {}\n", err)).into(),
				))
				}
				ListRevTrackedFilesErrorKind::InvalidRevision => {
				CommandErrorKind::Abort(Some(
				utf8_to_local(&format!(
				"abort: invalid revision identifier{}\n",
				rev
				))
				.into(),
				))
				}
				ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version) => {
				CommandErrorKind::Abort(Some(
				utf8_to_local(&format!(
				"abort: unsupported revlog version {}\n",
				version
				))
				.into(),
				))
				}
				ListRevTrackedFilesErrorKind::CorruptedRevlog => {
				CommandErrorKind::Abort(Some(
				"abort: corrupted revlog\n".into(),
				))
				}
				ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) => {
				CommandErrorKind::Abort(Some(
				utf8_to_local(&format!(
				"abort: unknow revlog dataformat {:?}\n",
				format
				))
				.into(),
				))
				}
				},
				}
				}

				/// Convert `ListDirstateTrackedFilesError` to `CommandError`
	fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {			fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {
	CommandError {			CommandError {
	kind: match err.kind {			kind: match err.kind {
	ListDirstateTrackedFilesErrorKind::IoError(err) => {			ListDirstateTrackedFilesErrorKind::IoError(err) => {
	CommandErrorKind::Abort(Some(			CommandErrorKind::Abort(Some(
	utf8_to_local(&format!("abort: {}\n", err)).into(),			utf8_to_local(&format!("abort: {}\n", err)).into(),
	))			))
	}			}

rust/rhg/src/main.rs

	.setting(AppSettings::AllowInvalidUtf8)			.setting(AppSettings::AllowInvalidUtf8)
	.setting(AppSettings::SubcommandRequired)			.setting(AppSettings::SubcommandRequired)
	.setting(AppSettings::VersionlessSubcommands)			.setting(AppSettings::VersionlessSubcommands)
	.version("0.0.1")			.version("0.0.1")
	.subcommand(			.subcommand(
	SubCommand::with_name("root").about(commands::root::HELP_TEXT),			SubCommand::with_name("root").about(commands::root::HELP_TEXT),
	)			)
	.subcommand(			.subcommand(
	SubCommand::with_name("files").about(commands::files::HELP_TEXT),			SubCommand::with_name("files")
				.arg(
				Arg::with_name("rev")
				.help("search the repository as it is in REV")
				.short("-r")
				.long("--revision")
				.value_name("REV")
				.takes_value(true),
				)
				.about(commands::files::HELP_TEXT),
	)			)
	.subcommand(			.subcommand(
	SubCommand::with_name("debugdata")			SubCommand::with_name("debugdata")
	.about(commands::debugdata::HELP_TEXT)			.about(commands::debugdata::HELP_TEXT)
	.arg(			.arg(
	Arg::with_name("changelog")			Arg::with_name("changelog")
	.help("open changelog")			.help("open changelog")
	.short("-c")			.short("-c")
	}			}

	fn match_subcommand(			fn match_subcommand(
	matches: ArgMatches,			matches: ArgMatches,
	ui: &ui::Ui,			ui: &ui::Ui,
	) -> Result<(), CommandError> {			) -> Result<(), CommandError> {
	match matches.subcommand() {			match matches.subcommand() {
	("root", _) => commands::root::RootCommand::new().run(&ui),			("root", _) => commands::root::RootCommand::new().run(&ui),
	("files", _) => commands::files::FilesCommand::new().run(&ui),			("files", Some(matches)) => {
				commands::files::FilesCommand::try_from(matches)?.run(&ui)
				}
	("debugdata", Some(matches)) => {			("debugdata", Some(matches)) => {
	commands::debugdata::DebugDataCommand::try_from(matches)?.run(&ui)			commands::debugdata::DebugDataCommand::try_from(matches)?.run(&ui)
	}			}
	_ => unreachable!(), // Because of AppSettings::SubcommandRequired,			_ => unreachable!(), // Because of AppSettings::SubcommandRequired,
	}			}
	}			}

				impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::files::FilesCommand<'a> {
				type Error = CommandError;

				fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
				let rev = args.value_of("rev");
				Ok(commands::files::FilesCommand::new(rev))
				}
				}

	impl<'a> TryFrom<&'a ArgMatches<'_>>			impl<'a> TryFrom<&'a ArgMatches<'_>>
	for commands::debugdata::DebugDataCommand<'a>			for commands::debugdata::DebugDataCommand<'a>
	{			{
	type Error = CommandError;			type Error = CommandError;

	fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {			fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
	let rev = args			let rev = args
	.value_of("rev")			.value_of("rev")