der_die_das 0.5.0

der_die_das: Learn german genders like a true geek.
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
116

pub mod nouns_attempts_repo;
pub mod nouns_repo;
pub mod sentence_attempts_repo;
pub mod sentence_repo;
use std::path::PathBuf;

use miette::{miette, Context as _, IntoDiagnostic as _, Report, Result};
use serde::{Deserialize, Serialize};
use tracing::{info, instrument};

use crate::nouns::Article;

#[derive(Debug, Clone)]
pub struct Storage(pub PathBuf);

impl Storage {
    fn nouns_attempts_path(&self) -> PathBuf {
        self.0.join("nouns_attempts")
    }
    fn nouns_path(&self) -> PathBuf {
        self.0.join("nouns")
    }
    fn sentence_path(&self) -> PathBuf {
        self.0.join("sentences")
    }
    #[allow(unused)]
    fn sentence_attempts_path(&self) -> PathBuf {
        self.0.join("sentence_attempts")
    }
}

impl TryFrom<PathBuf> for Storage {
    type Error = Report;
    #[instrument]
    fn try_from(at: PathBuf) -> Result<Self> {
        if !at
            .try_exists()
            .into_diagnostic()
            .wrap_err_with(|| "somethig good!")?
        {
            info!(
                directory = at.to_string_lossy().into_owned(),
                "storage directory does not exist yet. creating it right now."
            );
            fs_extra::dir::create_all(&at, false).into_diagnostic()?;
        };
        if at.is_file() {
            return Err(miette!(
                help = "The address should be directory where I can store a load of data files.",
                "The path at {} is not a directory.",
                at.to_string_lossy()
            ));
        };
        let storage = Storage(at);

        if !storage.nouns_path().try_exists().into_diagnostic()? {
            info!(
                directory = storage.nouns_path().to_string_lossy().into_owned(),
                "storage nouns directory does not exist yet. creating it right now."
            );
            fs_extra::dir::create_all(storage.nouns_path(), false).into_diagnostic()?;
        }

        if !storage
            .nouns_attempts_path()
            .try_exists()
            .into_diagnostic()?
        {
            info!(
                directory = storage.nouns_attempts_path().to_string_lossy().into_owned(),
                "storage nouns attempts directory does not exist yet. creating it right now."
            );
            fs_extra::dir::create_all(storage.nouns_attempts_path(), false).into_diagnostic()?;
        }

        Ok(storage)
    }
}

#[derive(Debug, Clone, Copy, clap::ValueEnum, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum ArticleFileV1 {
    Der,
    Die,
    Das,
}

impl From<ArticleFileV1> for Article {
    fn from(value: ArticleFileV1) -> Self {
        match value {
            ArticleFileV1::Der => Article::Der,
            ArticleFileV1::Die => Article::Die,
            ArticleFileV1::Das => Article::Das,
        }
    }
}
impl From<Article> for ArticleFileV1 {
    fn from(value: Article) -> Self {
        match value {
            Article::Der => ArticleFileV1::Der,
            Article::Die => ArticleFileV1::Die,
            Article::Das => ArticleFileV1::Das,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn is_normal<T: Sized + Send + Sync + Unpin>() {}
    #[test]
    fn normal_types() {
        is_normal::<Storage>();
    }
}