      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
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187

    use crate::lookups::canonical_combining_class;
    use crate::stream_safe;
    use crate::tables;
    use crate::UnicodeNormalization;

    /// The QuickCheck algorithm can quickly determine if a text is or isn't
    /// normalized without any allocations in many cases, but it has to be able to
    /// return `Maybe` when a full decomposition and recomposition is necessary.
    #[derive(Debug, Eq, PartialEq)]
    pub enum IsNormalized {
        /// The text is definitely normalized.
        Yes,
        /// The text is definitely not normalized.
        No,
        /// The text may be normalized.
        Maybe,
    }

    // https://unicode.org/reports/tr15/#Detecting_Normalization_Forms
    #[inline]
    fn quick_check<F, I>(s: I, is_allowed: F, stream_safe: bool) -> IsNormalized
    where
        I: Iterator<Item = char>,
        F: Fn(char) -> IsNormalized,
    {
        let mut last_cc = 0u8;
        let mut nonstarter_count = 0;
        let mut result = IsNormalized::Yes;
        for ch in s {
            // For ASCII we know it's always allowed and a starter
            if ch <= '\x7f' {
                last_cc = 0;
                nonstarter_count = 0;
                continue;
            }

            // Otherwise, lookup the combining class and QC property
            let cc = canonical_combining_class(ch);
            if last_cc > cc && cc != 0 {
                return IsNormalized::No;
            }
            match is_allowed(ch) {
                IsNormalized::Yes => (),
                IsNormalized::No => return IsNormalized::No,
                IsNormalized::Maybe => {
                    result = IsNormalized::Maybe;
                }
            }
            if stream_safe {
                let decomp = stream_safe::classify_nonstarters(ch);

                // If we're above `MAX_NONSTARTERS`, we're definitely *not*
                // stream-safe normalized.
                if nonstarter_count + decomp.leading_nonstarters > stream_safe::MAX_NONSTARTERS {
                    return IsNormalized::No;
                }
                if decomp.leading_nonstarters == decomp.decomposition_len {
                    nonstarter_count += decomp.decomposition_len;
                } else {
                    nonstarter_count = decomp.trailing_nonstarters;
                }
            }
            last_cc = cc;
        }
        result
    }

    /// Quickly check if a string is in NFC, potentially returning
    /// `IsNormalized::Maybe` if further checks are necessary.  In this case a check
    /// like `s.chars().nfc().eq(s.chars())` should suffice.
    #[inline]
    pub fn is_nfc_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
        quick_check(s, tables::qc_nfc, false)
    }

    /// Quickly check if a string is in NFKC.
    #[inline]
    pub fn is_nfkc_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
        quick_check(s, tables::qc_nfkc, false)
    }

    /// Quickly check if a string is in NFD.
    #[inline]
    pub fn is_nfd_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
        quick_check(s, tables::qc_nfd, false)
    }

    /// Quickly check if a string is in NFKD.
    #[inline]
    pub fn is_nfkd_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
        quick_check(s, tables::qc_nfkd, false)
    }

    /// Quickly check if a string is Stream-Safe NFC.
    #[inline]
    pub fn is_nfc_stream_safe_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
        quick_check(s, tables::qc_nfc, true)
    }

    /// Quickly check if a string is Stream-Safe NFD.
    #[inline]
    pub fn is_nfd_stream_safe_quick<I: Iterator<Item = char>>(s: I) -> IsNormalized {
        quick_check(s, tables::qc_nfd, true)
    }

    /// Authoritatively check if a string is in NFC.
    #[inline]
    pub fn is_nfc(s: &str) -> bool {
        match is_nfc_quick(s.chars()) {
            IsNormalized::Yes => true,
            IsNormalized::No => false,
            IsNormalized::Maybe => s.chars().eq(s.chars().nfc()),
        }
    }

    /// Authoritatively check if a string is in NFKC.
    #[inline]
    pub fn is_nfkc(s: &str) -> bool {
        match is_nfkc_quick(s.chars()) {
            IsNormalized::Yes => true,
            IsNormalized::No => false,
            IsNormalized::Maybe => s.chars().eq(s.chars().nfkc()),
        }
    }

    /// Authoritatively check if a string is in NFD.
    #[inline]
    pub fn is_nfd(s: &str) -> bool {
        match is_nfd_quick(s.chars()) {
            IsNormalized::Yes => true,
            IsNormalized::No => false,
            IsNormalized::Maybe => s.chars().eq(s.chars().nfd()),
        }
    }

    /// Authoritatively check if a string is in NFKD.
    #[inline]
    pub fn is_nfkd(s: &str) -> bool {
        match is_nfkd_quick(s.chars()) {
            IsNormalized::Yes => true,
            IsNormalized::No => false,
            IsNormalized::Maybe => s.chars().eq(s.chars().nfkd()),
        }
    }

    /// Authoritatively check if a string is Stream-Safe NFC.
    #[inline]
    pub fn is_nfc_stream_safe(s: &str) -> bool {
        match is_nfc_stream_safe_quick(s.chars()) {
            IsNormalized::Yes => true,
            IsNormalized::No => false,
            IsNormalized::Maybe => s.chars().eq(s.chars().stream_safe().nfc()),
        }
    }

    /// Authoritatively check if a string is Stream-Safe NFD.
    #[inline]
    pub fn is_nfd_stream_safe(s: &str) -> bool {
        match is_nfd_stream_safe_quick(s.chars()) {
            IsNormalized::Yes => true,
            IsNormalized::No => false,
            IsNormalized::Maybe => s.chars().eq(s.chars().stream_safe().nfd()),
        }
    }

    #[cfg(test)]
    mod tests {
        use super::{is_nfc_stream_safe_quick, is_nfd_stream_safe_quick, IsNormalized};

        #[test]
        fn test_stream_safe_nfd() {
            let okay = "Da\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}ngerzone";
            assert_eq!(is_nfd_stream_safe_quick(okay.chars()), IsNormalized::Yes);

            let too_much = "Da\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{031e}\u{0300}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}ngerzone";
            assert_eq!(is_nfd_stream_safe_quick(too_much.chars()), IsNormalized::No);
        }

        #[test]
        fn test_stream_safe_nfc() {
            let okay = "ok\u{e0}\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}y";
            assert_eq!(is_nfc_stream_safe_quick(okay.chars()), IsNormalized::Maybe);

            let too_much = "not ok\u{e0}\u{031b}\u{0316}\u{0317}\u{0318}\u{0319}\u{031c}\u{031d}\u{031e}\u{0301}\u{0302}\u{0303}\u{0304}\u{0305}\u{0306}\u{0307}\u{0308}\u{0309}\u{030a}\u{030b}\u{030c}\u{030d}\u{030e}\u{030f}\u{0310}\u{0311}\u{0312}\u{0313}\u{0314}\u{0315}\u{031a}y";
            assert_eq!(is_nfc_stream_safe_quick(too_much.chars()), IsNormalized::No);
        }
    }