typo-eq 0.1.1

Typo-eq is a typing training app for other languages. All it needs is a dictionary for words and their translations.
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

use std::fmt::Display;
use std::io::{BufReader, SeekFrom};
use std::{fs::File, io::Seek};

use quick_xml::events::Event;
use quick_xml::Reader;

#[derive(Debug, Clone)]
pub struct DictionaryEntry {
    pub kind: String,
    pub identifier: String,
    pub translation: String,
}

impl DictionaryEntry {
    pub fn new(kind: String) -> Self {
        Self {
            kind,
            identifier: String::new(),
            translation: String::new(),
        }
    }
}

impl Display for DictionaryEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}->{}", self.identifier, self.translation)
    }
}

#[derive(Clone)]
pub struct Dictionary {
    pub entries: Vec<DictionaryEntry>,
}

impl Dictionary {
    pub fn from_file(mut file: File) -> Self {
        file.seek(SeekFrom::Start(0)).unwrap();
        let file = BufReader::new(file);
        let mut dict = Vec::new();

        let mut parser = Reader::from_reader(file);
        let mut entry = None;
        let mut buf = Vec::new();
        let mut current_tag = String::new();
        loop {
            match parser.read_event_into(&mut buf) {
                Err(e) => panic!("Error at position {}: {:?}", parser.buffer_position(), e),
                Ok(Event::Eof) => break,
                Ok(Event::Start(e)) => {
                    let tag = e.name();
                    let tag = String::from_utf8(tag.as_ref().to_vec()).unwrap();
                    if tag.as_str() == "ar" {
                        let new_entry = DictionaryEntry::new(tag.clone());
                        entry = Some(new_entry);
                    }
                    current_tag = tag;
                }
                Ok(Event::Text(e)) => {
                    if let Some(entry) = entry.as_mut() {
                        if current_tag == "k" {
                            entry.identifier = e.unescape().unwrap().to_string();
                        }
                        if current_tag == "dtrn" {
                            entry.translation = e.unescape().unwrap().to_string();
                        }
                    }
                }
                Ok(Event::End(e)) => {
                    let tag = e.name();
                    let tag = String::from_utf8(tag.as_ref().to_vec()).unwrap();
                    if tag.as_str() == "ar" {
                        if let Some(new_entry) = entry {
                            dict.push(new_entry);
                            entry = None;
                        }
                    }
                    current_tag = String::new();
                }
                _ => {}
            }
            buf.clear();
        }
        return Dictionary { entries: dict };
    }
}