This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9052

rhg: add a limited `rhg cat -r` subcommand
ClosedPublic

Authored by acezar on Sep 18 2020, 12:01 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG33ded2d3f4fc: rhg: add a limited `rhg cat -r` subcommand
Summary

It only supports revision specification (rev or full hash) and the list of files
to cat.

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 18 2020, 12:01 PM
acezar added a commit: rHG33ded2d3f4fc: rhg: add a limited `rhg cat -r` subcommand.Sep 23 2020, 10:58 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG33ded2d3f4fc: rhg: add a limited `rhg cat -r` subcommand (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22801

rust/rhg/src/commands.rs

pub mod cat;
pub mod debugdata; pub mod debugdata;
pub mod files; pub mod files;
pub mod root; pub mod root;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
/// The common trait for rhg commands /// The common trait for rhg commands
/// ///
/// Normalize the interface of the commands provided by rhg /// Normalize the interface of the commands provided by rhg
pub trait Command { pub trait Command {
fn run(&self, ui: &Ui) -> Result<(), CommandError>; fn run(&self, ui: &Ui) -> Result<(), CommandError>;
} }

rust/rhg/src/commands/cat.rs

  • This file was added.
use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local;
use crate::ui::Ui;
use hg::operations::FindRoot;
use hg::operations::{CatRev, CatRevError, CatRevErrorKind};
use hg::utils::hg_path::HgPathBuf;
use micro_timer::timed;
use std::convert::TryFrom;
pub const HELP_TEXT: &str = "
Output the current or given revision of files
";
pub struct CatCommand<'a> {
rev: Option<&'a str>,
files: Vec<&'a str>,
}
impl<'a> CatCommand<'a> {
pub fn new(rev: Option<&'a str>, files: Vec<&'a str>) -> Self {
Self { rev, files }
}
fn display(&self, ui: &Ui, data: &[u8]) -> Result<(), CommandError> {
ui.write_stdout(data)?;
Ok(())
}
}
impl<'a> Command for CatCommand<'a> {
#[timed]
fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = FindRoot::new().run()?;
let cwd = std::env::current_dir()
.or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
let mut files = vec![];
for file in self.files.iter() {
let normalized = cwd.join(&file);
let stripped = normalized
.strip_prefix(&root)
.map_err(|_| CommandErrorKind::Abort(None))?;
let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
.map_err(|_| CommandErrorKind::Abort(None))?;
files.push(hg_file);
}
match self.rev {
Some(rev) => {
let mut operation = CatRev::new(&root, rev, &files)
.map_err(|e| map_rev_error(rev, e))?;
let data =
operation.run().map_err(|e| map_rev_error(rev, e))?;
self.display(ui, &data)
}
None => Err(CommandErrorKind::Unimplemented.into()),
}
}
}
/// Convert `CatRevErrorKind` to `CommandError`
fn map_rev_error(rev: &str, err: CatRevError) -> CommandError {
CommandError {
kind: match err.kind {
CatRevErrorKind::IoError(err) => CommandErrorKind::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(),
)),
CatRevErrorKind::InvalidRevision => CommandErrorKind::Abort(Some(
utf8_to_local(&format!(
"abort: invalid revision identifier{}\n",
rev
))
.into(),
)),
CatRevErrorKind::UnsuportedRevlogVersion(version) => {
CommandErrorKind::Abort(Some(
utf8_to_local(&format!(
"abort: unsupported revlog version {}\n",
version
))
.into(),
))
}
CatRevErrorKind::CorruptedRevlog => CommandErrorKind::Abort(Some(
"abort: corrupted revlog\n".into(),
)),
CatRevErrorKind::UnknowRevlogDataFormat(format) => {
CommandErrorKind::Abort(Some(
utf8_to_local(&format!(
"abort: unknow revlog dataformat {:?}\n",
format
))
.into(),
))
}
},
}
}

rust/rhg/src/error.rs

/// The current directory cannot be found /// The current directory cannot be found
CurrentDirNotFound(std::io::Error), CurrentDirNotFound(std::io::Error),
/// The standard output stream cannot be written to /// The standard output stream cannot be written to
StdoutError, StdoutError,
/// The standard error stream cannot be written to /// The standard error stream cannot be written to
StderrError, StderrError,
/// The command aborted /// The command aborted
Abort(Option<Vec<u8>>), Abort(Option<Vec<u8>>),
/// A mercurial capability as not been implemented.
Unimplemented,
} }
impl CommandErrorKind { impl CommandErrorKind {
pub fn get_exit_code(&self) -> exitcode::ExitCode { pub fn get_exit_code(&self) -> exitcode::ExitCode {
match self { match self {
CommandErrorKind::RootNotFound(_) => exitcode::ABORT, CommandErrorKind::RootNotFound(_) => exitcode::ABORT,
CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT, CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT,
CommandErrorKind::StdoutError => exitcode::ABORT, CommandErrorKind::StdoutError => exitcode::ABORT,
CommandErrorKind::StderrError => exitcode::ABORT, CommandErrorKind::StderrError => exitcode::ABORT,
CommandErrorKind::Abort(_) => exitcode::ABORT, CommandErrorKind::Abort(_) => exitcode::ABORT,
CommandErrorKind::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND,
} }
} }
/// Return the message corresponding to the error kind if any /// Return the message corresponding to the error kind if any
pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> { pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
match self { match self {
// TODO use formating macro // TODO use formating macro
CommandErrorKind::RootNotFound(path) => { CommandErrorKind::RootNotFound(path) => {

rust/rhg/src/main.rs

.short("-r") .short("-r")
.long("--revision") .long("--revision")
.value_name("REV") .value_name("REV")
.takes_value(true), .takes_value(true),
) )
.about(commands::files::HELP_TEXT), .about(commands::files::HELP_TEXT),
) )
.subcommand( .subcommand(
SubCommand::with_name("cat")
.arg(
Arg::with_name("rev")
.help("search the repository as it is in REV")
.short("-r")
.long("--revision")
.value_name("REV")
.takes_value(true),
)
.arg(
clap::Arg::with_name("files")
.required(true)
.multiple(true)
.empty_values(false)
.value_name("FILE")
.help("Activity to start: activity@category"),
)
.about(commands::cat::HELP_TEXT),
)
.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")
.long("--changelog"), .long("--changelog"),
) )
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", Some(matches)) => { ("files", Some(matches)) => {
commands::files::FilesCommand::try_from(matches)?.run(&ui) commands::files::FilesCommand::try_from(matches)?.run(&ui)
} }
("cat", Some(matches)) => {
commands::cat::CatCommand::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> { impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::files::FilesCommand<'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.value_of("rev"); let rev = args.value_of("rev");
Ok(commands::files::FilesCommand::new(rev)) Ok(commands::files::FilesCommand::new(rev))
} }
} }
impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::cat::CatCommand<'a> {
type Error = CommandError;
fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
let rev = args.value_of("rev");
let files = match args.values_of("files") {
Some(files) => files.collect(),
None => vec![],
};
Ok(commands::cat::CatCommand::new(rev, files))
}
}
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")