typing_rust

public

A small typing test program in Rust

Star0

Fork 0

Watch0

2 commits 1 branch 0 tags 0 releases329.6 KiB

Commit `84c1613e43da`

tarball

Jaglekon <58274093+Jaglekon@users.noreply.github.com>2026-09-24 21:10 UTC

3 files changed+329-113

added time

Modified file: Cargo.lock+69 additions−10 deletions@@ -650,14 +650,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "monkey"
-version = "0.1.0"
-dependencies = [
- "crossterm",
- "ratatui",
-]
-
 [[package]]
 name = "nix"
 version = "0.29.0"
@@ -856,7 +848,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
 dependencies = [
  "phf_shared",
- "rand",
+ "rand 0.8.8",
 ]
 
 [[package]]
@@ -899,6 +891,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.107"
@@ -935,7 +936,27 @@ version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
 dependencies = [
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -944,6 +965,15 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
 [[package]]
 name = "ratatui"
 version = "0.30.2"
@@ -1428,6 +1458,15 @@ version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
+[[package]]
+name = "typing_rust"
+version = "0.1.0"
+dependencies = [
+ "crossterm",
+ "rand 0.9.5",
+ "ratatui",
+]
+
 [[package]]
 name = "ucd-trie"
 version = "0.1.7"
@@ -1670,3 +1709,23 @@ name = "wit-bindgen"
 version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c17e8fafad82b542ff3717217ecdc736231b59e387768c9630123b4ce4d2db44"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "595f56e044df4f46a0c9a626f65c3d99eb8488f7e8a8baa12dd76326d9710bf2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]

Modified file: Cargo.toml+2 additions−1 deletions@@ -1,8 +1,9 @@
 [package]
-name = "monkey"
+name = "typing_rust"
 version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 crossterm = "0.29.0"
 ratatui = "0.30.2"
+rand = "0.9"

Modified file: src/main.rs+258 additions−102 deletions@@ -1,156 +1,312 @@
-use std::io;
+use std::{
+    io,
+    time::{
+        Duration,
+        Instant,
+    }
+};
+
+use rand::prelude::*;
+
+use crossterm::event::{
+    self, 
+    poll,
+    KeyCode,
+    KeyEvent,
+    KeyEventKind,
+    Event,
+};
 
-use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind};
 use ratatui::{
-    buffer::Buffer,
-    layout::{Rect, Layout, Direction, Constraint},
-    style::Stylize,
-    symbols::border,
-    text::{Line, Text},
-    widgets::{Block, Paragraph, Widget},
-    DefaultTerminal, Frame,
+    DefaultTerminal, 
+    buffer::Buffer, 
+    layout::Rect, 
+    style::{Stylize, Modifier}, 
+    symbols::border, 
+    text::{Line, Text}, 
+    widgets::{Block, Widget, Paragraph, Wrap},
+    Frame,
 };
 
