use std::collections::BTreeMap;
use std::path::Path;
use std::path::PathBuf;
use openehr_mapping_core::diagnostic::Diagnostic;
use openehr_mapping_core::diagnostic::DiagnosticCode;
use openehr_mapping_core::diagnostic::ModelPath;
use openehr_mapping_core::header::metadata::MappingName;
use openehr_mapping_core::header::metadata::MappingType;
use openehr_mapping_core::loader::MappingDocument;
use openehr_mapping_core::loader::in_path_order;
use openehr_mapping_core::loader::load_file;
use openehr_mapping_core::loader::load_str;
use crate::model::ast::ContextMappingFile;
use crate::model::ast::ModelMappingFile;
use crate::model::error::ModelCode;
use crate::model::parse::lower_context;
use crate::model::parse::lower_model;
use crate::model::schema::strict;
use crate::model::semantic::MappingCodeRegistry;
use crate::model::semantic::validate;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct MappingSet {
models: BTreeMap<MappingName, ModelMappingFile>,
contexts: BTreeMap<MappingName, ContextMappingFile>,
}
impl MappingSet {
pub fn insert_model(&mut self, file: ModelMappingFile) -> Result<(), Box<Diagnostic>> {
let name = file.header().name().value().clone();
if let Some(first) = self.file_of(&name) {
return Err(Box::new(duplicate(
&name,
first,
file.file(),
file.header(),
)));
}
self.models.insert(name, file);
Ok(())
}
pub fn insert_context(&mut self, file: ContextMappingFile) -> Result<(), Box<Diagnostic>> {
let name = file.header().name().value().clone();
if let Some(first) = self.file_of(&name) {
return Err(Box::new(duplicate(
&name,
first,
file.file(),
file.header(),
)));
}
self.contexts.insert(name, file);
Ok(())
}
#[must_use]
pub fn model(&self, name: &MappingName) -> Option<&ModelMappingFile> {
self.models.get(name)
}
#[must_use]
pub fn context(&self, name: &MappingName) -> Option<&ContextMappingFile> {
self.contexts.get(name)
}
pub fn models(&self) -> impl Iterator<Item = &ModelMappingFile> {
self.models.values()
}
pub fn contexts(&self) -> impl Iterator<Item = &ContextMappingFile> {
self.contexts.values()
}
#[must_use]
pub fn file_of(&self, name: &MappingName) -> Option<&Path> {
self.models
.get(name)
.map(ModelMappingFile::file)
.or_else(|| self.contexts.get(name).map(ContextMappingFile::file))
}
#[must_use]
pub fn len(&self) -> usize {
self.models.len() + self.contexts.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.models.is_empty() && self.contexts.is_empty()
}
}
fn duplicate(
name: &MappingName,
first: &Path,
second: &Path,
header: &openehr_mapping_core::header::Header,
) -> Diagnostic {
Diagnostic::error(
second.to_path_buf(),
DiagnosticCode::DuplicateMappingName,
format!(
"the mapping name `{name}` is declared by both {} and {}",
first.display(),
second.display()
),
)
.with_position(header.name().position())
.with_mapping_name(name.clone())
.with_model_path(ModelPath::root().field("metadata").field("name"))
}
pub fn load_model_file(file: impl AsRef<Path>) -> Result<ModelMappingFile, Vec<Diagnostic>> {
let document = read(file.as_ref())?;
check_schema(&document)?;
lower_model(&document)
}
pub fn load_context_file(file: impl AsRef<Path>) -> Result<ContextMappingFile, Vec<Diagnostic>> {
let document = read(file.as_ref())?;
check_schema(&document)?;
lower_context(&document)
}
pub fn load_set<I, P>(
files: I,
codes: &dyn MappingCodeRegistry,
) -> Result<MappingSet, Vec<Diagnostic>>
where
I: IntoIterator<Item = P>,
P: AsRef<Path>,
{
let paths = in_path_order(files);
load_documents(paths.iter().map(|path| read(path)), codes)
}
pub fn load_set_from_text<I, N, T>(
files: I,
codes: &dyn MappingCodeRegistry,
) -> Result<MappingSet, Vec<Diagnostic>>
where
I: IntoIterator<Item = (N, T)>,
N: Into<PathBuf>,
T: AsRef<str>,
{
let mut texts: Vec<(PathBuf, T)> = files
.into_iter()
.map(|(name, text)| (name.into(), text))
.collect();
texts.sort_unstable_by(|left, right| left.0.cmp(&right.0));
load_documents(
texts.iter().map(|(name, text)| {
load_str(name.clone(), text.as_ref()).map_err(|error| vec![Diagnostic::from(&error)])
}),
codes,
)
}
fn load_documents<I>(
documents: I,
codes: &dyn MappingCodeRegistry,
) -> Result<MappingSet, Vec<Diagnostic>>
where
I: Iterator<Item = Result<MappingDocument, Vec<Diagnostic>>>,
{
let mut set = MappingSet::default();
let mut diagnostics = Vec::new();
for document in documents {
let document = match document {
Ok(document) => document,
Err(mut errors) => {
diagnostics.append(&mut errors);
continue;
}
};
if let Err(mut errors) = check_schema(&document) {
diagnostics.append(&mut errors);
continue;
}
let is_context =
document.header().mapping_type().map(|t| *t.value()) == Some(MappingType::Context);
let outcome = if is_context {
lower_context(&document).and_then(|file| set.insert_context(file).map_err(|d| vec![*d]))
} else {
lower_model(&document).and_then(|file| set.insert_model(file).map_err(|d| vec![*d]))
};
if let Err(mut errors) = outcome {
diagnostics.append(&mut errors);
}
}
diagnostics.append(&mut validate(&set, codes));
if diagnostics.is_empty() {
Ok(set)
} else {
Err(diagnostics)
}
}
fn read(file: &Path) -> Result<MappingDocument, Vec<Diagnostic>> {
load_file(file).map_err(|error| vec![Diagnostic::from(&error)])
}
fn check_schema(document: &MappingDocument) -> Result<(), Vec<Diagnostic>> {
let schemas = strict::schemas().map_err(|error| {
vec![Diagnostic::error(
document.file().to_path_buf(),
ModelCode::SchemaCompilation.into(),
error.to_string(),
)]
})?;
let diagnostics = schemas.validate_document(document);
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
}
}
#[cfg(test)]
mod tests {
use openehr_mapping_core::diagnostic::DiagnosticCode;
use openehr_mapping_core::loader::load_str;
use super::MappingSet;
use crate::model::parse::lower_model;
use crate::model::semantic::StaticMappingCodes;
use crate::model::semantic::validate;
fn model(name: &str) -> String {
format!(
"grammar: FHIRConnect/v1.0.0\ntype: model\nmetadata:\n name: {name}\n version: \
1.0.0\nspec:\n system: FHIR\n version: R4\n openEhrConfig:\n archetype: \
openEHR-EHR-EVALUATION.test.v1\nmappings: []\n"
)
}
#[test]
fn a_duplicate_mapping_name_is_refused_naming_both_files() {
let first = load_str("a.yml", &model("KDS_composition")).expect("a header");
let second = load_str("b.yml", &model("KDS_composition")).expect("a header");
let mut set = MappingSet::default();
set.insert_model(lower_model(&first).expect("a model file"))
.expect("the first file loads");
let diagnostic = set
.insert_model(lower_model(&second).expect("a model file"))
.expect_err("the second is refused");
assert_eq!(diagnostic.code(), &DiagnosticCode::DuplicateMappingName);
assert!(diagnostic.message().contains("a.yml"), "{diagnostic}");
assert!(diagnostic.message().contains("b.yml"), "{diagnostic}");
assert_eq!(set.len(), 1);
assert!(!set.is_empty());
}
#[test]
fn an_empty_set_validates() {
let set = MappingSet::default();
assert!(set.is_empty());
assert_eq!(
validate(&set, &StaticMappingCodes::default()),
Vec::<openehr_mapping_core::diagnostic::Diagnostic>::new()
);
}
}