use std::fmt;
use crate::reflection;
use crate::utils;
use crate::Predicate;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct IsEmptyPredicate {}
impl Predicate<str> for IsEmptyPredicate {
fn eval(&self, variable: &str) -> bool {
variable.is_empty()
}
fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
utils::default_find_case(self, expected, variable)
.map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
}
}
impl reflection::PredicateReflection for IsEmptyPredicate {}
impl fmt::Display for IsEmptyPredicate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let palette = crate::Palette::new(f.alternate());
write!(
f,
"{}.{}()",
palette.var("var"),
palette.description("is_empty"),
)
}
}
pub fn is_empty() -> IsEmptyPredicate {
IsEmptyPredicate {}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StartsWithPredicate {
pattern: String,
}
impl Predicate<str> for StartsWithPredicate {
fn eval(&self, variable: &str) -> bool {
variable.starts_with(&self.pattern)
}
fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
utils::default_find_case(self, expected, variable)
.map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
}
}
impl reflection::PredicateReflection for StartsWithPredicate {}
impl fmt::Display for StartsWithPredicate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let palette = crate::Palette::new(f.alternate());
write!(
f,
"{}.{}({:?})",
palette.var("var"),
palette.description("starts_with"),
self.pattern
)
}
}
pub fn starts_with<P>(pattern: P) -> StartsWithPredicate
where
P: Into<String>,
{
StartsWithPredicate {
pattern: pattern.into(),
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EndsWithPredicate {
pattern: String,
}
impl Predicate<str> for EndsWithPredicate {
fn eval(&self, variable: &str) -> bool {
variable.ends_with(&self.pattern)
}
fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
utils::default_find_case(self, expected, variable)
.map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
}
}
impl reflection::PredicateReflection for EndsWithPredicate {}
impl fmt::Display for EndsWithPredicate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let palette = crate::Palette::new(f.alternate());
write!(
f,
"{}.{}({:?})",
palette.var("var"),
palette.description("ends_with"),
self.pattern
)
}
}
pub fn ends_with<P>(pattern: P) -> EndsWithPredicate
where
P: Into<String>,
{
EndsWithPredicate {
pattern: pattern.into(),
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ContainsPredicate {
pattern: String,
}
impl ContainsPredicate {
pub fn count(self, count: usize) -> MatchesPredicate {
MatchesPredicate {
pattern: self.pattern,
count,
}
}
}
impl Predicate<str> for ContainsPredicate {
fn eval(&self, variable: &str) -> bool {
variable.contains(&self.pattern)
}
fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
utils::default_find_case(self, expected, variable)
.map(|case| case.add_product(reflection::Product::new("var", variable.to_owned())))
}
}
impl reflection::PredicateReflection for ContainsPredicate {}
impl fmt::Display for ContainsPredicate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let palette = crate::Palette::new(f.alternate());
write!(
f,
"{}.{}({})",
palette.var("var"),
palette.description("contains"),
palette.expected(&self.pattern),
)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MatchesPredicate {
pattern: String,
count: usize,
}
impl Predicate<str> for MatchesPredicate {
fn eval(&self, variable: &str) -> bool {
variable.matches(&self.pattern).count() == self.count
}
fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
let actual_count = variable.matches(&self.pattern).count();
let result = self.count == actual_count;
if result == expected {
Some(
reflection::Case::new(Some(self), result)
.add_product(reflection::Product::new("var", variable.to_owned()))
.add_product(reflection::Product::new("actual count", actual_count)),
)
} else {
None
}
}
}
impl reflection::PredicateReflection for MatchesPredicate {
fn parameters<'a>(&'a self) -> Box<dyn Iterator<Item = reflection::Parameter<'a>> + 'a> {
let params = vec![reflection::Parameter::new("count", &self.count)];
Box::new(params.into_iter())
}
}
impl fmt::Display for MatchesPredicate {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let palette = crate::Palette::new(f.alternate());
write!(
f,
"{}.{}({})",
palette.var("var"),
palette.description("contains"),
palette.expected(&self.pattern),
)
}
}
pub fn contains<P>(pattern: P) -> ContainsPredicate
where
P: Into<String>,
{
ContainsPredicate {
pattern: pattern.into(),
}
}