datui-lib 0.4.1

Data Exploration in the Terminal (library)
Documentation 
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! `T` at the table: the other tables of the source on screen, to open one in its
//! place. Listed from what the open already holds (a workbook's or a database's tab of
//! the Info panel, a spec's record types, a cache's splits), so nothing is read to list
//! them; opening one is an open of the file with `--table`, as home's row for it is.

use std::path::PathBuf;

use crate::OpenOptions;
use crate::widgets::datatable::DataTableState;

/// One table of the source, as the picker lists it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Table {
    /// What `--table` names; `None` for the whole file (every record type).
    pub table: Option<String>,
    /// The picker's line.
    pub label: String,
    /// What is cheap to say of it: a sheet's range and size, a table's columns.
    pub detail: String,
}

/// The tables of the source on screen.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Tables {
    /// The file (or a cache's directory) the tables are in.
    pub file: PathBuf,
    pub tables: Vec<Table>,
    /// The one on screen.
    pub current: Option<usize>,
}

impl Tables {
    /// Whether there is another to switch to.
    pub fn several(&self) -> bool {
        self.tables.len() > 1
    }
}

/// The tables of the dataset `state` opened from `paths` with `options`: `None` for a
/// source of one table, or several files.
pub fn of(state: &DataTableState, paths: &[PathBuf], options: &OpenOptions) -> Option<Tables> {
    let [file] = paths else {
        return None;
    };
    let file = file.clone();
    if let Some(detail) = state.format_detail()
        && !detail.tables.is_empty()
    {
        return Some(from_detail(file, detail, options.table.as_deref()));
    }
    if let Some(read) = state.format_read()
        && !read.spec.is_delimited()
        && read.spec.records.variants.len() > 1
    {
        return Some(record_types(file, &read.spec));
    }
    let splits = options.splits.as_deref()?;
    let current = splits.split.clone()?;
    if splits.others.is_empty() {
        return None;
    }
    let mut names: Vec<String> = splits.others.clone();
    names.push(current.clone());
    names.sort();
    names.dedup();
    let at = names.iter().position(|n| *n == current);
    Some(Tables {
        file,
        tables: names
            .into_iter()
            .map(|name| Table {
                table: Some(name.clone()),
                label: name,
                detail: "split".to_string(),
            })
            .collect(),
        current: at,
    })
}

/// Whether [`of`] would list more than one table, without listing them: asked by the
/// footer each frame.
pub fn several(state: &DataTableState, paths: &[PathBuf], options: &OpenOptions) -> bool {
    if paths.len() != 1 {
        return false;
    }
    if let Some(detail) = state.format_detail()
        && !detail.tables.is_empty()
    {
        return detail.tables.len() > 1;
    }
    if let Some(read) = state.format_read()
        && !read.spec.is_delimited()
        && read.spec.records.variants.len() > 1
    {
        return true;
    }
    options
        .splits
        .as_deref()
        .is_some_and(|s| s.split.is_some() && s.others.iter().any(|o| Some(o) != s.split.as_ref()))
}

/// A workbook's worksheets or a database's tables, as its tab of the Info panel lists
/// them: what that says of each, less that it is the one opened, which the picker marks.
fn from_detail(file: PathBuf, detail: &crate::text_formats::Detail, asked: Option<&str>) -> Tables {
    let said = |name: &str| {
        detail
            .list
            .iter()
            .find(|(key, _)| key == name)
            .map(|(_, value)| match value {
                crate::model_files::MetaValue::Text(text) => text
                    .split(", ")
                    .filter(|part| *part != "opened")
                    .collect::<Vec<_>>()
                    .join(", "),
                _ => String::new(),
            })
            .unwrap_or_default()
    };
    let opened = detail.table.as_deref().or(asked);
    let current = opened.and_then(|name| detail.tables.iter().position(|t| t == name));
    Tables {
        file,
        tables: detail
            .tables
            .iter()
            .map(|name| Table {
                table: Some(name.clone()),
                label: name.clone(),
                detail: said(name),
            })
            .collect(),
        current,
    }
}

/// A format spec's record types, after the whole file (every type, a `type` column
/// saying which).
fn record_types(file: PathBuf, spec: &crate::formats::Spec) -> Tables {
    let current = spec.variant.as_deref();
    let whole = Table {
        table: None,
        label: file
            .file_name()
            .map(|n| n.to_string_lossy().into_owned())
            .unwrap_or_else(|| file.display().to_string()),
        detail: "every record type".to_string(),
    };
    let types = crate::members::variant_tables(spec)
        .into_iter()
        .map(|t| Table {
            detail: crate::text_formats::count(t.columns.len() as u64, "column", "columns"),
            table: Some(t.name.clone()),
            label: t.name,
        });
    let tables: Vec<Table> = std::iter::once(whole).chain(types).collect();
    let at = tables.iter().position(|t| t.table.as_deref() == current);
    Tables {
        file,
        tables,
        current: at,
    }
}