invr 0.2.3

Declarative data validation engine using invariants executed on Polars DataFrames.
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

/// A collection of invariants.
///
/// A `Spec` defines the validation contract for a dataset.
/// It can be validated before execution.
mod display;
pub mod error;

use crate::invariant::Invariant;
use crate::invariant::value_object::id::InvariantId;
use crate::spec::error::{SpecError, SpecResult};

use std::collections::BTreeSet;

#[derive(Debug, Clone, PartialEq)]
pub struct Spec<K> {
    invariants: Vec<Invariant<K>>,
}

impl<K> Spec<K> {
    pub fn new() -> Self {
        Self {
            invariants: Vec::new(),
        }
    }
    pub fn validate(&self) -> SpecResult<()> {
        let mut seen: BTreeSet<InvariantId> = BTreeSet::new();

        for invariant in &self.invariants {
            let id = invariant.id().clone();
            if !seen.insert(id.clone()) {
                return Err(SpecError::duplicate_invariant_id(id));
            }
        }

        Ok(())
    }
    pub fn from_invariants(invariants: Vec<Invariant<K>>) -> Self {
        Self { invariants }
    }

    pub fn invariants(&self) -> &[Invariant<K>] {
        &self.invariants
    }

    pub fn into_invariants(self) -> Vec<Invariant<K>> {
        self.invariants
    }

    pub fn push(&mut self, invariant: Invariant<K>) {
        self.invariants.push(invariant);
    }

    pub fn extend<I>(&mut self, invariants: I)
    where
        I: IntoIterator<Item = Invariant<K>>,
    {
        self.invariants.extend(invariants);
    }

    pub fn is_empty(&self) -> bool {
        self.invariants.is_empty()
    }

    pub fn len(&self) -> usize {
        self.invariants.len()
    }

    pub fn iter(&self) -> impl Iterator<Item = &Invariant<K>> {
        self.invariants.iter()
    }

    #[must_use]
    pub fn find_by_id(&self, id: &InvariantId) -> Option<&Invariant<K>> {
        self.invariants.iter().find(|inv| inv.id() == id)
    }

    /// Find an invariant by its string id. Convenience wrapper around [`find_by_id`](Self::find_by_id).
    #[must_use]
    pub fn find_by_str(&self, id: &str) -> Option<&Invariant<K>> {
        self.invariants.iter().find(|inv| inv.id().as_str() == id)
    }
}

impl<K> Default for Spec<K> {
    fn default() -> Self {
        Self::new()
    }
}