knowledge-base-extension-framework 0.1.0

Static extension contracts for the 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
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

use crate::contracts::{BindingKey, BindingKind, BindingReference, ContractVersion, ExtensionId};
use std::fmt;

/// An error returned when a canonical extension identifier or binding key is invalid.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct IdentifierError {
    value: String,
    expected: &'static str,
}

impl IdentifierError {
    pub(crate) fn new(value: &str, expected: &'static str) -> Self {
        Self {
            value: value.to_owned(),
            expected,
        }
    }
}

impl fmt::Display for IdentifierError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "invalid identifier {:?}; expected {}", self.value, self.expected)
    }
}

impl std::error::Error for IdentifierError {}

/// Errors returned while registering, activating, or resolving extensions.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum FrameworkError {
    DuplicateExtension(ExtensionId),
    DuplicateDependency {
        extension: ExtensionId,
        dependency: ExtensionId,
    },
    DuplicateBinding {
        extension: ExtensionId,
        key: BindingKey,
    },
    MissingDependency {
        extension: ExtensionId,
        dependency: ExtensionId,
    },
    UnsupportedContract {
        extension: ExtensionId,
        required: ContractVersion,
        available: ContractVersion,
    },
    DependencyCycle(Vec<ExtensionId>),
    InactiveDependency {
        extension: ExtensionId,
        dependency: ExtensionId,
    },
    InvalidRequirement {
        extension: ExtensionId,
        binding: BindingReference,
        expected: BindingKind,
    },
    UndeclaredBinding {
        extension: ExtensionId,
        binding: BindingReference,
    },
    InaccessibleBinding {
        extension: ExtensionId,
        binding: BindingReference,
    },
    MissingBinding(BindingReference),
    BindingKindMismatch {
        binding: BindingReference,
        expected: BindingKind,
        actual: BindingKind,
    },
}

impl fmt::Display for FrameworkError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::DuplicateExtension(id) => write!(formatter, "extension {id} is registered more than once"),
            Self::DuplicateDependency { extension, dependency } => write!(formatter, "extension {extension} declares dependency {dependency} more than once"),
            Self::DuplicateBinding { extension, key } => write!(formatter, "extension {extension} declares binding {key} more than once"),
            Self::MissingDependency { extension, dependency } => write!(formatter, "extension {extension} requires unavailable dependency {dependency}"),
            Self::UnsupportedContract { extension, required, available } => write!(formatter, "extension {extension} requires contract {required}, but {available} is available"),
            Self::DependencyCycle(ids) => write!(
                formatter,
                "extension dependency cycle: {}",
                ids.iter().map(ToString::to_string).collect::<Vec<_>>().join(" -> ")
            ),
            Self::InactiveDependency { extension, dependency } => write!(formatter, "active extension {extension} requires inactive dependency {dependency}"),
            Self::InvalidRequirement { extension, binding, expected } => write!(formatter, "extension {extension} requirement {binding} must reference a {expected:?} binding"),
            Self::UndeclaredBinding { extension, binding } => write!(formatter, "extension {extension} does not declare binding {binding}"),
            Self::InaccessibleBinding { extension, binding } => write!(formatter, "extension {extension} may not consume binding {binding}"),
            Self::MissingBinding(binding) => write!(formatter, "missing binding {binding}"),
            Self::BindingKindMismatch { binding, expected, actual } => write!(formatter, "binding {binding} has kind {actual:?}; expected {expected:?}"),
        }
    }
}

impl std::error::Error for FrameworkError {}