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
|
// Copyright 2019 Alexandros Frantzis
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
//
// SPDX-License-Identifier: MPL-2.0
//! Convenience functionality for regex searches of email data.
use std::str;
use regex::bytes::{RegexBuilder, RegexSetBuilder, SetMatches, Captures};
use crate::Result;
/// Trait providing convenience methods for regular expression searching
/// in emails. The trait methods can be use with the byte data returned by
/// the `Email::header`, `Email::body` and `Email::data` methods.
///
/// This trait treats and searches the email contents as bytes. The regular
/// expression parsing is configured for case-insensitive and multi-line
/// search (i.e., `^` and `$` match beginning and end of lines respectively).
///
/// In addition to the single regular expression searching, a method for
/// matching regular expression sets is provided. This can be more
/// efficient than matching multiple regular expressions independently.
///
/// All the trait methods will fail if the regular expression is
/// invalid, or the searched email data isn't valid utf-8.
pub trait EmailRegex {
/// Returns whether the contents match a regular expression.
///
/// # Example
///
/// ```no_run
/// use mda::{Email, EmailRegex};
/// let email = Email::from_stdin()?;
/// if email.header().search(r"^To:.*me@example.com")? {
/// email.deliver_to_maildir("/my/maildir/path")?;
/// }
/// # Ok::<(), Box<dyn std::error::Error>>(())
/// ```
fn search(&self, regex: &str) -> Result<bool>;
/// Returns the capture groups matched from a regular expression.
///
/// # Example
///
/// ```no_run
/// use std::path::Path;
/// use mda::{Email, EmailRegex};
/// let email = Email::from_stdin()?;
/// if let Some(captures) = email.header().search_with_captures(r"^X-Product: name=(\w+)")? {
/// let name = std::str::from_utf8(captures.get(1).unwrap().as_bytes()).unwrap();
/// email.deliver_to_maildir(Path::new("/my/maildir/").join(name))?;
/// }
/// # Ok::<(), Box<dyn std::error::Error>>(())
/// ```
fn search_with_captures(&self, regex: &str) -> Result<Option<Captures>>;
/// Returns the matches from a set of regular expression. This can be
/// more efficient than matching multiple regular expressions independently.
///
/// # Example
///
/// ```no_run
/// use mda::{Email, EmailRegex};
/// let email = Email::from_stdin()?;
/// let matched_sets = email.header().search_set(
/// &[
/// r"^To: confidential <confidential@example.com>",
/// r"^X-Confidential: true",
/// ]
/// )?;
/// if matched_sets.matched_any() {
/// email.deliver_to_maildir("/my/mail/confidential/")?;
/// }
/// # Ok::<(), Box<dyn std::error::Error>>(())
/// ```
fn search_set(&self, regex_set: &[&str]) -> Result<SetMatches>;
}
impl EmailRegex for &[u8] {
fn search(&self, regex: &str) -> Result<bool> {
Ok(
RegexBuilder::new(regex)
.multi_line(true)
.case_insensitive(true)
.build()?
.is_match(self)
)
}
fn search_with_captures(&self, regex: &str) -> Result<Option<Captures>> {
Ok(
RegexBuilder::new(regex)
.multi_line(true)
.case_insensitive(true)
.build()?
.captures(self)
)
}
fn search_set(&self, regex_set: &[&str]) -> Result<SetMatches> {
Ok(
RegexSetBuilder::new(regex_set)
.multi_line(true)
.case_insensitive(true)
.build()?
.matches(self)
)
}
}
|
