Properly added result

Author: philocalyst

.gitignore

@@ -10,3 +10,5 @@ result
 # Editor
 .vim/
 .nvimrc
+
+!/src/components/result

src/components/result/accuracy.rs

@@ -0,0 +1,9 @@
+use super::fraction::Fraction;
+use std::collections::HashMap;
+use tuirealm::ratatui::crossterm::event::KeyEvent;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Data {
+    pub overall: Fraction,
+    pub per_key: HashMap<KeyEvent, Fraction>,
+}

src/components/result/component.rs

@@ -0,0 +1,44 @@
+use rand::{seq::SliceRandom, thread_rng};
+use tuirealm::{
+    event::{Key, KeyModifiers},
+    Component, Event, NoUserEvent,
+};
+
+use super::ResultsComponent;
+use crate::messages::Msg;
+
+impl Component<Msg, NoUserEvent> for ResultsComponent {
+    fn on(&mut self, ev: Event<NoUserEvent>) -> Option<Msg> {
+        match ev {
+            Event::Keyboard(key)
+                if key.code == Key::Char('q') && key.modifiers == KeyModifiers::NONE =>
+            {
+                Some(Msg::AppClose)
+            }
+
+            Event::Keyboard(key)
+                if key.code == Key::Char('r') && key.modifiers == KeyModifiers::NONE =>
+            {
+                Some(Msg::RestartTest)
+            }
+
+            Event::Keyboard(key)
+                if key.code == Key::Char('p') && key.modifiers == KeyModifiers::NONE =>
+            {
+                if self.results.missed_words.is_empty() {
+                    return None;
+                }
+                // repeat each missed word 5 times
+                let mut practice_words: Vec<String> = (self.results.missed_words)
+                    .iter()
+                    .flat_map(|w: &String| vec![w.clone(); 5])
+                    .collect();
+
+                practice_words.shuffle(&mut thread_rng());
+
+                Some(Msg::StartTest(practice_words))
+            }
+            _ => None,
+        }
+    }
+}

src/components/result/fraction.rs

@@ -0,0 +1,47 @@
+use std::cmp;
+use std::fmt;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub struct Fraction {
+    pub numerator: usize,
+    pub denominator: usize,
+}
+
+impl Fraction {
+    pub fn new(numerator: usize, denominator: usize) -> Self {
+        Self {
+            numerator,
+            denominator,
+        }
+    }
+}
+
+impl From<Fraction> for f64 {
+    fn from(fraction: Fraction) -> Self {
+        if fraction.denominator == 0 {
+            0.0
+        } else {
+            fraction.numerator as f64 / fraction.denominator as f64
+        }
+    }
+}
+
+impl cmp::Ord for Fraction {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        f64::from(*self)
+            .partial_cmp(&f64::from(*other))
+            .unwrap_or(cmp::Ordering::Equal)
+    }
+}
+
+impl cmp::PartialOrd for Fraction {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl fmt::Display for Fraction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}/{}", self.numerator, self.denominator)
+    }
+}

src/components/result/mock_component.rs

