use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use crate::codec;
use crate::tools::helpers::find_subslice;
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct MatchRequest {
pub pattern: String,
#[serde(default)]
pub config: MatchConfig,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct MatchConfig {
#[serde(default = "default_match_mode")]
pub mode: MatchMode,
#[serde(default = "default_pattern_encoding")]
pub pattern_encoding: PatternEncoding,
#[serde(default)]
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub context_amount_of_matched_bytes: Option<usize>,
}
impl Default for MatchConfig {
fn default() -> Self {
Self {
mode: default_match_mode(),
pattern_encoding: default_pattern_encoding(),
context_amount_of_matched_bytes: None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum MatchMode {
LiteralSubstring,
Regex,
Glob,
}
fn default_match_mode() -> MatchMode {
MatchMode::LiteralSubstring
}
impl std::fmt::Display for MatchMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
MatchMode::LiteralSubstring => f.write_str("literal_substring"),
MatchMode::Regex => f.write_str("regex"),
MatchMode::Glob => f.write_str("glob"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum PatternEncoding {
Utf8,
Hex,
#[serde(rename = "base64")]
Base64,
}
fn default_pattern_encoding() -> PatternEncoding {
PatternEncoding::Utf8
}
impl std::fmt::Display for PatternEncoding {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PatternEncoding::Utf8 => f.write_str("utf8"),
PatternEncoding::Hex => f.write_str("hex"),
PatternEncoding::Base64 => f.write_str("base64"),
}
}
}
impl From<PatternEncoding> for codec::Encoding {
fn from(pe: PatternEncoding) -> Self {
match pe {
PatternEncoding::Utf8 => codec::Encoding::Utf8,
PatternEncoding::Hex => codec::Encoding::Hex,
PatternEncoding::Base64 => codec::Encoding::Base64,
}
}
}
#[derive(Debug)]
pub enum Matcher {
Literal {
needle: Vec<u8>,
window: Vec<u8>,
context_amount: Option<usize>,
},
Regex {
re: regex::bytes::Regex,
window: Vec<u8>,
context_amount: Option<usize>,
},
Glob {
pat: glob::Pattern,
window: Vec<u8>,
context_amount: Option<usize>,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MatchResult {
NoMatch,
Found(usize),
}
impl Matcher {
pub fn new_literal(needle: Vec<u8>) -> Option<Self> {
if needle.is_empty() {
return None;
}
Some(Self::Literal {
needle,
window: Vec::new(),
context_amount: None,
})
}
pub fn with_context(self, context_amount: Option<usize>) -> Self {
match self {
Self::Literal { needle, window, .. } => Self::Literal {
needle,
window,
context_amount,
},
Self::Regex { re, window, .. } => Self::Regex {
re,
window,
context_amount,
},
Self::Glob { pat, window, .. } => Self::Glob {
pat,
window,
context_amount,
},
}
}
pub fn context_amount(&self) -> Option<usize> {
match self {
Self::Literal { context_amount, .. }
| Self::Regex { context_amount, .. }
| Self::Glob { context_amount, .. } => *context_amount,
}
}
pub fn needle_len(&self) -> Option<usize> {
match self {
Self::Literal { needle, .. } => Some(needle.len()),
_ => None,
}
}
pub fn check(&self) -> MatchResult {
match self {
Self::Literal { needle, window, .. } => {
find_subslice(window, needle).map_or(MatchResult::NoMatch, MatchResult::Found)
}
Self::Regex { re, window, .. } => re
.find(window)
.map_or(MatchResult::NoMatch, |m| MatchResult::Found(m.start())),
Self::Glob { pat, window, .. } => {
let decoded = String::from_utf8_lossy(window);
let mut byte_offset: usize = 0;
for line in decoded.split('\n') {
let line_content = line.strip_suffix('\r').unwrap_or(line);
if pat.matches(line_content) {
return MatchResult::Found(byte_offset);
}
byte_offset += line.len() + 1; }
MatchResult::NoMatch
}
}
}
pub fn push(&mut self, chunk: &[u8]) -> MatchResult {
match self {
Self::Literal { window, .. }
| Self::Regex { window, .. }
| Self::Glob { window, .. } => {
window.extend_from_slice(chunk);
}
}
self.check()
}
#[cfg_attr(mutants, mutants::skip)]
pub fn truncate_front(&mut self, keep: usize) {
let window = match self {
Self::Literal { window, .. }
| Self::Regex { window, .. }
| Self::Glob { window, .. } => window,
};
let drop = window.len().saturating_sub(keep);
if drop > 0 {
window.drain(..drop);
}
}
pub fn len(&self) -> usize {
match self {
Self::Literal { window, .. }
| Self::Regex { window, .. }
| Self::Glob { window, .. } => window.len(),
}
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn reset_window(&mut self) {
let window = match self {
Self::Literal { window, .. }
| Self::Regex { window, .. }
| Self::Glob { window, .. } => window,
};
window.clear();
}
}
pub fn validate_match_request(req: &MatchRequest) -> Result<Matcher, String> {
let encoding: codec::Encoding = req.config.pattern_encoding.into();
let decoded = codec::decode(encoding, &req.pattern)
.map_err(|e| format!("Pattern decoding failed - {e}"))?;
if decoded.is_empty() {
return Err("Pattern must not be empty after decoding".into());
}
let context = req.config.context_amount_of_matched_bytes;
match req.config.mode {
MatchMode::LiteralSubstring => Matcher::new_literal(decoded)
.map(|m| m.with_context(context))
.ok_or_else(|| "Pattern must not be empty after decoding".into()),
MatchMode::Regex => {
let re = regex::bytes::Regex::new(&String::from_utf8_lossy(&decoded))
.map_err(|e| format!("Invalid regex pattern: {e}"))?;
Ok(Matcher::Regex {
re,
window: Vec::new(),
context_amount: context,
})
}
MatchMode::Glob => {
let pat = glob::Pattern::new(&String::from_utf8_lossy(&decoded))
.map_err(|e| format!("Invalid glob pattern: {e}"))?;
Ok(Matcher::Glob {
pat,
window: Vec::new(),
context_amount: context,
})
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ShapedMatchPayload {
pub data: Vec<u8>,
pub match_index: usize,
pub needle_len: usize,
}
pub fn shape_match_context(
accumulated: &[u8],
match_index: usize,
needle_len: usize,
context_amount: Option<usize>,
) -> ShapedMatchPayload {
let Some(n) = context_amount else {
return ShapedMatchPayload {
data: accumulated.to_vec(),
match_index,
needle_len,
};
};
let pre_start = match_index.saturating_sub(n);
let match_end = match_index + needle_len;
let shaped = accumulated[pre_start..match_end].to_vec();
let new_match_index = match_index - pre_start;
ShapedMatchPayload {
data: shaped,
match_index: new_match_index,
needle_len,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn byte_matcher_finds_immediate_match() {
let mut m = Matcher::new_literal(b"OK>".to_vec()).unwrap();
assert_eq!(m.push(b"OK>"), MatchResult::Found(0));
}
#[test]
fn byte_matcher_finds_offset_match() {
let mut m = Matcher::new_literal(b"OK>".to_vec()).unwrap();
assert_eq!(m.push(b"hell"), MatchResult::NoMatch);
assert_eq!(m.push(b"O"), MatchResult::NoMatch);
assert_eq!(m.push(b"K>!"), MatchResult::Found(4));
}
#[test]
fn byte_matcher_rejects_empty_needle() {
assert!(Matcher::new_literal(Vec::new()).is_none());
}
#[test]
fn byte_matcher_truncate_front_works() {
let mut m = Matcher::new_literal(b"OK>".to_vec()).unwrap();
m.push(b"AAAABBB");
m.truncate_front(3);
assert_eq!(m.len(), 3);
assert_eq!(m.push(b"OK>"), MatchResult::Found(3));
}
#[test]
fn validate_match_request_literal_hex() {
let req = MatchRequest {
pattern: "4f4b3e".into(),
config: MatchConfig {
mode: MatchMode::LiteralSubstring,
pattern_encoding: PatternEncoding::Hex,
context_amount_of_matched_bytes: None,
},
};
let matcher = validate_match_request(&req).unwrap();
assert_eq!(matcher.needle_len(), Some(3)); }
#[test]
fn validate_match_request_empty_pattern_rejected() {
let req = MatchRequest {
pattern: "".into(),
config: MatchConfig::default(),
};
assert!(validate_match_request(&req).is_err());
}
#[test]
fn match_config_default_is_literal_utf8() {
let cfg = MatchConfig::default();
assert_eq!(cfg.mode, MatchMode::LiteralSubstring);
assert_eq!(cfg.pattern_encoding, PatternEncoding::Utf8);
}
#[test]
fn pattern_encoding_display_roundtrips() {
assert_eq!(PatternEncoding::Utf8.to_string(), "utf8");
assert_eq!(PatternEncoding::Hex.to_string(), "hex");
assert_eq!(PatternEncoding::Base64.to_string(), "base64");
}
#[test]
fn byte_matcher_no_match_returns_no_match() {
let mut m = Matcher::new_literal(b"XYZ".to_vec()).unwrap();
assert_eq!(m.push(b"ABCDEF"), MatchResult::NoMatch);
assert_eq!(m.check(), MatchResult::NoMatch);
}
#[test]
fn shape_context_returns_pre_match_bytes_plus_matched() {
let accumulated = b"prefix___OK>suffix".to_vec();
let shaped = shape_match_context(&accumulated, 9, 3, Some(4));
assert_eq!(shaped.data, b"x___OK>");
assert_eq!(shaped.match_index, 4);
assert_eq!(shaped.needle_len, 3);
}
#[test]
fn shape_context_fewer_than_n_pre_match_bytes() {
let accumulated = b"OK>suffix".to_vec();
let shaped = shape_match_context(&accumulated, 0, 3, Some(128));
assert_eq!(shaped.data, b"OK>");
assert_eq!(shaped.match_index, 0);
}
#[test]
fn shape_context_none_returns_full_buffer() {
let accumulated = b"prefix___OK>suffix".to_vec();
let shaped = shape_match_context(&accumulated, 9, 3, None);
assert_eq!(shaped.data, accumulated);
assert_eq!(shaped.match_index, 9);
}
#[test]
fn shape_context_zero_amount_returns_only_matched_bytes() {
let accumulated = b"prefix___OK>suffix".to_vec();
let shaped = shape_match_context(&accumulated, 9, 3, Some(0));
assert_eq!(shaped.data, b"OK>");
assert_eq!(shaped.match_index, 0);
}
#[test]
fn shape_context_match_index_remains_relative_to_returned_payload() {
let accumulated = b"AAAAAAAAAOK>".to_vec();
let shaped = shape_match_context(&accumulated, 9, 3, Some(5));
assert_eq!(shaped.data, b"AAAAAOK>");
assert_eq!(shaped.match_index, 5);
}
#[test]
fn byte_matcher_with_context_stores_amount() {
let m = Matcher::new_literal(b"OK>".to_vec())
.map(|m| m.with_context(Some(64)))
.unwrap();
assert_eq!(m.context_amount(), Some(64));
}
#[test]
fn byte_matcher_with_context_none_same_as_new() {
let m = Matcher::new_literal(b"OK>".to_vec())
.map(|m| m.with_context(None))
.unwrap();
assert_eq!(m.context_amount(), None);
}
#[test]
fn byte_matcher_is_empty_on_fresh_instance() {
let m = Matcher::new_literal(b"OK>".to_vec()).unwrap();
assert!(m.is_empty());
}
#[test]
fn byte_matcher_is_not_empty_after_push() {
let mut m = Matcher::new_literal(b"OK>".to_vec()).unwrap();
m.push(b"hello");
assert!(!m.is_empty());
}
#[test]
fn validate_match_request_passes_context_through() {
let req = MatchRequest {
pattern: "OK>".into(),
config: MatchConfig {
mode: MatchMode::LiteralSubstring,
pattern_encoding: PatternEncoding::Utf8,
context_amount_of_matched_bytes: Some(128),
},
};
let matcher = validate_match_request(&req).unwrap();
assert_eq!(matcher.context_amount(), Some(128));
}
#[test]
fn regex_matches_simple_pattern() {
let mut m = Matcher::Regex {
re: regex::bytes::Regex::new("world").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"hello "), MatchResult::NoMatch);
assert_eq!(m.push(b"world"), MatchResult::Found(6));
}
#[test]
fn regex_matches_wildcard_dot() {
let mut m = Matcher::Regex {
re: regex::bytes::Regex::new("po.g").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"test"), MatchResult::NoMatch);
assert_eq!(m.push(b"pong"), MatchResult::Found(4));
}
#[test]
fn regex_no_match_returns_no_match() {
let mut m = Matcher::Regex {
re: regex::bytes::Regex::new("world").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"hello moon"), MatchResult::NoMatch);
}
#[test]
fn validate_match_request_regex_utf8() {
let req = MatchRequest {
pattern: "po.g".into(),
config: MatchConfig {
mode: MatchMode::Regex,
pattern_encoding: PatternEncoding::Utf8,
context_amount_of_matched_bytes: None,
},
};
let matcher = validate_match_request(&req).unwrap();
assert!(matcher.needle_len().is_none()); }
#[test]
fn validate_match_request_regex_invalid_rejected() {
let req = MatchRequest {
pattern: "[invalid".into(),
config: MatchConfig {
mode: MatchMode::Regex,
pattern_encoding: PatternEncoding::Utf8,
context_amount_of_matched_bytes: None,
},
};
assert!(validate_match_request(&req).is_err());
}
#[test]
fn glob_matches_line() {
let mut m = Matcher::Glob {
pat: glob::Pattern::new("pong").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"boot\npong\nready"), MatchResult::Found(5));
}
#[test]
fn glob_matches_line_with_crlf_endings() {
let mut m = Matcher::Glob {
pat: glob::Pattern::new("pong").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"boot\r\npong\r\nready"), MatchResult::Found(6));
}
#[test]
fn glob_matches_first_line_with_crlf() {
let mut m = Matcher::Glob {
pat: glob::Pattern::new("boot").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"boot\r\npong\r\nready"), MatchResult::Found(0));
}
#[test]
fn glob_matches_last_partial_line() {
let mut m = Matcher::Glob {
pat: glob::Pattern::new("pong").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"boot\r\npong"), MatchResult::Found(6));
}
#[test]
fn glob_no_match_returns_no_match() {
let mut m = Matcher::Glob {
pat: glob::Pattern::new("pong").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(m.push(b"boot\r\nready\r\ndone"), MatchResult::NoMatch);
}
#[test]
fn glob_matches_wildcard_pattern() {
let mut m = Matcher::Glob {
pat: glob::Pattern::new("error*").unwrap(),
window: Vec::new(),
context_amount: None,
};
assert_eq!(
m.push(b"boot\r\nerror: flash failed\r\nready"),
MatchResult::Found(6)
);
}
#[test]
fn validate_match_request_glob_invalid_rejected() {
let req = MatchRequest {
pattern: "[unclosed".into(),
config: MatchConfig {
mode: MatchMode::Glob,
pattern_encoding: PatternEncoding::Utf8,
context_amount_of_matched_bytes: None,
},
};
assert!(validate_match_request(&req).is_err());
}
}