( )⚙ D8868 rhg: add a `Files` `Command` to prepare the `rhg files` subcommand

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8868

rhg: add a `Files` `Command` to prepare the `rhg files` subcommand
ClosedPublic

Authored by acezar on Aug 3 2020, 10:26 AM.

Details

Reviewers
Alphare
indygreg
Group Reviewers
hg-reviewers
Commits
rHG5fe25f8ef5d9: rhg: add a `Files` `Command` to prepare the `rhg files` subcommand

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 3 2020, 10:26 AM
Alphare accepted this revision.Aug 3 2020, 11:17 AM
acezar updated this revision to Diff 22251.Aug 4 2020, 4:58 AM
indygreg accepted this revision.Aug 8 2020, 4:09 PM
indygreg added a subscriber: indygreg.
indygreg added inline comments.
rust/rhg/src/commands/files.rs
47

I imagine this pattern could become quite common. We may want to introduce some type of _writer_ type that has impl Drop so we can do something like the following:

{
    let mut stdout = self.ui.stdout_writer();
    stdout.write(b"...")?;
}
This revision is now accepted and ready to land.Aug 8 2020, 4:09 PM
Alphare added inline comments.Aug 12 2020, 5:58 AM
rust/rhg/src/commands/files.rs
47

I can see that being useful, we'll see if that comes up a lot. The question of doing line-buffering as a config option is still up for debate, maybe that'll complicate the pattern you're proposing somewhat.

Revision Contents
Changeset List

Diff 22363

rust/hg-core/src/lib.rs

/// attacks. We are not concerned about those: if an ill-minded person has /// attacks. We are not concerned about those: if an ill-minded person has
/// write access to your repository, you have other issues. /// write access to your repository, you have other issues.
pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>; pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>;
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum DirstateParseError { pub enum DirstateParseError {
TooLittleData, TooLittleData,
Overflow, Overflow,
// TODO refactor to use bytes instead of String
CorruptedEntry(String), CorruptedEntry(String),
Damaged, Damaged,
} }
impl From<std::io::Error> for DirstateParseError { impl From<std::io::Error> for DirstateParseError {
fn from(e: std::io::Error) -> Self { fn from(e: std::io::Error) -> Self {
DirstateParseError::CorruptedEntry(e.to_string()) DirstateParseError::CorruptedEntry(e.to_string())
} }

rust/rhg/src/commands.rs

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

rust/rhg/src/commands/files.rs

  • This file was added.
use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind};
use crate::ui::Ui;
use hg::operations::{ListTrackedFiles, ListTrackedFilesErrorKind};
pub const HELP_TEXT: &str = "
List tracked files.
Returns 0 on success.
";
pub struct FilesCommand<'a> {
ui: &'a Ui,
}
impl<'a> FilesCommand<'a> {
pub fn new(ui: &'a Ui) -> Self {
FilesCommand { ui }
}
}
impl<'a> Command<'a> for FilesCommand<'a> {
fn run(&self) -> Result<(), CommandError> {
let operation_builder = ListTrackedFiles::new()?;
let operation = operation_builder.load().map_err(|err| {
CommandErrorKind::Abort(Some(
[b"abort: ", err.to_string().as_bytes(), b"\n"]
.concat()
.to_vec(),
))
})?;
let files = operation.run().map_err(|err| match err.kind {
ListTrackedFilesErrorKind::ParseError(_) => {
CommandErrorKind::Abort(Some(
// TODO find a better error message
b"abort: parse error\n".to_vec(),
))
}
})?;
let mut stdout = self.ui.stdout_buffer();
for file in files {
stdout.write_all(file.as_bytes())?;
stdout.write_all(b"\n")?;
}
stdout.flush()?;
indygregUnsubmitted
Not Done

I imagine this pattern could become quite common. We may want to introduce some type of _writer_ type that has impl Drop so we can do something like the following:

{
    let mut stdout = self.ui.stdout_writer();
    stdout.write(b"...")?;
}
indygreg: I imagine this pattern could become quite common. We may want to introduce some type of…
AlphareUnsubmitted
Not Done

I can see that being useful, we'll see if that comes up a lot. The question of doing line-buffering as a config option is still up for debate, maybe that'll complicate the pattern you're proposing somewhat.

Alphare: I can see that being useful, we'll see if that comes up a lot. The question of doing line…
Ok(())
}
}

rust/rhg/src/error.rs

/// The root of the repository cannot be found /// The root of the repository cannot be found
RootNotFound(PathBuf), RootNotFound(PathBuf),
/// 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
Abort(Option<Vec<u8>>),
} }
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,
} }
} }
/// 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) => {
CommandErrorKind::CurrentDirNotFound(e) => Some( CommandErrorKind::CurrentDirNotFound(e) => Some(
[ [
b"abort: error getting current working directory: ", b"abort: error getting current working directory: ",
e.to_string().as_bytes(), e.to_string().as_bytes(),
b"\n", b"\n",
] ]
.concat(), .concat(),
), ),
CommandErrorKind::Abort(message) => message.to_owned(),
_ => None, _ => None,
} }
} }
} }
/// The error type for the Command trait /// The error type for the Command trait
#[derive(Debug)] #[derive(Debug)]
pub struct CommandError { pub struct CommandError {