@@ -0,0 +1,199 @@
+use tuirealm::ratatui::crossterm::event::{KeyCode as CrosstermKeyCode, KeyEvent};
+use tuirealm::ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    symbols::Marker,
+    text::{Line, Span, Text},
+    widgets::{Axis, Block, Borders, Chart, Dataset, GraphType, Paragraph, Widget},
+};
+use tuirealm::{
+    command::{Cmd, CmdResult},
+    AttrValue, Attribute, Frame, MockComponent, State,
+};
+
+use super::{
+    Fraction, ResultsComponent, WORDS_PER_MINUTE_MOVING_AVERAGE_WIDTH, WORDS_PER_MINUTE_PER_CPS,
+};
+
+impl MockComponent for ResultsComponent {
+    fn view(&mut self, frame: &mut Frame, area: Rect) {
+        let buffer = frame.buffer_mut();
+
+        buffer.set_style(area, self.theme.default);
+
+        // Chunks
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Min(1), Constraint::Length(1)])
+            .split(area);
+
+        let result_chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .margin(1) // Graph looks tremendously better with just a little margin
+            .constraints([Constraint::Ratio(1, 3), Constraint::Ratio(2, 3)])
+            .split(chunks[0]);
+
+        let info_chunks = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)])
+            .split(result_chunks[0]);
+
+        // Handling the incomplete tests
+        // TODO: Show a better screen here
+        let msg = if self.results.missed_words.is_empty() {
+            "Press 'q' to quit or 'r' for another test"
+        } else {
+            "Press 'q' to quit, 'r' for another test or 'p' to practice missed words"
+        };
+
+        let exit = Span::styled(msg, self.theme.results_restart_prompt);
+        buffer.set_span(chunks[1].x, chunks[1].y, &exit, chunks[1].width);
+
+        // Sections
+        let mut overview_text = Text::styled("", self.theme.results_overview);
+        overview_text.extend([
+            Line::from(format!(
+                "Adjusted WPM: {:.1}",
+                self.results.timing.overall_cps
+                    * WORDS_PER_MINUTE_PER_CPS
+                    * f64::from(self.results.accuracy.overall)
+            )),
+            Line::from(format!(
+                "Accuracy: {:.1}%",
+                f64::from(self.results.accuracy.overall) * 100f64
+            )),
+            Line::from(format!(
+                "Raw WPM: {:.1}",
+                self.results.timing.overall_cps * WORDS_PER_MINUTE_PER_CPS
+            )),
+            Line::from(format!(
+                "Correct Keypresses: {}",
+                self.results.accuracy.overall
+            )),
+        ]);
+        let overview = Paragraph::new(overview_text).block(
+            Block::default()
+                .title(Span::styled("Overview", self.theme.title))
+                .borders(Borders::ALL)
+                .border_type(self.theme.border_type)
+                .border_style(self.theme.results_overview_border),
+        );
+        overview.render(info_chunks[0], buffer);
+
+        let mut worst_keys: Vec<(&KeyEvent, &Fraction)> = self
+            .results
+            .accuracy
+            .per_key
+            .iter()
+            .filter(|(key, _)| matches!(key.code, CrosstermKeyCode::Char(_)))
+            .collect();
+
+        // Unstable because we don't care about order, just results
+        worst_keys.sort_unstable_by_key(|x| x.1);
+
+        let mut worst_text = Text::styled("", self.theme.results_worst_keys);
+        worst_text.extend(
+            worst_keys
+                .iter()
+                .filter_map(|(key, acc)| {
+                    if let CrosstermKeyCode::Char(character) = key.code {
+                        let key_accuracy = f64::from(**acc) * 100.0;
+                        if key_accuracy != 100.0 {
+                            Some(format!("- {} at {:.1}% accuracy", character, key_accuracy))
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                })
+                .take(5)
+                .map(Line::from),
+        );
+
+        let worst = Paragraph::new(worst_text).block(
+            Block::default()
+                .title(Span::styled("Worst Keys", self.theme.title))
+                .borders(Borders::ALL)
+                .border_type(self.theme.border_type)
+                .border_style(self.theme.results_worst_keys_border),
+        );
+
+        worst.render(info_chunks[1], buffer);
+
+        let words_per_minute_sliding_moving_average: Vec<(f64, f64)> = self
+            .results
+            .timing
+            .per_event
+            .windows(WORDS_PER_MINUTE_MOVING_AVERAGE_WIDTH)
+            .enumerate()
+            .map(|(i, window): (usize, &[f64])| {
+                (
+                    (i + WORDS_PER_MINUTE_MOVING_AVERAGE_WIDTH) as f64,
+                    window.len() as f64 / window.iter().copied().sum::<f64>()
+                        * WORDS_PER_MINUTE_PER_CPS,
+                )
+            })
+            .collect();
+
+        // Render the chart if possible.
+        if !words_per_minute_sliding_moving_average.is_empty() {
+            let minimum_average = words_per_minute_sliding_moving_average
+                .iter()
+                .map(|(_, x)| x)
+                .fold(f64::INFINITY, |a: f64, &b: &f64| a.min(b));
+
+            let maximum_average = words_per_minute_sliding_moving_average
+                .iter()
+                .map(|(_, x)| x)
+                .fold(f64::NEG_INFINITY, |a: f64, &b: &f64| a.max(b));
+
+            let wpm_datasets = vec![Dataset::default()
+                .name("WPM")
+                .marker(Marker::Braille)
+                .graph_type(GraphType::Line)
+                .style(self.theme.results_chart)
+                .data(&words_per_minute_sliding_moving_average)];
+
+            let y_label_minimum = minimum_average as u16;
+            let y_label_maximum = (maximum_average as u16).max(y_label_minimum + 6);
+
+            let wpm_chart = Chart::new(wpm_datasets)
+                .block(Block::default().title(vec![Span::styled("Chart", self.theme.title)]))
+                .x_axis(
+                    Axis::default()
+                        .title(Span::styled("Keypresses", self.theme.results_chart_x))
+                        .bounds([0.0, self.results.timing.per_event.len() as f64]),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title(Span::styled(
+                            "WPM (10-keypress rolling average)",
+                            self.theme.results_chart_y,
+                        ))
+                        .bounds([minimum_average, maximum_average])
+                        .labels(
+                            (y_label_minimum..y_label_maximum)
+                                .step_by(5)
+                                .map(|n| Span::raw(format!("{}", n)))
+                                .collect::<Vec<_>>(),
+                        ),
+                );
+            wpm_chart.render(result_chunks[1], buffer);
+        }
+    }
+
+    // DEFAULT IMPLEMENTATIONS ROUGHLY
+    fn query(&self, _attr: Attribute) -> Option<AttrValue> {
+        None
+    }
+
+    fn attr(&mut self, _attr: Attribute, _value: AttrValue) {}
+
+    fn state(&self) -> State {
+        State::None
+    }
+
+    fn perform(&mut self, _cmd: Cmd) -> CmdResult {
+        CmdResult::None
+    }
+}