-#[derive(Debug, PartialEq, Eq)]
-enum States {
-    Running,
-    Paused,
-    Quit,
+fn split_at_char(input: &str, n: usize) -> (&str, &str) {
+     let split = input
+            .char_indices()
+            .nth(n)
+            .map(|(idx , _)| idx)
+            .unwrap_or(input.len());
+
+        input.split_at(split)
+
 }
 
-impl Default for States {
-    fn default() -> Self {
-        States::Running
+
+#[derive(Debug)]
+struct TextCombine {
+    text: String,
+    len: usize,
+    pos: usize,
+    err_n: usize,
+    err_s: String,
+}
+
+impl TextCombine {
+    fn new() -> Self {
+        let words = [
+            "hello",
+            "how",
+            "to",
+            "back",
+            "big",
+            "small",
+            "something",
+            "glad",
+            "general",
+            "tall",
+            "nail",
+            "whatever",
+            "joke",
+            "feral",
+            "apple",
+            "plow"
+        ];
+
+        /*let text = words
+                    .choose_multiple(&mut rand::rng(), 10)
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .join(" ");*/
+        let mut rng = rand::rng();
+
+        let text = (0..60)
+            .filter_map(|_| words.choose(&mut rng))
+            .cloned()
+            .collect::<Vec<_>>()
+            .join(" ");
+
+        let len = text.chars().count();
+
+        Self {
+            text,
+            len,
+            pos: 0,
+            err_n: 0,
+            err_s: String::new(),
+        }
+
+    }
+
+    fn curr_char(&self) -> Option<char> {
+        self.pos_char(self.real_pos())
+    }
+
+    fn pos_char(&self, pos: usize) -> Option<char> {
+        self
+            .text
+            .chars()
+            .nth(pos) 
+    }
+
+    fn real_pos(&self) -> usize {
+        self.pos + self.err_n
+    }
+
+    fn back(&mut self) {
+        if self.err_s.len() > 0 {
+            self.err_s.pop() ;
+        } else if self.err_n > 0 {
+            self.err_n -= 1;
+        } else if self.pos > 0 {
+            self.pos -= 1;
+        }
     }
 }
 
-#[derive(Debug, Default)]
-pub struct App {
-    counter: u8,
-    state: States,
+#[derive(Debug)]
+pub struct  Timer {
+    start: Instant,
+    duration: Duration,
 }
 
-impl Widget for &App {
-    fn render(self, area: Rect, buf: &mut Buffer) {
+impl Timer {
+    fn new(duration: Duration) -> Self {
+        Self {
+            start: Instant::now(),
+            duration,
+        }
+    }
+
+    fn remaining (&self) -> Duration {
+        self.duration.saturating_sub(self.elapsed())
+    }
+
+    fn elapsed (&self) -> Duration {
+        self.start.elapsed()
+    }
+}
 
-        let title = Line::from(" Counter App Tutorial ".bold());
-        let instructions = Line::from(vec![
-            " Decrement ".into(),
-            "<Left>".blue().bold(),
-            " Increment ".into(),
-            "<Right>".blue().bold(),
-            " Pause ".into(),
-            "<P>".blue().bold(),
-            " Quit".into(),
-            "<Q> ".blue().bold(),
+#[derive(Debug)]
+pub struct TypingTest {
+    status: bool,
+    errors: usize,
+    typing: TextCombine,
+    words: usize,
+    timer: Timer,
+}
+
+impl Default for TypingTest {
+    fn default() -> Self {
+        Self {
+            status: true,
+            errors: 0,
+            words: 0,
+            typing: TextCombine::new(),
+            timer: Timer::new(Duration::from_secs(30))
+        }
+    }
+}
+
+impl Widget for &TypingTest {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let title = Line::from(vec![
+            " WPM ".into(),
+            format!("{:4.1}" ,(self.words as f64 / self.timer.elapsed().as_secs_f64()) * 60.0).into(),
+            " // Time ".into(),
+            format!("{:2}", (self.timer.remaining().as_secs())).into(),
+            " // Mistakes ".into(),
+            self.errors.to_string().into(),
+            (" ").into()
+        ]);
+        let bottom = Line::from(vec![
+            " Exit ".into(),
+            "<Esc> ".into(),
         ]);
+
         let block = Block::bordered()
-            .title(title.centered())
-            .title_bottom(instructions.centered())
+            .title(title.centered().bold())
+            .title_bottom(bottom.centered().bold())
             .border_set(border::THICK);
+        
+        let (first, rest) = 
+            split_at_char(self.typing.text.as_str(), self.typing.pos);
 
-        let counter_text = Text::from(vec![Line::from(vec![
-            "Value: ".into(),
-            self.counter.to_string().yellow(),
-        ])]);
+        let (second, rest2) = 
+            split_at_char(rest, self.typing.err_n);
 
-        Paragraph::new(counter_text)
-            .centered()
-            .block(block)
-            .render(area, buf);
+        let (third, fourth) =
+            split_at_char(rest2, 1); 
 
-        if self.state == States::Paused {
-            
-            let pause_area = area.centered(
-                Constraint::Length(20),
-                Constraint::Length(5),
-            );
+        
 
-            let pause_block = Block::bordered()
-                .border_set(border::ROUNDED);
+        let text = Line::from(vec![
+            first.green().into(),
+            second.red().into(),
+            self.typing.err_s.clone().red().into(),
+            if third.len() != 0 {
+                third
+            } else {
+                " "
+            }
+            .add_modifier(Modifier::UNDERLINED | Modifier::BOLD)
+            .into(),
+            fourth.into(),
+        ]);
 
-            let pause_text = Text::from("PAUSE");
-            
-            let pause_text_area = pause_area.centered(
-                Constraint::Length(pause_text.width() as u16),
-                Constraint::Length(1),
-            );
-            
-            pause_block.render(pause_area, buf);
 
-            Paragraph::new(pause_text)
-                .render(pause_text_area, buf);
-        }
+        Paragraph::new(text)
+            .wrap(Wrap {trim: true})
+            .block(block)
+            .render(area, buf);
     }
 }
 
-impl App {
 
-    pub fn run(&mut self, terminal: &mut DefaultTerminal) -> io::Result<()> {
-        while self.state != States::Quit {
+impl TypingTest {
+
+    fn run(&mut self, terminal: &mut DefaultTerminal) -> io::Result<()> {
+
+        while self.status {
             terminal.draw(|frame| self.draw(frame))?;
-            self.handle_events()?;
+            if poll(Duration::from_millis(100))? {
+                self.handle_events()?;
+            }
         }
+        
         Ok(())
     }
-
+    
     fn draw(&self, frame: &mut Frame) {
         frame.render_widget(self, frame.area());
     }
 
-    fn handle_events(&mut self) -> io::Result<()> {
+    fn handle_events(&mut self) -> io::Result<()>{
         match event::read()? {
             Event::Key(key_event) if key_event.kind == KeyEventKind::Press => {
-                self.handle_key_event(key_event)
-            },
+                self.handle_key_event(key_event);
+            }, 
             _ => {},
-        };
+        }
         Ok(())
     }
 
     fn handle_key_event(&mut self, key_event: KeyEvent) {
-        match self.state {
-            States::Running => 
-                match key_event.code {
-                    KeyCode::Char('p') => self.pause(),
-                    KeyCode::Char('q') => self.exit(),
-                    KeyCode::Left => self.decrement_counter(),
-                    KeyCode::Right => self.increment_counter(),
-                    _ => {}
-                },
-            States::Paused => 
-                match key_event.code {
-                    KeyCode::Char('p') => self.pause(),
-                    KeyCode::Char('q') => self.exit(),
-                    _ => {},
-                },
-
-            States::Quit => {},
+        match key_event.code {
+            KeyCode::Esc => self.exit(),
+            KeyCode::Backspace => self.back(),
+            KeyCode::Char(c) => self.handle_char(c),
+            _ => {},
         }
     }
 
-    fn pause(&mut self) {
-        if self.state == States::Paused {
-            self.state = States::Running;
-        } else {
-            self.state = States::Paused;
+    fn back(&mut self) {
+
+        if let Some(pos) = self.typing
+        .pos_char(self.typing.real_pos().saturating_sub(1))
+        {
+            if pos == ' ' {return;}
         }
-    }
 
-    fn exit(&mut self) {
-        self.state = States::Quit;
+        self.typing.back();
     }
 
-    fn increment_counter(&mut self) {
-        self.counter += 1;
+    fn handle_char(&mut self, c: char) {
+        
+        if self.typing.real_pos() >= self.typing.len {
+            return;
+        }
+
+        if let Some(curr) = self.typing
+            .curr_char()
+        {
+            
+            if curr == c 
+                && self.typing.err_n == 0 
+                && self.typing.err_s.len() == 0 
+            {
+                self.typing.pos += 1;
+                if c == ' ' {
+                    self.words += 1;
+                }
+            } else if c != ' ' {
+                if curr != ' ' {
+                    self.typing.err_n += 1;
+                    self.errors += 1;
+                } else if self.typing.err_s.len() < 16 {
+                    self.typing.err_s.push(c); 
+                    self.errors += 1;
+                }
+            }
+            
+        }
+        
     }
 
-    fn decrement_counter(&mut self) {
-        self.counter -= 1;
+    fn exit(&mut self) {
+        self.status = false;
     }
 }
 
 
-fn main() -> io::Result<()> {
-    ratatui::run(|terminal| App::default().run(terminal))
+
+fn main () -> io::Result<()> {
+    ratatui::run(|term| TypingTest::default().run(term))
 }

typing_rust

Commit 84c1613e43da

Commit `84c1613e43da`