inkhaven 1.8.9

Inkhaven — TUI literary work editor for Typst books
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! `inkhaven wordnet` — a sense-based multilingual thesaurus for manuscript
//! prose. `fetch` downloads open WordNet data and builds a local index; `lookup`
//! shows a word's senses with synonyms/antonyms/hypernyms/hyponyms; `list` shows
//! the available sources and which are installed. Data lives in the user data
//! dir, shared across projects.

use crate::error::{Error, Result};
use crate::wordnet::{self, fetch, WordNet};

/// `wordnet fetch <lang>…` — download + build each language's index.
pub fn fetch_langs(languages: &[String]) -> Result<()> {
    if languages.is_empty() {
        return Err(Error::Config("usage: inkhaven wordnet fetch <lang>… (e.g. `en`)".into()));
    }
    let rt = tokio::runtime::Runtime::new()
        .map_err(|e| Error::Config(format!("could not start async runtime: {e}")))?;
    for lang in languages {
        eprint!("fetching {lang} wordnet … ");
        let wn = rt.block_on(fetch::fetch(lang)).map_err(Error::Config)?;
        let path = wordnet::index_path(lang)
            .ok_or_else(|| Error::Config("could not resolve the user data directory".into()))?;
        wn.save(&path).map_err(Error::Store)?;
        eprintln!(
            "{} lemmas · {} synsets → {}",
            wn.lemma_count(),
            wn.synset_count(),
            path.display()
        );
    }
    Ok(())
}

/// `wordnet import <lang> <path>` — build a language's index from a local
/// WN-LMF file (the escape hatch for data that can't be openly redistributed,
/// e.g. Russian / RuWordNet: obtain it under its licence, then import here).
pub fn import(lang: &str, path: &std::path::Path) -> Result<()> {
    let wn = fetch::import_file(path).map_err(Error::Config)?;
    let out = wordnet::index_path(lang)
        .ok_or_else(|| Error::Config("could not resolve the user data directory".into()))?;
    wn.save(&out).map_err(Error::Store)?;
    eprintln!(
        "imported {lang} wordnet · {} lemmas · {} synsets → {}",
        wn.lemma_count(),
        wn.synset_count(),
        out.display()
    );
    Ok(())
}

/// `wordnet lookup <word> [--lang]` — print the word's senses and relations.
pub fn lookup(word: &str, language: Option<&str>) -> Result<()> {
    let lang = language.unwrap_or("en");
    let path = wordnet::index_path(lang)
        .ok_or_else(|| Error::Config("could not resolve the user data directory".into()))?;
    if !path.exists() {
        return Err(Error::Config(format!(
            "no `{lang}` wordnet installed — run `inkhaven wordnet fetch {lang}` first"
        )));
    }
    let wn = WordNet::load(&path).map_err(Error::Store)?;
    // For a non-English language, load English as a pivot (if installed) so
    // taxonomy relations expand through the interlingual index.
    let pivot = if lang.eq_ignore_ascii_case("en") {
        None
    } else {
        match wordnet::index_path("en").filter(|p| p.exists()) {
            Some(p) => match WordNet::load(&p) {
                Ok(wn) => Some(wn),
                // Don't hide a stale/incompatible pivot behind missing hypernyms.
                Err(e) => {
                    eprintln!("note: English pivot unavailable ({e}); hypernyms/hyponyms won't expand");
                    None
                }
            },
            None => None,
        }
    };
    let result = match pivot.as_ref() {
        Some(p) => wn.lookup_with_pivot(word, Some(p)),
        None => wn.lookup(word),
    };
    if result.is_empty() {
        println!("`{word}` — not found in the {lang} wordnet");
        return Ok(());
    }

    println!("{word} · {lang}");
    for (i, s) in result.senses.iter().enumerate() {
        println!("\n  {}. {}", i + 1, s.pos);
        if let Some(def) = &s.definition {
            if !def.is_empty() {
                println!("     {def}");
            }
        }
        let row = |label: &str, items: &[String]| {
            if !items.is_empty() {
                println!("     {label:<10} {}", items.join(", "));
            }
        };
        row("synonyms", &s.synonyms);
        row("antonyms", &s.antonyms);
        row("hypernyms", &s.hypernyms);
        row("hyponyms", &s.hyponyms);
    }
    Ok(())
}

/// `wordnet list` — the available sources and which are installed.
pub fn list() -> Result<()> {
    let installed = |lang: &str| -> &'static str {
        if wordnet::index_path(lang).map(|p| p.exists()).unwrap_or(false) {
            "installed"
        } else {
            "—"
        }
    };
    println!("WordNet sources (fetch with `inkhaven wordnet fetch <lang>`):\n");
    for src in fetch::SOURCES {
        println!("  {:<3} {:<11}  {:<34}  {}", src.lang, installed(src.lang), src.name, src.license);
    }
    // Russian is not openly redistributable, so it is imported, not fetched.
    println!(
        "  {:<3} {:<11}  {:<34}  {}",
        "ru", installed("ru"), "RuWordNet — import your own", "research licence"
    );
    println!(
        "\n  Russian has no open distribution — obtain a WN-LMF file under its licence and run\n  \
         `inkhaven wordnet import ru <file.xml>`. A non-English lookup expands its\n  \
         hypernyms/hyponyms through English, so `fetch en` too.",
    );
    if let Some(dir) = wordnet::data_dir() {
        println!("\ndata directory: {}", dir.display());
    }
    Ok(())
}