Lines
70.7 %
Functions
81.82 %
//! [`Filter`]s for querying the database and playlists.
//!
//! The filter syntax uses a context-free grammar, and has its own
//! set of parsers and parsing errors.
use std::fmt;
use chrono::{DateTime, Utc};
use lalrpop_util::lalrpop_mod;
use serde::{Deserialize, Serialize};
use crate::{
commands::RequestParserError,
types::{Priority, Tag},
};
/// Represents the case sensitivity of a string comparison,
/// used in multiple filter variants.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum CaseSensitivity {
CaseSensitive,
CaseInsensitive,
CommandDependent,
}
/// Represents a comparison operator for priority comparisons.
pub enum ComparisonOperator {
Equal,
NotEqual,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
/// Represents a filter expression for querying the music database.
pub enum Filter {
/// Logical NOT of a filter. e.g.
///
/// `(!(Artist == "The Beatles"))`
Not(Box<Filter>),
/// Logical AND of multiple filters. e.g.
/// `((Artist == "The Beatles") AND (Album == "Abbey Road") AND (Title == "Come Together"))`
And(Vec<Filter>),
/// Equality comparison on a tag. e.g.
/// `(Artist == "The Beatles")` or `(Album != "Greatest Hits")`
/// The bool indicates whether the comparison is negated (true for !=, false for ==)
EqTag(Tag, CaseSensitivity, bool),
/// Substring containment on a tag. e.g.
/// `(Title contains "Symphony")` or `(Album !contains "Live")`
/// The bool indicates whether the comparison is negated (true for !contains, false for contains)
Contains(Tag, CaseSensitivity, bool),
/// Prefix matching on a tag. e.g.
/// `(Title starts_with "Symphony")` or `(Album !starts_with "Live")`
////
/// The bool indicates whether the comparison is negated (true for !starts_with, false for starts_with)
StartsWith(Tag, CaseSensitivity, bool),
/// Perl-compatible regular expression matching on a tag. e.g.
/// `(Composer =~ "Beethoven.*")` or `(Genre !~ "Pop.*")`
/// The bool indicates whether the comparison is negated (true for !~, false for =~)
PerlRegex(Tag, bool),
/// Equality comparison on the URI. e.g.
/// `(uri == "Rock/Classics/track01.mp3")`
EqUri(String),
/// Base path filter. e.g.
/// `(base "Rock/Classics")`
Base(String),
/// Filter for files added since the given timestamp. e.g.
/// `(added-since '1622505600')` or `(added-since '2021-06-01T00:00:00Z')`
AddedSince(DateTime<Utc>),
/// Filter for files modified since the given timestamp. e.g.
/// `(modified-since '1622505600')` or `(modified-since '2021-06-01T00:00:00Z')`
ModifiedSince(DateTime<Utc>),
/// Equality comparison on audio format. e.g.
/// `(AudioFormat == '44100:16:2')`
AudioFormatEq {
sample_rate: u32,
bits: u8,
channels: u8,
},
/// Masked equality comparison on audio format. e.g.
/// `(AudioFormat =~ '44100:*:2')`
AudioFormatEqMask {
sample_rate: Option<u32>,
bits: Option<u8>,
channels: Option<u8>,
/// Priority comparison. e.g.
/// `(prio >= 42)` or `(prio != 10)`
PrioCmp(ComparisonOperator, Priority),
fn quote_string(s: &str) -> String {
let mut result = String::new();
result.push('"');
for c in s.chars() {
match c {
'\n' => result.push_str(r"\n"),
'\t' => result.push_str(r"\t"),
'\r' => result.push_str(r"\r"),
'\\' => result.push_str(r"\\"),
'"' => result.push_str(r#"\""#),
other => result.push(other),
result
impl fmt::Display for Filter {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Filter::Not(inner) => write!(f, "(!{})", inner),
Filter::And(inner) => write!(
f,
"({})",
inner
.iter()
.map(|f| format!("{}", f))
.collect::<Vec<_>>()
.join(" AND "),
),
Filter::EqTag(tag, case_sensitivity, negated) => {
let op = match (negated, case_sensitivity) {
(false, CaseSensitivity::CommandDependent) => "==",
(true, CaseSensitivity::CommandDependent) => "!=",
(false, CaseSensitivity::CaseSensitive) => "eq_cs",
(true, CaseSensitivity::CaseSensitive) => "!eq_cs",
(false, CaseSensitivity::CaseInsensitive) => "eq_ci",
(true, CaseSensitivity::CaseInsensitive) => "!eq_ci",
write!(f, "({} {} {})", tag.key(), op, quote_string(tag.value()))
Filter::Contains(tag, case_sensitivity, negated) => {
let op = if *negated { "!contains" } else { "contains" };
let cs = match case_sensitivity {
CaseSensitivity::CaseSensitive => "_cs",
CaseSensitivity::CaseInsensitive => "_ci",
CaseSensitivity::CommandDependent => "",
write!(
"({} {}{} {})",
tag.key(),
op,
cs,
quote_string(tag.value())
)
Filter::StartsWith(tag, case_sensitivity, negated) => {
let op = if *negated {
"!starts_with"
} else {
"starts_with"
Filter::PerlRegex(tag, negated) => {
if *negated {
write!(f, "({} !~ {})", tag.key(), quote_string(tag.value()))
write!(f, "({} =~ {})", tag.key(), quote_string(tag.value()))
Filter::EqUri(uri) => {
write!(f, "(uri == {})", quote_string(uri))
Filter::Base(path) => {
write!(f, "(base {})", quote_string(path))
Filter::ModifiedSince(timestamp) => {
"(modified-since {})",
quote_string(×tamp.timestamp().to_string())
Filter::AddedSince(timestamp) => {
"(added-since {})",
Filter::AudioFormatEq {
sample_rate,
bits,
channels,
} => {
"(AudioFormat == '{}:{}:{}')",
sample_rate, bits, channels
Filter::AudioFormatEqMask {
let sr_str = match sample_rate {
Some(sr) => sr.to_string(),
None => "*".to_string(),
let bits_str = match bits {
Some(b) => b.to_string(),
let ch_str = match channels {
Some(c) => c.to_string(),
write!(f, "(AudioFormat =~ '{}:{}:{}')", sr_str, bits_str, ch_str)
Filter::PrioCmp(op, prio) => {
let op_str = match op {
ComparisonOperator::Equal => "==",
ComparisonOperator::NotEqual => "!=",
ComparisonOperator::GreaterThan => ">",
ComparisonOperator::GreaterThanOrEqual => ">=",
ComparisonOperator::LessThan => "<",
ComparisonOperator::LessThanOrEqual => "<=",
write!(f, "(prio {} {})", op_str, prio)
pub(super) fn unescape_string(s: &str) -> String {
let mut chars = s.chars();
while let Some(c) = chars.next() {
if c == '\\' {
if let Some(escaped) = chars.next() {
match escaped {
'n' => result.push('\n'),
't' => result.push('\t'),
'r' => result.push('\r'),
'\\' => result.push('\\'),
'"' => result.push('"'),
other => {
result.push('\\');
result.push(other);
result.push(c);
lalrpop_mod!(filter_grammar, "/filter_grammar.rs");
impl Filter {
pub fn parse(input: &str) -> Result<Filter, RequestParserError> {
let parser = filter_grammar::ExpressionParser::new();
// println!("Parsing filter: {:#?}", parser.parse(input));
parser
.parse(input)
.map_err(|e| RequestParserError::SyntaxError(0, format!("{}", e)))
// TODO: There is a significant amount of error handling to be improved and tested here.
// TODO: thiserror
#[derive(Debug, Clone, PartialEq)]
pub enum FilterParserError<'a> {
/// Could not parse the response due to a syntax error.
SyntaxError(usize, &'a str),
/// Audio format string is invalid.
InvalidAudioFormat,
/// Parentheses are unbalanced.
UnbalancedParentheses,
/// String literal is not closed.
UnclosedStringLiteral,
#[cfg(test)]
mod tests {
use chrono::DateTime;
use super::*;
#[test]
fn test_parse_filter_eq_tag() {
let filter = Filter::parse(r#"(artist == "The Beatles")"#);
assert_eq!(
filter,
Ok(Filter::EqTag(
Tag::Artist("The Beatles".to_string()),
CaseSensitivity::CommandDependent,
false,
)),
);
let filter = Filter::parse(r#"(artist != "The Beatles")"#);
true,
fn test_parse_filter_contains() {
let filter = Filter::parse(r#"(album contains "Greatest Hits")"#);
Ok(Filter::Contains(
Tag::Album("Greatest Hits".to_string()),
))
let filter = Filter::parse(r#"(album !contains "Greatest Hits")"#);
fn test_parse_filter_starts_with() {
let filter = Filter::parse(r#"(title starts_with "Symphony No. ")"#);
Ok(Filter::StartsWith(
Tag::Title("Symphony No. ".to_string()),
let filter = Filter::parse(r#"(title !starts_with "Symphony No. ")"#);
fn test_parse_filter_perl_regex_positive() {
let filter = Filter::parse(r#"(composer =~ "Beethoven.*")"#);
Ok(Filter::PerlRegex(
Tag::Composer("Beethoven.*".to_string()),
let filter = Filter::parse(r#"(genre !~ "Pop.*")"#);
Ok(Filter::PerlRegex(Tag::Genre("Pop.*".to_string()), true)),
fn test_parse_filter_base() {
let filter = Filter::parse(r#"(base "Rock/Classics")"#);
assert_eq!(filter, Ok(Filter::Base("Rock/Classics".to_string())));
fn test_parse_filter_modified_since() {
let filter = Filter::parse(r#"(modified-since '1622505600')"#);
Ok(Filter::ModifiedSince(
DateTime::from_timestamp(1622505600, 0).unwrap()
let date_time = DateTime::from_timestamp(1622505600, 0).unwrap();
let iso8601_str = date_time.to_rfc3339();
let filter = Filter::parse(format!(r#"(modified-since "{}")"#, iso8601_str).as_str());
assert_eq!(filter, Ok(Filter::ModifiedSince(date_time)));
fn test_parse_filter_audio_added_since() {
let filter = Filter::parse(r#"(added-since '1622505600')"#);
Ok(Filter::AddedSince(
let filter = Filter::parse(format!(r#"(added-since "{}")"#, iso8601_str).as_str());
assert_eq!(filter, Ok(Filter::AddedSince(date_time)));
fn test_parse_filter_audio_format_eq() {
let filter = Filter::parse(r#"(AudioFormat == 44100:16:2)"#);
Ok(Filter::AudioFormatEq {
sample_rate: 44100,
bits: 16,
channels: 2,
}),
fn test_parse_filter_audio_format_eq_mask() {
let filter = Filter::parse(r#"(AudioFormat =~ 44100:*:2)"#);
Ok(Filter::AudioFormatEqMask {
sample_rate: Some(44100),
bits: None,
channels: Some(2),
fn test_parse_filter_prio_cmp() {
for (op_str, op_enum) in &[
(">", ComparisonOperator::GreaterThan),
(">=", ComparisonOperator::GreaterThanOrEqual),
("<", ComparisonOperator::LessThan),
("<=", ComparisonOperator::LessThanOrEqual),
("==", ComparisonOperator::Equal),
("!=", ComparisonOperator::NotEqual),
] {
let filter_str = format!(r#"(prio {} 42)"#, op_str);
let filter = Filter::parse(&filter_str);
assert_eq!(filter, Ok(Filter::PrioCmp(op_enum.clone(), 42)),);
fn test_parse_filter_not() {
let filter = Filter::parse(r#"(!(artist == "The Beatles"))"#);
Ok(Filter::Not(Box::new(Filter::EqTag(
)))),
fn test_parse_filter_and() {
let filter = Filter::parse(
r#"((artist == "The Beatles") AND (album == "Abbey Road") AND (title == "Come Together"))"#,
Ok(Filter::And(vec![
Filter::EqTag(
Tag::Album("Abbey Road".to_string()),
Tag::Title("Come Together".to_string()),
])),
fn test_parse_filter_explicitly_case_sensitive() {
let filter = Filter::parse(r#"(artist eq_cs "The Beatles")"#);
CaseSensitivity::CaseSensitive,
let filter = Filter::parse(r#"(artist !eq_cs "The Beatles")"#);
let filter = Filter::parse(r#"(album contains_cs "Greatest Hits")"#);
let filter = Filter::parse(r#"(album !contains_cs "Greatest Hits")"#);
let filter = Filter::parse(r#"(title starts_with_cs "Symphony No. ")"#);
let filter = Filter::parse(r#"(title !starts_with_cs "Symphony No. ")"#);
fn test_parse_filter_explicitly_case_insensitive() {
let filter = Filter::parse(r#"(artist eq_ci "The Beatles")"#);
CaseSensitivity::CaseInsensitive,
let filter = Filter::parse(r#"(artist !eq_ci "The Beatles")"#);
let filter = Filter::parse(r#"(album contains_ci "Greatest Hits")"#);
let filter = Filter::parse(r#"(album !contains_ci "Greatest Hits")"#);
let filter = Filter::parse(r#"(title starts_with_ci "Symphony No. ")"#);
let filter = Filter::parse(r#"(title !starts_with_ci "Symphony No. ")"#);
fn test_parse_filter_string_escapes() {
let filter = Filter::parse(r#"(Artist == "\"foo\\'bar\\\"")"#);
Tag::Artist(r#""foo\'bar\""#.to_string()),
fn test_parse_filter_excessive_whitespace() {
let filter = Filter::parse("(\tartist\n == \"The Beatles\" ) ");