aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/cli/src/inflection.rs284
-rw-r--r--crates/cli/src/locale.rs38
-rw-r--r--crates/cli/src/main.rs2
-rw-r--r--crates/cli/src/run.rs37
-rw-r--r--crates/cli/src/words.rs184
5 files changed, 492 insertions, 53 deletions
diff --git a/crates/cli/src/inflection.rs b/crates/cli/src/inflection.rs
new file mode 100644
index 0000000..1b9d932
--- /dev/null
+++ b/crates/cli/src/inflection.rs
@@ -0,0 +1,284 @@
+use mihi::{group_declension_inflections, Category, DeclensionInfo, DeclensionTable, Gender, Word};
+
+fn get_inflected_from(word: &Word, row: &[DeclensionInfo; 2]) -> String {
+ if word.is_flag_set("onlysingular") {
+ row[0].inflected.join("/")
+ } else if word.is_flag_set("onlyplural") {
+ row[1].inflected.join("/")
+ } else {
+ format!(
+ "{}, {}",
+ row[0].inflected.join("/"),
+ row[1].inflected.join("/")
+ )
+ }
+}
+
+fn get_noun_table(word: &Word) -> Result<DeclensionTable, String> {
+ let gender = match word.gender {
+ Gender::MasculineOrFeminine => Gender::Masculine as usize,
+ _ => word.gender as usize,
+ };
+ group_declension_inflections(word, &word.kind, gender)
+}
+
+fn print_noun_inflection(word: &Word) -> Result<(), String> {
+ let table = get_noun_table(word)?;
+
+ println!("\n== Inflection ==\n");
+
+ println!(
+ "Nominative:\t{}",
+ get_inflected_from(&word, &table.nominative)
+ );
+ println!("Vocative:\t{}", get_inflected_from(&word, &table.vocative));
+ println!(
+ "Accusative:\t{}",
+ get_inflected_from(&word, &table.accusative)
+ );
+ println!("Genitive:\t{}", get_inflected_from(&word, &table.genitive));
+ println!("Dative:\t\t{}", get_inflected_from(&word, &table.dative));
+ println!("Ablative:\t{}", get_inflected_from(&word, &table.ablative));
+ if word.locative {
+ println!("Locative:\t{}", get_inflected_from(&word, &table.locative));
+ }
+
+ Ok(())
+}
+
+fn get_adjective_table(word: &Word) -> Result<[DeclensionTable; 3], String> {
+ let kind_f = match word.declension_id {
+ Some(1 | 2) => &"a".to_string(),
+ _ => &word.kind,
+ };
+ let kind_n = if word.kind == "us" {
+ &"um".to_owned()
+ } else {
+ &word.kind
+ };
+
+ Ok([
+ group_declension_inflections(word, &word.kind, Gender::Masculine as usize)?,
+ group_declension_inflections(word, kind_f, Gender::Feminine as usize)?,
+ group_declension_inflections(word, kind_n, Gender::Neuter as usize)?,
+ ])
+}
+
+fn print_adjective_inflection(word: &Word) -> Result<(), String> {
+ let tables = get_adjective_table(word)?;
+
+ println!("\n== Inflection ==\n");
+
+ println!(
+ "Nominative:\t{} | {} | {}",
+ get_inflected_from(&word, &tables[0].nominative),
+ get_inflected_from(&word, &tables[1].nominative),
+ get_inflected_from(&word, &tables[2].nominative)
+ );
+ println!(
+ "Vocative:\t{} | {} | {}",
+ get_inflected_from(&word, &tables[0].vocative),
+ get_inflected_from(&word, &tables[1].vocative),
+ get_inflected_from(&word, &tables[2].vocative)
+ );
+ println!(
+ "Accusative:\t{} | {} | {}",
+ get_inflected_from(&word, &tables[0].accusative),
+ get_inflected_from(&word, &tables[1].accusative),
+ get_inflected_from(&word, &tables[2].accusative)
+ );
+ println!(
+ "Genitive:\t{} | {} | {}",
+ get_inflected_from(&word, &tables[0].genitive),
+ get_inflected_from(&word, &tables[1].genitive),
+ get_inflected_from(&word, &tables[2].genitive)
+ );
+ println!(
+ "Dative:\t\t{} | {} | {}",
+ get_inflected_from(&word, &tables[0].dative),
+ get_inflected_from(&word, &tables[1].dative),
+ get_inflected_from(&word, &tables[2].dative)
+ );
+ println!(
+ "Ablative:\t{} | {} | {}",
+ get_inflected_from(&word, &tables[0].ablative),
+ get_inflected_from(&word, &tables[1].ablative),
+ get_inflected_from(&word, &tables[2].ablative)
+ );
+ if word.locative {
+ println!(
+ "Locative:\t{} | {} | {}",
+ get_inflected_from(&word, &tables[0].locative),
+ get_inflected_from(&word, &tables[1].locative),
+ get_inflected_from(&word, &tables[2].locative)
+ );
+ }
+
+ Ok(())
+}
+
+pub fn print_full_inflection_for(word: Word) -> Result<(), String> {
+ if word.is_flag_set("indeclinable") {
+ return Ok(());
+ }
+
+ match word.category {
+ Category::Noun => print_noun_inflection(&word)?,
+ Category::Adjective => print_adjective_inflection(&word)?,
+ Category::Verb => todo!(),
+ Category::Pronoun => todo!(),
+ Category::Adverb
+ | Category::Preposition
+ | Category::Conjunction
+ | Category::Interjection
+ | Category::Determiner
+ | Category::Unknown => {
+ // Nothing to do.
+ }
+ }
+ // TODO: on the 'extra' info.
+
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn get_word(enunciated: &str) -> Word {
+ let words = mihi::select_enunciated(Some(enunciated.to_string())).unwrap();
+
+ assert_eq!(words.len(), 1);
+
+ mihi::find_by(words.first().unwrap().as_str()).unwrap()
+ }
+
+ fn stringify_with(word: &Word, table: &DeclensionTable) -> String {
+ let mut res = get_inflected_from(&word, &table.nominative);
+ res.push_str(" | ");
+ res.push_str(get_inflected_from(&word, &table.vocative).as_str());
+ res.push_str(" | ");
+ res.push_str(get_inflected_from(&word, &table.accusative).as_str());
+ res.push_str(" | ");
+ res.push_str(get_inflected_from(&word, &table.genitive).as_str());
+ res.push_str(" | ");
+ res.push_str(get_inflected_from(&word, &table.dative).as_str());
+ res.push_str(" | ");
+ res.push_str(get_inflected_from(&word, &table.ablative).as_str());
+ if word.locative {
+ res.push_str(" | ");
+ res.push_str(get_inflected_from(&word, &table.locative).as_str());
+ }
+
+ res
+ }
+
+ fn assert_noun_table(enunciated: &str, expected: &str) {
+ let word = get_word(enunciated);
+ let table = get_noun_table(&word).unwrap();
+
+ let res = stringify_with(&word, &table);
+
+ assert_eq!(res, expected);
+ }
+
+ fn assert_adjective_table(enunciated: &str, masculine: &str, feminine: &str, neuter: &str) {
+ let word = get_word(enunciated);
+ let tables = get_adjective_table(&word).unwrap();
+
+ let res = stringify_with(&word, &tables[0]);
+ assert_eq!(res, masculine);
+
+ let res = stringify_with(&word, &tables[1]);
+ assert_eq!(res, feminine);
+
+ let res = stringify_with(&word, &tables[2]);
+ assert_eq!(res, neuter);
+ }
+
+ #[test]
+ fn test_nouns() {
+ assert_noun_table(
+ "rosa, rosae",
+ "rosa, rosae | rosa, rosae | rosam, rosās | rosae, rosārum | rosae, rosīs | rosā, rosīs",
+ );
+ assert_noun_table(
+ "fīlia, fīliae",
+ "fīlia, fīliae | fīlia, fīliae | fīliam, fīliās | fīliae, fīliārum | fīliae, fīliīs/fīliābus | fīliā, fīliīs/fīliābus",
+ );
+ assert_noun_table(
+ "dea, deae",
+ "dea, deae | dea, deae | deam, deās | deae, deārum | deae, deābus | deā, deābus",
+ );
+ assert_noun_table(
+ "Rōma, Rōmae",
+ "Rōma | Rōma | Rōmam | Rōmae | Rōmae | Rōmā | Rōmae",
+ );
+ assert_noun_table(
+ "lupus, lupī",
+ "lupus, lupī | lupe, lupī | lupum, lupōs | lupī, lupōrum | lupō, lupīs | lupō, lupīs",
+ );
+ assert_noun_table(
+ "templum, templī",
+ "templum, templa | templum, templa | templum, templa | templī, templōrum | templō, templīs | templō, templīs",
+ );
+ assert_noun_table(
+ "vir, virī",
+ "vir, virī | vir, virī | virum, virōs | virī, virōrum | virō, virīs | virō, virīs",
+ );
+ assert_noun_table(
+ "liber, librī",
+ "liber, librī | liber, librī | librum, librōs | librī, librōrum | librō, librīs | librō, librīs",
+ );
+ assert_noun_table(
+ "fīlius, fīliī",
+ "fīlius, fīliī | fīlī, fīliī | fīlium, fīliōs | fīlī/fīliī, fīliōrum | fīliō, fīliīs | fīliō, fīliīs",
+ );
+ assert_noun_table(
+ "leō, leōnis",
+ "leō, leōnēs | leō, leōnēs | leōnem, leōnēs | leōnis, leōnum | leōnī, leōnibus | leōne, leōnibus",
+ );
+ assert_noun_table(
+ "ovis, ovis",
+ "ovis, ovēs | ovis, ovēs | ovem, ovēs | ovis, ovium | ovī, ovibus | ove, ovibus",
+ );
+ assert_noun_table(
+ "mare, maris",
+ "mare, maria | mare, maria | mare, maria | maris, marium/marum | marī, maribus | marī/mare, maribus",
+ );
+ assert_noun_table(
+ "Iuppiter, Iovis",
+ "Iuppiter | Iuppiter | Iovem | Iovis | Iovī | Iove",
+ );
+ assert_noun_table(
+ "portus, portūs",
+ "portus, portūs | portus, portūs | portum, portūs | portūs, portuum | portuī, portibus | portū, portibus",
+ );
+ assert_noun_table(
+ "cornū, cornūs",
+ "cornū, cornua | cornū, cornua | cornū, cornua | cornūs, cornuum | cornuī, cornibus | cornū, cornibus",
+ );
+ // TODO: domus
+ assert_noun_table(
+ "diēs, diēī",
+ "diēs, diēs | diēs, diēs | diem, diēs | diēī, diērum | diēī, diēbus | diē, diēbus",
+ );
+ assert_noun_table(
+ "rēs, reī",
+ "rēs, rēs | rēs, rēs | rem, rēs | reī, rērum | reī, rēbus | rē, rēbus",
+ );
+ }
+
+ #[test]
+ fn test_adjectives() {
+ assert_adjective_table(
+ "novus, nova, novum",
+ "novus, novī | nove, novī | novum, novōs | novī, novōrum | novō, novīs | novō, novīs",
+ "nova, novae | nova, novae | novam, novās | novae, novārum | novae, novīs | novā, novīs",
+ "novum, nova | novum, nova | novum, nova | novī, novōrum | novō, novīs | novō, novīs",
+ );
+ // TODO: pulcher
+ // TODO: unus nauta
+ // TODO: third
+ }
+}
diff --git a/crates/cli/src/locale.rs b/crates/cli/src/locale.rs
new file mode 100644
index 0000000..f9d42b6
--- /dev/null
+++ b/crates/cli/src/locale.rs
@@ -0,0 +1,38 @@
+// Locale represents the locales accepted for delivering answers on this
+// tool. That is, it's not about i18n on the strings for this application. but
+// rather the different translations accepted in places like
+// `Word.translations`.
+pub enum Locale {
+ English,
+ Catalan,
+}
+
+impl Locale {
+ // Returns the string representation for the locale's code.
+ pub fn to_code(&self) -> &str {
+ match self {
+ Self::English => "en",
+ Self::Catalan => "ca",
+ }
+ }
+}
+
+impl std::fmt::Display for Locale {
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+ match self {
+ Self::English => write!(f, "english"),
+ Self::Catalan => write!(f, "català"),
+ }
+ }
+}
+
+/// Fetches the Locale object that is suitable for the current environment.
+pub fn current_locale() -> Locale {
+ let raw_locale = std::env::var("LC_ALL").unwrap_or("en".to_string());
+
+ if raw_locale.starts_with("ca") {
+ Locale::Catalan
+ } else {
+ Locale::English
+ }
+}
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
index ffbcdae..62ffd45 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -1,5 +1,7 @@
mod exercises;
+mod inflection;
mod init;
+mod locale;
mod nuke;
mod run;
mod words;
diff --git a/crates/cli/src/run.rs b/crates/cli/src/run.rs
index 0046d47..3e1b866 100644
--- a/crates/cli/src/run.rs
+++ b/crates/cli/src/run.rs
@@ -6,6 +6,8 @@ use std::io::Write;
use std::process::Command;
use tempfile::NamedTempFile;
+use crate::locale::{current_locale, Locale};
+
// Maximum number of times a word has to be run in order to increase the number
// of successful runs.
const MAX_STEPS: usize = 5;
@@ -26,34 +28,6 @@ fn help(msg: Option<&str>) {
println!(" -k, --kind <KIND>\t\tOnly ask for exercises for the given <KIND>.");
}
-// Locale represents the locales accepted for delivering answers on this
-// tool. That is, it's not about i18n on the strings for this application. but
-// rather the different translations accepted in places like
-// `Word.translations`.
-enum Locale {
- English,
- Catalan,
-}
-
-impl Locale {
- // Returns the string representation for the locale's code.
- fn to_code(&self) -> &str {
- match self {
- Self::English => "en",
- Self::Catalan => "ca",
- }
- }
-}
-
-impl std::fmt::Display for Locale {
- fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
- match self {
- Self::English => write!(f, "english"),
- Self::Catalan => write!(f, "català"),
- }
- }
-}
-
// Run the quiz for all the given `words` while expecting answers to be
// delivered in the given `locale`.
fn run_words(words: Vec<Word>, locale: &Locale) -> i32 {
@@ -323,12 +297,7 @@ pub fn run(args: Vec<String>) {
}
}
- let raw_locale = std::env::var("LC_ALL").unwrap_or("en".to_string());
- let locale = if raw_locale.starts_with("ca") {
- Locale::Catalan
- } else {
- Locale::English
- };
+ let locale = current_locale();
let words = match category {
Some(cat) => select_relevant_words(cat, &flags, 15),
diff --git a/crates/cli/src/words.rs b/crates/cli/src/words.rs
index 7db84a2..d387f00 100644
--- a/crates/cli/src/words.rs
+++ b/crates/cli/src/words.rs
@@ -1,3 +1,6 @@
+use crate::inflection::print_full_inflection_for;
+use crate::locale::current_locale;
+
use inquire::{Confirm, Editor, Select, Text};
use mihi::{Category, Gender, Language, Word};
use std::vec::IntoIter;
@@ -148,15 +151,22 @@ fn get_initial_guess(value: &str) -> Word {
return Word::from(
second[0..second.len() - 2].to_string(),
Category::Noun,
- Some(5),
+ Some(3),
None,
Gender::Masculine,
- "es".to_string(),
+ "is".to_string(),
);
}
}
- Word::default()
+ Word::from(
+ value.to_string(),
+ Category::Unknown,
+ None,
+ None,
+ Gender::None,
+ String::from("-"),
+ )
}
// Remove comments from the "flags" text that was provided.
@@ -236,18 +246,32 @@ fn ask_for_word_based_on(enunciated: String, word: Word) -> Result<Word, String>
_ => Gender::None,
};
- let Ok(kind) = Text::new("Kind:").with_initial_value(&word.kind).prompt() else {
- return Err("abort!".to_string());
+ let inflection_id = match category {
+ Category::Noun | Category::Adjective => {
+ let Ok(inflection) = Text::new("Inflection:")
+ .with_initial_value(word.inflection_id().unwrap_or(0).to_string().as_str())
+ .prompt()
+ else {
+ return Err("abort!".to_string());
+ };
+ let Ok(inflection_id) = inflection.parse::<usize>() else {
+ return Err(format!("bad value for inflection ID '{inflection}'"));
+ };
+ Some(inflection_id)
+ }
+ _ => None,
};
- let Ok(inflection) = Text::new("Inflection:")
- .with_initial_value(word.inflection_id().to_string().as_str())
- .prompt()
- else {
- return Err("abort!".to_string());
- };
- let Ok(inflection_id) = inflection.parse::<usize>() else {
- return Err(format!("bad value for inflection ID '{inflection}'"));
+ // TODO: refine guess once the inflection is known: select from possible values.
+ let kind = match category {
+ Category::Noun | Category::Adjective => {
+ let Ok(kind) = Text::new("Kind:").with_initial_value(&word.kind).prompt() else {
+ return Err("abort!".to_string());
+ };
+ kind.trim().to_string()
+ }
+ Category::Verb => String::from("verb"),
+ _ => String::from("-"),
};
let Ok(regular) = Confirm::new("Regular:").with_default(word.regular).prompt() else {
@@ -267,7 +291,10 @@ fn ask_for_word_based_on(enunciated: String, word: Word) -> Result<Word, String>
return Err("abort!".to_string());
};
let Ok(weight) = raw_weight.parse::<usize>() else {
- return Err(format!("bad value for inflection ID '{inflection}'"));
+ return Err(format!(
+ "bad value for inflection ID '{}'",
+ inflection_id.unwrap_or(0)
+ ));
};
if weight > 10 {
return Err(format!(
@@ -306,10 +333,10 @@ fn ask_for_word_based_on(enunciated: String, word: Word) -> Result<Word, String>
declension_id: if matches!(category, Category::Verb) {
None
} else {
- Some(inflection_id)
+ inflection_id
},
conjugation_id: if matches!(category, Category::Verb) {
- Some(inflection_id)
+ inflection_id
} else {
None
},
@@ -409,7 +436,6 @@ fn create(args: IntoIter<String>) -> i32 {
}
}
-// TODO: accept a --raw flag, which is implied on pipe
fn ls(mut args: IntoIter<String>) -> i32 {
if args.len() > 1 {
help(Some("error: words: too many filters"));
@@ -509,8 +535,128 @@ fn edit(mut args: IntoIter<String>) -> i32 {
}
}
-fn show(mut _args: IntoIter<String>) -> i32 {
- todo!()
+// Returns a string with a more human-readable declension kind.
+fn humanize_kind(kind: &str) -> &str {
+ match kind {
+ // Noun
+ "a" => "-a",
+ "us" => "-us",
+ "er/ir" => "-er/-ir",
+ "um" => "-um",
+ "ius" => "-ius; like 'fīlius'",
+ "is" => "-is",
+ "istem" => "i-stem; '-i-' also in the genitive plural",
+ "pureistem" => "pure i-stem; '-i-' also in the ablative singular",
+ "visvis" => "irregular 'vīs, vīs'",
+ "sussuis" => "irregular 'sūs, suis'",
+ "bosbovis" => "irregular 'bōs, bovis'",
+ "iuppiteriovis" => "irregular 'Iuppiter, Iovis'",
+ "fus" => "-u-",
+ "domusdomus" => "irregular 'domus, domūs/domī'",
+ "ies" => "-iēs; like 'diēs, diēī'",
+ "es" => "-ēs; like 'rēs, reī'",
+ "indeclinable" => "indeclinable",
+
+ // Adjective
+ "one" => "one termination adjective",
+ "onenonistem" => "one termination adjective; non i-stem like 'melior, melius'",
+ "two" => "two termination adjective",
+ "three" => "three termination adjective",
+ "unusnauta" => "'ūnus nauta' like 'ūnus, ūna, ūnum'",
+ "unusnautaer/ir" => "'ūnus nauta' like 'neuter, neutra, neutrum'",
+ "duo" => "number 'duo, duae, duo'",
+ "tres" => "number 'trēs, trēs, tria'",
+ "mille" => "number 'mīlle, mīlle'",
+
+ // Others
+ "egonos" => "'ego, nōs'",
+ "demonstrative-weak" => "weak demonstrative",
+ "demonstrative-proximal" => "proximal demonstrative",
+ "demonstrative-distal" => "distal demonstrative",
+ "demonstrative-medial" => "medial demonstrative",
+ "demonstrative-idem" => "'īdem, eadem, idem' demonstrative",
+ "tuvos" => "'tū, vōs'",
+ "sesui" => "'sē, suī'",
+
+ _ => kind,
+ }
+}
+
+fn show_info(word: Word) -> Result<(), String> {
+ // Title.
+ match word.gender {
+ Gender::None => println!("Word: {} ({})", word.enunciated, word.category),
+ _ => println!(
+ "Word: {} ({} {})",
+ word.enunciated,
+ word.gender.abbrev(),
+ word.category
+ ),
+ }
+
+ // Conjugation, declension + kind.
+ match word.conjugation_id {
+ Some(id) => println!("Conjugation: {}", id),
+ None => match word.declension_id {
+ Some(did) => {
+ if did > 5 {
+ println!("Declension: {}", humanize_kind(&word.kind));
+ } else {
+ println!(
+ "Declension: {} ({})",
+ word.declension_id.unwrap(),
+ humanize_kind(&word.kind)
+ );
+ }
+ }
+ None => {}
+ },
+ };
+
+ // Show translation if available.
+ let locale = current_locale();
+ if let Some(translation) = word.translation.get(locale.to_code()) {
+ let s = translation.as_str().unwrap_or("");
+ if !s.is_empty() {
+ println!("Translation ({}): {}.", locale.to_code(), s);
+ }
+ }
+
+ print_full_inflection_for(word)?;
+
+ Ok(())
+}
+
+fn show(mut args: IntoIter<String>) -> i32 {
+ if args.len() > 1 {
+ help(Some(
+ "error: words: only one argument. If it's an enunciate, wrap it in double quotes",
+ ));
+ return 1;
+ }
+
+ let enunciated = match select_single_word(args.next()) {
+ Ok(word) => word,
+ Err(e) => {
+ println!("error: words: {e}.");
+ return 1;
+ }
+ };
+
+ let word = match mihi::find_by(enunciated.as_str()) {
+ Ok(word) => word,
+ Err(e) => {
+ println!("error: words: {e}.");
+ return 1;
+ }
+ };
+
+ if let Err(e) = show_info(word) {
+ println!("error: words: {e}.");
+ return 1;
+ }
+
+ 0
}
fn rm(mut args: IntoIter<String>) -> i32 {