tuwunel_core/info/
cargo.rs1#[cfg(test)]
8mod tests;
9
10use std::{collections::BTreeMap, sync::OnceLock};
11
12use semver::VersionReq;
13use serde::{Deserialize, de::IgnoredAny};
14use smallstr::SmallString;
15use toml::from_str;
16use tuwunel_macros::cargo_manifest;
17
18use crate::{Result, implement};
19
20type Dependencies = BTreeMap<Name, Dependency>;
21type Features = BTreeMap<String, Vec<IgnoredAny>>;
22type Name = SmallString<[u8; 16]>;
23
24#[derive(Deserialize)]
28struct Manifest {
29 #[serde(default)]
30 features: Features,
31}
32
33#[derive(Deserialize)]
37struct WorkspaceManifest {
38 workspace: Workspace,
39}
40
41#[derive(Deserialize)]
42struct Workspace {
43 #[serde(default)]
44 dependencies: Dependencies,
45}
46
47#[derive(Deserialize)]
52#[serde(untagged)]
53enum Dependency {
54 Simple(VersionReq),
55 Detailed {
56 #[serde(default)]
57 version: VersionReq,
58
59 #[serde(default)]
60 features: Vec<Name>,
61 },
62}
63
64#[cargo_manifest]
69const WORKSPACE_MANIFEST: &'static str = ();
70#[cargo_manifest(crate = "macros")]
71const MACROS_MANIFEST: &'static str = ();
72#[cargo_manifest(crate = "core")]
73const CORE_MANIFEST: &'static str = ();
74#[cargo_manifest(crate = "database")]
75const DATABASE_MANIFEST: &'static str = ();
76#[cargo_manifest(crate = "service")]
77const SERVICE_MANIFEST: &'static str = ();
78#[cargo_manifest(crate = "admin")]
79const ADMIN_MANIFEST: &'static str = ();
80#[cargo_manifest(crate = "router")]
81const ROUTER_MANIFEST: &'static str = ();
82#[cargo_manifest(crate = "main")]
83const MAIN_MANIFEST: &'static str = ();
84
85static FEATURES: OnceLock<Vec<String>> = OnceLock::new();
89
90static DEPENDENCIES: OnceLock<Dependencies> = OnceLock::new();
93
94pub fn dependencies_names() -> impl Iterator<Item = &'static str> {
103 dependencies().map(|(name, ..)| name)
104}
105
106pub fn dependencies() -> impl Iterator<Item = (&'static str, &'static VersionReq, &'static [Name])>
116{
117 DEPENDENCIES
118 .get_or_init(|| {
119 init_dependencies()
120 .unwrap_or_else(|e| panic!("Failed to initialize dependencies: {e}"))
121 })
122 .iter()
123 .map(|(name, dependency)| {
124 (name.as_str(), dependency.version(), dependency.enabled_features())
125 })
126}
127
128#[implement(Dependency)]
129#[inline]
130fn version(&self) -> &VersionReq {
131 match self {
132 | Self::Simple(version) | Self::Detailed { version, .. } => version,
133 }
134}
135
136#[implement(Dependency)]
137#[inline]
138fn enabled_features(&self) -> &[Name] {
139 match self {
140 | Self::Simple(_) => &[],
141 | Self::Detailed { features, .. } => features,
142 }
143}
144
145pub fn features() -> &'static Vec<String> {
148 FEATURES.get_or_init(|| {
149 init_features().unwrap_or_else(|e| panic!("Failed initialize features: {e}"))
150 })
151}
152
153fn init_features() -> Result<Vec<String>> {
154 let mut features = Vec::new();
155 append_features(&mut features, WORKSPACE_MANIFEST)?;
156 append_features(&mut features, MACROS_MANIFEST)?;
157 append_features(&mut features, CORE_MANIFEST)?;
158 append_features(&mut features, DATABASE_MANIFEST)?;
159 append_features(&mut features, SERVICE_MANIFEST)?;
160 append_features(&mut features, ADMIN_MANIFEST)?;
161 append_features(&mut features, ROUTER_MANIFEST)?;
162 append_features(&mut features, MAIN_MANIFEST)?;
163 features.sort();
164 features.dedup();
165
166 Ok(features)
167}
168
169fn append_features(features: &mut Vec<String>, manifest: &str) -> Result {
170 let manifest: Manifest = from_str(manifest)?;
171
172 features.extend(manifest.features.into_keys());
173
174 Ok(())
175}
176
177fn init_dependencies() -> Result<Dependencies> {
178 let manifest: WorkspaceManifest = from_str(WORKSPACE_MANIFEST)?;
179
180 Ok(manifest.workspace.dependencies)
181}