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
116
117
118
119
120
121
122
123

#[cfg(test)]
mod tests;

use self::Validity::*;
use super::{
    FailKind::*,
    Outcome,
    PassStatus::{self, *},
    TestOutcome,
};
use crate::{
    draft::{Draft, Message::*, Note, Rule, TestDraft},
    REGEX_MATCH_FAIL,
};

/// Whether test *matches* or not
///
/// NOTE: This is different to whether a test *passes* (See `PassStatus`)
#[derive(Debug, PartialEq)]
pub(crate) enum Validity {
    Valid,
    Invalid(Option<Note>),
}

impl Outcome {
    /// Run drafted tests, return `Output`
    pub fn run(draft: &Draft) -> Self {
        // No messages
        if draft.messages.is_empty() {
            return Self {
                messages: Vec::new(),
                fail_count: 0,
            };
        }

        // Builders
        let mut list = Vec::new();
        let mut fail_count = 0;

        // Loop messages
        for msg in &draft.messages {
            list.push(match msg {
                // Move note
                Info(note) => Info(note.clone()),
                // Run test
                Test(test) => {
                    let outcome = run_test(test.clone(), &draft.rules);

                    // Increase fail count if failed
                    if outcome.status.is_fail() {
                        fail_count += 1;
                    }

                    Test(outcome)
                }
            });
        }

        Self {
            messages: list,
            fail_count,
        }
    }
}

/// Run `TestDraft` against rules, return `TestOutcome`
fn run_test(test: TestDraft, rules: &[Rule]) -> TestOutcome {
    // Validate test
    let validity = validate_test(&test.word, rules);

    // Get status
    let status = get_status(validity, test.intent);

    TestOutcome {
        intent: test.intent,
        word: test.word,
        status,
    }
}

/// Check if test is valid against rules
pub(crate) fn validate_test(word: &str, rules: &[Rule]) -> Validity {
    // Check for match with every rule, if not, return fail
    for Rule {
        intent,
        pattern,
        note,
    } in rules
    {
        // Check if rule matches, and whether match signifies returning invalid or continuing
        if intent ^ pattern.is_match(word).expect(REGEX_MATCH_FAIL) {
            return Invalid(note.clone());
        }
    }

    Valid
}

/// Get `PassStatus` from `Validity` and test `intent`
fn get_status(validity: Validity, intent: bool) -> PassStatus {
    // Check if validity status matches test intent
    let is_pass = !(matches!(validity, Valid) ^ intent);

    // Get status from validity
    if is_pass {
        // Test passes
        Pass
    } else {
        // Test fails
        Fail(match validity {
            // Test was valid, but should have been invalid
            Valid => ShouldBeInvalid,

            // Test was invalid, but should have been valid
            Invalid(reason) => match reason {
                // Custom reason
                Some(reason) => CustomReason(reason),
                // No reason was given
                None => NoReasonGiven,
            },
        })
    }
}