src/components/result/mod.rs

@@ -0,0 +1,44 @@
+use crate::calculate;
+use crate::components::test::event::TestEvent;
+use crate::components::test::Test;
+use crate::config::Theme;
+
+pub mod accuracy;
+pub mod component;
+pub mod fraction;
+pub mod mock_component;
+pub mod timing;
+
+pub use accuracy::Data as AccuracyData;
+pub use fraction::Fraction;
+pub use timing::Data as TimingData;
+
+// Convert CPS to WPM (clicks per second)
+pub const WORDS_PER_MINUTE_PER_CPS: f64 = 12.0;
+
+// Width of the moving average window for the WPM chart
+pub const WORDS_PER_MINUTE_MOVING_AVERAGE_WIDTH: usize = 10;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Results {
+    pub timing: TimingData,
+    pub accuracy: AccuracyData,
+    pub missed_words: Vec<String>,
+}
+
+impl From<&Test> for Results {
+    fn from(test: &Test) -> Self {
+        let events: Vec<&TestEvent> = test.words.iter().flat_map(|w| w.events.iter()).collect();
+
+        Self {
+            timing: calculate::timing(&events),
+            accuracy: calculate::accuracy(&events),
+            missed_words: calculate::missed_words(test),
+        }
+    }
+}
+
+pub struct ResultsComponent {
+    pub results: Results,
+    pub theme: Theme,
+}

src/components/result/timing.rs

@@ -0,0 +1,10 @@
+use std::collections::HashMap;
+use tuirealm::ratatui::crossterm::event::KeyEvent;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Data {
+    // Instead of storing WPM, we store CPS (clicks per second)
+    pub overall_cps: f64,
+    pub per_event: Vec<f64>,
+    pub per_key: HashMap<KeyEvent, f64>,
+}