use crate::{Backend, Error, Manifest, Output, OutputFile, generate_from_model};
use serde_json::Value;
use tsurara_sem::{Model, Options, build_model};
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[error("{message}")]
pub struct PluginError {
pub message: String,
}
impl PluginError {
pub fn new(message: impl Into<String>) -> Self {
Self {
message: message.into(),
}
}
}
pub trait Plugin {
fn name(&self) -> &str;
fn transform_document(&self, _root: &mut Value) -> Result<(), PluginError> {
Ok(())
}
fn transform_model(&self, _model: &mut Model) -> Result<(), PluginError> {
Ok(())
}
fn extend(&self, _input: &ExtendInput) -> Result<Vec<OutputFile>, PluginError> {
Ok(Vec::new())
}
fn transform_files(&self, _files: &mut Vec<OutputFile>) -> Result<(), PluginError> {
Ok(())
}
}
#[derive(Debug, Clone, Copy, serde::Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(rename_all = "camelCase")]
pub struct ExtendInput<'a> {
pub language: &'a str,
pub model: &'a Model,
pub manifest: Option<&'a Manifest>,
pub common: &'a Options,
pub options: &'a Value,
pub marker: &'a str,
}
pub fn generate_with_plugins(
backend: &dyn Backend,
mut set: tsurara_loader::DocumentSet,
opts: &Options,
plugins: &[&dyn Plugin],
) -> Result<Output, Error> {
let failed = |p: &&dyn Plugin| {
let name = p.name().to_owned();
move |source| Error::Plugin { name, source }
};
if !plugins.is_empty() {
let mut root = set.root().clone();
for p in plugins {
p.transform_document(&mut root).map_err(failed(p))?;
}
set.replace_root(root);
}
let mut model = build_model(&set, opts)?;
for p in plugins {
p.transform_model(&mut model).map_err(failed(p))?;
}
let mut output = generate_from_model(backend, &model, opts)?;
let marker = backend.markers().generated;
let language_options = backend.options_json();
let mut added = Vec::new();
for p in plugins {
let input = ExtendInput {
language: backend.id(),
model: &model,
manifest: output.manifest.as_ref(),
common: opts,
options: &language_options,
marker: &marker,
};
for file in p.extend(&input).map_err(failed(p))? {
let error = |message: String| failed(p)(PluginError::new(message));
if !file.contents.starts_with(&marker) {
return Err(error(format!(
"`{}` does not start with the generated-file marker `{marker}`",
file.path
)));
}
if output
.files
.iter()
.chain(&added)
.any(|f: &OutputFile| f.path == file.path)
{
return Err(error(format!("`{}` is already generated", file.path)));
}
added.push(file);
}
}
output.files.extend(added);
for p in plugins {
p.transform_files(&mut output.files).map_err(failed(p))?;
}
output.files.sort_by(|a, b| a.path.cmp(&b.path));
Ok(output)
}