This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8954

rhg: pass `ui` to `Command` `run`
ClosedPublic

Authored by acezar on Aug 26 2020, 9:23 AM.

Details

Reviewers
marmoute
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHGed95ccc94333: rhg: pass `ui` to `Command` `run`
Summary

Allow implementation of From<clap::ArgMatches> for Command

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.Aug 26 2020, 9:23 AM
acezar retitled this revision from rhg: pass ui to Command run to rhg: pass `ui` to `Command` `run`.Aug 26 2020, 9:44 AM
marmoute accepted this revision.Aug 26 2020, 3:21 PM
Alphare accepted this revision.Aug 28 2020, 4:18 AM
pulkit accepted this revision.Sep 11 2020, 5:01 AM
This revision is now accepted and ready to land.Sep 11 2020, 5:01 AM
acezar added a commit: rHGed95ccc94333: rhg: pass `ui` to `Command` `run`.Sep 11 2020, 5:46 AM
Closed by commit rHGed95ccc94333: rhg: pass `ui` to `Command` `run` (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22621

rust/rhg/src/commands.rs

pub mod files; pub mod files;
pub mod root; pub mod root;
use crate::error::CommandError; use crate::error::CommandError;
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<'a> { pub trait Command {
fn run(&self) -> Result<(), CommandError>; fn run(&self, ui: &Ui) -> Result<(), CommandError>;
} }

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::Ui; use crate::ui::Ui;
use hg::operations::{ListTrackedFiles, ListTrackedFilesErrorKind}; use hg::operations::{ListTrackedFiles, ListTrackedFilesErrorKind};
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::HgPathBuf;
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<'a> { pub struct FilesCommand {}
ui: &'a Ui,
}
impl<'a> FilesCommand<'a> { impl FilesCommand {
pub fn new(ui: &'a Ui) -> Self { pub fn new() -> Self {
FilesCommand { ui } FilesCommand {}
} }
} }
impl<'a> Command<'a> for FilesCommand<'a> { impl Command for FilesCommand {
fn run(&self) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let operation_builder = ListTrackedFiles::new()?; let operation_builder = ListTrackedFiles::new()?;
let operation = operation_builder.load().map_err(|err| { let operation = operation_builder.load().map_err(|err| {
CommandErrorKind::Abort(Some( CommandErrorKind::Abort(Some(
[b"abort: ", err.to_string().as_bytes(), b"\n"] [b"abort: ", err.to_string().as_bytes(), b"\n"]
.concat() .concat()
.to_vec(), .to_vec(),
)) ))
})?; })?;
let files = operation.run().map_err(|err| match err.kind { let files = operation.run().map_err(|err| match err.kind {
ListTrackedFilesErrorKind::ParseError(_) => { ListTrackedFilesErrorKind::ParseError(_) => {
CommandErrorKind::Abort(Some( CommandErrorKind::Abort(Some(
// TODO find a better error message // TODO find a better error message
b"abort: parse error\n".to_vec(), b"abort: parse error\n".to_vec(),
)) ))
} }
})?; })?;
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(operation_builder.get_root()) .strip_prefix(operation_builder.get_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 = self.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(())
} }
} }

rust/rhg/src/commands/root.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::FindRoot; use hg::operations::FindRoot;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct RootCommand<'a> { pub struct RootCommand {}
ui: &'a Ui,
}
impl<'a> RootCommand<'a> { impl RootCommand {
pub fn new(ui: &'a Ui) -> Self { pub fn new() -> Self {
RootCommand { ui } RootCommand {}
} }
} }
impl<'a> Command<'a> for RootCommand<'a> { impl Command for RootCommand {
fn run(&self) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let path_buf = FindRoot::new().run()?; let path_buf = FindRoot::new().run()?;
let bytes = get_bytes_from_path(path_buf); let bytes = get_bytes_from_path(path_buf);
// TODO use formating macro // TODO use formating macro
self.ui.write_stdout(&[bytes.as_slice(), b"\n"].concat())?; ui.write_stdout(&[bytes.as_slice(), b"\n"].concat())?;
Ok(()) Ok(())
} }
} }

rust/rhg/src/main.rs

let matches = app.clone().get_matches_safe().unwrap_or_else(|_| { let matches = app.clone().get_matches_safe().unwrap_or_else(|_| {
std::process::exit(exitcode::UNIMPLEMENTED_COMMAND) std::process::exit(exitcode::UNIMPLEMENTED_COMMAND)
}); });
let ui = ui::Ui::new(); let ui = ui::Ui::new();
let command_result = match matches.subcommand_name() { let command_result = match matches.subcommand_name() {
Some(name) => match name { Some(name) => match name {
"root" => commands::root::RootCommand::new(&ui).run(), "root" => commands::root::RootCommand::new().run(&ui),
"files" => commands::files::FilesCommand::new(&ui).run(), "files" => commands::files::FilesCommand::new().run(&ui),
_ => std::process::exit(exitcode::UNIMPLEMENTED_COMMAND), _ => std::process::exit(exitcode::UNIMPLEMENTED_COMMAND),
}, },
_ => { _ => {
match app.print_help() { match app.print_help() {
Ok(_) => std::process::exit(exitcode::OK), Ok(_) => std::process::exit(exitcode::OK),
Err(_) => std::process::exit(exitcode::ABORT), Err(_) => std::process::exit(exitcode::ABORT),
}; };
} }