Mercurial > hg
view rust/rhg/src/ui.rs @ 47589:f5c24c124e07
dirstate: introduce an internal `_add` method
We want to split current user of `dirstate.add` between `hg add`-like cases and
update of the dirstate coming from update/merge.
To do this we will introduce new API. The first step is to introduces an
internal function that these new API migh use (or not use) to distinct between
the migrated users and the others.
Differential Revision: https://phab.mercurial-scm.org/D11010
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Wed, 07 Jul 2021 19:31:52 +0200 |
parents | 21d3b40b4c0e |
children | 38deb65d4441 |
line wrap: on
line source
use format_bytes::format_bytes; use std::borrow::Cow; use std::io; use std::io::{ErrorKind, Write}; #[derive(Debug)] pub struct Ui { stdout: std::io::Stdout, stderr: std::io::Stderr, } /// The kind of user interface error pub enum UiError { /// The standard output stream cannot be written to StdoutError(io::Error), /// The standard error stream cannot be written to StderrError(io::Error), } /// The commandline user interface impl Ui { pub fn new() -> Self { Ui { stdout: std::io::stdout(), stderr: std::io::stderr(), } } /// Returns a buffered handle on stdout for faster batch printing /// operations. pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> { StdoutBuffer::new(self.stdout.lock()) } /// Write bytes to stdout pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> { let mut stdout = self.stdout.lock(); stdout.write_all(bytes).or_else(handle_stdout_error)?; stdout.flush().or_else(handle_stdout_error) } /// Write bytes to stderr pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> { let mut stderr = self.stderr.lock(); stderr.write_all(bytes).or_else(handle_stderr_error)?; stderr.flush().or_else(handle_stderr_error) } } /// A buffered stdout writer for faster batch printing operations. pub struct StdoutBuffer<W: Write> { buf: io::BufWriter<W>, } impl<W: Write> StdoutBuffer<W> { pub fn new(writer: W) -> Self { let buf = io::BufWriter::new(writer); Self { buf } } /// Write bytes to stdout buffer pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> { self.buf.write_all(bytes).or_else(handle_stdout_error) } /// Flush bytes to stdout pub fn flush(&mut self) -> Result<(), UiError> { self.buf.flush().or_else(handle_stdout_error) } } /// Sometimes writing to stdout is not possible, try writing to stderr to /// signal that failure, otherwise just bail. fn handle_stdout_error(error: io::Error) -> Result<(), UiError> { if let ErrorKind::BrokenPipe = error.kind() { // This makes `| head` work for example return Ok(()); } let mut stderr = io::stderr(); stderr .write_all(&format_bytes!( b"abort: {}\n", error.to_string().as_bytes() )) .map_err(UiError::StderrError)?; stderr.flush().map_err(UiError::StderrError)?; Err(UiError::StdoutError(error)) } /// Sometimes writing to stderr is not possible. fn handle_stderr_error(error: io::Error) -> Result<(), UiError> { // A broken pipe should not result in a error // like with `| head` for example if let ErrorKind::BrokenPipe = error.kind() { return Ok(()); } Err(UiError::StdoutError(error)) } /// Encode rust strings according to the user system. pub fn utf8_to_local(s: &str) -> Cow<[u8]> { // TODO encode for the user's system // let bytes = s.as_bytes(); Cow::Borrowed(bytes) }