cic 0.1.0

An interactive csv editor.
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

use csv;

use std::io::{self, Write};

use crate::{Cursor};

/// Contains the data read from a csv
/// Assumes nonzero columns and rows
#[derive(Debug)]
pub struct Table {
    data: Vec<Vec<String>>,
}

impl Table {
    pub fn new() -> Self {
        Self {
            data: vec![vec![String::new()]],
        }
    }

    /// Construct new table from the csv at the provided path.
    pub fn from_path(path: &str) -> Self {
        let mut rdr = csv::Reader::from_path(path).unwrap();
        let mut data: Vec<Vec<String>> = Vec::new();

        let headers: Vec<String> = rdr
            .headers()
            .unwrap()
            .into_iter()
            .map(|x| x.to_string())
            .collect();

        data.push(headers);

        for record in rdr.into_records() {
            let strs = record
                .unwrap()
                .into_iter()
                .map(|x| x.to_owned())
                .collect();
            data.push(strs);
        }
        
        Table { data }
    }

    /// Returns the dimensions of the data within the table.
    /// Cache this value
    pub fn dims(&self) -> (usize, usize) {
        let dimy = self.data.len();
        let dimx = self.data[0].len();
        (dimx, dimy)
    }

    /// Calculates the max characters needed to display all values in a column.
    /// Needs rewrite to be more efficient (after removing headers)
    /// Also cache this value
    pub fn col_widths(&self) -> Vec<i32> {
        self.data.iter().fold(
            self.data[0].iter().map(|h| h.len()).map(|x| x as i32).collect::<Vec<i32>>(),
            |maxes, cur| {
                maxes
                    .iter()
                    .zip(cur.iter())
                    .map(|(m, c)| std::cmp::max::<i32>(*m, c.len() as i32))
                    .collect::<Vec<i32>>()
            },
        )
    }

    /// Add iterator for column widths along with row value?
    /// for (cell, width) in row.iter().zip(table.col_widths().iter()) {
    /// actually do fmt
    pub fn fmt_iter(&self) -> Vec<Vec<String>>{
        let widths = self.col_widths();
        self.data.iter().map(|row|
            row.iter().zip(widths.iter()).map(|(cell, width)| {
                let mut p = cell.clone();
                for _ in cell.len()..(*width as usize) {
                    p.push(' ');
                }
                p
            }).collect()
        ).collect()
    }

    /// Gets the internal data
    /// Should be formalized as iterators
    pub fn rows(&self) -> Vec<Vec<String>> {
        self.data.clone()
    }

    /// Gets a value in the table.
    pub fn get(&self, c: Cursor) -> String {
        self.data[c.y][c.x].clone()
    }

    /// Updates a value in the table.
    pub fn update(&mut self, c: Cursor, new: String) {
        self.data[c.y][c.x] = new;
    }

    /// Adds row before the cursor location.
    pub fn add_row_before(&mut self, c: Cursor) {
        self.add_row(c.y);
    }

    /// Adds row after the cursor location.
    pub fn add_row_after(&mut self, c: Cursor) {
        self.add_row(c.y + 1);
    }

    /// Adds new row before the given index.
    fn add_row(&mut self, r: usize) {
        let (w, _) = self.dims();
        let new_row = vec![String::new(); w];
        self.data.insert(r, new_row);
    }

    /// Adds column before the cursor location.
    pub fn add_col_before(&mut self, c: Cursor) {
        self.add_col(c.x);
    }

    /// Adds column after the cursor location.
    pub fn add_col_after(&mut self, c: Cursor) {
        self.add_col(c.x + 1);
    }

    /// Inserts new column at index
    fn add_col(&mut self, c: usize) {
        for row in &mut self.data {
            row.insert(c, String::new());
        }
    }

    /// Clears the value in the table.
    pub fn clear(&mut self, c: Cursor) {
        self.update(c, String::new());
    }

    /// Deletes the row the cursor lies.
    pub fn delete_row(&mut self, c: &mut Cursor) {
        self.data.remove(c.y);
    }

    /// Deletes the column the cursor lies.
    pub fn delete_col(&mut self, c: &mut Cursor) {
        for row in &mut self.data {
            row.remove(c.x);
        }
    }

    /// Writes the data as a csv to the given path.
    pub fn save_to_path(&self, path: String) {
        let mut wtr = csv::Writer::from_path(path).unwrap();
        for row in self.data.clone().into_iter() {
            wtr.write_record(row).unwrap();
        }
        wtr.flush().unwrap();
    }
}