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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 22733

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")