openfare-lib 0.6.2

OpenFare core library.
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

use super::common;
use anyhow::{format_err, Result};
use lazy_regex::regex;
use std::convert::TryFrom;

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct EmployeesCount {
    operator: common::Operator,
    count: usize,
}

impl std::convert::TryFrom<&str> for EmployeesCount {
    type Error = anyhow::Error;
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        let (operator, count) = parse_value(&value)?;
        Ok(Self { operator, count })
    }
}

impl EmployeesCount {
    pub fn evaluate(&self, parameters: &crate::lock::plan::conditions::Parameters) -> Result<bool> {
        let employees_count = parameters.employees_count.ok_or(format_err!(
            "Attempting to evaluate plan conditions using unset parameter `employees-count`."
        ))?;
        let result =
            common::evaluate_operator::<usize>(&employees_count, &self.operator, &self.count);
        Ok(result)
    }
}

impl serde::Serialize for EmployeesCount {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(format!("{} {}", self.operator.to_string(), self.count,).as_str())
    }
}

struct Visitor {
    marker: std::marker::PhantomData<fn() -> EmployeesCount>,
}

impl Visitor {
    fn new() -> Self {
        Visitor {
            marker: std::marker::PhantomData,
        }
    }
}

impl<'de> serde::de::Visitor<'de> for Visitor {
    type Value = EmployeesCount;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a string such as '> 100'")
    }

    fn visit_str<E>(self, value: &str) -> core::result::Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        let (operator, count) = parse_value(&value).expect("parse employee-count condition value");
        Ok(Self::Value { operator, count })
    }
}

impl<'de> serde::Deserialize<'de> for EmployeesCount {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_str(Visitor::new())
    }
}

fn parse_value(value: &str) -> Result<(common::Operator, usize)> {
    let re = regex!(r"(?P<operator>(>=)|(<=)|(<)|(>)|(=))\s*(?P<quantity>[0-9]+)");
    let captures = re
        .captures(value)
        .ok_or(format_err!("Regex failed to capture field."))?;

    let operator_match = captures
        .name("operator")
        .expect("extract operator from regex capture")
        .as_str();
    let operator = common::Operator::try_from(operator_match)?;

    let quantity_match = captures
        .name("quantity")
        .expect("extract quantity from regex capture")
        .as_str();
    let quantity = quantity_match.parse::<usize>()?;

    Ok((operator, quantity))
}

#[test]
fn test_from_str() -> Result<()> {
    let mut parameters = crate::lock::plan::conditions::Parameters::default();
    parameters.employees_count = Some(99);

    let employees_count = EmployeesCount::try_from("<= 99")?;
    assert!(employees_count.evaluate(&parameters)?);
    Ok(())
}