omnitrack 0.3.0

Universal issue-tracker provider contracts and clients (Linear, Jira, ...) for Rust, in one crate.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::collections::BTreeSet;

use super::IssueResult;
use super::capabilities::Capability;
use super::errors::{ErrorKind, error};

#[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
pub struct ProviderId(String);

impl ProviderId {
    pub fn make(value: impl Into<String>) -> Self {
        Self(value.into())
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

#[derive(Clone, Debug)]
pub struct ProviderDescriptor {
    id: ProviderId,
    display_name: String,
    capabilities: BTreeSet<Capability>,
}

impl ProviderDescriptor {
    pub fn id(&self) -> &ProviderId {
        &self.id
    }

    pub fn display_name(&self) -> &str {
        &self.display_name
    }

    pub fn capabilities(&self) -> &BTreeSet<Capability> {
        &self.capabilities
    }

    pub fn supports(&self, capability: Capability) -> bool {
        self.capabilities.contains(&capability)
    }
}

pub struct ProviderDescriptorBuilder {
    id: ProviderId,
    display_name: String,
    capabilities: BTreeSet<Capability>,
}

impl ProviderDescriptorBuilder {
    pub fn make(id: impl Into<String>, display_name: impl Into<String>) -> Self {
        Self {
            id: ProviderId::make(id),
            display_name: display_name.into(),
            capabilities: BTreeSet::new(),
        }
    }

    #[must_use]
    pub fn capability(mut self, capability: Capability) -> Self {
        self.capabilities.insert(capability);
        self
    }

    pub fn build(self) -> ProviderDescriptor {
        ProviderDescriptor {
            id: self.id,
            display_name: self.display_name,
            capabilities: self.capabilities,
        }
    }
}

pub trait Provider: Send + Sync {
    fn descriptor(&self) -> ProviderDescriptor;
}

#[derive(Default)]
pub struct ProviderRegistry {
    providers: Vec<Box<dyn Provider>>,
}

impl ProviderRegistry {
    pub fn descriptors(&self) -> Vec<ProviderDescriptor> {
        self.providers
            .iter()
            .map(|provider| provider.descriptor())
            .collect()
    }
}

#[derive(Default)]
pub struct ProviderRegistryBuilder {
    providers: Vec<Box<dyn Provider>>,
    ids: BTreeSet<ProviderId>,
}

impl ProviderRegistryBuilder {
    pub fn register(mut self, provider: impl Provider + 'static) -> IssueResult<Self> {
        let id = provider.descriptor().id().clone();
        if !self.ids.insert(id.clone()) {
            return Err(error().of(
                ErrorKind::Provider,
                format!("provider already registered: {}", id.as_str()),
            ));
        }
        self.providers.push(Box::new(provider));
        Ok(self)
    }

    pub fn build(self) -> ProviderRegistry {
        ProviderRegistry {
            providers: self.providers,
        }
    }
}

pub fn provider() -> ProviderRegistryBuilder {
    ProviderRegistryBuilder::default()
}