knowledge-base-crud 0.3.0

Filesystem CRUD operations for a file-based knowledge base
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

use crate::{read::ReadRepository, write::WriteRepository};
use knowledge_base_validation::{Diagnostic, KnowledgeBaseValidator, validate_repository_with};
use std::fmt;
use std::path::{Path, PathBuf};
use std::sync::Arc;

/// Filesystem-backed access point for one canonical knowledge-base repository.
#[derive(Clone)]
pub struct KnowledgeBaseRepository {
    root: PathBuf,
    validators: Vec<Arc<dyn KnowledgeBaseValidator>>,
}

impl fmt::Debug for KnowledgeBaseRepository {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("KnowledgeBaseRepository")
            .field("root", &self.root)
            .field("validator_count", &self.validators.len())
            .finish()
    }
}

impl KnowledgeBaseRepository {
    pub fn new(root: impl Into<PathBuf>) -> Self {
        Self::with_validators(root, [])
    }

    pub fn with_validators(root: impl Into<PathBuf>, validators: impl IntoIterator<Item = Arc<dyn KnowledgeBaseValidator>>) -> Self {
        Self {
            root: root.into(),
            validators: validators.into_iter().collect(),
        }
    }

    pub fn root(&self) -> &Path {
        &self.root
    }

    /// Validates the current repository with generic and configured validators.
    pub fn validate(&self) -> Vec<Diagnostic> {
        validate_repository_with(&self.root, self.validators.iter().map(AsRef::as_ref))
    }

    pub fn read(&self) -> ReadRepository<'_> {
        ReadRepository::new(self)
    }

    pub fn write(&self) -> WriteRepository<'_> {
        WriteRepository::new(self)
    }

    pub(crate) fn validators(&self) -> &[Arc<dyn KnowledgeBaseValidator>] {
        &self.validators
    }
}