rust-censure 0.2.1

Simple profanity filter.
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

use std::collections::HashMap;
use std::sync::{Arc};
use parking_lot::RwLock;
use once_cell::sync::Lazy;
use thiserror::Error;
use crate::lang::LangProvider;

#[derive(Debug)]
pub struct LangData {
    pub beep: &'static str,
    pub beep_html: &'static str,

    pub foul_data: &'static HashMap<&'static str, Vec<&'static str>>,
    pub foul_core: &'static HashMap<&'static str, &'static str>,
    pub excludes_data: &'static HashMap<&'static str, Vec<&'static str>>,
    pub excludes_core: &'static HashMap<&'static str, &'static str>,
    pub bad_semi_phrases: &'static Vec<&'static str>,
    pub bad_phrases: &'static Vec<&'static str>,
    pub trans_tab: &'static HashMap<char, char>,
}

impl LangData {
    pub fn get_beep(&self) -> &str {
        self.beep
    }

    pub fn set_beep(&mut self, val: &'static str) -> &str {
        self.beep = val;
        self.beep
    }

    pub fn get_beep_html(&self) -> &str {
        self.beep_html
    }

    pub fn set_beep_html(&mut self, val: &'static str) -> &str {
        self.beep_html = val;
        self.beep_html
    }
}

#[derive(Clone, Copy, Debug)]
pub enum CensorLang { Ru, En }

pub struct Censor {
    pub lang: Arc<dyn LangProvider + Send + Sync + 'static>,
    pub data: LangData,
    pub re_cache: Lazy<Arc<RwLock<HashMap<String, fancy_regex::Regex>>>>
}

#[derive(Debug, Error)]
pub enum CensorError {
    #[error("unsupported language: {0}")]
    UnsupportedLang(String),

    #[error("regex compilation failed: {0}")]
    RegexCompilationFailed(String)
}

#[derive(Debug)]
pub struct WordInfo {
    pub is_good: bool,
    pub word: Box<str>,
    pub accuse: Vec<Box<str>>,
    pub excuse: Vec<Box<str>>,
}
impl WordInfo {
    pub fn new(word: Box<str>) -> Self {
        Self { is_good: true, word, accuse: vec![], excuse: vec![] }
    }
}

#[derive(Debug)]
pub struct CleanLineResult {
    pub line: String,
    pub bad_words_count: usize,
    pub bad_phrases_count: usize,
    pub detected_bad_words: Vec<Box<str>>,
    pub detected_patterns: Vec<Box<str>>,
}

#[derive(Debug)]
pub struct CleanHtmlResult {
    pub line: String,
    pub bad_words_count: usize,
}