medic-lib 0.3.0

Helpers for writing checks and steps for medic
Documentation
use std::io::{self, Write};
use std::ops::{ControlFlow, FromResidual, Try};

pub enum StepResult {
  StepOk,
  StepError(String, Option<String>, Option<String>),
}

impl std::process::Termination for StepResult {
  fn report(self) -> std::process::ExitCode {
    match self {
      StepResult::StepOk => std::process::ExitCode::from(0),
      StepResult::StepError(msg, stdout, stderr) => {
        eprintln!("\x1b[31;1mError:\x1b[0m {msg}\r\n");
        if let Some(stdout) = stdout
          && !stdout.is_empty()
        {
          eprintln!("\x1b[31;1mstdout:\x1b[0m\r\n{stdout}");
        }
        if let Some(stderr) = stderr
          && !stderr.is_empty()
        {
          eprintln!("\x1b[31;1mstderr:\x1b[0m\r\n{stderr}");
        }
        io::stderr().flush().unwrap();

        std::process::ExitCode::from(1)
      }
    }
  }
}

pub struct ResultCodeResidual(String, Option<String>, Option<String>);

impl Try for StepResult {
  type Output = ();
  type Residual = ResultCodeResidual;

  fn branch(self) -> ControlFlow<Self::Residual> {
    match self {
      StepResult::StepError(msg, stdout, stderr) => ControlFlow::Break(ResultCodeResidual(msg, stdout, stderr)),
      StepResult::StepOk => ControlFlow::Continue(()),
    }
  }
  fn from_output((): ()) -> Self {
    StepResult::StepOk
  }
}

impl FromResidual for StepResult {
  fn from_residual(r: ResultCodeResidual) -> Self {
    Self::StepError(r.0, r.1, r.2)
  }
}

impl std::ops::Residual<()> for ResultCodeResidual {
  type TryType = StepResult;
}