rpick 0.9.1

Helps you pick items from a list by various algorithms. Example uses: pick a restaurant you haven't been to in a while, or an album to listen to.
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

/* Copyright © 2021 Randy Barlow
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.*/
//! Define the code that drives the rpick CLI UI.

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

use prettytable::{format, Cell, Row, Table};

use rpick::ui;

/// This implements the Ui trait for the rpick engine.
pub struct Cli {
    /// If true, print out the chance tables.
    verbose: bool,
}

impl Cli {
    /// Construct a new Cli.
    ///
    /// # Arguments
    ///
    /// * `verbose`: If true, the Cli will print out chance tables.
    pub fn new(verbose: bool) -> Self {
        Cli { verbose }
    }

    /// Convert a slice of Cells into a [`prettytable::Row`].
    ///
    /// # Arguments
    ///
    /// * `row`: The slice of Cells to convert.
    /// * `highlight`: If true, this row will get emphasized on terminals that support colors.
    fn convert_row(row: &[ui::Cell], highlight: bool) -> Row {
        let mut r = Row::empty();

        for c in row {
            let mut c = if let ui::Cell::Float(value) = c {
                Cell::new(&format!("{:>6.2}%", value))
            } else {
                Cell::new(&String::from(c))
            };
            if highlight {
                c = c.style_spec("bFy");
            }
            r.add_cell(c);
        }

        r
    }
}

impl ui::Ui for Cli {
    /// Return `self.verbose`.
    fn call_display_table(&self) -> bool {
        self.verbose
    }

    /// Print the given table to the terminal.
    fn display_table(&self, table: &ui::Table) {
        let mut t = Table::new();
        t.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);

        t.set_titles(Cli::convert_row(&table.header, false));

        for row in &table.rows {
            t.add_row(Cli::convert_row(&row.cells, row.chosen));
        }
        t.add_row(Cli::convert_row(&table.footer, false));

        println!();
        t.printstd();
        println!();
    }

    /// Print the given message to the terminal.
    fn info(&self, message: &str) {
        println!("{}", message);
    }

    /// Ask the user if they accept the given choice and return their answer.
    fn prompt_choice(&self, choice: &str) -> bool {
        print!("Choice is {}. Accept? (Y/n) ", choice);
        io::stdout().flush().unwrap();
        let line = io::stdin().lock().lines().next().unwrap().unwrap();
        if ["", "y", "Y"].contains(&line.as_str()) {
            return true;
        }
        false
    }
}