liquid 0.18.2

The liquid templating language for Rust
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
124
125

use deunicode;
use liquid_value::Value;
use regex::Regex;

use super::check_args_len;

use compiler::FilterResult;

#[derive(PartialEq)]
enum SlugifyMode {
    No,
    Def,
    Raw,
    Pretty,
    Ascii,
    Latin,
}

lazy_static! {
    static ref SLUG_INVALID_CHARS_DEFAULT: Regex = Regex::new(r"([^0-9\p{Alphabetic}]+)").unwrap();
    static ref SLUG_INVALID_CHARS_RAW: Regex = Regex::new(r"([\s]+)").unwrap();
    static ref SLUG_INVALID_CHARS_PRETTY: Regex =
        Regex::new(r"([^\p{Alphabetic}0-9\._\~!\$&'\(\)\+,;=@]+)").unwrap();
    static ref SLUG_INVALID_CHARS_ASCII: Regex = Regex::new(r"([^a-zA-Z0-9]+)").unwrap();
}

pub fn slugify(input: &Value, args: &[Value]) -> FilterResult {
    check_args_len(args, 0, 1)?;

    let s = input.to_str();
    let mode = if args.is_empty() {
        SlugifyMode::Def
    } else {
        get_mode(&args[0].to_str())
    };

    let s = if mode == SlugifyMode::Latin {
        deunicode::deunicode_with_tofu(&s.trim(), "-")
    } else {
        s.trim().to_string()
    };
    let result = match mode {
        SlugifyMode::No => s,
        SlugifyMode::Def => SLUG_INVALID_CHARS_DEFAULT.replace_all(&s, "-").to_string(),
        SlugifyMode::Raw => SLUG_INVALID_CHARS_RAW.replace_all(&s, "-").to_string(),
        SlugifyMode::Pretty => SLUG_INVALID_CHARS_PRETTY.replace_all(&s, "-").to_string(),
        SlugifyMode::Ascii | SlugifyMode::Latin => {
            SLUG_INVALID_CHARS_ASCII.replace_all(&s, "-").to_string()
        }
    };

    Ok(Value::scalar(result.trim_matches('-').to_lowercase()))
}

fn get_mode(mode_str: &str) -> SlugifyMode {
    match mode_str {
        "none" => SlugifyMode::No,
        "raw" => SlugifyMode::Raw,
        "pretty" => SlugifyMode::Pretty,
        "ascii" => SlugifyMode::Ascii,
        "latin" => SlugifyMode::Latin,
        _ => SlugifyMode::Def,
    }
}

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

    macro_rules! unit {
        ($a:ident, $b:expr) => {{
            unit!($a, $b, &[])
        }};
        ($a:ident, $b:expr, $c:expr) => {{
            $a(&$b, $c).unwrap()
        }};
    }

    macro_rules! tos {
        ($a:expr) => {{
            Value::scalar($a.to_owned())
        }};
    }

    #[test]
    fn test_slugify_default() {
        assert_eq!(
            unit!(slugify, tos!("The _cönfig.yml file")),
            tos!("the-cönfig-yml-file")
        );
    }

    #[test]
    fn test_slugify_ascii() {
        assert_eq!(
            unit!(slugify, tos!("The _cönfig.yml file"), &[tos!("ascii")]),
            tos!("the-c-nfig-yml-file")
        );
    }

    #[test]
    fn test_slugify_latin() {
        assert_eq!(
            unit!(slugify, tos!("The _cönfig.yml file"), &[tos!("latin")]),
            tos!("the-config-yml-file")
        );
    }

    #[test]
    fn test_slugify_raw() {
        assert_eq!(
            unit!(slugify, tos!("The _config.yml file"), &[tos!("raw")]),
            tos!("the-_config.yml-file")
        );
    }

    #[test]
    fn test_slugify_none() {
        assert_eq!(
            unit!(slugify, tos!("The _config.yml file"), &[tos!("none")]),
            tos!("the _config.yml file")
        );
    }

}