use serde::{Deserialize, Serialize};
use super::{Kind, Role, object};
use crate::Error;
pub(super) static KINDS: [Kind; 4] = [
Kind {
name: "drawing",
role: Role::Rendering,
form: "drawing",
level: None,
stored: false,
label: "A drawing, as SVG",
},
Kind {
name: "text",
role: Role::Rendering,
form: "text",
level: None,
stored: false,
label: "A text in a format: plain, LaTeX or Typst",
},
Kind {
name: "certificate",
role: Role::Rendering,
form: "certificate",
level: None,
stored: false,
label: "A certificate that the proof assistant Rocq checks",
},
Kind {
name: "term",
role: Role::Rendering,
form: "lambda_term",
level: None,
stored: false,
label: "A proof read back as a lambda-term",
},
];
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct Drawing {
pub(super) svg: String,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct Text {
pub(super) format: String,
pub(super) text: String,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct Certificate {
pub(super) text: String,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct Term {
pub(super) text: String,
pub(super) judgement: String,
}
pub(super) fn read(kind: &Kind, value: &str) -> Result<(), Error> {
summary(kind, value).map(drop)
}
pub(super) fn summary(kind: &Kind, value: &str) -> Result<String, Error> {
Ok(match kind.name {
"drawing" => {
object::<Drawing>(value, "drawing")?;
"A drawing".to_owned()
}
"text" => {
let text: Text = object(value, "text")?;
match text.format.as_str() {
"latex" => "LaTeX".to_owned(),
"typst" => "Typst".to_owned(),
_ => "Text".to_owned(),
}
}
"certificate" => {
object::<Certificate>(value, "certificate")?;
"A Rocq certificate".to_owned()
}
_ => object::<Term>(value, "term")?.text,
})
}