timmy 0.2.0

A time tracker mainly for programming tasks
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

use std::iter;

#[derive(Debug, Clone)]
pub enum CellType {
    Separator,
    Data(String),
}

#[derive(Debug, Clone)]
pub struct Cell {
    typ: CellType,
    border_left: String,
    border_right: String,
}

impl Cell {
    pub fn new_left_bordered(t: CellType, border: &str) -> Cell {
        Cell {typ: t, border_left: border.into(), border_right: "".into()}
    }

    pub fn new_both_bordered(t: CellType, left: &str, right: &str) -> Cell {
        Cell {typ: t, border_left: left.into(), border_right: right.into()}
    }

    pub fn new_right_bordered(t: CellType, border: &str) -> Cell {
        Cell {typ: t, border_left: "".into(), border_right: border.into()}
    }

    fn print(&self, width: usize) {
        let middle = match self.typ {
            CellType::Separator => iter::repeat("─").take(width+2).collect(),
            CellType::Data(ref s) => {
                let to_pad = width - s.len();
                let spaces: String = iter::repeat(" ").take(to_pad).collect();
                format!(" {}{} ", s, spaces)
            },
        };
        print!("{}{}{}", self.border_left, middle, self.border_right);
    }

    fn len(&self) -> usize {
        match self.typ {
            CellType::Separator => 0,
            CellType::Data(ref s) => s.len(),
        }
    }
}

pub struct Table {
    rows: Vec<Vec<Cell>>,
    cols: usize,
}

impl Table {
    pub fn with_headers(headers: Vec<String>) -> Table {
        let mut table = Table {rows: vec![], cols: headers.len()};
        table.add_border_top();
        table.add_simple(headers);
        table.add_full_separator();
        table
    }

    pub fn add_row(&mut self, row: Vec<Cell>) {
        self.rows.push(row);
    }

    pub fn add_simple(&mut self, data: Vec<String>) {
        let len = data.len();
        let cells =
            data.into_iter()
                .enumerate()
                .map(|(i, data)| {
                    if i != len-1 {
                        Cell::new_left_bordered(CellType::Data(data), "│")
                    } else {
                        Cell::new_both_bordered(CellType::Data(data), "│", "│")
                    }
                })
                .collect();
        self.rows.push(cells);
    }

    pub fn add_full_separator(&mut self) {
        self.add_full_separator_custom("├", "┼", "┤");
    }

    pub fn add_border_top(&mut self) {
        self.add_full_separator_custom("┌", "┬", "┐");
    }

    pub fn add_border_bottom(&mut self) {
        self.add_full_separator_custom("└", "┴", "┘");
    }

    pub fn add_full_separator_custom(&mut self, left: &str, middle: &str, right: &str) {
        let mut cells = vec![];
        let middle_cell = Cell::new_left_bordered(CellType::Separator, middle);
        if self.cols == 1 {
            cells.push(Cell::new_both_bordered(CellType::Separator, left, right));
        } else {
            cells.push(Cell::new_left_bordered(CellType::Separator, left));
        }
        let mut middle_cells: Vec<Cell> = (0..self.cols-2).map(|_| middle_cell.clone()).collect();
        cells.append(&mut middle_cells);
        if self.cols != 1 {
            cells.push(Cell::new_both_bordered(CellType::Separator, middle, right));
        }
        self.rows.push(cells);
    }

    pub fn print(&self) {
        let max_lengths: Vec<usize> = (0..self.cols)
            .map(|i| {
                let lens = self.rows.iter().map(|row| row[i].len());
                lens.max().unwrap()
            })
            .collect();

        for row in &self.rows {
            for (i, cell) in row.iter().enumerate() {
                cell.print(max_lengths[i]);
            }
            println!("");
        }
    }
}