citum_schema_style/options/
integral_name_memory.rs1#[cfg(feature = "schema")]
7use schemars::JsonSchema;
8use serde::{Deserialize, Serialize};
9
10#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
15#[cfg_attr(feature = "schema", derive(JsonSchema))]
16#[serde(rename_all = "kebab-case")]
17pub struct IntegralNameMemoryConfig {
18 #[serde(skip_serializing_if = "Option::is_none")]
20 pub scope: Option<IntegralNameScope>,
21 #[serde(skip_serializing_if = "Option::is_none")]
23 pub contexts: Option<IntegralNameContexts>,
24 #[serde(skip_serializing_if = "Option::is_none")]
26 pub subsequent_form: Option<SubsequentNameForm>,
27 #[serde(
31 flatten,
32 default,
33 skip_serializing_if = "std::collections::BTreeMap::is_empty"
34 )]
35 #[cfg_attr(feature = "schema", schemars(skip))]
36 pub unknown_fields: std::collections::BTreeMap<String, serde_yaml::Value>,
37}
38
39impl IntegralNameMemoryConfig {
40 pub fn merge(&mut self, other: &IntegralNameMemoryConfig) {
42 if other.scope.is_some() {
43 self.scope = other.scope;
44 }
45 if other.contexts.is_some() {
46 self.contexts = other.contexts;
47 }
48 if other.subsequent_form.is_some() {
49 self.subsequent_form = other.subsequent_form;
50 }
51 }
52
53 pub fn resolve(&self) -> ResolvedIntegralNameMemoryConfig {
55 ResolvedIntegralNameMemoryConfig {
56 scope: self.scope.unwrap_or_default(),
57 contexts: self.contexts.unwrap_or_default(),
58 subsequent_form: self.subsequent_form.unwrap_or_default(),
59 }
60 }
61}
62
63#[derive(Debug, Default, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
65#[cfg_attr(feature = "schema", derive(JsonSchema))]
66#[serde(rename_all = "kebab-case")]
67pub enum IntegralNameScope {
68 #[default]
70 Document,
71 Chapter,
73 Section,
75}
76
77#[derive(Debug, Default, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
79#[cfg_attr(feature = "schema", derive(JsonSchema))]
80#[serde(rename_all = "kebab-case")]
81pub enum IntegralNameContexts {
82 #[default]
84 BodyOnly,
85 BodyAndNotes,
87}
88
89#[derive(Debug, Default, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
94#[cfg_attr(feature = "schema", derive(JsonSchema))]
95#[serde(rename_all = "kebab-case")]
96pub enum SubsequentNameForm {
97 #[default]
99 Short,
100 FamilyOnly,
102}
103
104#[derive(Debug, Default, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
106#[cfg_attr(feature = "schema", derive(JsonSchema))]
107#[serde(rename_all = "kebab-case")]
108pub enum ShortNameDisplay {
109 #[default]
111 FullThenParenthetical,
112 FullThenBracketed,
114 ShortThenParenthetical,
116 ShortThenBracketed,
118}
119
120#[cfg(test)]
121#[allow(clippy::unwrap_used, reason = "Panicking is acceptable in tests.")]
122mod tests {
123 use super::*;
124
125 #[test]
126 fn captures_unknown_fields_for_forward_compat() {
127 let yaml = r#"
128scope: chapter
129future-key: true
130"#;
131 let cfg: IntegralNameMemoryConfig = serde_yaml::from_str(yaml).unwrap();
132 assert!(cfg.unknown_fields.contains_key("future-key"));
133 assert_eq!(cfg.scope, Some(IntegralNameScope::Chapter));
134 }
135}
136
137#[derive(Debug, PartialEq, Eq, Clone, Copy)]
139pub struct ResolvedIntegralNameMemoryConfig {
140 pub scope: IntegralNameScope,
142 pub contexts: IntegralNameContexts,
144 pub subsequent_form: SubsequentNameForm,
146}
147
148#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
154#[cfg_attr(feature = "schema", derive(JsonSchema))]
155#[serde(rename_all = "kebab-case")]
156pub struct OrgAbbreviationMemoryConfig {
157 #[serde(skip_serializing_if = "Option::is_none")]
159 pub scope: Option<IntegralNameScope>,
160 #[serde(skip_serializing_if = "Option::is_none")]
162 pub contexts: Option<IntegralNameContexts>,
163 #[serde(skip_serializing_if = "Option::is_none")]
165 pub short_name_display: Option<ShortNameDisplay>,
166 #[serde(
168 flatten,
169 default,
170 skip_serializing_if = "std::collections::BTreeMap::is_empty"
171 )]
172 #[cfg_attr(feature = "schema", schemars(skip))]
173 pub unknown_fields: std::collections::BTreeMap<String, serde_yaml::Value>,
174}
175
176impl OrgAbbreviationMemoryConfig {
177 pub fn merge(&mut self, other: &OrgAbbreviationMemoryConfig) {
179 if other.scope.is_some() {
180 self.scope = other.scope;
181 }
182 if other.contexts.is_some() {
183 self.contexts = other.contexts;
184 }
185 if other.short_name_display.is_some() {
186 self.short_name_display = other.short_name_display;
187 }
188 }
189
190 pub fn resolve(&self) -> ResolvedOrgAbbreviationMemoryConfig {
192 ResolvedOrgAbbreviationMemoryConfig {
193 scope: self.scope.unwrap_or_default(),
194 contexts: self.contexts.unwrap_or_default(),
195 short_name_display: self.short_name_display.unwrap_or_default(),
196 }
197 }
198}
199
200#[derive(Debug, PartialEq, Eq, Clone, Copy)]
202pub struct ResolvedOrgAbbreviationMemoryConfig {
203 pub scope: IntegralNameScope,
205 pub contexts: IntegralNameContexts,
207 pub short_name_display: ShortNameDisplay,
209}