zspell 0.5.5

Native Rust library for spellchecking
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

use std::sync::Arc;

use super::RuleType;
use crate::error::ParseErrorKind;
use crate::helpers::{compile_re_pattern, ReWrapper};
use crate::morph::MorphInfo;
use crate::Error;

/// A simple prefix or suffix rule
///
/// This struct represents a prefix or suffix option that may be applied to any
/// base word. It contains multiple possible rule definitions that describe how
/// to apply the rule.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ParsedRuleGroup {
    /// Character identifier for this specific affix, usually any uppercase
    /// letter
    pub(crate) flag: String,
    /// Prefix or suffix
    pub(crate) kind: RuleType,
    /// Whether or not this can be combined with the opposite affix
    pub(crate) can_combine: bool,
    /// Actual rules for replacing
    pub(crate) rules: Vec<ParsedRule>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ParsedRule {
    /// Affix to be added
    pub(crate) affix: String,
    /// Characters to remove from the beginning or end
    pub(crate) strip: Option<Arc<str>>,
    /// Regex-based rule for when this rule is true. `None` indicates `.`, i.e.,
    /// always true
    pub(crate) condition: Option<ReWrapper>,
    /// Morphological information
    pub(crate) morph_info: Vec<Arc<MorphInfo>>,
}

impl ParsedRule {
    #[allow(unused)]
    pub(crate) fn new(
        kind: RuleType,
        affix: &str,
        strip: Option<&str>,
        condition: Option<&str>,
        morph_info: Vec<Arc<MorphInfo>>,
    ) -> Result<Self, Error> {
        let cond_re = match condition {
            Some(c) => compile_re_pattern(c, kind)?,
            None => None,
        };

        Ok(Self {
            strip: strip.map(Into::into),
            affix: affix.to_owned(),
            condition: cond_re,
            morph_info,
        })
    }

    /// Same as `new` but don't modify the regex string
    #[allow(unused)]
    pub(crate) fn new_raw_re(
        kind: RuleType,
        affix: &str,
        strip: Option<&str>,
        condition: Option<&str>,
        morph_info: Vec<Arc<MorphInfo>>,
    ) -> Result<Self, Error> {
        let cond_re = match condition {
            Some(c) => Some(ReWrapper::new(c)?),
            None => None,
        };

        Ok(Self {
            strip: strip.map(Into::into),
            affix: affix.to_owned(),
            condition: cond_re,
            morph_info,
        })
    }

    /// Create from the information we have available during parse
    pub(crate) fn new_parse(
        kind: RuleType,
        affix: &str,
        strip: &str,
        condition: &str,
        morph_info: Vec<Arc<MorphInfo>>,
    ) -> Result<Self, ParseErrorKind> {
        let cond_re = compile_re_pattern(condition, kind)?;
        let strip_chars = if strip == "0" {
            None
        } else {
            Some(strip.into())
        };

        Ok(Self {
            strip: strip_chars,
            affix: affix.to_owned(),
            condition: cond_re,
            morph_info,
        })
    }
}