use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::Path;
use crate::error::{Error, Result};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeckDefinition {
pub package: PackageInfo,
#[serde(default)]
pub models: Vec<ModelDef>,
#[serde(default)]
pub decks: Vec<DeckDef>,
#[serde(default)]
pub notes: Vec<NoteDef>,
#[serde(default)]
pub media: Vec<MediaDef>,
}
impl DeckDefinition {
pub fn from_file(path: impl AsRef<Path>) -> Result<Self> {
let content = std::fs::read_to_string(path)?;
Self::parse(&content)
}
pub fn parse(content: &str) -> Result<Self> {
let def: DeckDefinition = toml::from_str(content)?;
def.validate()?;
Ok(def)
}
pub fn validate(&self) -> Result<()> {
let model_names: std::collections::HashSet<_> =
self.models.iter().map(|m| m.name.as_str()).collect();
for note in &self.notes {
if !model_names.contains(note.model.as_str()) {
return Err(Error::ModelNotFound(note.model.clone()));
}
let model = self.models.iter().find(|m| m.name == note.model).unwrap();
for field_name in note.fields.keys() {
if !model.fields.contains(field_name) {
return Err(Error::FieldNotFound {
model: note.model.clone(),
field: field_name.clone(),
});
}
}
}
let deck_names: std::collections::HashSet<_> =
self.decks.iter().map(|d| d.name.as_str()).collect();
for note in &self.notes {
if !deck_names.contains(note.deck.as_str()) {
return Err(Error::DeckNotFound(note.deck.clone()));
}
}
Ok(())
}
pub fn get_model(&self, name: &str) -> Option<&ModelDef> {
self.models.iter().find(|m| m.name == name)
}
pub fn get_deck(&self, name: &str) -> Option<&DeckDef> {
self.decks.iter().find(|d| d.name == name)
}
pub fn notes_for_deck(&self, deck_name: &str) -> impl Iterator<Item = &NoteDef> {
self.notes.iter().filter(move |n| n.deck == deck_name)
}
pub fn html_to_markdown(&mut self) {
use crate::markdown::html_to_markdown;
for note in &mut self.notes {
if let Some(model) = self.models.iter().find(|m| m.name == note.model) {
for field_name in &model.markdown_fields {
if let Some(value) = note.fields.get_mut(field_name) {
*value = html_to_markdown(value);
}
}
}
}
}
pub fn markdown_to_html(&mut self) {
use crate::markdown::markdown_to_html;
for note in &mut self.notes {
if let Some(model) = self.models.iter().find(|m| m.name == note.model) {
for field_name in &model.markdown_fields {
if let Some(value) = note.fields.get_mut(field_name) {
*value = markdown_to_html(value);
}
}
}
}
}
pub fn set_markdown_fields(&mut self, model_name: &str, fields: &[&str]) {
if let Some(model) = self.models.iter_mut().find(|m| m.name == model_name) {
model.markdown_fields = fields.iter().map(|s| s.to_string()).collect();
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PackageInfo {
pub name: String,
#[serde(default = "default_version")]
pub version: String,
#[serde(default)]
pub author: Option<String>,
#[serde(default)]
pub description: Option<String>,
}
fn default_version() -> String {
"1.0.0".to_string()
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelDef {
pub name: String,
pub fields: Vec<String>,
pub templates: Vec<TemplateDef>,
#[serde(default)]
pub css: Option<String>,
#[serde(default)]
pub sort_field: Option<String>,
#[serde(default)]
pub id: Option<i64>,
#[serde(default)]
pub markdown_fields: Vec<String>,
#[serde(default)]
pub model_type: Option<String>,
}
impl ModelDef {
pub fn cloze(name: impl Into<String>, fields: Vec<impl Into<String>>) -> Self {
Self {
name: name.into(),
fields: fields.into_iter().map(Into::into).collect(),
templates: vec![TemplateDef {
name: "Cloze".to_string(),
front: "{{cloze:Text}}".to_string(),
back: "{{cloze:Text}}<br>{{Extra}}".to_string(),
}],
css: None,
sort_field: None,
id: None,
markdown_fields: vec![],
model_type: Some("cloze".to_string()),
}
}
pub fn is_cloze(&self) -> bool {
self.model_type.as_deref() == Some("cloze")
}
}
impl ModelDef {
pub fn sort_field_index(&self) -> usize {
if let Some(ref name) = self.sort_field {
self.fields.iter().position(|f| f == name).unwrap_or(0)
} else {
0
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemplateDef {
pub name: String,
pub front: String,
pub back: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DeckDef {
pub name: String,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub id: Option<i64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NoteDef {
pub deck: String,
pub model: String,
pub fields: HashMap<String, String>,
#[serde(default)]
pub tags: Vec<String>,
#[serde(default)]
pub guid: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub note_id: Option<i64>,
}
impl NoteDef {
pub fn fields_ordered(&self, model: &ModelDef) -> Vec<String> {
model
.fields
.iter()
.map(|f| self.fields.get(f).cloned().unwrap_or_default())
.collect()
}
pub fn tags_string(&self) -> String {
if self.tags.is_empty() {
String::new()
} else {
format!(" {} ", self.tags.join(" "))
}
}
pub fn fields_as_html(&self, markdown_fields: &[String]) -> HashMap<String, String> {
use crate::markdown::markdown_to_html;
self.fields
.iter()
.map(|(name, value)| {
let converted = if markdown_fields.contains(name) {
markdown_to_html(value)
} else {
value.clone()
};
(name.clone(), converted)
})
.collect()
}
pub fn convert_html_to_markdown(&mut self, markdown_fields: &[String]) {
use crate::markdown::html_to_markdown;
for field_name in markdown_fields {
if let Some(value) = self.fields.get_mut(field_name) {
*value = html_to_markdown(value);
}
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MediaDef {
pub name: String,
pub path: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_basic_definition() {
let toml = r#"
[package]
name = "Test Deck"
version = "1.0.0"
[[models]]
name = "Basic"
fields = ["Front", "Back"]
[[models.templates]]
name = "Card 1"
front = "{{Front}}"
back = "{{FrontSide}}<hr>{{Back}}"
[[decks]]
name = "Test Deck"
[[notes]]
deck = "Test Deck"
model = "Basic"
tags = ["test"]
[notes.fields]
Front = "Question"
Back = "Answer"
"#;
let def = DeckDefinition::parse(toml).unwrap();
assert_eq!(def.package.name, "Test Deck");
assert_eq!(def.models.len(), 1);
assert_eq!(def.models[0].fields, vec!["Front", "Back"]);
assert_eq!(def.decks.len(), 1);
assert_eq!(def.notes.len(), 1);
assert_eq!(def.notes[0].fields.get("Front").unwrap(), "Question");
}
#[test]
fn test_invalid_model_reference() {
let toml = r#"
[package]
name = "Test"
[[decks]]
name = "Test Deck"
[[notes]]
deck = "Test Deck"
model = "NonExistent"
[notes.fields]
Front = "Q"
"#;
let result = DeckDefinition::parse(toml);
assert!(matches!(result, Err(Error::ModelNotFound(_))));
}
#[test]
fn test_invalid_deck_reference() {
let toml = r#"
[package]
name = "Test"
[[models]]
name = "Basic"
fields = ["Front"]
[[models.templates]]
name = "Card 1"
front = "{{Front}}"
back = "{{Front}}"
[[notes]]
deck = "NonExistent"
model = "Basic"
[notes.fields]
Front = "Q"
"#;
let result = DeckDefinition::parse(toml);
assert!(matches!(result, Err(Error::DeckNotFound(_))));
}
#[test]
fn test_invalid_field_reference() {
let toml = r#"
[package]
name = "Test"
[[models]]
name = "Basic"
fields = ["Front", "Back"]
[[models.templates]]
name = "Card 1"
front = "{{Front}}"
back = "{{Back}}"
[[decks]]
name = "Test Deck"
[[notes]]
deck = "Test Deck"
model = "Basic"
[notes.fields]
Front = "Q"
InvalidField = "X"
"#;
let result = DeckDefinition::parse(toml);
assert!(matches!(result, Err(Error::FieldNotFound { .. })));
}
#[test]
fn test_fields_ordered() {
let model = ModelDef {
name: "Test".to_string(),
fields: vec!["A".to_string(), "B".to_string(), "C".to_string()],
templates: vec![],
css: None,
sort_field: None,
id: None,
markdown_fields: vec![],
model_type: None,
};
let mut fields = HashMap::new();
fields.insert("C".to_string(), "third".to_string());
fields.insert("A".to_string(), "first".to_string());
let note = NoteDef {
deck: "Test".to_string(),
model: "Test".to_string(),
fields,
tags: vec![],
guid: None,
note_id: None,
};
let ordered = note.fields_ordered(&model);
assert_eq!(ordered, vec!["first", "", "third"]);
}
#[test]
fn test_cloze_model() {
let model = ModelDef::cloze("My Cloze", vec!["Text", "Extra"]);
assert_eq!(model.name, "My Cloze");
assert_eq!(model.fields, vec!["Text", "Extra"]);
assert!(model.is_cloze());
assert_eq!(model.model_type, Some("cloze".to_string()));
assert_eq!(model.templates.len(), 1);
assert_eq!(model.templates[0].name, "Cloze");
assert!(model.templates[0].front.contains("{{cloze:Text}}"));
}
#[test]
fn test_standard_model_is_not_cloze() {
let model = ModelDef {
name: "Basic".to_string(),
fields: vec!["Front".to_string(), "Back".to_string()],
templates: vec![],
css: None,
sort_field: None,
id: None,
markdown_fields: vec![],
model_type: None,
};
assert!(!model.is_cloze());
}
#[test]
fn test_parse_cloze_model_from_toml() {
let toml = r#"
[package]
name = "Cloze Test"
[[models]]
name = "My Cloze"
model_type = "cloze"
fields = ["Text", "Extra"]
[[models.templates]]
name = "Cloze"
front = "{{cloze:Text}}"
back = "{{cloze:Text}}<br>{{Extra}}"
[[decks]]
name = "Cloze Test"
"#;
let def = DeckDefinition::parse(toml).unwrap();
assert!(def.models[0].is_cloze());
}
}