hecto/src/row.rs

236 lines
6.2 KiB
Rust
Raw Normal View History

2021-03-15 13:53:30 -04:00
use crate::highlighting;
use crate::SearchDirection;
2021-03-08 10:43:40 -05:00
use std::cmp;
2021-03-12 17:46:31 -05:00
use termion::color;
2021-03-08 14:21:24 -05:00
use unicode_segmentation::UnicodeSegmentation;
2021-03-08 10:43:40 -05:00
2021-03-10 13:48:21 -05:00
#[derive(Default)]
2021-03-08 10:21:06 -05:00
pub struct Row {
string: String,
2021-03-15 13:53:30 -04:00
highlighting: Vec<highlighting::Type>,
2021-03-08 14:21:24 -05:00
len: usize,
2021-03-08 10:43:40 -05:00
}
impl From<&str> for Row {
fn from(slice: &str) -> Self {
Self {
2021-03-08 10:43:40 -05:00
string: String::from(slice),
2021-03-15 13:53:30 -04:00
highlighting: Vec::new(),
len: slice.graphemes(true).count(),
}
2021-03-08 10:43:40 -05:00
}
}
impl Row {
pub fn render(&self, start: usize, end: usize) -> String {
let end = cmp::min(end, self.string.len());
let start = cmp::min(start, end);
2021-03-08 14:21:24 -05:00
let mut result = String::new();
2021-03-15 14:37:41 -04:00
let mut current_highlighting = &highlighting::Type::None;
2021-03-08 14:21:24 -05:00
#[allow(clippy::integer_arithmetic)]
2021-03-15 14:37:41 -04:00
for (index, grapheme) in self.string[..]
2021-03-08 14:21:24 -05:00
.graphemes(true)
2021-03-15 14:37:41 -04:00
.enumerate()
2021-03-08 14:21:24 -05:00
.skip(start)
.take(end - start)
{
2021-03-12 17:46:31 -05:00
if let Some(c) = grapheme.chars().next() {
2021-03-15 14:37:41 -04:00
let highlighting_type = self
.highlighting
.get(index)
.unwrap_or(&highlighting::Type::None);
if highlighting_type != current_highlighting {
current_highlighting = highlighting_type;
let start_highlight =
format!("{}", termion::color::Fg(highlighting_type.to_color()));
result.push_str(&start_highlight[..]);
}
2021-03-12 17:46:31 -05:00
if c == '\t' {
result.push_str(" ");
} else {
result.push(c);
}
2021-03-08 14:21:24 -05:00
}
}
2021-03-15 14:37:41 -04:00
let end_highlight = format!("{}", termion::color::Fg(color::Reset));
result.push_str(&end_highlight[..]);
2021-03-08 14:21:24 -05:00
result
}
pub fn len(&self) -> usize {
self.len
}
pub fn is_empty(&self) -> bool {
self.len == 0
}
2021-03-10 13:48:21 -05:00
pub fn insert(&mut self, at: usize, c: char) {
if at >= self.len() {
self.string.push(c);
self.len += 1;
return;
}
let mut result = String::new();
let mut length = 0;
for (index, grapheme) in self.string[..].graphemes(true).enumerate() {
length += 1;
2021-03-10 13:48:21 -05:00
if index == at {
length += 1;
result.push(c);
}
2021-03-10 13:48:21 -05:00
result.push_str(grapheme);
2021-03-10 13:48:21 -05:00
}
self.len = length;
self.string = result;
2021-03-10 13:48:21 -05:00
}
#[allow(clippy::integer_arithmetic)]
2021-03-10 13:48:21 -05:00
pub fn delete(&mut self, at: usize) {
if at >= self.len() {
return;
}
2021-03-10 13:48:21 -05:00
let mut result = String::new();
let mut length = 0;
2021-03-10 13:48:21 -05:00
for (index, grapheme) in self.string[..].graphemes(true).enumerate() {
if index != at {
length += 1;
result.push_str(grapheme);
}
2021-03-10 13:48:21 -05:00
}
self.len = length;
self.string = result;
2021-03-10 13:48:21 -05:00
}
2021-03-10 14:37:58 -05:00
pub fn append(&mut self, new: &Self) {
self.string = format!("{}{}", self.string, new.string);
self.len += new.len;
2021-03-10 14:37:58 -05:00
}
pub fn split(&mut self, at: usize) -> Self {
let mut row = String::new();
let mut length = 0;
let mut splitted_row = String::new();
let mut splittend_length = 0;
for (index, grapheme) in self.string[..].graphemes(true).enumerate() {
if index < at {
length += 1;
row.push_str(grapheme);
} else {
splittend_length += 1;
splitted_row.push_str(grapheme);
}
}
2021-03-10 14:37:58 -05:00
self.string = row;
self.len = length;
2021-03-10 14:37:58 -05:00
Self {
string: splitted_row,
len: splittend_length,
2021-03-15 13:53:30 -04:00
highlighting: Vec::new(),
}
2021-03-10 14:37:58 -05:00
}
2021-03-10 14:51:11 -05:00
pub fn as_bytes(&self) -> &[u8] {
self.string.as_bytes()
}
2021-03-12 11:50:28 -05:00
pub fn find(&self, query: &str, at: usize, direction: SearchDirection) -> Option<usize> {
2021-03-15 14:53:08 -04:00
if at > self.len || query.is_empty() {
return None;
}
let (start, end) = match direction {
SearchDirection::Forward => (at, self.len),
SearchDirection::Backward => (0, at),
};
let substring: String = self.string[..]
.graphemes(true)
.skip(start)
.take(end - start)
.collect();
let matching_byte_index = if direction == SearchDirection::Forward {
substring.find(query)
} else {
substring.rfind(query)
};
2021-03-12 12:17:32 -05:00
2021-03-12 11:50:28 -05:00
if let Some(matching_byte_index) = matching_byte_index {
for (grapheme_index, (byte_index, _)) in
2021-03-12 12:17:32 -05:00
substring[..].grapheme_indices(true).enumerate()
2021-03-12 11:50:28 -05:00
{
if matching_byte_index == byte_index {
return Some(start + grapheme_index);
2021-03-12 11:50:28 -05:00
}
}
}
None
}
2021-03-15 13:53:30 -04:00
2021-03-15 14:53:08 -04:00
pub fn highlight(&mut self, word: Option<&str>) {
2021-03-15 13:53:30 -04:00
let mut highlighting = Vec::new();
2021-03-15 14:53:08 -04:00
let chars: Vec<char> = self.string.chars().collect();
let mut matches = Vec::new();
let mut search_index = 0;
if let Some(word) = word {
while let Some(search_match) = self.find(word, search_index, SearchDirection::Forward) {
matches.push(search_match);
if let Some(next_index) = search_match.checked_add(word[..].graphemes(true).count())
{
search_index = next_index
} else {
break;
}
}
}
let mut index = 0;
while let Some(c) = chars.get(index) {
if let Some(word) = word {
if matches.contains(&index) {
for _ in word[..].graphemes(true) {
index += 1;
highlighting.push(highlighting::Type::Match);
}
continue;
}
}
2021-03-15 13:53:30 -04:00
if c.is_ascii_digit() {
highlighting.push(highlighting::Type::Number)
} else {
highlighting.push(highlighting::Type::None)
}
2021-03-15 14:53:08 -04:00
index += 1;
2021-03-15 13:53:30 -04:00
}
self.highlighting = highlighting;
}
}