mirror of
https://github.com/nushell/nushell.git
synced 2025-06-03 00:26:26 +02:00
69e4790b00
# Description I introduced a regression in #13272 that resulted in `detect columns --guess` to panic whenever it had to handle empty, whitespace-only, or non-whitespace-only lines that go all the way to the last column (and as such, cannot be considered to be lines that only have entries for the first colum). I fix this by detecting these cases and skipping them, since these are usually decoration lines. An example is the second line output by `winget list`:  What we don't want to skip, however, is lines that contain no whitespace, and fit into the detected first column, since these lines represent cases where data is only available for the first column, and are not just decoration lines. For example (made up example, there are no such entries in `winget lits`'s output), in this output we would not want to skip the `Docker Desktop` line : ``` Name Id Version Available Source ------------------------------------------------------------------------------------------------------------------------------------- AMD Software ARPMachineX64AMD Catalyst Install Manager 24.4.1 AMD Ryzen Master ARPMachineX64AMD Ryzen Master 2.13.0.2908 Docker Desktop Mozilla Firefox (x64 en-US) Mozilla.Firefox 127.0.2 winget ```  NOTE: `winget list | detect columns --guess` does not panic, but sadly still does not work as expected. I believe this is not a nushell issue anymore, but a `winget` one. When being piped, `winget` seems to add extra whitespace and random `\r` symbols at the beginning of the text. This messes with the column detection, of course.    # User-Facing Changes `detect columns --guess` should not panic when receiving output from `winget list` at all anymore. A breaking change is the skipping of decoration lines, especially since scripts probably were doing something like `winget list | lines | reject 1 | str join "\n" | detect columns --guess`. This will now cause them to reject a line with valid data. # Tests + Formatting Added tests that exercise these edge cases, as well as a single-column test to make sure that trivial cases keep working. # After Submitting <!-- If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date. -->
636 lines
19 KiB
Rust
636 lines
19 KiB
Rust
/// Attribution: https://github.com/noborus/guesswidth/blob/main/guesswidth.go
|
|
/// The MIT License (MIT) as of 2024-03-22
|
|
///
|
|
/// GuessWidth handles the format as formatted by printf.
|
|
/// Spaces exist as delimiters, but spaces are not always delimiters.
|
|
/// The width seems to be a fixed length, but it doesn't always fit.
|
|
/// GuessWidth finds the column separation position
|
|
/// from the reference line(header) and multiple lines(body).
|
|
|
|
/// Briefly, the algorithm uses a histogram of spaces to find widths.
|
|
/// blanks, lines, and pos are variables used in the algorithm. The other
|
|
/// items names below are just for reference.
|
|
/// blanks = 0000003000113333111100003000
|
|
/// lines = " PID TTY TIME CMD"
|
|
/// "302965 pts/3 00:00:11 zsh"
|
|
/// "709737 pts/3 00:00:00 ps"
|
|
///
|
|
/// measure= "012345678901234567890123456789"
|
|
/// spaces = " ^ ^ ^"
|
|
/// pos = 6 15 24 <- the carets show these positions
|
|
/// the items in pos map to 3's in the blanks array
|
|
|
|
/// Now that we have pos, we can let split() use this pos array to figure out
|
|
/// how to split all lines by comparing each index to see if there's a space.
|
|
/// So, it looks at position 6, 15, 24 and sees if it has a space in those
|
|
/// positions. If it does, it splits the line there. If it doesn't, it wiggles
|
|
/// around the position to find the next space and splits there.
|
|
use std::io::{self, BufRead};
|
|
use unicode_width::UnicodeWidthStr;
|
|
|
|
/// the number to scan to analyze.
|
|
const SCAN_NUM: u8 = 128;
|
|
/// the minimum number of lines to recognize as a separator.
|
|
/// 1 if only the header, 2 or more if there is a blank in the body.
|
|
const MIN_LINES: usize = 2;
|
|
/// whether to trim the space in the value.
|
|
const TRIM_SPACE: bool = true;
|
|
/// the base line number. It starts from 0.
|
|
const HEADER: usize = 0;
|
|
|
|
/// GuessWidth reads records from printf-like output.
|
|
pub struct GuessWidth {
|
|
pub(crate) reader: io::BufReader<Box<dyn io::Read>>,
|
|
// a list of separator positions.
|
|
pub(crate) pos: Vec<usize>,
|
|
// stores the lines read for scan.
|
|
pub(crate) pre_lines: Vec<String>,
|
|
// the number returned by read.
|
|
pub(crate) pre_count: usize,
|
|
// the maximum number of columns to split.
|
|
pub(crate) limit_split: usize,
|
|
}
|
|
|
|
impl GuessWidth {
|
|
pub fn new_reader(r: Box<dyn io::Read>) -> GuessWidth {
|
|
let reader = io::BufReader::new(r);
|
|
GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
}
|
|
}
|
|
|
|
/// read_all reads all rows
|
|
/// and returns a two-dimensional slice of rows and columns.
|
|
pub fn read_all(&mut self) -> Vec<Vec<String>> {
|
|
if self.pre_lines.is_empty() {
|
|
self.scan(SCAN_NUM);
|
|
}
|
|
|
|
let mut rows = Vec::new();
|
|
while let Ok(columns) = self.read() {
|
|
if !columns.is_empty() {
|
|
rows.push(columns);
|
|
}
|
|
}
|
|
rows
|
|
}
|
|
|
|
/// scan preReads and parses the lines.
|
|
fn scan(&mut self, num: u8) {
|
|
for _ in 0..num {
|
|
let mut buf = String::new();
|
|
if self.reader.read_line(&mut buf).unwrap_or(0) == 0 {
|
|
break;
|
|
}
|
|
|
|
let line = buf.trim_end().to_string();
|
|
self.pre_lines.push(line);
|
|
}
|
|
|
|
self.pos = positions(&self.pre_lines, HEADER, MIN_LINES);
|
|
if self.limit_split > 0 && self.pos.len() > self.limit_split {
|
|
self.pos.truncate(self.limit_split);
|
|
}
|
|
}
|
|
|
|
/// read reads one row and returns a slice of columns.
|
|
/// scan is executed first if it is not preRead.
|
|
fn read(&mut self) -> Result<Vec<String>, io::Error> {
|
|
if self.pre_lines.is_empty() {
|
|
self.scan(SCAN_NUM);
|
|
}
|
|
|
|
if self.pre_count < self.pre_lines.len() {
|
|
let line = &self.pre_lines[self.pre_count];
|
|
self.pre_count += 1;
|
|
Ok(split(line, &self.pos, TRIM_SPACE))
|
|
} else {
|
|
let mut buf = String::new();
|
|
if self.reader.read_line(&mut buf)? == 0 {
|
|
return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "End of file"));
|
|
}
|
|
|
|
let line = buf.trim_end().to_string();
|
|
Ok(split(&line, &self.pos, TRIM_SPACE))
|
|
}
|
|
}
|
|
}
|
|
|
|
// positions returns separator positions
|
|
// from multiple lines and header line number.
|
|
// Lines before the header line are ignored.
|
|
fn positions(lines: &[String], header: usize, min_lines: usize) -> Vec<usize> {
|
|
let mut blanks = Vec::new();
|
|
for (n, line) in lines.iter().enumerate() {
|
|
if n < header {
|
|
continue;
|
|
}
|
|
|
|
if n == header {
|
|
blanks = lookup_blanks(line.trim_end_matches(' '));
|
|
continue;
|
|
}
|
|
|
|
count_blanks(&mut blanks, line.trim_end_matches(' '));
|
|
}
|
|
|
|
positions_helper(&blanks, min_lines)
|
|
}
|
|
|
|
fn separator_position(lr: &[char], p: usize, pos: &[usize], n: usize) -> usize {
|
|
if lr[p].is_whitespace() {
|
|
return p;
|
|
}
|
|
|
|
let mut f = p;
|
|
while f < lr.len() && !lr[f].is_whitespace() {
|
|
f += 1;
|
|
}
|
|
|
|
let mut b = p;
|
|
while b > 0 && !lr[b].is_whitespace() {
|
|
b -= 1;
|
|
}
|
|
|
|
if b == pos[n] {
|
|
return f;
|
|
}
|
|
|
|
if n < pos.len() - 1 {
|
|
if f == pos[n + 1] {
|
|
return b;
|
|
}
|
|
if b == pos[n] {
|
|
return f;
|
|
}
|
|
if b > pos[n] && b < pos[n + 1] {
|
|
return b;
|
|
}
|
|
}
|
|
|
|
f
|
|
}
|
|
|
|
fn split(line: &str, pos: &[usize], trim_space: bool) -> Vec<String> {
|
|
let mut n = 0;
|
|
let mut start_char = 0;
|
|
let mut columns = Vec::with_capacity(pos.len() + 1);
|
|
let (line_char_boundaries, line_chars): (Vec<usize>, Vec<char>) = line.char_indices().unzip();
|
|
let mut w = 0;
|
|
|
|
if line_chars.is_empty() || line_chars.iter().all(|&c| c.is_whitespace()) {
|
|
// current line is completely empty, or only filled with whitespace
|
|
return Vec::new();
|
|
} else if !pos.is_empty()
|
|
&& line_chars.iter().all(|&c| !c.is_whitespace())
|
|
&& pos[0] < UnicodeWidthStr::width(line)
|
|
{
|
|
// we have more than 1 column in the input, but the current line has no whitespace,
|
|
// and it is longer than the first detected column separation position
|
|
// this indicates some kind of decoration line. let's skip it
|
|
return Vec::new();
|
|
}
|
|
|
|
for p in 0..line_char_boundaries.len() {
|
|
if pos.is_empty() || n > pos.len() - 1 {
|
|
start_char = p;
|
|
break;
|
|
}
|
|
|
|
if pos[n] <= w {
|
|
let end_char = separator_position(&line_chars, p, pos, n);
|
|
if start_char > end_char {
|
|
break;
|
|
}
|
|
let col = &line[line_char_boundaries[start_char]..line_char_boundaries[end_char]];
|
|
let col = if trim_space { col.trim() } else { col };
|
|
columns.push(col.to_string());
|
|
n += 1;
|
|
start_char = end_char;
|
|
}
|
|
|
|
w += UnicodeWidthStr::width(line_chars[p].to_string().as_str());
|
|
}
|
|
|
|
// add last part.
|
|
let col = &line[line_char_boundaries[start_char]..];
|
|
let col = if trim_space { col.trim() } else { col };
|
|
columns.push(col.to_string());
|
|
columns
|
|
}
|
|
|
|
// Creates a blank(1) and non-blank(0) slice.
|
|
// Execute for the base line (header line).
|
|
fn lookup_blanks(line: &str) -> Vec<usize> {
|
|
let mut blanks = Vec::new();
|
|
let mut first = true;
|
|
|
|
for c in line.chars() {
|
|
if c == ' ' {
|
|
if first {
|
|
blanks.push(0);
|
|
continue;
|
|
}
|
|
blanks.push(1);
|
|
continue;
|
|
}
|
|
|
|
first = false;
|
|
blanks.push(0);
|
|
if UnicodeWidthStr::width(c.to_string().as_str()) == 2 {
|
|
blanks.push(0);
|
|
}
|
|
}
|
|
|
|
blanks
|
|
}
|
|
|
|
// count up if the line is blank where the reference line was blank.
|
|
fn count_blanks(blanks: &mut [usize], line: &str) {
|
|
let mut n = 0;
|
|
|
|
for c in line.chars() {
|
|
if n >= blanks.len() {
|
|
break;
|
|
}
|
|
|
|
if c == ' ' && blanks[n] > 0 {
|
|
blanks[n] += 1;
|
|
}
|
|
|
|
n += 1;
|
|
if UnicodeWidthStr::width(c.to_string().as_str()) == 2 {
|
|
n += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generates a list of separator positions from a blank slice.
|
|
fn positions_helper(blanks: &[usize], min_lines: usize) -> Vec<usize> {
|
|
let mut max = min_lines;
|
|
let mut p = 0;
|
|
let mut pos = Vec::new();
|
|
|
|
for (n, v) in blanks.iter().enumerate() {
|
|
if *v >= max {
|
|
max = *v;
|
|
p = n;
|
|
}
|
|
if *v == 0 {
|
|
max = min_lines;
|
|
if p > 0 {
|
|
pos.push(p);
|
|
p = 0;
|
|
}
|
|
}
|
|
}
|
|
pos
|
|
}
|
|
|
|
// to_rows returns rows separated by columns.
|
|
#[allow(dead_code)]
|
|
fn to_rows(lines: Vec<String>, pos: Vec<usize>, trim_space: bool) -> Vec<Vec<String>> {
|
|
let mut rows: Vec<Vec<String>> = Vec::with_capacity(lines.len());
|
|
for line in lines {
|
|
let columns = split(&line, &pos, trim_space);
|
|
rows.push(columns);
|
|
}
|
|
rows
|
|
}
|
|
|
|
// to_table parses a slice of lines and returns a table.
|
|
#[allow(dead_code)]
|
|
pub fn to_table(lines: Vec<String>, header: usize, trim_space: bool) -> Vec<Vec<String>> {
|
|
let pos = positions(&lines, header, 2);
|
|
to_rows(lines, pos, trim_space)
|
|
}
|
|
|
|
// to_table_n parses a slice of lines and returns a table, but limits the number of splits.
|
|
#[allow(dead_code)]
|
|
pub fn to_table_n(
|
|
lines: Vec<String>,
|
|
header: usize,
|
|
num_split: usize,
|
|
trim_space: bool,
|
|
) -> Vec<Vec<String>> {
|
|
let mut pos = positions(&lines, header, 2);
|
|
if pos.len() > num_split {
|
|
pos.truncate(num_split);
|
|
}
|
|
to_rows(lines, pos, trim_space)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{to_table, to_table_n, GuessWidth};
|
|
|
|
#[test]
|
|
fn test_guess_width_ps_trim() {
|
|
let input = " PID TTY TIME CMD
|
|
302965 pts/3 00:00:11 zsh
|
|
709737 pts/3 00:00:00 ps";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
#[rustfmt::skip]
|
|
let want = vec![
|
|
vec!["PID", "TTY", "TIME", "CMD"],
|
|
vec!["302965", "pts/3", "00:00:11", "zsh"],
|
|
vec!["709737", "pts/3", "00:00:00", "ps"],
|
|
];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_ps_overflow_trim() {
|
|
let input = "USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
|
|
root 1 0.0 0.0 168576 13788 ? Ss Mar11 0:49 /sbin/init splash
|
|
noborus 703052 2.1 0.7 1184814400 230920 ? Sl 10:03 0:45 /opt/google/chrome/chrome
|
|
noborus 721971 0.0 0.0 13716 3524 pts/3 R+ 10:39 0:00 ps aux";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
#[rustfmt::skip]
|
|
let want = vec![
|
|
vec!["USER", "PID", "%CPU", "%MEM", "VSZ", "RSS", "TTY", "STAT", "START", "TIME", "COMMAND"],
|
|
vec!["root", "1", "0.0", "0.0", "168576", "13788", "?", "Ss", "Mar11", "0:49", "/sbin/init splash"],
|
|
vec!["noborus", "703052", "2.1", "0.7", "1184814400", "230920", "?", "Sl", "10:03", "0:45", "/opt/google/chrome/chrome"],
|
|
vec!["noborus", "721971", "0.0", "0.0", "13716", "3524", "pts/3", "R+", "10:39", "0:00", "ps aux"],
|
|
];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_ps_limit_trim() {
|
|
let input = " PID TTY TIME CMD
|
|
302965 pts/3 00:00:11 zsh
|
|
709737 pts/3 00:00:00 ps";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 2,
|
|
};
|
|
|
|
#[rustfmt::skip]
|
|
let want = vec![
|
|
vec!["PID", "TTY", "TIME CMD"],
|
|
vec!["302965", "pts/3", "00:00:11 zsh"],
|
|
vec!["709737", "pts/3", "00:00:00 ps"],
|
|
];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_windows_df_trim() {
|
|
let input = "Filesystem 1K-blocks Used Available Use% Mounted on
|
|
C:/Apps/Git 998797308 869007000 129790308 88% /
|
|
D: 104792064 17042676 87749388 17% /d";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
#[rustfmt::skip]
|
|
let want = vec![
|
|
vec!["Filesystem","1K-blocks","Used","Available","Use%","Mounted on"],
|
|
vec!["C:/Apps/Git","998797308","869007000","129790308","88%","/"],
|
|
vec!["D:","104792064","17042676","87749388","17%","/d"],
|
|
];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_multibyte() {
|
|
let input = "A… B\nC… D";
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
let want = vec![vec!["A…", "B"], vec!["C…", "D"]];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_combining_diacritical_marks() {
|
|
let input = "Name Surname
|
|
Ștefan Țincu ";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
let want = vec![vec!["Name", "Surname"], vec!["Ștefan", "Țincu"]];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_single_column() {
|
|
let input = "A
|
|
|
|
B
|
|
|
|
C";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
let want = vec![vec!["A"], vec!["B"], vec!["C"]];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_row_without_whitespace() {
|
|
let input = "A B C D
|
|
-------
|
|
E F G H";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
let want = vec![vec!["A", "B", "C", "D"], vec!["E", "F", "G", "H"]];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_row_with_single_column() {
|
|
let input = "A B C D
|
|
E
|
|
F G H I";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
let want = vec![
|
|
vec!["A", "B", "C", "D"],
|
|
vec!["E"],
|
|
vec!["F", "G", "H", "I"],
|
|
];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_empty_row() {
|
|
let input = "A B C D
|
|
|
|
E F G H";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
let want = vec![vec!["A", "B", "C", "D"], vec!["E", "F", "G", "H"]];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_guess_width_row_with_only_whitespace() {
|
|
let input = "A B C D
|
|
|
|
E F G H";
|
|
|
|
let r = Box::new(std::io::BufReader::new(input.as_bytes())) as Box<dyn std::io::Read>;
|
|
let reader = std::io::BufReader::new(r);
|
|
|
|
let mut guess_width = GuessWidth {
|
|
reader,
|
|
pos: Vec::new(),
|
|
pre_lines: Vec::new(),
|
|
pre_count: 0,
|
|
limit_split: 0,
|
|
};
|
|
|
|
let want = vec![vec!["A", "B", "C", "D"], vec!["E", "F", "G", "H"]];
|
|
let got = guess_width.read_all();
|
|
assert_eq!(got, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_table() {
|
|
let lines = vec![
|
|
" PID TTY TIME CMD".to_string(),
|
|
"302965 pts/3 00:00:11 zsh".to_string(),
|
|
"709737 pts/3 00:00:00 ps".to_string(),
|
|
];
|
|
|
|
let want = vec![
|
|
vec!["PID", "TTY", "TIME", "CMD"],
|
|
vec!["302965", "pts/3", "00:00:11", "zsh"],
|
|
vec!["709737", "pts/3", "00:00:00", "ps"],
|
|
];
|
|
|
|
let header = 0;
|
|
let trim_space = true;
|
|
let table = to_table(lines, header, trim_space);
|
|
assert_eq!(table, want);
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_table_n() {
|
|
let lines = vec![
|
|
"2022-12-21T09:50:16+0000 WARN A warning that should be ignored is usually at this level and should be actionable.".to_string(),
|
|
"2022-12-21T09:50:17+0000 INFO This is less important than debug log and is often used to provide context in the current task.".to_string(),
|
|
];
|
|
|
|
let want = vec![
|
|
vec!["2022-12-21T09:50:16+0000", "WARN", "A warning that should be ignored is usually at this level and should be actionable."],
|
|
vec!["2022-12-21T09:50:17+0000", "INFO", "This is less important than debug log and is often used to provide context in the current task."],
|
|
];
|
|
|
|
let header = 0;
|
|
let trim_space = true;
|
|
let num_split = 2;
|
|
let table = to_table_n(lines, header, num_split, trim_space);
|
|
assert_eq!(table, want);
|
|
}
|
|
}
|