v0.2.9 : ps/where/get facon Nushell avec mini-pipeline (ls | where size > 1mb | get name), dir = ls sur Windows, ls beaucoup plus rapide (taille des dossiers bornee a 500 entrees), autocomplet : prefixe commun + menu avec descriptions + fallback chemins

src/tables.rs

@@ -0,0 +1,328 @@
+//! Generic Nushell-style tables: render a boxed table, filter rows with
+//! where-like predicates and select a column with get.
+
+use anyhow::{bail, Result};
+use colored::Colorize;
+
+/// One cell: the text to display plus a typed value for filtering
+/// (number, byte size, or plain string).
+#[derive(Debug, Clone)]
+pub struct Cell {
+    pub text: String,
+    pub num: Option<f64>,
+    pub bytes: Option<u64>,
+}
+
+impl Cell {
+    pub fn str(s: impl Into<String>) -> Self {
+        Cell {
+            text: s.into(),
+            num: None,
+            bytes: None,
+        }
+    }
+
+    pub fn num(n: f64, text: String) -> Self {
+        Cell {
+            text,
+            num: Some(n),
+            bytes: None,
+        }
+    }
+
+    pub fn bytes(b: u64, text: String) -> Self {
+        Cell {
+            text,
+            num: None,
+            bytes: Some(b),
+        }
+    }
+}
+
+/// A tabular result produced by ls, ps, where or get.
+#[derive(Debug, Clone, Default)]
+pub struct DataTable {
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<Cell>>,
+}
+
+impl DataTable {
+    pub fn column_index(&self, name: &str) -> Option<usize> {
+        self.columns
+            .iter()
+            .position(|c| c.eq_ignore_ascii_case(name))
+    }
+
+    /// Render the boxed Nushell-style table.
+    pub fn render(&self, color: bool) -> String {
+        let headers = self.columns.clone();
+        // Column 0 is the row index; the data columns follow.
+        let index_width = self.rows.len().to_string().len().max(1);
+        let mut widths: Vec<usize> = headers.iter().map(|h| visible_len(h)).collect();
+        let mut cells: Vec<Vec<String>> = Vec::new();
+        for (i, row) in self.rows.iter().enumerate() {
+            let mut line = vec![i.to_string()];
+            for cell in row {
+                line.push(cell.text.clone());
+            }
+            for (c, cell) in line.iter().enumerate().skip(1) {
+                widths[c - 1] = widths[c - 1].max(visible_len(cell));
+            }
+            cells.push(line);
+        }
+        let all_headers: Vec<String> = std::iter::once("#".to_string())
+            .chain(headers.iter().cloned())
+            .collect();
+        let mut all_widths = vec![index_width];
+        all_widths.extend(widths.iter().cloned());
+        for (c, w) in all_widths.iter_mut().enumerate() {
+            if c < all_headers.len() {
+                *w = (*w).max(visible_len(&all_headers[c]));
+            }
+        }
+
+        let pad = |s: &str, w: usize| -> String {
+            let n = visible_len(s);
+            format!("{s}{}", " ".repeat(w.saturating_sub(n)))
+        };
+        let border = |left: char, mid: char, right: char| -> String {
+            let mut line = String::new();
+            line.push(left);
+            for (i, w) in all_widths.iter().enumerate() {
+                if i > 0 {
+                    line.push(mid);
+                }
+                line.push_str(&"─".repeat(w + 2));
+            }
+            line.push(right);
+            line
+        };
+        let row_line = |row: &[String], bold: bool| -> String {
+            let mut line = String::from("│");
+            for (i, c) in row.iter().enumerate() {
+                line.push(' ');
+                let cell = pad(c, all_widths[i]);
+                let rendered = if bold {
+                    cell.bold().to_string()
+                } else {
+                    cell
+                };
+                line.push_str(&rendered);
+                line.push(' ');
+                line.push('│');
+            }
+            line
+        };
+        let dim = |s: &str| -> String {
+            if color {
+                s.dimmed().to_string()
+            } else {
+                s.to_string()
+            }
+        };
+
+        let mut out = String::new();
+        out.push_str(&dim(&border('╭', '┬', '╮')));
+        out.push('\n');
+        out.push_str(&row_line(&all_headers, true));
+        out.push('\n');
+        out.push_str(&dim(&border('├', '┼', '┤')));
+        out.push('\n');
+        for line in &cells {
+            out.push_str(&row_line(line, false));
+            out.push('\n');
+        }
+        out.push_str(&dim(&border('╰', '┴', '╯')));
+        out.push('\n');
+        out
+    }
+}
+
+/// Parse a where value: "1mb"/"512kb"/"2gb" become byte sizes, numbers
+/// become numbers, everything else is a string.
+#[derive(Debug, Clone, PartialEq)]
+enum WhereValue {
+    Num(f64),
+    Bytes(u64),
+    Str(String),
+}
+
+fn parse_value(raw: &str) -> WhereValue {
+    let lower = raw.trim().to_lowercase();
+    for (suffix, mult) in [("gb", 1024u64.pow(3)), ("mb", 1024u64.pow(2)), ("kb", 1024)] {
+        if let Some(n) = lower.strip_suffix(suffix) {
+            if let Ok(v) = n.trim().parse::<f64>() {
+                return WhereValue::Bytes((v * mult as f64) as u64);
+            }
+        }
+    }
+    if let Ok(v) = raw.trim().parse::<f64>() {
+        return WhereValue::Num(v);
+    }
+    WhereValue::Str(raw.trim().to_string())
+}
+
+fn num_cmp(a: f64, b: f64, op: &str) -> bool {
+    match op {
+        ">" => a > b,
+        "<" => a < b,
+        ">=" => a >= b,
+        "<=" => a <= b,
+        "==" => (a - b).abs() < f64::EPSILON,
+        "!=" => (a - b).abs() >= f64::EPSILON,
+        _ => false,
+    }
+}
+
+/// Filter the rows of a table: where <field> <op> <value>.
+pub fn filter_where(table: &DataTable, field: &str, op: &str, value: &str) -> Result<DataTable> {
+    let Some(idx) = table.column_index(field) else {
+        bail!(
+            "unknown column '{field}' — available: {}",
+            table.columns.join(", ")
+        );
+    };
+    let val = parse_value(value);
+    let supported = matches!(op, ">" | "<" | ">=" | "<=" | "==" | "!=" | "=~");
+    if !supported {
+        bail!("unknown operator '{op}' — use > < >= <= == != =~");
+    }
+    let mut out = table.clone();
+    out.rows.retain(|row| match row.get(idx) {
+        None => false,
+        Some(cell) => match &val {
+            WhereValue::Num(n) => match cell.num {
+                Some(v) => num_cmp(v, *n, op),
+                None => false,
+            },
+            WhereValue::Bytes(b) => match cell.bytes {
+                Some(v) => num_cmp(v as f64, *b as f64, op),
+                None => false,
+            },
+            WhereValue::Str(s) => {
+                let text = strip_ansi(&cell.text);
+                match op {
+                    "==" => text.eq_ignore_ascii_case(s),
+                    "!=" => !text.eq_ignore_ascii_case(s),
+                    "=~" => text.to_lowercase().contains(&s.to_lowercase()),
+                    _ => false,
+                }
+            }
+        },
+    });
+    Ok(out)
+}
+
+/// Select one column: get <column>.
+pub fn get_column(table: &DataTable, field: &str) -> Result<DataTable> {
+    let Some(idx) = table.column_index(field) else {
+        bail!(
+            "unknown column '{field}' — available: {}",
+            table.columns.join(", ")
+        );
+    };
+    Ok(DataTable {
+        columns: vec![field.to_string()],
+        rows: table
+            .rows
+            .iter()
+            .map(|row| vec![row[idx].clone()])
+            .collect(),
+    })
+}
+
+fn strip_ansi(s: &str) -> String {
+    let mut out = String::new();
+    let mut chars = s.chars();
+    while let Some(c) = chars.next() {
+        if c == '\u{1b}' {
+            for n in chars.by_ref() {
+                if n == 'm' {
+                    break;
+                }
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
+fn visible_len(s: &str) -> usize {
+    strip_ansi(s).chars().count()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn sample() -> DataTable {
+        DataTable {
+            columns: vec!["name".into(), "type".into(), "size".into()],
+            rows: vec![
+                vec![
+                    Cell::str("src"),
+                    Cell::str("dir"),
+                    Cell::bytes(2048, "2.0 KB".into()),
+                ],
+                vec![
+                    Cell::str("am.exe"),
+                    Cell::str("file"),
+                    Cell::bytes(5_000_000, "4.8 MB".into()),
+                ],
+                vec![
+                    Cell::str("readme.md"),
+                    Cell::str("file"),
+                    Cell::bytes(512, "512 B".into()),
+                ],
+            ],
+        }
+    }
+
+    #[test]
+    fn filters_numeric_and_size() {
+        let t = sample();
+        let big = filter_where(&t, "size", ">", "1mb").unwrap();
+        assert_eq!(big.rows.len(), 1);
+        assert_eq!(big.rows[0][0].text, "am.exe");
+        let eq = filter_where(&t, "type", "==", "dir").unwrap();
+        assert_eq!(eq.rows.len(), 1);
+        let contains = filter_where(&t, "name", "=~", "read").unwrap();
+        assert_eq!(contains.rows.len(), 1);
+    }
+
+    #[test]
+    fn get_selects_column() {
+        let t = sample();
+        let names = get_column(&t, "name").unwrap();
+        assert_eq!(names.columns, vec!["name".to_string()]);
+        assert_eq!(names.rows.len(), 3);
+        assert_eq!(names.rows[1][0].text, "am.exe");
+    }
+
+    #[test]
+    fn unknown_column_errors() {
+        let t = sample();
+        assert!(filter_where(&t, "nope", "==", "x").is_err());
+        assert!(get_column(&t, "nope").is_err());
+    }
+
+    #[test]
+    fn parses_where_values() {
+        assert_eq!(parse_value("1mb"), WhereValue::Bytes(1024 * 1024));
+        assert_eq!(parse_value("512kb"), WhereValue::Bytes(512 * 1024));
+        assert_eq!(parse_value("3.5"), WhereValue::Num(3.5));
+        assert_eq!(parse_value("hello"), WhereValue::Str("hello".into()));
+    }
+
+    #[test]
+    fn render_is_aligned() {
+        let t = sample();
+        let text = t.render(false);
+        assert!(text.contains("╭"));
+        assert!(text.contains("name"));
+        assert!(text.contains("am.exe"));
+        let widths: Vec<usize> = text.lines().map(|l| l.chars().count()).collect();
+        assert!(widths.iter().all(|w| *w == widths[0]), "unaligned:\n{text}");
+    }
+}