lexi 0.2.0

Renders a YAML lexicon file into dictionary files.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use std::{
	collections::{HashMap, HashSet},
	fs::File,
	io::BufReader,
	path::Path,
};

use anyhow::Result;
use itertools::Itertools;
use serde::{Deserialize, Serialize};
use serde_yaml::Deserializer;

use crate::format::Format;

#[derive(Serialize, Deserialize)]
pub struct Lexeme {
	pub lemma: String,
	pub class: String,
	pub definition: Option<String>,
	pub translation: Option<String>,
	#[serde(default)]
	pub glosses: Vec<String>,
}

#[derive(Serialize, Deserialize)]
pub struct Lexicon {
	#[serde(default)]
	pub format: Format,
	pub classes: Vec<String>,
	pub lexemes: Vec<Lexeme>,
}

impl Lexicon {
	pub fn load<P>(path: P) -> Result<Self>
	where
		P: AsRef<Path>,
	{
		let file = File::open(path)?;
		let reader = BufReader::new(file);
		let de = Deserializer::from_reader(reader);
		let mut lexicon = Lexicon::deserialize(de)?;

		// Validate lexeme classes and required fields.
		let classes = HashSet::<&String>::from_iter(lexicon.classes.iter());
		for lexeme in &lexicon.lexemes {
			if !classes.contains(&lexeme.class) {
				log::error!(
					"Lexeme '{}' has unrecognized class '{}'",
					lexeme.lemma,
					lexeme.class
				)
			}
			if lexeme.definition.is_none()
				&& lexeme.translation.is_none()
				&& lexeme.glosses.is_empty()
			{
				log::warn!(
					"Lexeme '{}' has no definition, translation, or glosses",
					lexeme.lemma
				)
			}
		}

		// Sort lexemes by lemma, according to the specified sort.
		match &lexicon.format.native.sort {
			Some(sort) => {
				// TODO: Support multigraphs.
				let sort = HashMap::<char, usize>::from_iter(
					sort.iter().enumerate().filter_map(|(i, grapheme)| {
						grapheme.chars().next().map(|c| (c, i))
					}),
				);
				lexicon.lexemes.sort_by(|a, b| {
					a.lemma
						.chars()
						.map(|c| sort.get(&c).unwrap_or(&usize::MAX))
						.cmp(
							b.lemma
								.chars()
								.map(|c| sort.get(&c).unwrap_or(&usize::MAX)),
						)
				});
			}
			None => lexicon.lexemes.sort_by(|a, b| a.lemma.cmp(&b.lemma)),
		};

		// Warn about duplicate lemmas.
		for (first, second) in lexicon
			.lexemes
			.iter()
			.map(|lexeme| &lexeme.lemma)
			.tuple_windows()
		{
			if first == second {
				log::warn!("Duplicate lemma '{}'", first)
			}
		}

		Ok(lexicon)
	}
}