691 lines
16 KiB
Rust
691 lines
16 KiB
Rust
use std::{env, fmt::{Debug, Write}, io::{BufRead, BufReader, Read}, iter::Peekable, os::fd::{AsFd, BorrowedFd, RawFd}, str::Chars};
|
||
|
||
use nix::{errno::Errno, libc::{self, STDIN_FILENO}, poll::{self, PollFlags, PollTimeout}, sys::termios, unistd::isatty};
|
||
use unicode_segmentation::UnicodeSegmentation;
|
||
use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
|
||
|
||
use crate::{libsh::error::{ShErr, ShErrKind, ShResult}, prompt::readline::keys::{KeyCode, ModKeys}};
|
||
use crate::prelude::*;
|
||
|
||
use super::{keys::KeyEvent, linebuf::LineBuf};
|
||
|
||
pub fn raw_mode() -> RawModeGuard {
|
||
let orig = termios::tcgetattr(unsafe{BorrowedFd::borrow_raw(STDIN_FILENO)}).expect("Failed to get terminal attributes");
|
||
let mut raw = orig.clone();
|
||
termios::cfmakeraw(&mut raw);
|
||
termios::tcsetattr(unsafe{BorrowedFd::borrow_raw(STDIN_FILENO)}, termios::SetArg::TCSANOW, &raw)
|
||
.expect("Failed to set terminal to raw mode");
|
||
RawModeGuard { orig, fd: STDIN_FILENO }
|
||
}
|
||
|
||
pub type Row = u16;
|
||
pub type Col = u16;
|
||
|
||
#[derive(Default,Clone,Copy,PartialEq,Eq,PartialOrd,Ord,Debug)]
|
||
pub struct Pos {
|
||
col: Col,
|
||
row: Row
|
||
}
|
||
|
||
// I'd like to thank rustyline for this idea
|
||
nix::ioctl_read_bad!(win_size, libc::TIOCGWINSZ, libc::winsize);
|
||
|
||
pub fn get_win_size(fd: RawFd) -> (Col,Row) {
|
||
use std::mem::zeroed;
|
||
|
||
if cfg!(test) {
|
||
return (80,24)
|
||
}
|
||
|
||
unsafe {
|
||
let mut size: libc::winsize = zeroed();
|
||
match win_size(fd, &mut size) {
|
||
Ok(0) => {
|
||
/* rustyline code says:
|
||
In linux pseudo-terminals are created with dimensions of
|
||
zero. If host application didn't initialize the correct
|
||
size before start we treat zero size as 80 columns and
|
||
infinite rows
|
||
*/
|
||
let cols = if size.ws_col == 0 { 80 } else { size.ws_col };
|
||
let rows = if size.ws_row == 0 {
|
||
u16::MAX
|
||
} else {
|
||
size.ws_row
|
||
};
|
||
(cols, rows)
|
||
}
|
||
_ => (80,24)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn write_all(fd: RawFd, buf: &str) -> nix::Result<()> {
|
||
let mut bytes = buf.as_bytes();
|
||
while !bytes.is_empty() {
|
||
match nix::unistd::write(unsafe { BorrowedFd::borrow_raw(fd) }, bytes) {
|
||
Ok(0) => return Err(Errno::EIO),
|
||
Ok(n) => bytes = &bytes[n..],
|
||
Err(Errno::EINTR) => {}
|
||
Err(r) => return Err(r),
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
// Big credit to rustyline for this
|
||
fn width(s: &str, esc_seq: &mut u8) -> u16 {
|
||
let w_calc = width_calculator();
|
||
if *esc_seq == 1 {
|
||
if s == "[" {
|
||
// CSI
|
||
*esc_seq = 2;
|
||
} else {
|
||
// two-character sequence
|
||
*esc_seq = 0;
|
||
}
|
||
0
|
||
} else if *esc_seq == 2 {
|
||
if s == ";" || (s.as_bytes()[0] >= b'0' && s.as_bytes()[0] <= b'9') {
|
||
/*} else if s == "m" {
|
||
// last
|
||
*esc_seq = 0;*/
|
||
} else {
|
||
// not supported
|
||
*esc_seq = 0;
|
||
}
|
||
0
|
||
} else if s == "\x1b" {
|
||
*esc_seq = 1;
|
||
0
|
||
} else if s == "\n" {
|
||
0
|
||
} else {
|
||
w_calc.width(s) as u16
|
||
}
|
||
}
|
||
|
||
pub fn width_calculator() -> Box<dyn WidthCalculator> {
|
||
match env::var("TERM_PROGRAM").as_deref() {
|
||
Ok("Apple_Terminal") => Box::new(UnicodeWidth),
|
||
Ok("iTerm.app") => Box::new(UnicodeWidth),
|
||
Ok("WezTerm") => Box::new(UnicodeWidth),
|
||
Err(std::env::VarError::NotPresent) => match std::env::var("TERM").as_deref() {
|
||
Ok("xterm-kitty") => Box::new(NoZwj),
|
||
_ => Box::new(WcWidth)
|
||
},
|
||
_ => Box::new(WcWidth)
|
||
}
|
||
}
|
||
|
||
fn read_digits_until(rdr: &mut TermReader, sep: char) -> ShResult<Option<u32>> {
|
||
let mut num: u32 = 0;
|
||
loop {
|
||
match rdr.next_byte()? as char {
|
||
digit @ '0'..='9' => {
|
||
let digit = digit.to_digit(10).unwrap();
|
||
num = append_digit(num, digit);
|
||
continue;
|
||
}
|
||
c if c == sep => break,
|
||
_ => return Ok(None),
|
||
}
|
||
}
|
||
Ok(Some(num))
|
||
}
|
||
|
||
pub fn append_digit(left: u32, right: u32) -> u32 {
|
||
left.saturating_mul(10)
|
||
.saturating_add(right)
|
||
}
|
||
|
||
|
||
pub trait WidthCalculator {
|
||
fn width(&self, text: &str) -> usize;
|
||
}
|
||
|
||
pub trait KeyReader {
|
||
fn read_key(&mut self) -> Option<KeyEvent>;
|
||
}
|
||
|
||
pub trait LineWriter {
|
||
fn clear_rows(&mut self, layout: &Layout) -> ShResult<()>;
|
||
fn redraw(
|
||
&mut self,
|
||
prompt: &str,
|
||
line: &LineBuf,
|
||
new_layout: &Layout,
|
||
) -> ShResult<()>;
|
||
fn flush_write(&mut self, buf: &str) -> ShResult<()>;
|
||
}
|
||
|
||
#[derive(Clone,Copy,Debug)]
|
||
pub struct UnicodeWidth;
|
||
|
||
impl WidthCalculator for UnicodeWidth {
|
||
fn width(&self, text: &str) -> usize {
|
||
text.width()
|
||
}
|
||
}
|
||
|
||
#[derive(Clone,Copy,Debug)]
|
||
pub struct WcWidth;
|
||
|
||
impl WcWidth {
|
||
pub fn cwidth(&self, ch: char) -> usize {
|
||
ch.width().unwrap()
|
||
}
|
||
}
|
||
|
||
impl WidthCalculator for WcWidth {
|
||
fn width(&self, text: &str) -> usize {
|
||
let mut width = 0;
|
||
for ch in text.chars() {
|
||
width += self.cwidth(ch)
|
||
}
|
||
width
|
||
}
|
||
}
|
||
|
||
const ZWJ: char = '\u{200D}';
|
||
#[derive(Clone,Copy,Debug)]
|
||
pub struct NoZwj;
|
||
|
||
impl WidthCalculator for NoZwj {
|
||
fn width(&self, text: &str) -> usize {
|
||
let mut width = 0;
|
||
for slice in text.split(ZWJ) {
|
||
width += UnicodeWidth.width(slice);
|
||
}
|
||
width
|
||
}
|
||
}
|
||
|
||
pub struct TermBuffer {
|
||
tty: RawFd
|
||
}
|
||
|
||
impl TermBuffer {
|
||
pub fn new(tty: RawFd) -> Self {
|
||
assert!(isatty(tty).is_ok_and(|r| r));
|
||
Self {
|
||
tty
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Read for TermBuffer {
|
||
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
|
||
assert!(isatty(self.tty).is_ok_and(|r| r));
|
||
loop {
|
||
match nix::unistd::read(self.tty, buf) {
|
||
Ok(n) => return Ok(n),
|
||
Err(Errno::EINTR) => {}
|
||
Err(e) => return Err(std::io::Error::from_raw_os_error(e as i32))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
pub struct RawModeGuard {
|
||
orig: termios::Termios,
|
||
fd: RawFd,
|
||
}
|
||
|
||
impl RawModeGuard {
|
||
/// Disable raw mode temporarily for a specific operation
|
||
pub fn disable_for<F: FnOnce() -> R, R>(&self, func: F) -> R {
|
||
unsafe {
|
||
let fd = BorrowedFd::borrow_raw(self.fd);
|
||
// Temporarily restore the original termios
|
||
termios::tcsetattr(fd, termios::SetArg::TCSANOW, &self.orig)
|
||
.expect("Failed to temporarily disable raw mode");
|
||
|
||
// Run the function
|
||
let result = func();
|
||
|
||
// Re-enable raw mode
|
||
let mut raw = self.orig.clone();
|
||
termios::cfmakeraw(&mut raw);
|
||
termios::tcsetattr(fd, termios::SetArg::TCSANOW, &raw)
|
||
.expect("Failed to re-enable raw mode");
|
||
|
||
result
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Drop for RawModeGuard {
|
||
fn drop(&mut self) {
|
||
unsafe {
|
||
let _ = termios::tcsetattr(BorrowedFd::borrow_raw(self.fd), termios::SetArg::TCSANOW, &self.orig);
|
||
}
|
||
}
|
||
}
|
||
|
||
pub struct TermReader {
|
||
buffer: BufReader<TermBuffer>
|
||
}
|
||
|
||
impl Default for TermReader {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|
||
|
||
impl TermReader {
|
||
pub fn new() -> Self {
|
||
Self {
|
||
buffer: BufReader::new(TermBuffer::new(1))
|
||
}
|
||
}
|
||
|
||
|
||
/// Execute some logic in raw mode
|
||
///
|
||
/// Saves the termios before running the given function.
|
||
/// If the given function panics, the panic will halt momentarily to restore the termios
|
||
pub fn poll(&mut self, timeout: PollTimeout) -> ShResult<bool> {
|
||
if !self.buffer.buffer().is_empty() {
|
||
return Ok(true)
|
||
}
|
||
|
||
let mut fds = [poll::PollFd::new(self.as_fd(),PollFlags::POLLIN)];
|
||
let r = poll::poll(&mut fds, timeout);
|
||
match r {
|
||
Ok(n) => Ok(n != 0),
|
||
Err(Errno::EINTR) => Ok(false),
|
||
Err(e) => Err(e.into())
|
||
}
|
||
}
|
||
|
||
pub fn next_byte(&mut self) -> std::io::Result<u8> {
|
||
let mut buf = [0u8];
|
||
self.buffer.read_exact(&mut buf)?;
|
||
Ok(buf[0])
|
||
}
|
||
|
||
pub fn peek_byte(&mut self) -> std::io::Result<u8> {
|
||
let buf = self.buffer.fill_buf()?;
|
||
if buf.is_empty() {
|
||
Err(std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "EOF"))
|
||
} else {
|
||
Ok(buf[0])
|
||
}
|
||
}
|
||
|
||
pub fn consume_byte(&mut self) {
|
||
self.buffer.consume(1);
|
||
}
|
||
|
||
|
||
|
||
pub fn parse_esc_seq(&mut self) -> ShResult<KeyEvent> {
|
||
let mut seq = vec![0x1b];
|
||
|
||
let b1 = self.peek_byte()?;
|
||
self.consume_byte();
|
||
seq.push(b1);
|
||
|
||
match b1 {
|
||
b'[' => {
|
||
let b2 = self.peek_byte()?;
|
||
self.consume_byte();
|
||
seq.push(b2);
|
||
|
||
match b2 {
|
||
b'A' => Ok(KeyEvent(KeyCode::Up, ModKeys::empty())),
|
||
b'B' => Ok(KeyEvent(KeyCode::Down, ModKeys::empty())),
|
||
b'C' => Ok(KeyEvent(KeyCode::Right, ModKeys::empty())),
|
||
b'D' => Ok(KeyEvent(KeyCode::Left, ModKeys::empty())),
|
||
b'1'..=b'9' => {
|
||
let mut digits = vec![b2];
|
||
|
||
loop {
|
||
let b = self.peek_byte()?;
|
||
seq.push(b);
|
||
self.consume_byte();
|
||
|
||
if b == b'~' || b == b';' {
|
||
break;
|
||
} else if b.is_ascii_digit() {
|
||
digits.push(b);
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
let key = match digits.as_slice() {
|
||
[b'1'] => KeyCode::Home,
|
||
[b'3'] => KeyCode::Delete,
|
||
[b'4'] => KeyCode::End,
|
||
[b'5'] => KeyCode::PageUp,
|
||
[b'6'] => KeyCode::PageDown,
|
||
[b'7'] => KeyCode::Home, // xterm alternate
|
||
[b'8'] => KeyCode::End, // xterm alternate
|
||
|
||
[b'1', b'5'] => KeyCode::F(5),
|
||
[b'1', b'7'] => KeyCode::F(6),
|
||
[b'1', b'8'] => KeyCode::F(7),
|
||
[b'1', b'9'] => KeyCode::F(8),
|
||
[b'2', b'0'] => KeyCode::F(9),
|
||
[b'2', b'1'] => KeyCode::F(10),
|
||
[b'2', b'3'] => KeyCode::F(11),
|
||
[b'2', b'4'] => KeyCode::F(12),
|
||
_ => KeyCode::Esc,
|
||
};
|
||
|
||
Ok(KeyEvent(key, ModKeys::empty()))
|
||
}
|
||
_ => Ok(KeyEvent(KeyCode::Esc, ModKeys::empty())),
|
||
}
|
||
}
|
||
b'O' => {
|
||
let b2 = self.peek_byte()?;
|
||
self.consume_byte();
|
||
seq.push(b2);
|
||
|
||
let key = match b2 {
|
||
b'P' => KeyCode::F(1),
|
||
b'Q' => KeyCode::F(2),
|
||
b'R' => KeyCode::F(3),
|
||
b'S' => KeyCode::F(4),
|
||
_ => KeyCode::Esc,
|
||
};
|
||
|
||
Ok(KeyEvent(key, ModKeys::empty()))
|
||
}
|
||
_ => Ok(KeyEvent(KeyCode::Esc, ModKeys::empty())),
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
impl KeyReader for TermReader {
|
||
fn read_key(&mut self) -> Option<KeyEvent> {
|
||
use core::str;
|
||
|
||
let mut collected = Vec::with_capacity(4);
|
||
|
||
loop {
|
||
let byte = self.next_byte().ok()?;
|
||
flog!(DEBUG, "read byte: {:?}",byte as char);
|
||
collected.push(byte);
|
||
|
||
// If it's an escape seq, delegate to ESC sequence handler
|
||
if collected[0] == 0x1b && collected.len() == 1 && self.poll(PollTimeout::ZERO).ok()? {
|
||
return self.parse_esc_seq().ok();
|
||
}
|
||
|
||
// Try parse as valid UTF-8
|
||
if let Ok(s) = str::from_utf8(&collected) {
|
||
return Some(KeyEvent::new(s, ModKeys::empty()));
|
||
}
|
||
|
||
// UTF-8 max 4 bytes — if it’s invalid at this point, bail
|
||
if collected.len() >= 4 {
|
||
break;
|
||
}
|
||
}
|
||
|
||
None
|
||
}
|
||
}
|
||
|
||
impl AsFd for TermReader {
|
||
fn as_fd(&self) -> BorrowedFd<'_> {
|
||
let fd = self.buffer.get_ref().tty;
|
||
unsafe { BorrowedFd::borrow_raw(fd) }
|
||
}
|
||
}
|
||
|
||
pub struct Layout {
|
||
pub w_calc: Box<dyn WidthCalculator>,
|
||
pub prompt_end: Pos,
|
||
pub cursor: Pos,
|
||
pub end: Pos
|
||
}
|
||
|
||
impl Debug for Layout {
|
||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||
writeln!(f, "Layout: ")?;
|
||
writeln!(f, "\tPrompt End: {:?}",self.prompt_end)?;
|
||
writeln!(f, "\tCursor: {:?}",self.cursor)?;
|
||
writeln!(f, "\tEnd: {:?}",self.end)
|
||
}
|
||
}
|
||
|
||
impl Layout {
|
||
pub fn new() -> Self {
|
||
let w_calc = width_calculator();
|
||
Self {
|
||
w_calc,
|
||
prompt_end: Pos::default(),
|
||
cursor: Pos::default(),
|
||
end: Pos::default(),
|
||
}
|
||
}
|
||
pub fn from_parts(
|
||
tab_stop: u16,
|
||
term_width: u16,
|
||
prompt: &str,
|
||
to_cursor: &str,
|
||
to_end: &str,
|
||
) -> Self {
|
||
flog!(DEBUG,to_cursor);
|
||
let prompt_end = Self::calc_pos(tab_stop, term_width, prompt, Pos { col: 0, row: 0 });
|
||
let cursor = Self::calc_pos(tab_stop, term_width, to_cursor, prompt_end);
|
||
let end = Self::calc_pos(tab_stop, term_width, to_end, prompt_end);
|
||
Layout { w_calc: width_calculator(), prompt_end, cursor, end }
|
||
}
|
||
|
||
pub fn calc_pos(tab_stop: u16, term_width: u16, s: &str, orig: Pos) -> Pos {
|
||
let mut pos = orig;
|
||
let mut esc_seq = 0;
|
||
for c in s.graphemes(true) {
|
||
if c == "\n" {
|
||
pos.row += 1;
|
||
pos.col = 0;
|
||
}
|
||
let c_width = if c == "\t" {
|
||
tab_stop - (pos.col % tab_stop)
|
||
} else {
|
||
width(c, &mut esc_seq)
|
||
};
|
||
pos.col += c_width;
|
||
if pos.col > term_width {
|
||
pos.row += 1;
|
||
pos.col = c_width;
|
||
}
|
||
}
|
||
if pos.col >= term_width {
|
||
pos.row += 1;
|
||
pos.col = 0;
|
||
}
|
||
|
||
pos
|
||
}
|
||
}
|
||
|
||
impl Default for Layout {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|
||
|
||
pub struct TermWriter {
|
||
out: RawFd,
|
||
t_cols: Col, // terminal width
|
||
buffer: String,
|
||
w_calc: Box<dyn WidthCalculator>,
|
||
tab_stop: u16,
|
||
}
|
||
|
||
impl TermWriter {
|
||
pub fn new(out: RawFd) -> Self {
|
||
let w_calc = width_calculator();
|
||
let (t_cols,_) = get_win_size(out);
|
||
Self {
|
||
out,
|
||
t_cols,
|
||
buffer: String::new(),
|
||
w_calc,
|
||
tab_stop: 8 // TODO: add a way to configure this
|
||
}
|
||
}
|
||
pub fn get_cursor_movement(&self, old: Pos, new: Pos) -> ShResult<String> {
|
||
let mut buffer = String::new();
|
||
let err = |_| ShErr::simple(ShErrKind::InternalErr, "Failed to write to cursor movement buffer");
|
||
|
||
match new.row.cmp(&old.row) {
|
||
std::cmp::Ordering::Greater => {
|
||
let shift = new.row - old.row;
|
||
match shift {
|
||
1 => buffer.push_str("\x1b[B"),
|
||
_ => write!(buffer, "\x1b[{shift}B").map_err(err)?
|
||
}
|
||
}
|
||
std::cmp::Ordering::Less => {
|
||
let shift = old.row - new.row;
|
||
match shift {
|
||
1 => buffer.push_str("\x1b[A"),
|
||
_ => write!(buffer, "\x1b[{shift}A").map_err(err)?
|
||
}
|
||
}
|
||
std::cmp::Ordering::Equal => { /* Do nothing */ }
|
||
}
|
||
|
||
match new.col.cmp(&old.col) {
|
||
std::cmp::Ordering::Greater => {
|
||
let shift = new.col - old.col;
|
||
match shift {
|
||
1 => buffer.push_str("\x1b[C"),
|
||
_ => write!(buffer, "\x1b[{shift}C").map_err(err)?
|
||
}
|
||
}
|
||
std::cmp::Ordering::Less => {
|
||
let shift = old.col - new.col;
|
||
match shift {
|
||
1 => buffer.push_str("\x1b[D"),
|
||
_ => write!(buffer, "\x1b[{shift}D").map_err(err)?
|
||
}
|
||
}
|
||
std::cmp::Ordering::Equal => { /* Do nothing */ }
|
||
}
|
||
Ok(buffer)
|
||
}
|
||
pub fn move_cursor(&mut self, old: Pos, new: Pos) -> ShResult<()> {
|
||
self.buffer.clear();
|
||
let movement = self.get_cursor_movement(old, new)?;
|
||
|
||
write_all(self.out, &movement)?;
|
||
Ok(())
|
||
}
|
||
|
||
|
||
|
||
pub fn update_t_cols(&mut self) {
|
||
let (t_cols,_) = get_win_size(self.out);
|
||
self.t_cols = t_cols;
|
||
}
|
||
|
||
pub fn move_cursor_at_leftmost(&mut self, rdr: &mut TermReader, use_newline: bool) -> ShResult<()> {
|
||
let result = rdr.poll(PollTimeout::ZERO)?;
|
||
if result {
|
||
// The terminals reply is going to be stuck behind the currently buffered output
|
||
// So let's get out of here
|
||
return Ok(())
|
||
}
|
||
|
||
// Ping the cursor's position
|
||
self.flush_write("\x1b[6n\n")?;
|
||
|
||
if !rdr.poll(PollTimeout::from(255u8))? {
|
||
return Ok(())
|
||
}
|
||
|
||
if rdr.next_byte()? as char != '\x1b' {
|
||
return Ok(())
|
||
}
|
||
|
||
if rdr.next_byte()? as char != '[' {
|
||
return Ok(())
|
||
}
|
||
|
||
if read_digits_until(rdr, ';')?.is_none() {
|
||
return Ok(())
|
||
}
|
||
|
||
// We just consumed everything up to the column number, so let's get that now
|
||
let col = read_digits_until(rdr, 'R')?;
|
||
|
||
// The cursor is not at the leftmost, so let's fix that
|
||
if col != Some(1) {
|
||
if use_newline {
|
||
// We use '\n' instead of '\r' sometimes because if there's a bunch of garbage on this line,
|
||
// It might pollute the prompt/line buffer if those are shorter than said garbage
|
||
self.flush_write("\n")?;
|
||
} else {
|
||
// Sometimes though, we know that there's nothing to the right of the cursor after moving
|
||
// So we just move to the left.
|
||
self.flush_write("\r")?;
|
||
}
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
impl LineWriter for TermWriter {
|
||
fn clear_rows(&mut self, layout: &Layout) -> ShResult<()> {
|
||
self.buffer.clear();
|
||
let rows_to_clear = layout.end.row;
|
||
let cursor_row = layout.cursor.row;
|
||
|
||
let cursor_motion = rows_to_clear.saturating_sub(cursor_row);
|
||
if cursor_motion > 0 {
|
||
write!(self.buffer, "\x1b[{cursor_motion}B").unwrap()
|
||
}
|
||
|
||
for _ in 0..rows_to_clear {
|
||
self.buffer.push_str("\x1b[2K\x1b[A");
|
||
}
|
||
self.buffer.push_str("\x1b[2K");
|
||
write_all(self.out,self.buffer.as_str())?;
|
||
self.buffer.clear();
|
||
Ok(())
|
||
}
|
||
|
||
fn redraw(
|
||
&mut self,
|
||
prompt: &str,
|
||
line: &LineBuf,
|
||
new_layout: &Layout,
|
||
) -> ShResult<()> {
|
||
let err = |_| ShErr::simple(ShErrKind::InternalErr, "Failed to write to LineWriter internal buffer");
|
||
self.buffer.clear();
|
||
|
||
let end = new_layout.end;
|
||
let cursor = new_layout.cursor;
|
||
|
||
self.buffer.push_str(prompt);
|
||
self.buffer.push_str(&line.to_string());
|
||
|
||
if end.col == 0 && end.row > 0 && !self.buffer.ends_with('\n') {
|
||
// The line has wrapped. We need to use our own line break.
|
||
self.buffer.push('\n');
|
||
}
|
||
|
||
let movement = self.get_cursor_movement(end, cursor)?;
|
||
write!(self.buffer, "{}", &movement).map_err(err)?;
|
||
|
||
write_all(self.out, self.buffer.as_str())?;
|
||
Ok(())
|
||
}
|
||
|
||
fn flush_write(&mut self, buf: &str) -> ShResult<()> {
|
||
write_all(self.out, buf)?;
|
||
Ok(())
|
||
}
|
||
}
|