phonet 1.0.2

A CLI tool and library to validate phonotactic patterns for constructed languages
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

/// Example of `Classes` hashmap FOR TESTS
#[cfg(test)]
macro_rules! example_classes {
    () => {{
        let mut hm = crate::draft::Classes::new();

        hm.insert("C".to_string(), ("[ptk]".to_string(), 0));
        hm.insert("V".to_string(), ("[aeiou]".to_string(), 0));
        hm.insert("_".to_string(), ("[⟨C⟩⟨V⟩]".to_string(), 0));

        hm
    }};
}

/// An unrecoverable error occurred
///
/// Panics with a message
///
/// This error should ideally NEVER happen, as long as the code of this crate is working!
///
/// Returns a closure, to lazy evaluate
macro_rules! unrecoverable_error {
    ( $msg: expr ) => {
        (|| {
            let len = $msg.len() as i32;
            let outer = (len - 49).max(0) as usize;
            let inner = (49 - len).max(0) as usize;
            eprintln!(
                "
  ┌───────────────────────────────────────────────────────{0}┐
  │ Phonet broke!                                         {1}│
  │ This is an issue with the source code, not with you.  {1}│
  │ ┌───────────────────────────────────────────────────{0}┐ │
  │ │ {msg} {2}│ │
  │ └───────────────────────────────────────────────────{0}┘ │
  │ Please create an issue, and include the problem above {1}│
  │ https://github.com/darccyy/phonet/issues/new          {1}│
  └───────────────────────────────────────────────────────{0}┘
",
                "─".repeat(outer),
                " ".repeat(outer),
                " ".repeat(inner),
                msg = $msg,
            );
            panic!("Unrecoverable error");
        })()
    };
}

/// Parsing of *Phonet* `Draft`
pub mod draft;
/// Error type for *Phonet*
pub mod error;
/// Running and displaying of *Phonet* `Draft`
pub mod outcome;

/// Color styles for stdout
// mod color;

/// Generation of random words
mod generate;

pub use crate::{
    // color::colorize,
    draft::Draft,
    outcome::{DisplayLevel, Outcome},
};

/// Message for failed matching of static regex
const REGEX_MATCH_FAIL: &str = "Regex failed on 'match' method. This should never happen";

/// Adds '.min' to filename, before last file extension
///
/// Returns 'min.' before the entire name, if the filename has no extension
///
/// Returns an empty string, if `file` is an empty string
pub fn get_min_filename(file: &str) -> String {
    let mut split = file.split('.');

    // Get last file extension
    let ext = match split.next_back() {
        // Return blank string if filename is empty
        None | Some("") => return String::new(),

        Some(string) => string,
    };

    let rest: Vec<&str> = split.collect();
    if !rest.is_empty() {
        // Filename and extension
        rest.join(".") + ".min." + ext
    } else {
        // No extension or only extension (no filename)
        "min.".to_string() + ext
    }
}

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

    #[test]
    fn get_min_filename_works() {
        assert_eq!(get_min_filename(""), "");
        assert_eq!(get_min_filename("phonet"), "min.phonet");
        assert_eq!(get_min_filename("myfile.phonet"), "myfile.min.phonet");
        assert_eq!(get_min_filename("one.two.phonet"), "one.two.min.phonet");
    }

    #[test]
    #[should_panic]
    fn unrecoverable_error_works() {
        unrecoverable_error!("whoops!");
    }
}