validation core as a dependency2

validation-core/src/set.rs

@@ -0,0 +1,118 @@
+use crate::{ValidationConfig, ValidationMergeError, ValidationSettings};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ValidationRule {
+    pub name: String,
+    pub description: Option<String>,
+    pub settings: ValidationSettings,
+}
+
+impl ValidationRule {
+    pub fn resolve(&self) -> ValidationConfig {
+        self.settings.resolve()
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ValidationSet {
+    pub name: String,
+    pub description: Option<String>,
+    pub rules: Vec<ValidationRule>,
+}
+
+impl ValidationSet {
+    pub fn resolve_settings(&self) -> Result<ValidationSettings, ValidationMergeError> {
+        ValidationSettings::merge_rules(self.rules.iter().map(|rule| &rule.settings))
+    }
+
+    pub fn resolve(&self) -> Result<ValidationConfig, ValidationMergeError> {
+        Ok(self.resolve_settings()?.resolve())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AppliedValidation {
+    pub set_name: Option<String>,
+    pub settings: ValidationSettings,
+}
+
+impl AppliedValidation {
+    pub fn resolve(&self) -> ValidationConfig {
+        self.settings.resolve()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        CharacterFilterSettings, CharacterLimits, PatternSettings, PositionFilterSettings,
+        PositionRange,
+    };
+
+    #[test]
+    fn validation_set_merges_rule_fragments() {
+        let set = ValidationSet {
+            name: "phone".to_string(),
+            description: None,
+            rules: vec![
+                ValidationRule {
+                    name: "phone-length".to_string(),
+                    description: None,
+                    settings: ValidationSettings {
+                        character_limits: Some(CharacterLimits::new_range(10, 15)),
+                        ..ValidationSettings::default()
+                    },
+                },
+                ValidationRule {
+                    name: "digits-only".to_string(),
+                    description: None,
+                    settings: ValidationSettings {
+                        pattern: Some(PatternSettings {
+                            filters: vec![PositionFilterSettings {
+                                positions: PositionRange::From(0),
+                                filter: CharacterFilterSettings::Numeric,
+                            }],
+                            description: None,
+                        }),
+                        ..ValidationSettings::default()
+                    },
+                },
+            ],
+        };
+
+        let settings = set.resolve_settings().expect("set should resolve");
+
+        assert!(settings.character_limits.is_some());
+        assert_eq!(settings.pattern.expect("pattern").filters.len(), 1);
+    }
+
+    #[test]
+    fn validation_set_rejects_duplicate_singleton_rules() {
+        let set = ValidationSet {
+            name: "conflict".to_string(),
+            description: None,
+            rules: vec![
+                ValidationRule {
+                    name: "short".to_string(),
+                    description: None,
+                    settings: ValidationSettings {
+                        character_limits: Some(CharacterLimits::new(10)),
+                        ..ValidationSettings::default()
+                    },
+                },
+                ValidationRule {
+                    name: "long".to_string(),
+                    description: None,
+                    settings: ValidationSettings {
+                        character_limits: Some(CharacterLimits::new(20)),
+                        ..ValidationSettings::default()
+                    },
+                },
+            ],
+        };
+
+        assert!(set.resolve_settings().is_err());
+    }
+}