use crate::state::{
language::Language,
oca::{DynOverlay, OCABuilder, OCATranslation, OCA},
};
use std::collections::{HashMap, HashSet};
#[derive(Debug)]
pub enum Error {
Custom(String),
MissingTranslations(Language),
MissingMetaTranslation(Language, String),
UnexpectedTranslations(Language),
MissingAttributeTranslation(Language, String),
}
pub struct Validator {
enforced_translations: Vec<Language>,
}
impl Default for Validator {
fn default() -> Self {
Self::new()
}
}
impl Validator {
pub fn new() -> Validator {
Validator {
enforced_translations: vec![],
}
}
pub fn enforce_translations(mut self, languages: Vec<Language>) -> Validator {
self.enforced_translations = self
.enforced_translations
.into_iter()
.chain(languages.into_iter())
.collect::<Vec<Language>>();
self
}
pub fn validate(self, oca: &OCA) -> Result<(), Vec<Error>> {
let enforced_langs: HashSet<_> = self.enforced_translations.iter().collect();
let mut errors: Vec<Error> = vec![];
let oca_str = serde_json::to_string(&serde_json::value::to_value(oca).unwrap()).unwrap();
let oca_builder: OCABuilder = serde_json::from_str(oca_str.as_str()).unwrap();
if !oca_builder.meta_translations.is_empty() {
if let Err(meta_errors) =
self.validate_meta(&enforced_langs, &oca_builder.meta_translations)
{
errors = errors
.into_iter()
.chain(meta_errors.into_iter().map(|e| {
if let Error::UnexpectedTranslations(lang) = e {
Error::Custom(format!(
"meta overlay: translations in {:?} language are not enforced",
lang
))
} else if let Error::MissingTranslations(lang) = e {
Error::Custom(format!(
"meta overlay: translations in {:?} language are missing",
lang
))
} else if let Error::MissingMetaTranslation(lang, attr) = e {
Error::Custom(format!(
"meta overlay: for '{}' translation in {:?} language is missing",
attr, lang
))
} else {
e
}
}))
.collect();
}
}
for overlay_type in &["entry", "information", "label"] {
let typed_overlays: Vec<_> = oca
.overlays
.iter()
.filter(|x| {
x.overlay_type()
.contains(format!("/{}/", overlay_type).as_str())
})
.collect();
if typed_overlays.is_empty() {
continue;
}
if let Err(translation_errors) =
self.validate_translations(&enforced_langs, typed_overlays)
{
errors = errors.into_iter().chain(
translation_errors.into_iter().map(|e| {
if let Error::UnexpectedTranslations(lang) = e {
Error::Custom(
format!("{} overlay: translations in {:?} language are not enforced", overlay_type, lang)
)
} else if let Error::MissingTranslations(lang) = e {
Error::Custom(
format!("{} overlay: translations in {:?} language are missing", overlay_type, lang)
)
} else if let Error::MissingAttributeTranslation(lang, attr_name) = e {
Error::Custom(
format!("{} overlay: for '{}' attribute missing translations in {:?} language", overlay_type, attr_name, lang)
)
} else {
e
}
})
).collect();
}
}
if errors.is_empty() {
Ok(())
} else {
Err(errors)
}
}
fn validate_meta(
&self,
enforced_langs: &HashSet<&Language>,
translations: &HashMap<Language, OCATranslation>,
) -> Result<(), Vec<Error>> {
let mut errors: Vec<Error> = vec![];
let translation_langs: HashSet<_> = translations.keys().collect();
let missing_enforcement: HashSet<&_> =
translation_langs.difference(enforced_langs).collect();
for m in missing_enforcement {
errors.push(Error::UnexpectedTranslations(m.to_string()));
}
let missing_translations: HashSet<&_> =
enforced_langs.difference(&translation_langs).collect();
for m in missing_translations {
errors.push(Error::MissingTranslations(m.to_string()));
}
let (name_defined, name_undefined): (Vec<_>, Vec<_>) =
translations.iter().partition(|(_lang, t)| t.name.is_some());
if !name_defined.is_empty() {
let name_undefined_langs: HashSet<_> = name_undefined.iter().map(|x| x.0).collect();
for m in name_undefined_langs {
errors.push(Error::MissingMetaTranslation(
m.to_string(),
"name".to_string(),
));
}
}
let (desc_defined, desc_undefined): (Vec<_>, Vec<_>) = translations
.iter()
.partition(|(_lang, t)| t.description.is_some());
if !desc_defined.is_empty() {
let desc_undefined_langs: HashSet<_> = desc_undefined.iter().map(|x| x.0).collect();
for m in desc_undefined_langs {
errors.push(Error::MissingMetaTranslation(
m.to_string(),
"description".to_string(),
));
}
}
if errors.is_empty() {
Ok(())
} else {
Err(errors)
}
}
fn validate_translations(
&self,
enforced_langs: &HashSet<&Language>,
overlays: Vec<&DynOverlay>,
) -> Result<(), Vec<Error>> {
let mut errors: Vec<Error> = vec![];
let overlay_langs: HashSet<_> = overlays.iter().map(|x| x.language().unwrap()).collect();
let missing_enforcement: HashSet<&_> = overlay_langs.difference(enforced_langs).collect();
for m in missing_enforcement {
errors.push(Error::UnexpectedTranslations(m.to_string()));
}
let missing_translations: HashSet<&_> = enforced_langs.difference(&overlay_langs).collect();
for m in missing_translations {
errors.push(Error::MissingTranslations(m.to_string()));
}
let all_attributes: HashSet<&String> =
overlays.iter().flat_map(|o| o.attributes()).collect();
for overlay in overlays.iter() {
let attributes: HashSet<_> = overlay.attributes().into_iter().collect();
let missing_attr_translation: HashSet<&_> =
all_attributes.difference(&attributes).collect();
for m in missing_attr_translation {
errors.push(Error::MissingAttributeTranslation(
overlay.language().unwrap().clone(),
m.to_string(),
));
}
}
if errors.is_empty() {
Ok(())
} else {
Err(errors)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::state::{
attribute::{AttributeBuilder, AttributeType},
encoding::Encoding,
oca::OCABuilder,
};
use maplit::hashmap;
#[test]
fn validate_valid_oca() {
let validator =
Validator::new().enforce_translations(vec!["En".to_string(), "Pl".to_string()]);
let oca = OCABuilder::new(Encoding::Utf8)
.add_name(hashmap! {
"En".to_string() => "Driving Licence".to_string(),
"Pl".to_string() => "Prawo Jazdy".to_string(),
})
.add_description(hashmap! {
"En".to_string() => "DL".to_string(),
"Pl".to_string() => "PJ".to_string(),
})
.add_attribute(
AttributeBuilder::new("name".to_string(), AttributeType::Text)
.add_label(hashmap! {
"En".to_string() => "Name: ".to_string(),
"Pl".to_string() => "Imię: ".to_string(),
})
.build(),
)
.add_attribute(
AttributeBuilder::new("age".to_string(), AttributeType::Number)
.add_label(hashmap! {
"En".to_string() => "Age: ".to_string(),
"Pl".to_string() => "Wiek: ".to_string(),
})
.add_format("asd".to_string())
.build(),
)
.finalize();
let result = validator.validate(&oca);
assert!(result.is_ok());
}
#[test]
fn validate_oca_with_missing_name_translation() {
let validator =
Validator::new().enforce_translations(vec!["En".to_string(), "Pl".to_string()]);
let oca = OCABuilder::new(Encoding::Utf8)
.add_name(hashmap! {
"En".to_string() => "Driving Licence".to_string(),
})
.finalize();
let result = validator.validate(&oca);
assert!(result.is_err());
if let Err(errors) = result {
assert_eq!(errors.len(), 1);
}
}
}