tabiew 0.14.0

A lightweight TUI application to view and query tabular data files, such as CSV, TSV, and parquet.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::io::Read;

use polars::{
    frame::DataFrame,
    prelude::{AnyValue, Column},
};
use scraper::{ElementRef, Html, Selector};

use crate::{
    AppResult,
    args::Args,
    io::reader::{DataFrameReader, NamedFrames, ReaderSource},
    misc::stdin::stdin,
};

#[derive(Debug, Default)]
pub struct HtmlToDataFrame;

impl HtmlToDataFrame {
    pub fn from_args(_args: &Args) -> Self {
        Self
    }
}

impl DataFrameReader for HtmlToDataFrame {
    fn read_to_data_frames(&self, input: ReaderSource) -> AppResult<NamedFrames> {
        let contents = match &input {
            ReaderSource::File(path) => std::fs::read_to_string(path)?,
            ReaderSource::Stdin => {
                let mut s = String::new();
                stdin().read_to_string(&mut s)?;
                s
            }
        };

        let document = Html::parse_document(&contents);
        let table_selector = Selector::parse("table").unwrap();

        document
            .select(&table_selector)
            .enumerate()
            .map(|(idx, table)| {
                let df = table_to_data_frame(table)?;
                Ok((format!("html_table_{}", idx + 1), df))
            })
            .collect::<AppResult<Vec<_>>>()
            .map(Vec::into_boxed_slice)
    }
}

fn table_to_data_frame(table: ElementRef) -> AppResult<DataFrame> {
    let thead_th_selector = Selector::parse("thead th").unwrap();
    let tr_selector = Selector::parse("tr").unwrap();
    let cell_selector = Selector::parse("th, td").unwrap();

    let header_cells: Vec<String> = table.select(&thead_th_selector).map(cell_text).collect();

    let has_thead_headers = !header_cells.is_empty();

    let data_rows: Vec<Vec<String>> = table
        .select(&tr_selector)
        .filter(|tr| {
            if !has_thead_headers {
                return true;
            }
            !tr.ancestors().any(|node| {
                ElementRef::wrap(node)
                    .map(|e| e.value().name() == "thead")
                    .unwrap_or(false)
            })
        })
        .map(|tr| tr.select(&cell_selector).map(cell_text).collect())
        .collect();

    let column_count = if has_thead_headers {
        header_cells.len()
    } else {
        data_rows.iter().map(Vec::len).max().unwrap_or(0)
    };

    let headers: Vec<String> = if has_thead_headers {
        header_cells
    } else {
        (1..=column_count).map(|i| format!("column_{i}")).collect()
    };

    let mut columns: Vec<Vec<AnyValue<'static>>> = (0..column_count).map(|_| Vec::new()).collect();
    for row in data_rows {
        let mut row_iter = row.into_iter();
        for col in columns.iter_mut() {
            col.push(match row_iter.next() {
                Some(value) => AnyValue::StringOwned(value.into()),
                None => AnyValue::Null,
            });
        }
    }

    Ok(DataFrame::new_infer_height(
        headers
            .into_iter()
            .zip(columns)
            .map(|(name, values)| Column::new(name.into(), values))
            .collect(),
    )?)
}

fn cell_text(elem: ElementRef) -> String {
    elem.text().collect::<String>().trim().to_owned()
}