perky 0.1.0

An application to permute and score keyboard layouts.
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

use core::{
    fmt::{self, Display},
    time::Duration,
};

use std::io;

use serde_json::{Value, json};

use termcolor::WriteColor;

use crate::{goals::Goal, metrics::Metric, ui::styles::WriteStyled, weights::Weight};

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Metadata {
    pub unigram_table_sum: u64,
    pub bigram_table_sum: u64,
    pub trigram_table_sum: u64,
    pub goal: Goal,
    pub metric: Metric,
    pub tolerance: f64,
    pub weight: Weight,
    pub total_permutations: u64,
    pub elapsed_duration: Duration,
    pub score: u64,
    pub total_records: usize,
    pub total_unique_records: usize,
    pub total_selected_records: usize,
}

impl Metadata {
    pub fn efficiency(&self) -> Option<Duration> {
        if self.total_permutations == 0 {
            None
        } else {
            Some(Duration::from_secs_f64(
                self.elapsed_duration.as_secs_f64() / self.total_permutations as f64,
            ))
        }
    }
}

impl Display for Metadata {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl From<&Metadata> for Value {
    fn from(value: &Metadata) -> Self {
        // TODO add tolerance
        let score = value.score;
        json!({
            "unigram_table_sum": value.unigram_table_sum,
            "bigram_table_sum": value.bigram_table_sum,
            "trigram_table_sum": value.trigram_table_sum,
            "goal": value.goal.to_string().to_lowercase(),
            "metric": value.metric.to_string().to_lowercase(),
            "weight": value.weight.to_string().to_lowercase(),
            "total_permutations": value.total_permutations,
            "elapsed_duration": format_duration(value.elapsed_duration),
            "efficiency": format_opt_duration(value.efficiency()),
            "score": score,
            "total_records": value.total_records,
            "total_unique_records": value.total_unique_records,
            "total_selected_records": value.total_selected_records
        })
    }
}

impl WriteStyled for Metadata {
    fn write_styled(&self, writer: &mut dyn WriteColor) -> io::Result<()> {
        // TODO add tolerance
        writeln!(
            writer,
            "unigram table sum:      {}\n\
             bigram table sum:       {}\n\
             trigram table sum:      {}\n\
             goal:                   {}\n\
             metric:                 {}\n\
             weight:                 {}\n\
             total permutations:     {}\n\
             elapsed duration:       {:?}\n\
             efficiency:             {} / permutation\n\
             score:                  {}\n\
             total records:          {}\n\
             total unique records:   {}\n\
             total selected records: {}",
            self.unigram_table_sum,
            self.bigram_table_sum,
            self.trigram_table_sum,
            self.goal.to_string().to_lowercase(),
            self.metric.to_string().to_lowercase(),
            self.weight.to_string().to_lowercase(),
            self.total_permutations,
            self.elapsed_duration,
            format_opt_duration(self.efficiency()),
            self.score,
            self.total_records,
            self.total_unique_records,
            self.total_selected_records,
        )
    }
}

fn format_duration(duration: Duration) -> String {
    format!("{:?}", duration)
}

fn format_opt_duration(opt_duration: Option<Duration>) -> String {
    match opt_duration {
        None => String::from("n/a"),
        Some(duration) => format_duration(duration),
    }
}