From 35e520f40b7da55e43659c4d03c19cf1f2711887 Mon Sep 17 00:00:00 2001 From: wareya Date: Sat, 9 Dec 2017 13:38:55 -0500 Subject: [PATCH] load the dictionary asynchronously --- background-script.js | 88 ++++++++++++++++++++++---------------------- texthook.js | 37 +++++++++++++++++-- 2 files changed, 76 insertions(+), 49 deletions(-) diff --git a/background-script.js b/background-script.js index 8dc9a07..94b080d 100644 --- a/background-script.js +++ b/background-script.js @@ -8,64 +8,62 @@ // We have to send an HTTP request and store the result in a string before parsing it into an object. // Seriously. -let text = ""; +let dict = undefined; +let lookup_kan = {}; +let lookup_kana = {}; -function listener() +function builddict() { if (this.readyState === 4) { if (this.status === 200) - text = this.responseText; + { + dict = JSON.parse(this.responseText); + + // Build map of spellings to dictionary entry. + + + for (let i = 0; i < dict.length; i++) + { + let entry = dict[i]; + if (entry.k_ele != undefined) for (let j = 0; j < entry.k_ele.length; j++) + { + let s = entry.k_ele[j]; + if (lookup_kan[s.keb] == undefined) + lookup_kan[s.keb] = [i]; + else + lookup_kan[s.keb].push(i); + } + for (let j = 0; j < entry.r_ele.length; j++) + { + let s = entry.r_ele[j]; + if (lookup_kana[s.reb] == undefined) + lookup_kana[s.reb] = [i]; + else + lookup_kana[s.reb].push(i); + } + } + for (let i = 0; i < 5; i++) + { + console.log(dict[i]); + } + console.log("built lookup tables"); + console.log("size:"); + console.log(Object.keys(lookup_kan).length); + console.log(Object.keys(lookup_kana).length); + console.log("dict size:"); + console.log(dict.length); + } else console.error(xhr.statusText); } } - let req = new XMLHttpRequest(); -req.addEventListener("load", listener); +req.addEventListener("load", builddict); // FIXME: apparently this has to be in an async function now. -req.open("GET", browser.extension.getURL("dict/JMdict.json"), false); +req.open("GET", browser.extension.getURL("dict/JMdict.json")); req.send(); -let dict = JSON.parse(text); -text = ""; - -// Build map of spellings to dictionary entry. - -let lookup_kan = {}; -let lookup_kana = {}; - -for (let i = 0; i < dict.length; i++) -{ - let entry = dict[i]; - if (entry.k_ele != undefined) for (let j = 0; j < entry.k_ele.length; j++) - { - let s = entry.k_ele[j]; - if (lookup_kan[s.keb] == undefined) - lookup_kan[s.keb] = [i]; - else - lookup_kan[s.keb].push(i); - } - for (let j = 0; j < entry.r_ele.length; j++) - { - let s = entry.r_ele[j]; - if (lookup_kana[s.reb] == undefined) - lookup_kana[s.reb] = [i]; - else - lookup_kana[s.reb].push(i); - } -} -for (let i = 0; i < 5; i++) -{ - console.log(dict[i]); -} -console.log("built lookup tables"); -console.log("size:"); -console.log(Object.keys(lookup_kan).length); -console.log(Object.keys(lookup_kana).length); -console.log("dict size:"); -console.log(dict.length); - // In JMdict, part-of-speech tags are XML entities. // We processed JMdict's XML with entity processing disabled so we can just use the bare tags (e.g. "v1", not "ichidan verb"). // This left the entity syntax &this; behind so we want to cut it off when we return results. diff --git a/texthook.js b/texthook.js index 03a53c4..dd17fd9 100644 --- a/texthook.js +++ b/texthook.js @@ -92,6 +92,8 @@ function build_div (text, result) for(let i = 0; i < result.length; i++) { let term = result[i]; + if(term.deconj.size > 0) + text = term.deconj.values().next().value.text; //print_object(term); let temptag = ""; let found_kanji = true; @@ -234,6 +236,21 @@ function build_div (text, result) if(!found_kanji) { temptag += text; + if(term.deconj) + { + for(let form of term.deconj) + { + if(form.process.length > 0) + temptag += "～"; + for(let f = 0; f < form.process.length; f++) + { + let info = form.process[f]; + temptag += info; + if(f+1 < form.process.length) + temptag += "―"; + } + } + } // list alternatives let alternatives = []; @@ -350,13 +367,14 @@ function build_div (text, result) // deconjugation rules let rules = []; +// TODO: load rules from an underlay rules.push({type: "stdrule", dec_end:"る", con_end:"た", dec_tag:"v1", con_tag:"stem_past", detail:"past"}); rules.push({type: "stdrule", dec_end:"る", con_end:"て", dec_tag:"v1", con_tag:"stem_te", detail:"te form"}); -rules.push({type: "stdrule", dec_end:"る", con_end:"ない", dec_tag:"v1", con_tag:"negative", detail:"negative form"}); -rules.push({type: "stdrule", dec_end:"る", con_end:"らない", dec_tag:"v5r", con_tag:"negative", detail:"negative form"}); +rules.push({type: "stdrule", dec_end:"る", con_end:"ない", dec_tag:"v1", con_tag:"negative", detail:"negative"}); +rules.push({type: "stdrule", dec_end:"る", con_end:"らない", dec_tag:"v5r", con_tag:"negative", detail:"negative"}); +rules.push({type: "rewriterule", dec_end:"です", con_end:"でした", dec_tag:"exp", con_tag:"aux", detail:"past"}); // return deconjugated form if stdrule applies to form, return otherwise -// TODO: load rules from an underlay function stdrule_deconjugate(my_form, my_rule) { // can't deconjugate nothingness @@ -399,6 +417,17 @@ function stdrule_deconjugate(my_form, my_rule) return newform; }; +function rewriterule_deconjugate(my_form, my_rule) +{ + if(my_form.text != my_rule.con_end) + return; + return stdrule_deconjugate(my_form, my_rule); +}; + +let rule_functions = { +stdrule: stdrule_deconjugate, +rewriterule: rewriterule_deconjugate, +}; Set.prototype.union = function(setB) { @@ -430,7 +459,7 @@ function deconjugate(mytext) { let rule = rules[i]; - let newform = stdrule_deconjugate(form, rule); + let newform = rule_functions[rule.type](form, rule); if(newform != undefined && !processed.has(newform) && !novel.has(newform) && !new_novel.has(newform)) new_novel.add(newform);