679 lines
18 KiB
Rust
679 lines
18 KiB
Rust
use std::ops::Range;
|
|
|
|
use crate::{libsh::{error::ShResult, term::{Style, Styled}}, prompt::readline::linecmd::Anchor};
|
|
|
|
use super::linecmd::{At, CharSearch, MoveCmd, Movement, Repeat, Verb, VerbCmd, Word};
|
|
|
|
|
|
#[derive(Default,Debug)]
|
|
pub struct LineBuf {
|
|
pub buffer: Vec<char>,
|
|
pub inserting: bool,
|
|
pub last_insert: String,
|
|
cursor: usize
|
|
}
|
|
|
|
impl LineBuf {
|
|
pub fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
pub fn with_initial<S: ToString>(mut self, init: S) -> Self {
|
|
self.buffer = init.to_string().chars().collect();
|
|
self
|
|
}
|
|
pub fn begin_insert(&mut self) {
|
|
self.inserting = true;
|
|
}
|
|
pub fn finish_insert(&mut self) {
|
|
self.inserting = false;
|
|
}
|
|
pub fn take_ins_text(&mut self) -> String {
|
|
std::mem::take(&mut self.last_insert)
|
|
}
|
|
pub fn display_lines(&self) -> Vec<String> {
|
|
let line_bullet = "∙ ".styled(Style::Dim);
|
|
self.split_lines()
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(i, line)| {
|
|
if i == 0 {
|
|
line.to_string()
|
|
} else {
|
|
format!("{line_bullet}{line}")
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
pub fn repos_cursor(&mut self) {
|
|
if self.cursor >= self.len() {
|
|
self.cursor = self.len_minus_one();
|
|
}
|
|
}
|
|
pub fn split_lines(&self) -> Vec<String> {
|
|
let line = self.prepare_line();
|
|
let mut lines = vec![];
|
|
let mut cur_line = String::new();
|
|
for ch in line.chars() {
|
|
match ch {
|
|
'\n' => lines.push(std::mem::take(&mut cur_line)),
|
|
_ => cur_line.push(ch)
|
|
}
|
|
}
|
|
lines.push(cur_line);
|
|
lines
|
|
}
|
|
pub fn count_lines(&self) -> usize {
|
|
self.buffer.iter().filter(|&&c| c == '\n').count()
|
|
}
|
|
pub fn cursor(&self) -> usize {
|
|
self.cursor
|
|
}
|
|
pub fn prepare_line(&self) -> String {
|
|
self.buffer
|
|
.iter()
|
|
.filter(|&&c| c != '\r')
|
|
.collect::<String>()
|
|
}
|
|
pub fn clear(&mut self) {
|
|
self.buffer.clear();
|
|
self.cursor = 0;
|
|
}
|
|
pub fn cursor_display_coords(&self) -> (usize, usize) {
|
|
let mut x = 0;
|
|
let mut y = 0;
|
|
for i in 0..self.cursor() {
|
|
let ch = self.get_char(i);
|
|
match ch {
|
|
'\n' => {
|
|
y += 1;
|
|
x = 0;
|
|
}
|
|
'\r' => continue,
|
|
_ => {
|
|
x += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
(x, y)
|
|
}
|
|
pub fn cursor_real_coords(&self) -> (usize,usize) {
|
|
let mut x = 0;
|
|
let mut y = 0;
|
|
for i in 0..self.cursor() {
|
|
let ch = self.get_char(i);
|
|
match ch {
|
|
'\n' => {
|
|
y += 1;
|
|
x = 0;
|
|
}
|
|
_ => {
|
|
x += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
(x, y)
|
|
}
|
|
pub fn backspace(&mut self) {
|
|
if self.cursor() == 0 {
|
|
return
|
|
}
|
|
self.delete_pos(self.cursor() - 1);
|
|
}
|
|
pub fn delete(&mut self) {
|
|
if self.cursor() >= self.buffer.len() {
|
|
return
|
|
}
|
|
self.delete_pos(self.cursor());
|
|
}
|
|
pub fn delete_pos(&mut self, pos: usize) {
|
|
self.buffer.remove(pos);
|
|
if pos < self.cursor() {
|
|
self.cursor = self.cursor.saturating_sub(1)
|
|
}
|
|
}
|
|
pub fn insert_at_pos(&mut self, pos: usize, ch: char) {
|
|
self.buffer.insert(pos, ch)
|
|
}
|
|
pub fn insert_at_cursor(&mut self, ch: char) {
|
|
self.buffer.insert(self.cursor, ch);
|
|
self.move_cursor_right();
|
|
}
|
|
pub fn insert_after_cursor(&mut self, ch: char) {
|
|
self.buffer.insert(self.cursor, ch);
|
|
}
|
|
pub fn backspace_at_cursor(&mut self) {
|
|
assert!(self.cursor <= self.buffer.len());
|
|
if self.buffer.is_empty() {
|
|
return
|
|
}
|
|
self.buffer.remove(self.cursor.saturating_sub(1));
|
|
self.move_cursor_left();
|
|
}
|
|
pub fn del_at_cursor(&mut self) {
|
|
assert!(self.cursor <= self.buffer.len());
|
|
if self.buffer.is_empty() || self.cursor == self.buffer.len() {
|
|
return
|
|
}
|
|
self.buffer.remove(self.cursor);
|
|
}
|
|
pub fn move_cursor_left(&mut self) {
|
|
self.cursor = self.cursor.saturating_sub(1);
|
|
}
|
|
pub fn move_cursor_start(&mut self) {
|
|
self.cursor = 0;
|
|
}
|
|
pub fn move_cursor_end(&mut self) {
|
|
self.cursor = self.buffer.len();
|
|
}
|
|
pub fn move_cursor_right(&mut self) {
|
|
if self.cursor == self.buffer.len() {
|
|
return
|
|
}
|
|
self.cursor = self.cursor.saturating_add(1);
|
|
}
|
|
pub fn del_from_cursor(&mut self) {
|
|
self.buffer.truncate(self.cursor);
|
|
}
|
|
pub fn del_word_back(&mut self) {
|
|
if self.cursor == 0 {
|
|
return
|
|
}
|
|
let end = self.cursor;
|
|
let mut start = self.cursor;
|
|
|
|
while start > 0 && self.buffer[start - 1].is_whitespace() {
|
|
start -= 1;
|
|
}
|
|
|
|
while start > 0 && !self.buffer[start - 1].is_whitespace() {
|
|
start -= 1;
|
|
}
|
|
|
|
self.buffer.drain(start..end);
|
|
self.cursor = start;
|
|
}
|
|
pub fn len(&self) -> usize {
|
|
self.buffer.len()
|
|
}
|
|
pub fn len_minus_one(&self) -> usize {
|
|
self.buffer.len().saturating_sub(1)
|
|
}
|
|
pub fn is_empty(&self) -> bool {
|
|
self.buffer.is_empty()
|
|
}
|
|
pub fn cursor_char(&self) -> Option<&char> {
|
|
self.buffer.get(self.cursor())
|
|
}
|
|
pub fn get_char(&self, pos: usize) -> char {
|
|
assert!((0..self.len()).contains(&pos));
|
|
|
|
self.buffer[pos]
|
|
}
|
|
pub fn prev_char(&self) -> Option<char> {
|
|
if self.cursor() == 0 {
|
|
None
|
|
} else {
|
|
Some(self.get_char(self.cursor() - 1))
|
|
}
|
|
}
|
|
pub fn next_char(&self) -> Option<char> {
|
|
if self.cursor() == self.len_minus_one() {
|
|
None
|
|
} else {
|
|
Some(self.get_char(self.cursor() + 1))
|
|
}
|
|
}
|
|
pub fn on_word_bound_left(&self) -> bool {
|
|
if self.cursor() == 0 {
|
|
return false
|
|
}
|
|
let Some(ch) = self.cursor_char() else {
|
|
return false
|
|
};
|
|
let cur_char_class = CharClass::from(*ch);
|
|
let prev_char_pos = self.cursor().saturating_sub(1).max(0);
|
|
cur_char_class.is_opposite(self.get_char(prev_char_pos))
|
|
}
|
|
pub fn on_word_bound_right(&self) -> bool {
|
|
if self.cursor() >= self.len_minus_one() {
|
|
return false
|
|
}
|
|
let Some(ch) = self.cursor_char() else {
|
|
return false
|
|
};
|
|
let cur_char_class = CharClass::from(*ch);
|
|
let next_char_pos = self.cursor().saturating_add(1).min(self.len());
|
|
cur_char_class.is_opposite(self.get_char(next_char_pos))
|
|
}
|
|
fn backward_until<F: Fn(usize) -> bool>(&self, mut start: usize, cond: F) -> usize {
|
|
while start > 0 && !cond(start) {
|
|
start -= 1;
|
|
}
|
|
start
|
|
}
|
|
fn forward_until<F: Fn(usize) -> bool>(&self, mut start: usize, cond: F) -> usize {
|
|
while start < self.len() && !cond(start) {
|
|
start += 1;
|
|
}
|
|
start
|
|
}
|
|
pub fn calc_range(&mut self, movement: &Movement) -> Range<usize> {
|
|
let mut start = self.cursor();
|
|
let mut end = self.cursor();
|
|
|
|
match movement {
|
|
Movement::WholeLine => {
|
|
start = self.backward_until(start, |pos| self.buffer[pos] == '\n');
|
|
if self.buffer.get(start) == Some(&'\n') {
|
|
start += 1; // Exclude the previous newline
|
|
}
|
|
end = self.forward_until(end, |pos| self.buffer[pos] == '\n');
|
|
}
|
|
Movement::BeginningOfLine => {
|
|
start = self.backward_until(start, |pos| self.buffer[pos] == '\n');
|
|
}
|
|
Movement::BeginningOfFirstWord => {
|
|
let start_of_line = self.backward_until(start, |pos| self.buffer[pos] == '\n');
|
|
start = self.forward_until(start_of_line, |pos| !self.buffer[pos].is_whitespace());
|
|
}
|
|
Movement::EndOfLine => {
|
|
end = self.forward_until(end, |pos| self.buffer[pos] == '\n');
|
|
}
|
|
Movement::BackwardWord(word) => {
|
|
match word {
|
|
Word::Big => {
|
|
if self.cursor_char().is_none() {
|
|
self.cursor = self.cursor.saturating_sub(1);
|
|
start = start.saturating_sub(1)
|
|
}
|
|
// Skip whitespace
|
|
let Some(cur_char) = self.cursor_char() else {
|
|
return start..end
|
|
};
|
|
if cur_char.is_whitespace() {
|
|
start = self.backward_until(start, |pos| !self.buffer[pos].is_whitespace())
|
|
}
|
|
|
|
let ch_class = CharClass::from(self.get_char(start));
|
|
let should_step = self.prev_char().is_some_and(|ch| ch_class.is_opposite(ch));
|
|
// If we are on a word boundary, move forward one character
|
|
// If we are now on whitespace, skip it
|
|
if should_step {
|
|
start = start.saturating_sub(1).max(0);
|
|
if self.get_char(start).is_whitespace() {
|
|
start = self.backward_until(start, |pos| !self.buffer[pos].is_whitespace())
|
|
}
|
|
}
|
|
start = self.backward_until(start, |pos| self.buffer[pos].is_whitespace());
|
|
if self.get_char(start).is_whitespace() {
|
|
start += 1;
|
|
}
|
|
}
|
|
Word::Normal => {
|
|
if self.cursor_char().is_none() {
|
|
self.cursor = self.cursor.saturating_sub(1);
|
|
start = start.saturating_sub(1)
|
|
}
|
|
let Some(cur_char) = self.cursor_char() else {
|
|
return start..end
|
|
};
|
|
// Skip whitespace
|
|
if cur_char.is_whitespace() {
|
|
start = self.backward_until(start, |pos| !self.get_char(pos).is_whitespace())
|
|
}
|
|
|
|
let ch_class = CharClass::from(self.get_char(start));
|
|
let should_step = self.prev_char().is_some_and(|ch| ch_class.is_opposite(ch));
|
|
// If we are on a word boundary, move forward one character
|
|
// If we are now on whitespace, skip it
|
|
if should_step {
|
|
start = start.saturating_sub(1).max(0);
|
|
if self.get_char(start).is_whitespace() {
|
|
start = self.backward_until(start, |pos| !self.get_char(pos).is_whitespace())
|
|
}
|
|
}
|
|
|
|
// Find an alternate charclass to stop at
|
|
let cur_char = self.get_char(start);
|
|
let cur_char_class = CharClass::from(cur_char);
|
|
start = self.backward_until(start, |pos| cur_char_class.is_opposite(self.get_char(pos)));
|
|
if cur_char_class.is_opposite(self.get_char(start)) {
|
|
start += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Movement::ForwardWord(at, word) => {
|
|
let Some(cur_char) = self.cursor_char() else {
|
|
return start..end
|
|
};
|
|
let is_ws = |pos: usize| self.buffer[pos].is_whitespace();
|
|
let not_ws = |pos: usize| !self.buffer[pos].is_whitespace();
|
|
|
|
match word {
|
|
Word::Big => {
|
|
if cur_char.is_whitespace() {
|
|
end = self.forward_until(end, not_ws);
|
|
}
|
|
|
|
let ch_class = CharClass::from(self.buffer[end]);
|
|
let should_step = self.next_char().is_some_and(|ch| ch_class.is_opposite(ch));
|
|
|
|
if should_step {
|
|
end = end.saturating_add(1).min(self.len_minus_one());
|
|
if self.get_char(end).is_whitespace() {
|
|
end = self.forward_until(end, |pos| !self.get_char(pos).is_whitespace())
|
|
}
|
|
}
|
|
|
|
match at {
|
|
At::Start => {
|
|
if !should_step {
|
|
end = self.forward_until(end, is_ws);
|
|
end = self.forward_until(end, not_ws);
|
|
}
|
|
}
|
|
At::AfterEnd => {
|
|
end = self.forward_until(end, is_ws);
|
|
}
|
|
At::BeforeEnd => {
|
|
end = self.forward_until(end, is_ws);
|
|
if self.buffer.get(end).is_some_and(|ch| ch.is_whitespace()) {
|
|
end = end.saturating_sub(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Word::Normal => {
|
|
if cur_char.is_whitespace() {
|
|
end = self.forward_until(end, not_ws);
|
|
}
|
|
|
|
let ch_class = CharClass::from(self.buffer[end]);
|
|
let should_step = self.next_char().is_some_and(|ch| ch_class.is_opposite(ch));
|
|
|
|
if should_step {
|
|
end = end.saturating_add(1).min(self.len_minus_one());
|
|
if self.get_char(end).is_whitespace() {
|
|
end = self.forward_until(end, |pos| !self.get_char(pos).is_whitespace())
|
|
}
|
|
}
|
|
|
|
match at {
|
|
At::Start => {
|
|
if !should_step {
|
|
end = self.forward_until(end, |pos| ch_class.is_opposite(self.buffer[pos]));
|
|
if self.get_char(end).is_whitespace() {
|
|
end = self.forward_until(end, |pos| !self.get_char(pos).is_whitespace())
|
|
}
|
|
}
|
|
}
|
|
At::AfterEnd => {
|
|
end = self.forward_until(end, |pos| ch_class.is_opposite(self.buffer[pos]));
|
|
}
|
|
At::BeforeEnd => {
|
|
end = self.forward_until(end, |pos| ch_class.is_opposite(self.buffer[pos]));
|
|
if self.buffer.get(end).is_some_and(|ch| ch.is_whitespace()) {
|
|
end = end.saturating_sub(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Movement::BackwardChar => {
|
|
start = start.saturating_sub(1);
|
|
}
|
|
Movement::ForwardChar => {
|
|
end = end.saturating_add(1);
|
|
}
|
|
Movement::TextObj(text_obj, bound) => todo!(),
|
|
Movement::CharSearch(char_search) => {
|
|
match char_search {
|
|
CharSearch::FindFwd(ch) => {
|
|
let ch = ch.unwrap();
|
|
end = end.saturating_add(1).min(self.len_minus_one());
|
|
let search = self.forward_until(end, |pos| self.buffer[pos] == ch);
|
|
|
|
// we check anyway because it may have reached the end without finding anything
|
|
if self.buffer.get(search).is_some_and(|&s_ch| s_ch == ch) {
|
|
end = search;
|
|
}
|
|
}
|
|
CharSearch::FwdTo(ch) => {
|
|
let ch = ch.unwrap();
|
|
end = end.saturating_add(1).min(self.len_minus_one());
|
|
let search = self.forward_until(end, |pos| self.buffer[pos] == ch);
|
|
|
|
// we check anyway because it may have reached the end without finding anything
|
|
if self.buffer.get(search).is_some_and(|&s_ch| s_ch == ch) {
|
|
end = search.saturating_sub(1);
|
|
}
|
|
}
|
|
CharSearch::FindBkwd(ch) => {
|
|
let ch = ch.unwrap();
|
|
start = start.saturating_sub(1);
|
|
let search = self.backward_until(start, |pos| self.buffer[pos] == ch);
|
|
|
|
// we check anyway because it may have reached the end without finding anything
|
|
if self.buffer.get(search).is_some_and(|&s_ch| s_ch == ch) {
|
|
start = search;
|
|
}
|
|
}
|
|
CharSearch::BkwdTo(ch) => {
|
|
let ch = ch.unwrap();
|
|
start = start.saturating_sub(1);
|
|
let search = self.backward_until(start, |pos| self.buffer[pos] == ch);
|
|
|
|
// we check anyway because it may have reached the end without finding anything
|
|
if self.buffer.get(search).is_some_and(|&s_ch| s_ch == ch) {
|
|
start = search.saturating_add(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Movement::LineUp => todo!(),
|
|
Movement::LineDown => todo!(),
|
|
Movement::WholeBuffer => {
|
|
start = 0;
|
|
end = self.len_minus_one();
|
|
}
|
|
Movement::BeginningOfBuffer => {
|
|
start = 0;
|
|
}
|
|
Movement::EndOfBuffer => {
|
|
end = self.len_minus_one();
|
|
}
|
|
Movement::Null => {/* nothing */}
|
|
}
|
|
|
|
end = end.min(self.len());
|
|
|
|
start..end
|
|
}
|
|
pub fn exec_vi_cmd(&mut self, verb: Option<Verb>, move_cmd: Option<MoveCmd>) -> ShResult<()> {
|
|
match (verb, move_cmd) {
|
|
(Some(v), None) => self.exec_vi_verb(v),
|
|
(None, Some(m)) => self.exec_vi_movement(m),
|
|
(Some(v), Some(m)) => self.exec_vi_moveverb(v,m),
|
|
(None, None) => unreachable!()
|
|
}
|
|
}
|
|
pub fn exec_vi_verb(&mut self, verb: Verb) -> ShResult<()> {
|
|
assert!(!verb.needs_movement());
|
|
match verb {
|
|
Verb::DeleteOne(anchor) => {
|
|
match anchor {
|
|
Anchor::After => {
|
|
self.delete();
|
|
}
|
|
Anchor::Before => {
|
|
self.backspace();
|
|
}
|
|
}
|
|
}
|
|
Verb::Breakline(anchor) => {
|
|
match anchor {
|
|
Anchor::Before => {
|
|
let last_newline = self.backward_until(self.cursor(), |pos| self.get_char(pos) == '\n');
|
|
self.cursor = last_newline;
|
|
self.insert_at_cursor('\n');
|
|
self.insert_at_cursor('\r');
|
|
}
|
|
Anchor::After => {
|
|
let next_newline = self.forward_until(self.cursor(), |pos| self.get_char(pos) == '\n');
|
|
self.cursor = next_newline;
|
|
self.insert_at_cursor('\n');
|
|
self.insert_at_cursor('\r');
|
|
}
|
|
}
|
|
}
|
|
Verb::InsertChar(ch) => {
|
|
if self.inserting {
|
|
self.last_insert.push(ch);
|
|
}
|
|
self.insert_at_cursor(ch)
|
|
}
|
|
Verb::Insert(text) => {
|
|
for ch in text.chars() {
|
|
if self.inserting {
|
|
self.last_insert.push(ch);
|
|
}
|
|
self.insert_at_cursor(ch);
|
|
}
|
|
}
|
|
Verb::InsertMode => todo!(),
|
|
Verb::JoinLines => todo!(),
|
|
Verb::ToggleCase => todo!(),
|
|
Verb::OverwriteMode => todo!(),
|
|
Verb::Substitute => todo!(),
|
|
Verb::Put(_) => todo!(),
|
|
Verb::Undo => todo!(),
|
|
Verb::RepeatLast => todo!(),
|
|
Verb::Dedent => {
|
|
let mut start_pos = self.backward_until(self.cursor(), |pos| self.get_char(pos) == '\n');
|
|
if self.get_char(start_pos) == '\n' {
|
|
start_pos += 1;
|
|
}
|
|
if self.get_char(start_pos) == '\t' {
|
|
self.delete_pos(start_pos);
|
|
}
|
|
}
|
|
Verb::Indent => {
|
|
let mut line_start = self.backward_until(self.cursor(), |pos| self.get_char(pos) == '\n');
|
|
if self.get_char(line_start) == '\n' {
|
|
line_start += 1;
|
|
}
|
|
self.insert_at_pos(line_start, '\t');
|
|
}
|
|
Verb::ReplaceChar(_) => todo!(),
|
|
_ => unreachable!()
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn exec_vi_movement(&mut self, move_cmd: MoveCmd) -> ShResult<()> {
|
|
let MoveCmd { move_count, movement } = move_cmd;
|
|
for _ in 0..move_count {
|
|
let range = self.calc_range(&movement);
|
|
if range.start != self.cursor() {
|
|
self.cursor = range.start.max(0);
|
|
} else {
|
|
self.cursor = range.end.min(self.len());
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn exec_vi_moveverb(&mut self, verb: Verb, move_cmd: MoveCmd) -> ShResult<()> {
|
|
let MoveCmd { move_count, movement } = move_cmd;
|
|
match verb {
|
|
Verb::Delete => {
|
|
(0..move_count).for_each(|_| {
|
|
let range = self.calc_range(&movement);
|
|
let range = range.start..(range.end + 1).min(self.len());
|
|
self.buffer.drain(range);
|
|
self.repos_cursor();
|
|
});
|
|
}
|
|
Verb::Change => {
|
|
(0..move_count).for_each(|_| {
|
|
let range = self.calc_range(&movement);
|
|
let range = range.start..(range.end + 1).min(self.len());
|
|
self.buffer.drain(range);
|
|
self.repos_cursor();
|
|
});
|
|
}
|
|
Verb::Repeat(rep) => {
|
|
|
|
}
|
|
Verb::DeleteOne(anchor) => todo!(),
|
|
Verb::Breakline(anchor) => todo!(),
|
|
Verb::Yank => todo!(),
|
|
Verb::ReplaceChar(_) => todo!(),
|
|
Verb::Substitute => todo!(),
|
|
Verb::ToggleCase => todo!(),
|
|
Verb::Undo => todo!(),
|
|
Verb::RepeatLast => todo!(),
|
|
Verb::Put(anchor) => todo!(),
|
|
Verb::OverwriteMode => todo!(),
|
|
Verb::InsertMode => todo!(),
|
|
Verb::JoinLines => todo!(),
|
|
Verb::InsertChar(_) => todo!(),
|
|
Verb::Indent => todo!(),
|
|
Verb::Dedent => todo!(),
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub enum CharClass {
|
|
AlphaNum,
|
|
Symbol,
|
|
}
|
|
|
|
impl CharClass {
|
|
pub fn is_opposite(&self, other: char) -> bool {
|
|
let other_class = CharClass::from(other);
|
|
other_class != *self
|
|
}
|
|
}
|
|
|
|
impl From<char> for CharClass {
|
|
fn from(value: char) -> Self {
|
|
if value.is_alphanumeric() || value == '_' {
|
|
CharClass::AlphaNum
|
|
} else {
|
|
CharClass::Symbol
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pub fn strip_ansi_codes_and_escapes(s: &str) -> String {
|
|
let mut out = String::with_capacity(s.len());
|
|
let mut chars = s.chars().peekable();
|
|
|
|
while let Some(c) = chars.next() {
|
|
if c == '\x1b' && chars.peek() == Some(&'[') {
|
|
// Skip over the escape sequence
|
|
chars.next(); // consume '['
|
|
while let Some(&ch) = chars.peek() {
|
|
if ch.is_ascii_lowercase() || ch.is_ascii_uppercase() {
|
|
chars.next(); // consume final letter
|
|
break;
|
|
}
|
|
chars.next(); // consume intermediate characters
|
|
}
|
|
} else {
|
|
match c {
|
|
'\n' |
|
|
'\r' => { /* Continue */ }
|
|
_ => out.push(c)
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|