rust/rhg/src/commands/debugdata.rs

use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local;
use crate::ui::Ui;
use hg::operations::{
    DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind,
};
use micro_timer::timed;

pub const HELP_TEXT: &str = "
Dump the contents of a data file revision
";

pub struct DebugDataCommand<'a> {
    rev: &'a str,
    kind: DebugDataKind,
}

impl<'a> DebugDataCommand<'a> {
    pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
        DebugDataCommand { rev, kind }
    }
}

impl<'a> Command for DebugDataCommand<'a> {
    #[timed]
    fn run(&self, ui: &Ui) -> Result<(), CommandError> {
        let mut operation = DebugData::new(self.rev, self.kind);
        let data =
            operation.run().map_err(|e| to_command_error(self.rev, e))?;

        let mut stdout = ui.stdout_buffer();
        stdout.write_all(&data)?;
        stdout.flush()?;

        Ok(())
    }
}

/// Convert operation errors to command errors
fn to_command_error(rev: &str, err: DebugDataError) -> CommandError {
    match err.kind {
        DebugDataErrorKind::FindRootError(err) => CommandError::from(err),
        DebugDataErrorKind::IoError(err) => CommandError {
            kind: CommandErrorKind::Abort(Some(
                utf8_to_local(&format!("abort: {}\n", err)).into(),
            )),
        },
        DebugDataErrorKind::InvalidRevision => CommandError {
            kind: CommandErrorKind::Abort(Some(
                utf8_to_local(&format!(
                    "abort: invalid revision identifier{}\n",
                    rev
                ))
                .into(),
            )),
        },
        DebugDataErrorKind::UnsuportedRevlogVersion(version) => CommandError {
            kind: CommandErrorKind::Abort(Some(
                utf8_to_local(&format!(
                    "abort: unsupported revlog version {}\n",
                    version
                ))
                .into(),
            )),
        },
        DebugDataErrorKind::CorruptedRevlog => CommandError {
            kind: CommandErrorKind::Abort(Some(
                "abort: corrupted revlog\n".into(),
            )),
        },
        DebugDataErrorKind::UnknowRevlogDataFormat(format) => CommandError {
            kind: CommandErrorKind::Abort(Some(
                utf8_to_local(&format!(
                    "abort: unknow revlog dataformat {:?}\n",
                    format
                ))
                .into(),
            )),
        },
    }
}