-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+ Éditeur lexical
- - - -
-
-
- Nouveau mot (lemme)
- - -
-
-
-
-
-
-
-
- Nom, adjectif
- Verbe
- Adverbe
- Prénom
- Patronyme
- Nom propre
- Autre
-
-
-
-
- Sélectionnez une catégorie.
-
-
-
-
-
- Nom, adjectif
-- - - -
-
-
-
-
-
- Genre
- - - -
-
- Pluriel
- - - -[optionnel] Autre forme (masculine, féminine, variante, etc.)
- -
-
- - - - -
-
-
-
-
- Genre
- - - -
-
- Pluriel
- - - -
-
-
- Verbe
-
-
-
- Cochez cette case si ce verbe peut s’utiliser sans complément d’objet.
-
-
-
-
- Je dors.
Tu pars.
Elle pense.
Nous écrivons.
Vous manifestez.
Ils viennent.
- Tu pars.
Elle pense.
Nous écrivons.
Vous manifestez.
Ils viennent.
J’appartiens à ce groupe…
-
-
-
- Cochez cette case si ce verbe peut s’utiliser avec un complément d’objet direct (COD).
-
-
-
-
- Je mange une pomme.
Tu donnes une bonne impression.
Elle écrit un livre.
Nous fabriquons une œuvre.
- Tu donnes une bonne impression.
Elle écrit un livre.
Nous fabriquons une œuvre.
Je pars.
J’appartiens à…
- J’appartiens à…
-
-
- Cochez cette case, si ce verbe peut s’utiliser avec un complément d’objet indirect (COI). Attention à ne pas confondre avec un complément circonstanciel de temps, de lieu ou de manière.
-
-
-
-
- Je donne un cadeau à sa femme.
Elle appartient à ce groupe.
-
- Elle appartient à ce groupe.
-
-
- Cochez cette case si ce verbe peut s’utiliser pronominalement.
-
-
-
-
- Je me suis trompé.
Tu t’es étonné toi-même.
Elle s’est souvenu de ses études.
Nous nous sommes égarés.
Vous vous êtes retrouvées.
Ils se sont rappelé leur enfance.
- Tu t’es étonné toi-même.
Elle s’est souvenu de ses études.
Nous nous sommes égarés.
Vous vous êtes retrouvées.
Ils se sont rappelé leur enfance.
Je me suis venu.
tu t’es arrivé.
elle s’est marché.
nous nous sommes courus.
vous vous êtes acculés.
Elles se sont capitulées.
- tu t’es arrivé.
elle s’est marché.
nous nous sommes courus.
vous vous êtes acculés.
Elles se sont capitulées.
-
-
- Cochez cette case si ce verbe ne peut s’utiliser à la première personne, mais uniquement à la troisième personne du singulier ou du pluriel.
-
-
-
-
- Il pleut.
- Je pleus.
-
-
-
- Cochez cette case si ce verbe s’emploie au passé composé avec l’auxilaire “être”.
-
-
-
-
- Je suis venu.
Je suis parti.
- Je suis parti.
J’ai venu.
J’ai parti.
- J’ai parti.
-
-
-
- Cochez cette case si ce verbe s’emploie au passé composé avec l’auxilaire “avoir”.
-
-
-
-
- J’ai mangé.
J’ai prié.
- J’ai prié.
Je suis mangé.
Je suis prié.
- Je suis prié.
-
-
-
- Cette option est ignorée si vous utilisez un verbe modèle.
-
-
- Verbe modèle [optionnel]
-Indiquer un verbe qui doit servir de modèle n’est pas nécessaire pour la très grande majorité des verbes du 1ᵉʳ groupe et du 2ᵉ groupe. Failes-le seulement si les formes fléchies engendrées automatiquement ne vous satisfont pas.
- -
-
- Il est fortement recommandé d’appliquer les règles d’un verbe du même groupe que celui que vous créez. Mais aucune restriction n’est imposée.
-Classification des groupes :
--
-
- 1ᵉʳ groupe : verbes finissant par -er. Attention : contrairement au préjugé commun, ce groupe est irrégulier. Beaucoup de verbes voient leur racine modifiée dans certaines formes conjuguées :
-
-
-
- ajout ou modification de diacritiques (verbes finissant par -cer, -ecer, -emer, -ener, -eper, -erer, -eser, -ever, -evrer, -eler, -eter, -ébrer, -écer, -écher, -écrer, -éder, -éger, -égler, -égner, -égrer, -éguer, -éler, -émer, -éner, -éper, -équer, -érer, -éser, -éter, -étrer, -évrer, -éyer), -
- un ‹e› euphonique est ajouté sur la plupart des verbes finissant par -ger, -
- certains verbes finissant par -yer remplacent éventuellement le ‹y› par un ‹i›, -
- doublement irrégulier de certaines consonnes (geler ne se conjugue pas comme appeler, acheter ne se conjugue pas comme jeter) -
- irrégularités diverses (aller, envoyer, renvoyer)… -
- - 2ᵉ groupe : verbes finissant par -ir. Ce groupe est de loin le plus régulier. Mais de nombreux verbes finissant par -ir appartiennent au 3ᵉ groupe. -
- 3ᵉ groupe. Autres verbes irréguliers. -
- Les verbes être et avoir n’appartiennent à aucun groupe. Il est recommandé de ne pas s’en servir comme modèle. -
-
-
- Adverbe
-Les adverbes sont invariables en genre et en nombre.
-
-
-
- Prénom
-
-
-
-
- Genre
- - - -
-
- Pluriel
-Les prénoms sont invariables en nombre.
-
-
-
- Patronyme
-
-
-
-
- Genre
- - - -
-
- Pluriel
-Les noms de famille sont invariables en nombre.
-
-
-
- Nom propre
-
-
-
-
- Genre
- - - -
-
- Pluriel
-Les noms propres sont invariables en nombre.
-
-
- Autre
-Indiquez les étiquettes grammaticales que vous voulez appliquer au mot. À utiliser seulement si vous savez ce que vous faites.
-Flexion
- -Étiquettes
- -
-
- Mots générés
-Forme fléchie (lemme), étiquettes
-- -- - -
-
-
-
-
-
- Votre lexique
- - - - -Aucun élément.
- - -
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Index: gc_lang/fr/webext/panel/lex_editor.js
==================================================================
--- gc_lang/fr/webext/panel/lex_editor.js
+++ gc_lang/fr/webext/panel/lex_editor.js
@@ -8,10 +8,19 @@
if (typeof(browser) !== "object") {
var browser = chrome;
bChrome = true;
}
+
+/*
+ Common functions
+*/
+
+function showError (e) {
+ console.error(e.fileName + "\n" + e.name + "\nline: " + e.lineNumber + "\n" + e.message);
+}
+
function createNode (sType, oAttr, oDataset=null) {
try {
let xNode = document.createElement(sType);
Object.assign(xNode, oAttr);
if (oDataset) {
@@ -22,87 +31,227 @@
catch (e) {
showError(e);
}
}
-function showError (e) {
- console.error(e.fileName + "\n" + e.name + "\nline: " + e.lineNumber + "\n" + e.message);
-}
-
-
-document.getElementById("lexicon_button").addEventListener("click", () => { oWidgets.showPage("lexicon"); }, false);
-document.getElementById("add_word_button").addEventListener("click", () => { oWidgets.showPage("lemma"); }, false);
-
-document.getElementById("table").addEventListener("click", (xEvent) => { oWidgets.onTableClick(xEvent); }, false);
-document.getElementById("save_button").addEventListener("click", () => { oLexicon.save(); }, false);
-document.getElementById("export_button").addEventListener("click", () => { oBinaryDict.export(); }, false);
-
-document.getElementById("editor").addEventListener("click", (xEvent) => { oWidgets.onSelectionClick(xEvent); }, false);
-document.getElementById("lemma").addEventListener("keyup", () => { oWidgets.onWrite(); }, false);
-document.getElementById("lemma2").addEventListener("keyup", () => { oWidgets.onWrite2(); }, false);
-document.getElementById("verb_pattern").addEventListener("keyup", () => { oFlexGen.update(); }, false);
-document.getElementById("flexion").addEventListener("keyup", () => { oFlexGen.update(); }, false);
-document.getElementById("tags").addEventListener("keyup", () => { oFlexGen.update(); }, false);
-document.getElementById("add_to_lexicon").addEventListener("click", () => { oFlexGen.addToLexicon(); }, false);
-
-
-
-/*
- ACTIONS
-*/
-
-const oWidgets = {
-
- showPage: function (sPage) {
- if (sPage == "lexicon") {
- this.hideElement("add_word_page");
- this.showElement("lexicon_page");
- document.getElementById("lexicon_button").style.backgroundColor = "hsl(210, 80%, 90%)";
- document.getElementById("add_word_button").style.backgroundColor = "hsl(210, 10%, 95%)";
- } else {
- this.hideElement("lexicon_page");
- this.showElement("add_word_page");
- document.getElementById("lexicon_button").style.backgroundColor = "hsl(210, 10%, 95%)";
- document.getElementById("add_word_button").style.backgroundColor = "hsl(210, 80%, 90%)";
+function showElement (sElemId) {
+ if (document.getElementById(sElemId)) {
+ document.getElementById(sElemId).style.display = "block";
+ } else {
+ console.log("HTML node named <" + sElemId + "> not found.")
+ }
+}
+
+function hideElement (sElemId) {
+ if (document.getElementById(sElemId)) {
+ document.getElementById(sElemId).style.display = "none";
+ } else {
+ console.log("HTML node named <" + sElemId + "> not found.")
+ }
+}
+
+
+const oTabulations = {
+
+ lPage: ["lexicon_page", "add_page", "search_page", "info_page"],
+
+ showPage: function (sRequestedPage) {
+ for (let sPage of this.lPage) {
+ if (sPage !== sRequestedPage) {
+ hideElement(sPage);
+ this.downlightButton(sPage.slice(0,-5) + "_button");
+ }
+ }
+ showElement(sRequestedPage);
+ this.highlightButton(sRequestedPage.slice(0,-5) + "_button");
+ if (sRequestedPage == "add_page") {
document.getElementById("lemma").focus();
}
},
- showElement: function (sElemId) {
- if (document.getElementById(sElemId)) {
- document.getElementById(sElemId).style.display = "block";
- } else {
- console.log("HTML node named <" + sElemId + "> not found.")
- }
- },
-
- hideElement: function (sElemId) {
- if (document.getElementById(sElemId)) {
- document.getElementById(sElemId).style.display = "none";
- } else {
- console.log("HTML node named <" + sElemId + "> not found.")
- }
- },
+ highlightButton: function (sButton) {
+ if (document.getElementById(sButton)) {
+ let xButton = document.getElementById(sButton);
+ xButton.style.backgroundColor = "hsl(210, 80%, 90%)";
+ xButton.style.color = "hsl(210, 80%, 30%)";
+ xButton.style.fontWeight = "bold";
+ }
+ },
+
+ downlightButton: function (sButton) {
+ if (document.getElementById(sButton)) {
+ let xButton = document.getElementById(sButton);
+ xButton.style.backgroundColor = "hsl(210, 10%, 95%)";
+ xButton.style.color = "hsl(210, 10%, 50%)";
+ xButton.style.fontWeight = "normal";
+ }
+ },
+
+ listen: function () {
+ document.getElementById("lexicon_button").addEventListener("click", () => { this.showPage("lexicon_page"); }, false);
+ document.getElementById("add_button").addEventListener("click", () => { this.showPage("add_page"); }, false);
+ document.getElementById("search_button").addEventListener("click", () => { this.showPage("search_page"); }, false);
+ document.getElementById("info_button").addEventListener("click", () => { this.showPage("info_page"); }, false);
+ }
+}
+
+
+class Table {
+
+ constructor (sNodeId, lColumn, sProgressBarId, sResultId="", bDeleteButtons=true) {
+ this.sNodeId = sNodeId;
+ this.xTable = document.getElementById(sNodeId);
+ this.nColumn = lColumn.length;
+ this.lColumn = lColumn;
+ this.xProgressBar = document.getElementById(sProgressBarId);
+ this.xNumEntry = document.getElementById(sResultId);
+ this.iEntryIndex = 0;
+ this.lEntry = [];
+ this.nEntry = 0;
+ this.bDeleteButtons = bDeleteButtons;
+ this._createHeader();
+ this.listen();
+ }
+
+ _createHeader () {
+ let xRowNode = createNode("tr");
+ if (this.bDeleteButtons) {
+ xRowNode.appendChild(createNode("th", { textContent: "·", width: "12px" }));
+ }
+ for (let sColumn of this.lColumn) {
+ xRowNode.appendChild(createNode("th", { textContent: sColumn }));
+ }
+ this.xTable.appendChild(xRowNode);
+ }
+
+ clear () {
+ while (this.xTable.firstChild) {
+ this.xTable.removeChild(this.xTable.firstChild);
+ }
+ this.iEntryIndex = 0;
+ this._createHeader();
+ }
+
+ fill (lFlex) {
+ this.clear();
+ if (lFlex.length > 0) {
+ this.xProgressBar.max = lFlex.length;
+ this.xProgressBar.value = 1;
+ for (let lData of lFlex) {
+ this._addRow(lData);
+ this.xProgressBar.value += 1;
+ }
+ this.xProgressBar.value = this.xProgressBar.max;
+ }
+ this.lEntry = lFlex;
+ this.nEntry = lFlex.length;
+ this.showEntryNumber();
+ }
+
+ addEntries (lFlex) {
+ this.lEntry.push(...lFlex);
+ for (let lData of lFlex) {
+ this._addRow(lData);
+ }
+ this.nEntry += lFlex.length;
+ this.showEntryNumber();
+ }
+
+ showEntryNumber () {
+ if (this.xNumEntry) {
+ this.xNumEntry.textContent = this.nEntry;
+ }
+ }
+
+ _addRow (lData) {
+ let xRowNode = createNode("tr", { id: this.sNodeId + "_row_" + this.iEntryIndex });
+ if (this.bDeleteButtons) {
+ xRowNode.appendChild(createNode("td", { textContent: "×", className: "delete_entry", title: "Effacer cette entrée" }, { id_entry: this.iEntryIndex }));
+ }
+ for (let data of lData) {
+ xRowNode.appendChild(createNode("td", { textContent: data }));
+ }
+ this.xTable.appendChild(xRowNode);
+ this.iEntryIndex += 1;
+ }
+
+ listen () {
+ if (this.bDeleteButtons) {
+ this.xTable.addEventListener("click", (xEvent) => { this.onTableClick(xEvent); }, false);
+ }
+ }
+
+ onTableClick (xEvent) {
+ try {
+ let xElem = xEvent.target;
+ if (xElem.className) {
+ if (xElem.className == "delete_entry") {
+ this.deleteRow(xElem.dataset.id_entry);
+ }
+ }
+ }
+ catch (e) {
+ showError(e);
+ }
+ }
+
+ deleteRow (iEntry) {
+ this.lEntry[parseInt(iEntry)] = null;
+ if (document.getElementById(this.sNodeId + "_row_" + iEntry)) {
+ document.getElementById(this.sNodeId + "_row_" + iEntry).style.display = "none";
+ }
+ this.nEntry -= 1;
+ this.showEntryNumber();
+ }
+
+ getEntries () {
+ return this.lEntry.filter((e) => e !== null);
+ }
+}
+
+
+const oGenerator = {
+
+ sLemma: "",
+
+ cMainTag: "",
+
+ lFlexion: [],
+
+ listen: function () {
+ document.getElementById("editor").addEventListener("click", (xEvent) => { this.onSelectionClick(xEvent); }, false);
+ document.getElementById("lemma").addEventListener("keyup", () => { this.onWrite(); }, false);
+ document.getElementById("lemma2").addEventListener("keyup", () => { this.onWrite2(); }, false);
+ document.getElementById("verb_pattern").addEventListener("keyup", () => { this.update(); }, false);
+ document.getElementById("flexion").addEventListener("keyup", () => { this.update(); }, false);
+ document.getElementById("tags").addEventListener("keyup", () => { this.update(); }, false);
+ document.getElementById("add_to_lexicon").addEventListener("click", () => { this.addToLexicon(); }, false);
+ },
+
+ lSection: ["nom", "verbe", "adverbe", "nom_propre", "autre"],
hideAllSections: function () {
- for (let xElem of document.getElementById("sections").childNodes) {
- if (xElem.id) {
- xElem.style.display = "none";
- }
+ for (let sSection of this.lSection) {
+ hideElement("section_" + sSection);
+ document.getElementById("select_" + sSection).style.backgroundColor = "";
}
},
showSection: function (sName) {
this.clear();
this.hideAllSections();
- this.showElement(sName);
+ if (document.getElementById(sName).style.display == "none") {
+ showElement(sName);
+ } else {
+ hideElement(sName);
+ }
},
clear: function () {
try {
document.getElementById("lemma2").value = "";
- this.hideElement("word_section2");
+ hideElement("word_section2");
// nom, adjectif, noms propres
for (let xElem of document.getElementsByName("POS")) {
xElem.checked = false;
}
for (let xElem of document.getElementsByName("POS2")) {
@@ -142,14 +291,15 @@
try {
let xElem = xEvent.target;
if (xElem.id) {
if (xElem.id.startsWith("select_")) {
this.showSection("section_" + xElem.id.slice(7));
- oFlexGen.setMainTag(xElem.dataset.tag);
- oFlexGen.update();
+ xElem.style.backgroundColor = "hsl(210, 50%, 90%)";
+ this.cMainTag = xElem.dataset.tag;
+ this.update();
} else if (xElem.id.startsWith("up_")) {
- oFlexGen.update();
+ this.update();
}
}
}
catch (e) {
showError(e);
@@ -156,356 +306,182 @@
}
},
onWrite: function () {
if (document.getElementById("lemma").value.trim() !== "") {
- this.showElement("editor");
- oFlexGen.update();
+ showElement("editor");
+ this.update();
} else {
- this.showSection("section_vide");
- this.hideElement("editor");
- this.hideElement("actions");
+ hideElement("editor");
}
},
onWrite2: function () {
if (document.getElementById("lemma2").value.trim() !== "") {
- this.showElement("word_section2");
- oFlexGen.update();
- } else {
- this.hideElement("word_section2");
- }
- },
-
- createTableHeader: function () {
- let xRowNode = createNode("tr");
- xRowNode.appendChild(createNode("th", { textContent: "·" }));
- xRowNode.appendChild(createNode("th", { textContent: "#" }));
- xRowNode.appendChild(createNode("th", { textContent: "Forme fléchie" }));
- xRowNode.appendChild(createNode("th", { textContent: "Lemme" }));
- xRowNode.appendChild(createNode("th", { textContent: "Étiquettes" }));
- return xRowNode;
- },
-
- createRowNode: function (n, sFlexion, sLemma, sTags) {
- let xRowNode = createNode("tr", { id: "row_" + n });
- xRowNode.appendChild(createNode("td", { textContent: "×", className: "delete_entry", title: "Effacer cette entrée" }, { id_entry: n }));
- xRowNode.appendChild(createNode("td", { textContent: n }));
- xRowNode.appendChild(createNode("td", { textContent: sFlexion }));
- xRowNode.appendChild(createNode("td", { textContent: sLemma }));
- xRowNode.appendChild(createNode("td", { textContent: sTags }));
- return xRowNode;
- },
-
- displayTable: function (lFlex) {
- this.clearTable();
- if (lFlex.length > 0) {
- this.showElement("display_progress");
- let xDisplayProgress = document.getElementById("display_progress");
- let xTable = document.getElementById("table");
- let n = 0;
- xDisplayProgress.max = lFlex.length;
- xDisplayProgress.value = 1;
- this.hideElement("no_elem_line");
- xTable.appendChild(this.createTableHeader());
- for (let [sFlexion, sLemma, sTags] of lFlex) {
- xTable.appendChild(this.createRowNode(n, sFlexion, sLemma, sTags));
- n += 1;
- xDisplayProgress.value += 1;
- }
- xDisplayProgress.value = xDisplayProgress.max;
- this.hideElement("display_progress");
- } else {
- this.showElement("no_elem_line");
- }
- this.updateData();
- },
-
- clearTable: function () {
- let xTable = document.getElementById("table");
- while (xTable.firstChild) {
- xTable.removeChild(xTable.firstChild);
- }
- },
-
- onTableClick: function (xEvent) {
- try {
- let xElem = xEvent.target;
- if (xElem.className) {
- if (xElem.className == "delete_entry") {
- this.deleteEntry(xElem.dataset.id_entry);
- }
- }
- }
- catch (e) {
- showError(e);
- }
- },
-
- addEntriesToTable: function (iStart, lFlex) {
- let xTable = document.getElementById("table");
- if (lFlex.length > 0) {
- if (document.getElementById("no_elem_line").style.display !== "none") {
- this.hideElement("no_elem_line");
- xTable.appendChild(this.createTableHeader());
- }
- for (let [sFlexion, sLemma, sTags] of lFlex) {
- xTable.appendChild(this.createRowNode(iStart, sFlexion, sLemma, sTags));
- iStart += 1;
- }
- }
- this.updateData();
- },
-
- deleteEntry: function (iEntry) {
- oLexicon.deleteEntry(iEntry);
- this.hideElement("row_"+iEntry);
- this.showElement("save_button");
- this.updateData();
- },
-
- updateData: function () {
- document.getElementById("num_added_entries").textContent = oLexicon.nAddedEntries;
- document.getElementById("num_deleted_entries").textContent = oLexicon.nDeletedEntries;
- document.getElementById("num_entries").textContent = oLexicon.nEntries;
- },
-
- setDictData: function (nEntries, sDate) {
- document.getElementById("num_entries_saved").textContent = nEntries;
- document.getElementById("save_date").textContent = sDate;
- }
-}
-
-
-
-const oFlexGen = {
-
- cMainTag: "",
-
- lFlexion: [],
-
- clear: function () {
- this.lFlexion = [];
- oWidgets.hideElement("actions");
- },
-
- setMainTag: function (sValue) {
- this.cMainTag = sValue;
- },
-
- addFlexion: function (sFlexion, sLemma, sTag) {
- this.lFlexion.push( [sFlexion, sLemma, sTag] );
+ showElement("word_section2");
+ this.update();
+ } else {
+ hideElement("word_section2");
+ }
},
update: function () {
try {
- this.clear();
- let sGenderTag = "";
- let sLemma = document.getElementById("lemma").value.trim();
- if (sLemma.length > 0) {
+ this.lFlexion = [];
+ this.sLemma = document.getElementById("lemma").value.trim();
+ if (this.sLemma.length > 0) {
switch (this.cMainTag) {
case "N":
if (!this.getRadioValue("POS") || !this.getRadioValue("genre")) {
break;
}
let sTag = this.getRadioValue("POS") + this.getRadioValue("genre");
switch (this.getRadioValue("pluriel")) {
case "s":
- this.addFlexion(sLemma, sLemma, sTag+":s/*");
- this.addFlexion(sLemma+"s", sLemma, sTag+":p/*");
+ this.lFlexion.push([this.sLemma, sTag+":s/*"]);
+ this.lFlexion.push([this.sLemma+"s", sTag+":p/*"]);
break;
case "x":
- this.addFlexion(sLemma, sLemma, sTag+":s/*");
- this.addFlexion(sLemma+"x", sLemma, sTag+":p/*");
+ this.lFlexion.push([this.sLemma, sTag+":s/*"]);
+ this.lFlexion.push([this.sLemma+"x", sTag+":p/*"]);
break;
case "i":
- this.addFlexion(sLemma, sLemma, sTag+":i/*");
+ this.lFlexion.push([this.sLemma, sTag+":i/*"]);
break;
}
let sLemma2 = document.getElementById("lemma2").value.trim();
if (sLemma2.length > 0 && this.getRadioValue("POS2") && this.getRadioValue("genre2")) {
let sTag2 = this.getRadioValue("POS2") + this.getRadioValue("genre2");
switch (this.getRadioValue("pluriel2")) {
case "s":
- this.addFlexion(sLemma2, sLemma, sTag2+":s/*");
- this.addFlexion(sLemma2+"s", sLemma, sTag2+":p/*");
+ this.lFlexion.push([sLemma2, sTag2+":s/*"]);
+ this.lFlexion.push([sLemma2+"s", sTag2+":p/*"]);
break;
case "x":
- this.addFlexion(sLemma2, sLemma, sTag2+":s/*");
- this.addFlexion(sLemma2+"x", sLemma, sTag2+":p/*");
+ this.lFlexion.push([sLemma2, sTag2+":s/*"]);
+ this.lFlexion.push([sLemma2+"x", sTag2+":p/*"]);
break;
case "i":
- this.addFlexion(sLemma2, sLemma, sTag2+":i/*");
+ this.lFlexion.push([sLemma2, sTag2+":i/*"]);
break;
}
}
break;
case "V": {
- if (!sLemma.endsWith("er") && !sLemma.endsWith("ir") && !sLemma.endsWith("re")) {
+ if (!this.sLemma.endsWith("er") && !this.sLemma.endsWith("ir") && !this.sLemma.endsWith("re")) {
break;
}
- sLemma = sLemma.toLowerCase();
+ this.sLemma = this.sLemma.toLowerCase();
let cGroup = "";
let c_i = (document.getElementById("up_v_i").checked) ? "i" : "_";
let c_t = (document.getElementById("up_v_t").checked) ? "t" : "_";
let c_n = (document.getElementById("up_v_n").checked) ? "n" : "_";
let c_p = (document.getElementById("up_v_p").checked) ? "p" : "_";
let c_m = (document.getElementById("up_v_m").checked) ? "m" : "_";
let c_ae = (document.getElementById("up_v_ae").checked) ? "e" : "_";
let c_aa = (document.getElementById("up_v_aa").checked) ? "a" : "_";
let sVerbTag = c_i + c_t + c_n + c_p + c_m + c_ae + c_aa;
+ if (sVerbTag.includes("p") && !sVerbTag.startsWith("___p_")) {
+ sVerbTag = sVerbTag.replace("p", "q");
+ }
if (!sVerbTag.endsWith("__") && !sVerbTag.startsWith("____")) {
let sVerbPattern = document.getElementById("verb_pattern").value.trim();
if (sVerbPattern.length == 0) {
- if (!sLemma.endsWith("er") && !sLemma.endsWith("ir")) {
- break;
- }
- // tables de conjugaison du 1er et du 2e groupe
- let cGroup = (sLemma.endsWith("er")) ? "1" : "2";
- for (let [nCut, sAdd, sFlexTags, sPattern] of this._getConjRules(sLemma)) {
- if (!sPattern || RegExp(sPattern).test(sLemma)) {
- this.addFlexion(sLemma.slice(0,-nCut)+sAdd, sLemma, ":V" + cGroup + "_" + sVerbTag + sFlexTags);
- }
- }
- // participes passés
- let bPpasVar = (document.getElementById("up_partpas").checked) ? "var" : "invar";
- let lPpasRules = (sLemma.endsWith("er")) ? oConj["V1_ppas"][bPpasVar] : oConj["V2_ppas"][bPpasVar];
- for (let [nCut, sAdd, sFlexTags, sPattern] of lPpasRules) {
- if (!sPattern || RegExp(sPattern).test(sLemma)) {
- this.addFlexion(sLemma.slice(0,-nCut)+sAdd, sLemma, ":V" + cGroup + "_" + sVerbTag + sFlexTags);
- }
+ // utilisation du générateur de conjugaison
+ let bVarPpas = !document.getElementById("up_v_ppas").checked;
+ for (let [sFlexion, sFlexTags] of conj_generator.conjugate(this.sLemma, sVerbTag, bVarPpas)) {
+ this.lFlexion.push([sFlexion, sFlexTags]);
}
} else {
// copie du motif d’un autre verbe : utilisation du conjugueur
if (conj.isVerb(sVerbPattern)) {
- let oVerb = new Verb(sLemma, sVerbPattern);
+ let oVerb = new Verb(this.sLemma, sVerbPattern);
for (let [sTag1, dFlex] of oVerb.dConj.entries()) {
if (sTag1 !== ":Q") {
for (let [sTag2, sConj] of dFlex.entries()) {
if (sTag2.startsWith(":") && sConj !== "") {
- this.addFlexion(sConj, sLemma, ":V" + oVerb.cGroup + "_" + sVerbTag + sTag1 + sTag2);
+ this.lFlexion.push([sConj, ":V" + oVerb.cGroup + "_" + sVerbTag + sTag1 + sTag2]);
}
}
} else {
// participes passés
if (dFlex.get(":Q3") !== "") {
if (dFlex.get(":Q2") !== "") {
- this.addFlexion(dFlex.get(":Q1"), sLemma, ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:m:s/*");
- this.addFlexion(dFlex.get(":Q2"), sLemma, ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:m:p/*");
- } else {
- this.addFlexion(dFlex.get(":Q1"), sLemma, ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:m:i/*");
- }
- this.addFlexion(dFlex.get(":Q3"), sLemma, ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:f:s/*");
- this.addFlexion(dFlex.get(":Q4"), sLemma, ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:f:p/*");
- } else {
- this.addFlexion(dFlex.get(":Q1"), sLemma, ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:e:i/*");
+ this.lFlexion.push([dFlex.get(":Q1"), ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:m:s/*"]);
+ this.lFlexion.push([dFlex.get(":Q2"), ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:m:p/*"]);
+ } else {
+ this.lFlexion.push([dFlex.get(":Q1"), ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:m:i/*"]);
+ }
+ this.lFlexion.push([dFlex.get(":Q3"), ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:f:s/*"]);
+ this.lFlexion.push([dFlex.get(":Q4"), ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:A:f:p/*"]);
+ } else {
+ this.lFlexion.push([dFlex.get(":Q1"), ":V" + oVerb.cGroup + "_" + sVerbTag + ":Q:e:i/*"]);
}
}
}
}
}
}
break;
}
case "W":
- sLemma = sLemma.toLowerCase();
- this.addFlexion(sLemma, sLemma, ":W/*");
- break;
- case "M1":
- sLemma = sLemma.slice(0,1).toUpperCase() + sLemma.slice(1);
- sGenderTag = this.getRadioValue("genre_m1");
- if (sGenderTag) {
- this.addFlexion(sLemma, sLemma, ":M1"+sGenderTag+":i/*");
- }
- break;
- case "M2":
- sLemma = sLemma.slice(0,1).toUpperCase() + sLemma.slice(1);
- sGenderTag = this.getRadioValue("genre_m2");
- if (sGenderTag) {
- this.addFlexion(sLemma, sLemma, ":M2"+sGenderTag+":i/*");
- }
- break;
- case "MP":
- sGenderTag = this.getRadioValue("genre_mp");
- if (sGenderTag) {
- this.addFlexion(sLemma, sLemma, ":MP"+sGenderTag+":i/*");
+ this.sLemma = this.sLemma.toLowerCase();
+ this.lFlexion.push([this.sLemma, ":W/*"]);
+ break;
+ case "M":
+ this.sLemma = this.sLemma.slice(0,1).toUpperCase() + this.sLemma.slice(1);
+ let sPOSTag = this.getRadioValue("pos_nom_propre")
+ let sGenderTag = this.getRadioValue("genre_m");
+ if (sGenderTag) {
+ this.lFlexion.push([this.sLemma, sPOSTag+sGenderTag+":i/*"]);
}
break;
case "X":
let sFlexion = document.getElementById("flexion").value.trim();
let sTags = document.getElementById("tags").value.trim();
if (sFlexion.length > 0 && sTags.startsWith(":")) {
- this.addFlexion(sFlexion, sLemma, sTags);
+ this.lFlexion.push([sFlexion, sTags]);
}
break;
}
}
- this.show();
+ if (this.lFlexion.length > 0) {
+ showElement("add_to_lexicon");
+ } else {
+ hideElement("add_to_lexicon");
+ }
+ oGenWordsTable.fill(this.lFlexion);
}
catch (e) {
showError(e);
}
},
- _getConjRules: function (sVerb) {
- if (sVerb.endsWith("ir")) {
- // deuxième groupe
- return oConj["V2"];
- } else if (sVerb.endsWith("er")) {
- // premier groupe, conjugaison en fonction de la terminaison du lemme
- // 5 lettres
- if (sVerb.slice(-5) in oConj["V1"]) {
- return oConj["V1"][sVerb.slice(-5)];
- }
- // 4 lettres
- if (sVerb.slice(-4) in oConj["V1"]) {
- if (sVerb.endsWith("eler") || sVerb.endsWith("eter")) {
- return oConj["V1"][sVerb.slice(-4)]["1"];
- }
- return oConj["V1"][sVerb.slice(-4)];
- }
- // 3 lettres
- if (sVerb.slice(-3) in oConj["V1"]) {
- return oConj["V1"][sVerb.slice(-3)];
- }
- return oConj["V1"]["er"];
- } else {
- // troisième groupe
- return [ [0, "", ":Y/*", false] ];
- }
- },
-
getRadioValue: function (sName) {
if (document.querySelector('input[name="' + sName + '"]:checked')) {
return document.querySelector('input[name="' + sName + '"]:checked').value;
}
return null;
},
- show: function () {
- let sText = "";
- for (let [sFlexion, sLemma, sTag] of this.lFlexion) {
- sText += sFlexion + " (" + sLemma + ") " + sTag + "\n";
- }
- if (sText) {
- document.getElementById("results").textContent = sText;
- oWidgets.showElement("actions");
- } else {
- oWidgets.hideElement("actions");
- }
+ createFlexLemmaTagArray: function () {
+ let lEntry = [];
+ for (let [sFlex, sTags] of oGenWordsTable.getEntries()) {
+ lEntry.push([sFlex, this.sLemma, sTags]);
+ }
+ return lEntry;
},
addToLexicon: function () {
try {
- oLexicon.addFlexions(this.lFlexion);
+ oLexiconTable.addEntries(this.createFlexLemmaTagArray());
+ oGenWordsTable.clear();
document.getElementById("lemma").value = "";
document.getElementById("lemma").focus();
- oWidgets.showSection("section_vide");
- oWidgets.hideElement("editor");
- oWidgets.hideElement("actions");
- oWidgets.clear();
- oWidgets.showElement("save_button");
+ this.hideAllSections();
+ hideElement("editor");
+ showElement("save_button");
this.clear();
this.cMainTag = "";
}
catch (e) {
showError(e);
@@ -512,115 +488,179 @@
}
}
}
-
-const oLexicon = {
-
- lFlexion: [],
- nEntries: 0,
- nDeletedEntries: 0,
- nAddedEntries: 0,
-
- set: function (lFlexion) {
- this.lFlexion = lFlexion;
- this.resetModif();
- oWidgets.displayTable(this.lFlexion);
- if (this.lFlexion.length > 0) {
- oWidgets.showElement("export_button");
- } else {
- oWidgets.hideElement("export_button");
- }
- },
-
- addFlexions: function (lNewFlex) {
- let iStart = this.lFlexion.length;
- for (let aFlex of lNewFlex) {
- this.lFlexion.push(aFlex);
- }
- this.nAddedEntries += lNewFlex.length;
- this.nEntries += lNewFlex.length;
- oWidgets.addEntriesToTable(iStart, lNewFlex);
- },
-
- deleteEntry: function (iEntry) {
- this.lFlexion[parseInt(iEntry)] = null;
- this.nDeletedEntries++;
- this.nEntries--;
- },
-
- resetModif: function () {
- this.nEntries = this.lFlexion.length;
- this.nAddedEntries = 0;
- this.nDeletedEntries = 0;
- },
-
- save: function () {
- oWidgets.hideElement("save_button");
- this.lFlexion = this.lFlexion.filter((e) => e !== null);
- oBinaryDict.build(this.lFlexion);
- this.resetModif();
- oWidgets.displayTable(this.lFlexion);
- oWidgets.updateData();
- }
-}
-
-
const oBinaryDict = {
oIBDAWG: null,
load: function () {
if (bChrome) {
- browser.storage.local.get("oPersonalDictionary", this._load);
+ browser.storage.local.get("oPersonalDictionary", this._load.bind(this));
return;
}
let xPromise = browser.storage.local.get("oPersonalDictionary");
xPromise.then(this._load.bind(this), showError);
},
_load: function (oResult) {
if (!oResult.hasOwnProperty("oPersonalDictionary")) {
- oWidgets.hideElement("export_button");
+ hideElement("export_button");
return;
}
let oJSON = oResult.oPersonalDictionary;
- this.oIBDAWG = new IBDAWG(oJSON);
- let lEntry = [];
- for (let s of this.oIBDAWG.select()) {
- lEntry.push(s.split("\t"));
- }
- oLexicon.set(lEntry);
- oWidgets.setDictData(this.oIBDAWG.nEntry, this.oIBDAWG.sDate);
- oWidgets.showElement("export_button");
- },
-
- build: function (lEntry) {
- oWidgets.showElement("build_progress");
- let xProgressNode = document.getElementById("build_progress");
- let oDAWG = new DAWG(lEntry, "S", "fr", "Français", "Dictionnaire personnel", xProgressNode);
- let oJSON = oDAWG.createBinaryJSON(1);
- this.save(oJSON);
- this.oIBDAWG = new IBDAWG(oJSON);
- oWidgets.setDictData(this.oIBDAWG.nEntry, this.oIBDAWG.sDate);
- oWidgets.hideElement("build_progress");
- oWidgets.showElement("export_button");
- browser.runtime.sendMessage({ sCommand: "setDictionary", dParam: {sType: "personal", oDict: oJSON}, dInfo: {} });
- },
-
- save: function (oJSON) {
- browser.storage.local.set({ "oPersonalDictionary": oJSON });
+ if (oJSON) {
+ this.__load(oJSON);
+ } else {
+ oLexiconTable.clear();
+ this.setDictData(0, "[néant]");
+ }
+ },
+
+ __load: function (oJSON) {
+ try {
+ this.oIBDAWG = new IBDAWG(oJSON);
+ }
+ catch (e) {
+ console.error(e);
+ this.setDictData(0, "#Erreur. Voir la console.");
+ return;
+ }
+ let lEntry = [];
+ for (let aRes of this.oIBDAWG.select()) {
+ lEntry.push(aRes);
+ }
+ oLexiconTable.fill(lEntry);
+ this.setDictData(this.oIBDAWG.nEntry, this.oIBDAWG.sDate);
},
import: function () {
- // TO DO
+ let xInput = document.getElementById("import_input");
+ let xFile = xInput.files[0];
+ let xURL = URL.createObjectURL(xFile);
+ let sJSON = helpers.loadFile(xURL);
+ if (sJSON) {
+ try {
+ let oJSON = JSON.parse(sJSON);
+ browser.storage.local.set({ "oPersonalDictionary": oJSON });
+ this.__load(oJSON);
+ }
+ catch (e) {
+ console.error(e);
+ this.setDictData(0, "#Erreur. Voir la console.");
+ return;
+ }
+ } else {
+ this.setDictData(0, "[néant]");
+ browser.storage.local.set({ "oPersonalDictionary": "" });
+ }
+ },
+
+ setDictData: function (nEntries, sDate) {
+ document.getElementById("dic_num_entries").textContent = nEntries;
+ document.getElementById("dic_save_date").textContent = sDate;
+ if (nEntries == 0) {
+ hideElement("export_button");
+ } else {
+ showElement("export_button");
+ }
+ },
+
+ listen: function () {
+ document.getElementById("save_button").addEventListener("click", () => { this.build(); }, false);
+ document.getElementById("export_button").addEventListener("click", () => { this.export(); }, false);
+ document.getElementById("import_input").addEventListener("change", () => { this.import(); }, false);
+ },
+
+ build: function () {
+ let xProgressNode = document.getElementById("wait_progress");
+ let lEntry = oLexiconTable.getEntries();
+ if (lEntry.length > 0) {
+ let oDAWG = new DAWG(lEntry, "S", "fr", "Français", "Dictionnaire personnel", xProgressNode);
+ let oJSON = oDAWG.createBinaryJSON(1);
+ browser.storage.local.set({ "oPersonalDictionary": oJSON });
+ this.oIBDAWG = new IBDAWG(oJSON);
+ this.setDictData(this.oIBDAWG.nEntry, this.oIBDAWG.sDate);
+ browser.runtime.sendMessage({ sCommand: "setDictionary", dParam: {sDictionary: "personal", oDict: oJSON}, dInfo: {} });
+ } else {
+ this.setDictData(0, "[néant]");
+ browser.storage.local.set({ "oPersonalDictionary": "" });
+ browser.runtime.sendMessage({ sCommand: "setDictionary", dParam: {sDictionary: "personal", oDict: null}, dInfo: {} });
+ }
},
export: function () {
let xBlob = new Blob([ JSON.stringify(this.oIBDAWG.getJSON()) ], {type: 'application/json'});
let sURL = URL.createObjectURL(xBlob);
browser.downloads.download({ filename: "fr.personal.json", url: sURL, saveAs: true });
}
}
+
+const oSearch = {
+
+ oSpellChecker: null,
+
+ load: function () {
+ this.oSpellChecker = new SpellChecker("fr", browser.extension.getURL("")+"grammalecte/graphspell/_dictionaries", "fr.json");
+ },
+
+ loadOtherDictionaries: function () {
+ //TODO
+ },
+
+ listen: function () {
+ document.getElementById("search_similar_button").addEventListener("click", () => { this.searchSimilar(); }, false);
+ document.getElementById("search_regex_button").addEventListener("click", () => { this.searchRegex() }, false);
+ },
+
+ searchSimilar: function () {
+ oSearchTable.clear();
+ let sWord = document.getElementById("search_similar").value;
+ if (sWord !== "") {
+ let lResult = this.oSpellChecker.getSimilarEntries(sWord, 20);
+ oSearchTable.fill(lResult);
+ }
+ },
+
+ searchRegex: function () {
+ let sFlexPattern = document.getElementById("search_flexion_pattern").value.trim();
+ let sTagsPattern = document.getElementById("search_tags_pattern").value.trim();
+ let lEntry = [];
+ let i = 0;
+ for (let aRes of this.oSpellChecker.select(sFlexPattern, sTagsPattern)) {
+ lEntry.push(aRes);
+ i++;
+ if (i >= 2000) {
+ break;
+ }
+ }
+ oSearchTable.fill(lEntry);
+ }
+}
+
+
+const oTagsInfo = {
+ load: function () {
+ let lEntry = [];
+ for (let [sTag, [_, sLabel]] of _dTag) {
+ lEntry.push([sTag, sLabel.trim()]);
+ }
+ oTagsTable.fill(lEntry);
+ }
+}
+
+
+const oGenWordsTable = new Table("generated_words_table", ["Flexions", "Étiquettes"], "wait_progress");
+const oLexiconTable = new Table("lexicon_table", ["Flexions", "Lemmes", "Étiquettes"], "wait_progress", "num_entries");
+const oSearchTable = new Table("search_table", ["Flexions", "Lemmes", "Étiquettes"], "wait_progress", "search_num_entries", false);
+const oTagsTable = new Table("tags_table", ["Étiquette", "Signification"], "wait_progress", "", false);
+
+
+oTagsInfo.load();
+oSearch.load();
oBinaryDict.load();
+oBinaryDict.listen();
+oGenerator.listen();
+oTabulations.listen();
+oSearch.listen();
Index: gc_lang/fr/webext/panel/main.css
==================================================================
--- gc_lang/fr/webext/panel/main.css
+++ gc_lang/fr/webext/panel/main.css
@@ -249,18 +249,22 @@
*/
#sc_options_page {
display: none;
padding: 20px;
}
-#dictionaries_info {
+.dictionaries_info {
margin: 10px 0;
padding: 10px;
border-radius: 3px;
background-color: hsl(0, 50%, 40%);
color: hsl(0, 10%, 96%);
}
-
+#sc_options_page h2 {
+ margin-top: 20px;
+ font: normal 22px 'Yanone Kaffeesatz', "Oswald", "Liberation Sans Narrow", sans-serif;
+ color: hsl(210, 50%, 50%);
+}
/*
Options
*/
.option_section {
@@ -316,10 +320,29 @@
font-size: 12px;
text-align: center;
cursor: pointer;
}
+
+#info_page {
+ display: none;
+ padding: 20px;
+}
+#info_page h2 {
+ margin-top: 20px;
+ font: bold 18px "Trebuchet MS", "Fira Sans", "Liberation Sans", sans-serif;
+ color: hsl(210, 50%, 50%);
+}
+#info_page h3 {
+ margin-top: 20px;
+ font: bold 16px "Trebuchet MS", "Fira Sans", "Liberation Sans", sans-serif;
+ color: hsl(210, 20%, 50%);
+}
+#info_page p {
+ font-size: 14px;
+}
+
/*
CSS Spinner
Double bounce
http://tobiasahlin.com/spinkit/
Index: gc_lang/fr/webext/panel/main.html
==================================================================
--- gc_lang/fr/webext/panel/main.html
+++ gc_lang/fr/webext/panel/main.html
@@ -26,14 +26,18 @@
Éditeur lexical
+ +
+
+
+
+
+
+
+
+
+ Dictionnaire personnel
Enregistré le : —
+ 0 entrées
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Nouveau mot (lemme)
+ + +
+
+
+
+
+ Nom commun
+
+
+
+ + + + +
+
+
+
+
+
+ Genre
+ + + +
+
+ Pluriel
+ + + +[optionnel] Autre forme (masculine, féminine, variante, etc.)
+ +
+
+ + + + +
+
+
+
+
+ Genre
+ + + +
+
+ Pluriel
+ + + +Verbe
+
+
+
+
+
+
+ Le verbe peut s’utiliser sans complément d’objet.
+
+
+
+
+ Je dors.
Tu pars.
Elle pense.
Nous écrivons.
Vous manifestez.
Ils viennent.
+ Tu pars.
Elle pense.
Nous écrivons.
Vous manifestez.
Ils viennent.
J’appartiens à ce groupe…
J’accède au niveau supérieur.
+ J’accède au niveau supérieur.
+
+
+ Ce verbe peut s’utiliser avec un complément d’objet direct (COD).
+
+
+
+
+ Je mange une pomme.
Tu donnes une bonne impression.
Elle écrit un livre.
Nous fabriquons une œuvre.
+ Tu donnes une bonne impression.
Elle écrit un livre.
Nous fabriquons une œuvre.
Je pars ce matin.
J’appartiens à…
+ J’appartiens à…
+
+
+ Ce verbe peut s’utiliser avec un complément d’objet indirect (COI). Attention à ne pas confondre avec un complément circonstanciel de temps, de lieu ou de manière.
+
+
+
+
+ Je donne un cadeau à sa femme.
Elle appartient à ce groupe.
+ Elle appartient à ce groupe.
Elle danse à l’opéra.
+
+
+
+ Ce verbe peut s’utiliser pronominalement.
+
+
+
+
+ Je me suis trompé.
Tu t’es étonné toi-même.
Elle s’est souvenu de ses études.
Nous nous sommes égarés.
Vous vous êtes retrouvées.
Ils se sont rappelé leur enfance.
+ Tu t’es étonné toi-même.
Elle s’est souvenu de ses études.
Nous nous sommes égarés.
Vous vous êtes retrouvées.
Ils se sont rappelé leur enfance.
Je me suis venu.
tu t’es arrivé.
elle s’est marché.
nous nous sommes courus.
vous vous êtes acculés.
Elles se sont capitulées.
+ tu t’es arrivé.
elle s’est marché.
nous nous sommes courus.
vous vous êtes acculés.
Elles se sont capitulées.
+
+
+ Ce verbe ne peut s’utiliser à la première personne, mais uniquement à la troisième personne du singulier ou du pluriel.
+
+
+
+
+ Il pleut.
Il faut.
+ Il faut.
Je pleus.
Nous fallons.
+ Nous fallons.
+
+
+ Auxiliaire pour le passé composé
+
+
+
+
+
+
+
+
+
+
+ Je suis venu.
Je suis parti.
+ Je suis parti.
J’ai venu.
J’ai parti.
+ J’ai parti.
+
+
+
+
+
+
+
+
+ J’ai mangé.
J’ai prié.
+ J’ai prié.
Je suis mangé.
Je suis prié.
+ Je suis prié.
+
+
+
+ Cette option est ignorée si vous utilisez un verbe modèle.
+
+
+ Verbe modèle [optionnel]
+Il est déconseillé d’utiliser un verbe modèle : ce n’est pas nécessaire la très grande majorité des verbes du 1ᵉʳ groupe et du 2ᵉ groupe. Ce ne peut être utile et bénéfique que pour les cas particuliers.
+ +
+
+ Il est fortement recommandé d’appliquer les règles d’un verbe du même groupe que celui que vous créez. Mais aucune restriction n’est imposée.
+Classification des groupes :
+-
+
-
+ 1ᵉʳ groupe : verbes finissant par -er. Attention : contrairement au préjugé commun, ce groupe est irrégulier. Beaucoup de verbes voient leur racine modifiée dans certaines formes conjuguées :
+
-
+
- ajout ou modification de diacritiques (verbes finissant par -cer, -ecer, -emer, -ener, -eper, -erer, -eser, -ever, -evrer, -eler, -eter, -ébrer, -écer, -écher, -écrer, -éder, -éger, -égler, -égner, -égrer, -éguer, -éler, -émer, -éner, -éper, -équer, -érer, -éser, -éter, -étrer, -évrer, -éyer), +
- un ‹e› euphonique est ajouté sur la plupart des verbes finissant par -ger, +
- certains verbes finissant par -yer remplacent éventuellement le ‹y› par un ‹i›, +
- doublement irrégulier de certaines consonnes (geler ne se conjugue pas comme appeler, acheter ne se conjugue pas comme jeter) +
- irrégularités diverses (aller, envoyer, renvoyer)… +
+ - 2ᵉ groupe : verbes finissant par -ir. Ce groupe est de loin le plus régulier. Mais de nombreux verbes finissant par -ir appartiennent au 3ᵉ groupe. +
- 3ᵉ groupe. Autres verbes irréguliers. +
- Les verbes être et avoir n’appartiennent à aucun groupe. Il est recommandé de ne pas s’en servir comme modèle. +
Adverbe
+ + +Nom propre
+
+
+
+
+
+
+ Genre
+ + + +
+
+ Genre
+ + + +Autre
+
+
+ Flexion
+ +Étiquettes
+ +
+
+
+
+
+
+ Mots générés
+
+
+
+
+
+
+
+ Votre lexique
+
+
+
+
+ Nombre d’entrées : 0.
+
+
+
+
+
+
+
+
+
+ Recherche
+ +Graphies similaires
+ + + +Expressions régulières
+Flexion
++ +
Étiquettes
+ + + +La recherche par expressions régulières peut générer un nombre gigantesque de résultats. Seules les 2000 premières occurrences trouvées seront affichées. La recherche peut être longue, parce tout le graphe de mots, qui contient 500 000 flexions, sera parcouru si besoin.
+
+
+
+
+
+ Résultats
+
+
+
+
+
+
+
+
+ Informations
+Enregistrement
+Les modifications apportées au lexique ne sont enregistrées dans le dictionnaire qu’au moment où vous cliquez sur ‹Enregistrer› dans l’onglet ‹Lexique›.
++ +
Doublons
+Il est inutile de purger votre lexique des doublons éventuels. Les doublons sont automatiquement supprimés lors de la création du dictionnaire.
++ +
Compilation du dictionnaire
+Le dictionnaire est compilé comme un graphe de mots sous la forme d’une chaîne binaire dans un fichier JSON. Cette opération peut prendre du temps et consommer beaucoup de mémoire si votre lexique contient plusieurs dizaines de milliers d’entrées.
++ +
Étiquettes rares
+Il est déconseillé d’utiliser la catégorie ‹Autre› pour générer autre chose que des noms, des adjectifs, des noms propres, des verbes et des adverbes. Il n’y a aucune garantie que les étiquettes pour les autres catégories, notamment les mots grammaticaux, ne changeront pas.
+
+
+
+
+
+
Grammaire
+
+
Informations
+
Zone de test
Version ${version}
Site web
-
-
-
+
to get the value of an arc, to get the char of an arc with its value
@@ -181,11 +181,11 @@
` Address size: ${this.nBytesNodeAddress} bytes, Arc size: ${this.nBytesArc} bytes\n`;
}
getJSON () {
let oJSON = {
- "sHeader": "/pyfsa/",
+ "sHeader": "/grammalecte-fsa/",
"sLangCode": this.sLangCode,
"sLangName": this.sLangName,
"sDicName": this.sDicName,
"sFileName": this.sFileName,
"sDate": this.sDate,
@@ -415,39 +415,55 @@
}
// morph (sWord) {
// is defined in constructor
// }
-
- * select (sPattern="") {
- // generator: returns all entries which morphology fits
- let zPattern = null;
- if (sPattern !== "") {
- try {
- zPattern = new RegExp(sPattern);
- }
- catch (e) {
- console.log("Error in regex pattern");
- console.log(e.message);
+ getSimilarEntries (sWord, nSuggLimit=10) {
+ // return a list of tuples (similar word, stem, morphology)
+ if (sWord == "") {
+ return [];
+ }
+ let lResult = [];
+ for (let sSimilar of this.suggest(sWord, nSuggLimit)) {
+ for (let sMorph of this.getMorph(sSimilar)) {
+ let nCut = sMorph.indexOf(" ");
+ lResult.push( [sSimilar, sMorph.slice(1, nCut), sMorph.slice(nCut+1)] );
}
}
- yield* this._select1(zPattern, 0, "");
+ return lResult;
+ }
+
+ * select (sFlexPattern="", sTagsPattern="") {
+ // generator: returns all entries which flexion fits and morphology fits
+ let zFlexPattern = null;
+ let zTagsPattern = null;
+ try {
+ zFlexPattern = (sFlexPattern !== "") ? new RegExp(sFlexPattern) : null;
+ zTagsPattern = (sTagsPattern !== "") ? new RegExp(sTagsPattern) : null;
+ }
+ catch (e) {
+ console.log("Error in regex pattern");
+ console.log(e.message);
+ }
+ yield* this._select1(zFlexPattern, zTagsPattern, 0, "");
}
// VERSION 1
- * _select1 (zPattern, iAddr, sWord) {
+ * _select1 (zFlexPattern, zTagsPattern, iAddr, sWord) {
// recursive generator
for (let [nVal, jAddr] of this._getArcs1(iAddr)) {
if (nVal <= this.nChar) {
// simple character
- yield* this._select1(zPattern, jAddr, sWord + this.lArcVal[nVal]);
+ yield* this._select1(zFlexPattern, zTagsPattern, jAddr, sWord + this.lArcVal[nVal]);
} else {
- let sEntry = sWord + "\t" + this.funcStemming(sWord, this.lArcVal[nVal]);
- for (let [nMorphVal, _] of this._getArcs1(jAddr)) {
- if (!zPattern || zPattern.test(this.lArcVal[nMorphVal])) {
- yield sEntry + "\t" + this.lArcVal[nMorphVal];
+ if (!zFlexPattern || zFlexPattern.test(sWord)) {
+ let sStem = this.funcStemming(sWord, this.lArcVal[nVal]);
+ for (let [nMorphVal, _] of this._getArcs1(jAddr)) {
+ if (!zTagsPattern || zTagsPattern.test(this.lArcVal[nMorphVal])) {
+ yield [sWord, sStem, this.lArcVal[nMorphVal]];
+ }
}
}
}
}
}
Index: graphspell-js/spellchecker.js
==================================================================
--- graphspell-js/spellchecker.js
+++ graphspell-js/spellchecker.js
@@ -2,11 +2,12 @@
// Wrapper for the IBDAWG class.
// Useful to check several dictionaries at once.
// To avoid iterating over a pile of dictionaries, it is assumed that 3 are enough:
// - the main dictionary, bundled with the package
-// - the extended dictionary, added by an organization
+// - the extended dictionary
+// - the community dictionary, added by an organization
// - the personal dictionary, created by the user for its own convenience
"use strict";
@@ -26,23 +27,27 @@
]);
class SpellChecker {
- constructor (sLangCode, sPath="", mainDic="", extentedDic="", personalDic="") {
+ constructor (sLangCode, sPath="", mainDic="", extentedDic="", communityDic="", personalDic="") {
// returns true if the main dictionary is loaded
this.sLangCode = sLangCode;
if (!mainDic) {
mainDic = dDefaultDictionaries.gl_get(sLangCode, "");
}
this.oMainDic = this._loadDictionary(mainDic, sPath, true);
this.oExtendedDic = this._loadDictionary(extentedDic, sPath);
+ this.oCommunityDic = this._loadDictionary(communityDic, sPath);
this.oPersonalDic = this._loadDictionary(personalDic, sPath);
+ this.bExtendedDic = Boolean(this.oExtendedDic);
+ this.bCommunityDic = Boolean(this.oCommunityDic);
+ this.bPersonalDic = Boolean(this.oPersonalDic);
this.oTokenizer = null;
}
- _loadDictionary (dictionary, sPath, bNecessary=false) {
+ _loadDictionary (dictionary, sPath="", bNecessary=false) {
// returns an IBDAWG object
if (!dictionary) {
return null;
}
try {
@@ -76,27 +81,61 @@
this.loadTokenizer();
}
return this.oTokenizer;
}
- setMainDictionary (dictionary) {
+ setMainDictionary (dictionary, sPath="") {
// returns true if the dictionary is loaded
- this.oMainDic = this._loadDictionary(dictionary);
+ this.oMainDic = this._loadDictionary(dictionary, sPath, true);
return Boolean(this.oMainDic);
}
- setExtendedDictionary (dictionary) {
+ setExtendedDictionary (dictionary, sPath="", bActivate=true) {
// returns true if the dictionary is loaded
- this.oExtendedDic = this._loadDictionary(dictionary);
+ this.oExtendedDic = this._loadDictionary(dictionary, sPath);
+ this.bExtendedDic = (bActivate) ? Boolean(this.oExtendedDic) : false;
return Boolean(this.oExtendedDic);
}
- setPersonalDictionary (dictionary) {
+ setCommunityDictionary (dictionary, sPath="", bActivate=true) {
+ // returns true if the dictionary is loaded
+ this.oCommunityDic = this._loadDictionary(dictionary, sPath);
+ this.bCommunityDic = (bActivate) ? Boolean(this.oCommunityDic) : false;
+ return Boolean(this.oCommunityDic);
+ }
+
+ setPersonalDictionary (dictionary, sPath="", bActivate=true) {
// returns true if the dictionary is loaded
- this.oPersonalDic = this._loadDictionary(dictionary);
+ this.oPersonalDic = this._loadDictionary(dictionary, sPath);
+ this.bPersonalDic = (bActivate) ? Boolean(this.oPersonalDic) : false;
return Boolean(this.oPersonalDic);
}
+
+ activateExtendedDictionary () {
+ this.bExtendedDic = Boolean(this.oExtendedDic);
+ }
+
+ activateCommunityDictionary () {
+ this.bCommunityDic = Boolean(this.oCommunityDic);
+ }
+
+ activatePersonalDictionary () {
+ this.bPersonalDic = Boolean(this.oPersonalDic);
+ }
+
+ deactivateExtendedDictionary () {
+ this.bExtendedDic = false;
+ }
+
+ deactivateCommunityDictionary () {
+ this.bCommunityDic = false;
+ }
+
+ deactivatePersonalDictionary () {
+ this.bPersonalDic = false;
+ }
+
// parse text functions
parseParagraph (sText) {
if (!this.oTokenizer) {
@@ -116,14 +155,17 @@
isValidToken (sToken) {
// checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)
if (this.oMainDic.isValidToken(sToken)) {
return true;
}
- if (this.oExtendedDic && this.oExtendedDic.isValidToken(sToken)) {
+ if (this.bExtendedDic && this.oExtendedDic.isValidToken(sToken)) {
+ return true;
+ }
+ if (this.bCommunityDic && this.oCommunityDic.isValidToken(sToken)) {
return true;
}
- if (this.oPersonalDic && this.oPersonalDic.isValidToken(sToken)) {
+ if (this.bPersonalDic && this.oPersonalDic.isValidToken(sToken)) {
return true;
}
return false;
}
@@ -130,14 +172,17 @@
isValid (sWord) {
// checks if sWord is valid (different casing tested if the first letter is a capital)
if (this.oMainDic.isValid(sWord)) {
return true;
}
- if (this.oExtendedDic && this.oExtendedDic.isValid(sWord)) {
+ if (this.bExtendedDic && this.oExtendedDic.isValid(sWord)) {
+ return true;
+ }
+ if (this.bCommunityDic && this.oCommunityDic.isValid(sToken)) {
return true;
}
- if (this.oPersonalDic && this.oPersonalDic.isValid(sWord)) {
+ if (this.bPersonalDic && this.oPersonalDic.isValid(sWord)) {
return true;
}
return false;
}
@@ -144,52 +189,79 @@
lookup (sWord) {
// checks if sWord is in dictionary as is (strict verification)
if (this.oMainDic.lookup(sWord)) {
return true;
}
- if (this.oExtendedDic && this.oExtendedDic.lookup(sWord)) {
+ if (this.bExtendedDic && this.oExtendedDic.lookup(sWord)) {
+ return true;
+ }
+ if (this.bCommunityDic && this.oCommunityDic.lookup(sToken)) {
return true;
}
- if (this.oPersonalDic && this.oPersonalDic.lookup(sWord)) {
+ if (this.bPersonalDic && this.oPersonalDic.lookup(sWord)) {
return true;
}
return false;
}
getMorph (sWord) {
// retrieves morphologies list, different casing allowed
let lResult = this.oMainDic.getMorph(sWord);
- if (this.oExtendedDic) {
+ if (this.bExtendedDic) {
lResult.push(...this.oExtendedDic.getMorph(sWord));
}
- if (this.oPersonalDic) {
+ if (this.bCommunityDic) {
+ lResult.push(...this.oCommunityDic.getMorph(sWord));
+ }
+ if (this.bPersonalDic) {
lResult.push(...this.oPersonalDic.getMorph(sWord));
}
return lResult;
}
* suggest (sWord, nSuggLimit=10) {
// generator: returns 1, 2 or 3 lists of suggestions
yield this.oMainDic.suggest(sWord, nSuggLimit);
- if (this.oExtendedDic) {
+ if (this.bExtendedDic) {
yield this.oExtendedDic.suggest(sWord, nSuggLimit);
}
- if (this.oPersonalDic) {
+ if (this.bCommunityDic) {
+ yield this.oCommunityDic.suggest(sWord, nSuggLimit);
+ }
+ if (this.bPersonalDic) {
yield this.oPersonalDic.suggest(sWord, nSuggLimit);
}
}
- * select (sPattern="") {
- // generator: returns all entries which morphology fits
- yield* this.oMainDic.select(sPattern)
- if (this.oExtendedDic) {
- yield* this.oExtendedDic.select(sPattern);
- }
- if (this.oPersonalDic) {
- yield* this.oPersonalDic.select(sPattern);
- }
+ * select (sFlexPattern="", sTagsPattern="") {
+ // generator: returns all entries which flexion fits and morphology fits
+ yield* this.oMainDic.select(sFlexPattern, sTagsPattern)
+ if (this.bExtendedDic) {
+ yield* this.oExtendedDic.select(sFlexPattern, sTagsPattern);
+ }
+ if (this.bCommunityDic) {
+ yield* this.oCommunityDic.select(sFlexPattern, sTagsPattern);
+ }
+ if (this.bPersonalDic) {
+ yield* this.oPersonalDic.select(sFlexPattern, sTagsPattern);
+ }
+ }
+
+ getSimilarEntries (sWord, nSuggLimit=10) {
+ // return a list of tuples (similar word, stem, morphology)
+ let lResult = this.oMainDic.getSimilarEntries(sWord, nSuggLimit);
+ if (this.bExtendedDic) {
+ lResult.push(...this.oExtendedDic.getSimilarEntries(sWord, nSuggLimit));
+ }
+ if (this.bCommunityDic) {
+ lResult.push(...this.oCommunityDic.getSimilarEntries(sWord, nSuggLimit));
+ }
+ if (this.bPersonalDic) {
+ lResult.push(...this.oPersonalDic.getSimilarEntries(sWord, nSuggLimit));
+ }
+ return lResult;
}
}
if (typeof(exports) !== 'undefined') {
exports.SpellChecker = SpellChecker;
}
Index: graphspell-js/str_transform.js
==================================================================
--- graphspell-js/str_transform.js
+++ graphspell-js/str_transform.js
@@ -211,8 +211,14 @@
}
};
if (typeof(exports) !== 'undefined') {
+ exports.longestCommonSubstring = str_transform.longestCommonSubstring;
+ exports.distanceDamerauLevenshtein = str_transform.distanceDamerauLevenshtein;
+ exports.distanceDamerauLevenshtein2 = str_transform.distanceDamerauLevenshtein2;
+ exports.showDistance = str_transform.showDistance;
exports.changeWordWithSuffixCode = str_transform.changeWordWithSuffixCode;
exports.changeWordWithAffixCode = str_transform.changeWordWithAffixCode;
+ exports.defineAffixCode = str_transform.defineAffixCode;
+ exports.defineSuffixCode = str_transform.defineSuffixCode;
}
Index: graphspell/dawg.py
==================================================================
--- graphspell/dawg.py
+++ graphspell/dawg.py
@@ -25,11 +25,11 @@
if os.path.isfile(spf):
with open(spf, "r", encoding="utf-8") as hSrc:
for sLine in hSrc:
sLine = sLine.strip()
if sLine and not sLine.startswith("#"):
- yield sLine
+ yield sLine.split("\t")
else:
raise OSError("# Error. File not found or not loadable: " + spf)
@@ -39,11 +39,11 @@
# We store suffix/affix codes and tags within the graph after the “real” word.
# A word is a list of numbers [ c1, c2, c3 . . . cN, iAffix, iTags]
# Each arc is an index in self.lArcVal, where are stored characters, suffix/affix codes for stemming and tags.
# Important: As usual, the last node (after ‘iTags’) is tagged final, AND the node after ‘cN’ is ALSO tagged final.
- def __init__ (self, spfSrc, cStemming, sLangCode, sLangName="", sDicName=""):
+ def __init__ (self, src, cStemming, sLangCode, sLangName="", sDicName=""):
print("===== Direct Acyclic Word Graph - Minimal Acyclic Finite State Automaton =====")
cStemming = cStemming.upper()
if cStemming == "A":
funcStemmingGen = st.defineAffixCode
elif cStemming == "S":
@@ -51,60 +51,59 @@
elif cStemming == "N":
funcStemmingGen = st.noStemming
else:
raise ValueError("# Error. Unknown stemming code: {}".format(cStemming))
- lEntry = []
+ aEntry = set()
lChar = ['']; dChar = {}; nChar = 1; dCharOccur = {}
lAff = []; dAff = {}; nAff = 0; dAffOccur = {}
lTag = []; dTag = {}; nTag = 0; dTagOccur = {}
nErr = 0
-
+
# read lexicon
- for sLine in readFile(spfSrc):
- sFlex, sStem, sTag = sLine.split("\t")
+ if type(src) is str:
+ iterable = readFile(src)
+ else:
+ iterable = src
+ for sFlex, sStem, sTag in iterable:
addWordToCharDict(sFlex)
# chars
for c in sFlex:
if c not in dChar:
dChar[c] = nChar
lChar.append(c)
nChar += 1
dCharOccur[c] = dCharOccur.get(c, 0) + 1
# affixes to find stem from flexion
- aff = funcStemmingGen(sFlex, sStem)
- if aff not in dAff:
- dAff[aff] = nAff
- lAff.append(aff)
+ sAff = funcStemmingGen(sFlex, sStem)
+ if sAff not in dAff:
+ dAff[sAff] = nAff
+ lAff.append(sAff)
nAff += 1
- dAffOccur[aff] = dCharOccur.get(aff, 0) + 1
+ dAffOccur[sAff] = dCharOccur.get(sAff, 0) + 1
# tags
if sTag not in dTag:
dTag[sTag] = nTag
lTag.append(sTag)
nTag += 1
dTagOccur[sTag] = dTagOccur.get(sTag, 0) + 1
- lEntry.append((sFlex, dAff[aff], dTag[sTag]))
- if not lEntry:
+ aEntry.add((sFlex, dAff[sAff], dTag[sTag]))
+ if not aEntry:
raise ValueError("# Error. Empty lexicon")
# Preparing DAWG
print(" > Preparing list of words")
lVal = lChar + lAff + lTag
- lWord = [ [dChar[c] for c in sFlex] + [iAff+nChar] + [iTag+nChar+nAff] for sFlex, iAff, iTag in lEntry ]
- lEntry = None
+ lWord = [ [dChar[c] for c in sFlex] + [iAff+nChar] + [iTag+nChar+nAff] for sFlex, iAff, iTag in aEntry ]
+ aEntry = None
# Dictionary of arc values occurrency, to sort arcs of each node
dValOccur = dict( [ (dChar[c], dCharOccur[c]) for c in dChar ] \
+ [ (dAff[aff]+nChar, dAffOccur[aff]) for aff in dAff ] \
+ [ (dTag[tag]+nChar+nAff, dTagOccur[tag]) for tag in dTag ] )
- #with open(spfSrc[:-8]+".valuesfreq.txt", 'w', encoding='utf-8') as hFreqDst: # DEBUG
- # for iKey, nOcc in sorted(dValOccur.items(), key=lambda t: t[1], reverse=True):
- # hFreqDst.write("{}: {}\n".format(lVal[iKey], nOcc))
- # hFreqDst.close()
- self.sFileName = spfSrc
+ self.sFileName = src if type(src) is str else "[None]"
self.sLangCode = sLangCode
self.sLangName = sLangName
self.sDicName = sDicName
self.nEntry = len(lWord)
self.aPreviousEntry = []
@@ -308,11 +307,11 @@
if not zPattern or zPattern.search(self.lArcVal[nMorphVal]):
yield sEntry + "\t" + self.lArcVal[nMorphVal]
# BINARY CONVERSION
- def createBinary (self, sPathFile, nCompressionMethod, bDebug=False):
+ def _calculateBinary (self, nCompressionMethod):
print(" > Write DAWG as an indexable binary dictionary [method: %d]" % nCompressionMethod)
if nCompressionMethod == 1:
self.nBytesArc = ( (self.nArcVal.bit_length() + 2) // 8 ) + 1 # We add 2 bits. See DawgNode.convToBytes1()
self.nBytesOffset = 0
self._calcNumBytesNodeAddress()
@@ -332,14 +331,10 @@
print(" # Error: unknown compression method")
print(" Arc values (chars, affixes and tags): {} -> {} bytes".format( self.nArcVal, len("\t".join(self.lArcVal).encode("utf-8")) ))
print(" Arc size: {} bytes, Address size: {} bytes -> {} * {} = {} bytes".format( self.nBytesArc, self.nBytesNodeAddress, \
self.nBytesArc+self.nBytesNodeAddress, self.nArc, \
(self.nBytesArc+self.nBytesNodeAddress)*self.nArc ))
- self._writeBinary(sPathFile, nCompressionMethod)
- self._writeAsJSObject(sPathFile, nCompressionMethod)
- if bDebug:
- self._writeNodes(sPathFile, nCompressionMethod)
def _calcNumBytesNodeAddress (self):
"how many bytes needed to store all nodes/arcs in the binary dictionary"
self.nBytesNodeAddress = 1
while ((self.nBytesArc + self.nBytesNodeAddress) * self.nArc) > (2 ** (self.nBytesNodeAddress * 8)):
@@ -387,13 +382,12 @@
nSize -= nDiff
if self.lSortedNodes[i].size != nSize:
self.lSortedNodes[i].size = nSize
bEnd = False
- def _writeAsJSObject (self, spfDst, nCompressionMethod, bInJSModule=False, bBinaryDictAsHexString=True):
- if not spfDst.endswith(".json"):
- spfDst += "."+str(nCompressionMethod)+".json"
+ def getBinaryAsJSON (self, nCompressionMethod=1, bBinaryDictAsHexString=True):
+ self._calculateBinary(nCompressionMethod)
byDic = b""
if nCompressionMethod == 1:
byDic = self.oRoot.convToBytes1(self.nBytesArc, self.nBytesNodeAddress)
for oNode in self.lMinimizedNodes:
byDic += oNode.convToBytes1(self.nBytesArc, self.nBytesNodeAddress)
@@ -403,50 +397,54 @@
byDic += oNode.convToBytes2(self.nBytesArc, self.nBytesNodeAddress)
elif nCompressionMethod == 3:
byDic = self.oRoot.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset)
for oNode in self.lSortedNodes:
byDic += oNode.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset)
+ return {
+ "sHeader": "/grammalecte-fsa/",
+ "sLangCode": self.sLangCode,
+ "sLangName": self.sLangName,
+ "sDicName": self.sDicName,
+ "sFileName": self.sFileName,
+ "sDate": self._getDate(),
+ "nEntry": self.nEntry,
+ "nChar": self.nChar,
+ "nAff": self.nAff,
+ "nTag": self.nTag,
+ "cStemming": self.cStemming,
+ "dChar": self.dChar,
+ "nNode": self.nNode,
+ "nArc": self.nArc,
+ "nArcVal": self.nArcVal,
+ "lArcVal": self.lArcVal,
+ "nCompressionMethod": nCompressionMethod,
+ "nBytesArc": self.nBytesArc,
+ "nBytesNodeAddress": self.nBytesNodeAddress,
+ "nBytesOffset": self.nBytesOffset,
+ # Mozilla’s JS parser don’t like file bigger than 4 Mb!
+ # So, if necessary, we use an hexadecimal string, that we will convert later in Firefox’s extension.
+ # https://github.com/mozilla/addons-linter/issues/1361
+ "sByDic": byDic.hex() if bBinaryDictAsHexString else [ e for e in byDic ]
+ }
+ def writeAsJSObject (self, spfDst, nCompressionMethod, bInJSModule=False, bBinaryDictAsHexString=True):
+ if not spfDst.endswith(".json"):
+ spfDst += "."+str(nCompressionMethod)+".json"
with open(spfDst, "w", encoding="utf-8", newline="\n") as hDst:
if bInJSModule:
hDst.write('// JavaScript\n// Generated data (do not edit)\n\n"use strict";\n\nconst dictionary = ')
- hDst.write(json.dumps({
- "sHeader": "/pyfsa/",
- "sLangCode": self.sLangCode,
- "sLangName": self.sLangName,
- "sDicName": self.sDicName,
- "sFileName": self.sFileName,
- "sDate": self._getDate(),
- "nEntry": self.nEntry,
- "nChar": self.nChar,
- "nAff": self.nAff,
- "nTag": self.nTag,
- "cStemming": self.cStemming,
- "dChar": self.dChar,
- "nNode": self.nNode,
- "nArc": self.nArc,
- "nArcVal": self.nArcVal,
- "lArcVal": self.lArcVal,
- "nCompressionMethod": nCompressionMethod,
- "nBytesArc": self.nBytesArc,
- "nBytesNodeAddress": self.nBytesNodeAddress,
- "nBytesOffset": self.nBytesOffset,
- # JavaScript is a pile of shit, so Mozilla’s JS parser don’t like file bigger than 4 Mb!
- # So, if necessary, we use an hexadecimal string, that we will convert later in Firefox’s extension.
- # https://github.com/mozilla/addons-linter/issues/1361
- "sByDic": byDic.hex() if bBinaryDictAsHexString else [ e for e in byDic ]
- }, ensure_ascii=False))
+ hDst.write( json.dumps(self.getBinaryAsJSON(nCompressionMethod, bBinaryDictAsHexString), ensure_ascii=False) )
if bInJSModule:
hDst.write(";\n\nexports.dictionary = dictionary;\n")
- def _writeBinary (self, sPathFile, nCompressionMethod):
+ def writeBinary (self, sPathFile, nCompressionMethod, bDebug=False):
"""
Format of the binary indexable dictionary:
Each section is separated with 4 bytes of \0
- Section Header:
- /pyfsa/[compression method]
+ /grammalecte-fsa/[compression method]
* compression method is an ASCII string
- Section Informations:
/[lang code]
/[lang name]
@@ -471,15 +469,16 @@
- Section Word Graph (nodes / arcs)
* A list of nodes which are a list of arcs with an address of the next node.
See DawgNode.convToBytes() for details.
"""
+ self._calculateBinary(nCompressionMethod)
if not sPathFile.endswith(".bdic"):
sPathFile += "."+str(nCompressionMethod)+".bdic"
with open(sPathFile, 'wb') as hDst:
# header
- hDst.write("/pyfsa/{}/".format(nCompressionMethod).encode("utf-8"))
+ hDst.write("/grammalecte-fsa/{}/".format(nCompressionMethod).encode("utf-8"))
hDst.write(b"\0\0\0\0")
# infos
sInfo = "{}//{}//{}//{}//{}//{}//{}//{}//{}//{}//{}//{}//".format(self.sLangCode, self.sLangName, self.sDicName, self._getDate(), \
self.nChar, self.nBytesArc, self.nBytesNodeAddress, \
self.nEntry, self.nNode, self.nArc, self.nAff, self.cStemming)
@@ -499,11 +498,12 @@
hDst.write(oNode.convToBytes2(self.nBytesArc, self.nBytesNodeAddress))
elif nCompressionMethod == 3:
hDst.write(self.oRoot.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset))
for oNode in self.lSortedNodes:
hDst.write(oNode.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset))
- hDst.close()
+ if bDebug:
+ self._writeNodes(sPathFile, nCompressionMethod)
def _getDate (self):
return time.strftime("%Y.%m.%d, %H:%M")
def _writeNodes (self, sPathFile, nCompressionMethod):
@@ -522,23 +522,10 @@
if nCompressionMethod == 3:
hDst.write(self.oRoot.getTxtRepr3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset, self.lArcVal)+"\n")
#hDst.write( ''.join( [ "%02X " % z for z in self.oRoot.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset) ] ).strip() )
for oNode in self.lSortedNodes:
hDst.write(oNode.getTxtRepr3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset, self.lArcVal)+"\n")
- hDst.close()
-
- def writeResults (self, sPathFile):
- bFileExits = os.path.isfile("_lexicons.res.txt")
- with open("_lexicons.res.txt", "a", encoding='utf-8', newline="\n") as hDst:
- sFormat1 = "{:<12} {:>12} {:>5} {:>8} {:>8} {:>6} {:>8} {:>9} {:>9} {:>15} {:>12} {:>12}\n"
- sFormat2 = "{:<12} {:>12,} {:>5,} {:>8,} {:>8} {:>6,} {:>8,} {:>9,} {:>9,} {:>15,} {:>12,} {:>12,}\n"
- if not bFileExits:
- hDst.write(sFormat1.format("Lexicon", "Entries", "Chars", "Affixes", "Stemming", "Tags", "Values", "Nodes", "Arcs", "Lexicon (Kb)", "Dict (Kb)", "LT Dict (Kb)"))
- hDst.write(sFormat2.format(self.sLangName, self.nEntry, self.nChar, self.nAff, self.cStemming + "FX", self.nTag, self.nArcVal, \
- self.nNode, self.nArc, os.path.getsize(self.sFileName), os.path.getsize(sPathFile), \
- os.path.getsize("cfsa/dict/{}.dict".format(self.sLangName)) if os.path.isfile("cfsa/dict/{}.dict".format(self.sLangName)) else 0))
- hDst.close()
class DawgNode:
NextId = 0
Index: graphspell/ibdawg.py
==================================================================
--- graphspell/ibdawg.py
+++ graphspell/ibdawg.py
@@ -77,23 +77,26 @@
class IBDAWG:
"""INDEXABLE BINARY DIRECT ACYCLIC WORD GRAPH"""
- def __init__ (self, sfDict):
- self.by = pkgutil.get_data(__package__, "_dictionaries/" + sfDict)
- if not self.by:
- raise OSError("# Error. File not found or not loadable: "+sfDict)
-
- if sfDict.endswith(".bdic"):
- self._initBinary()
- elif sfDict.endswith(".json"):
- self._initJSON()
+ def __init__ (self, source):
+ if type(source) is str:
+ self.by = pkgutil.get_data(__package__, "_dictionaries/" + source)
+ if not self.by:
+ raise OSError("# Error. File not found or not loadable: "+source)
+
+ if source.endswith(".bdic"):
+ self._initBinary()
+ elif source.endswith(".json"):
+ self._initJSON(json.loads(self.by.decode("utf-8"))) #json.loads(self.by) # In Python 3.6, can read directly binary strings
+ else:
+ raise OSError("# Error. Unknown file type: "+source)
else:
- raise OSError("# Error. Unknown file type: "+sfDict)
+ self._initJSON(source)
- self.sFileName = sfDict
+ self.sFileName = source if type(source) is str else "[None]"
self._arcMask = (2 ** ((self.nBytesArc * 8) - 3)) - 1
self._finalNodeMask = 1 << ((self.nBytesArc * 8) - 1)
self._lastArcMask = 1 << ((self.nBytesArc * 8) - 2)
self._addrBitMask = 1 << ((self.nBytesArc * 8) - 3) # version 2
@@ -131,20 +134,20 @@
self.bOptNumSigle = False
self.bOptNumAtLast = False
def _initBinary (self):
"initialize with binary structure file"
- if self.by[0:7] != b"/pyfsa/":
- raise TypeError("# Error. Not a pyfsa binary dictionary. Header: {}".format(self.by[0:9]))
- if not(self.by[7:8] == b"1" or self.by[7:8] == b"2" or self.by[7:8] == b"3"):
- raise ValueError("# Error. Unknown dictionary version: {}".format(self.by[7:8]))
+ if self.by[0:17] != b"/grammalecte-fsa/":
+ raise TypeError("# Error. Not a grammalecte-fsa binary dictionary. Header: {}".format(self.by[0:9]))
+ if not(self.by[17:18] == b"1" or self.by[17:18] == b"2" or self.by[17:18] == b"3"):
+ raise ValueError("# Error. Unknown dictionary version: {}".format(self.by[17:18]))
try:
header, info, values, bdic = self.by.split(b"\0\0\0\0", 3)
except Exception:
raise Exception
- self.nCompressionMethod = int(self.by[7:8].decode("utf-8"))
+ self.nCompressionMethod = int(self.by[17:18].decode("utf-8"))
self.sHeader = header.decode("utf-8")
self.lArcVal = values.decode("utf-8").split("\t")
self.nArcVal = len(self.lArcVal)
self.byDic = bdic
@@ -167,15 +170,15 @@
for i in range(1, self.nChar+1):
self.dChar[self.lArcVal[i]] = i
self.dCharVal = { v: k for k, v in self.dChar.items() }
self.nBytesOffset = 1 # version 3
- def _initJSON (self):
+ def _initJSON (self, oJSON):
"initialize with a JSON text file"
- self.__dict__.update(json.loads(self.by.decode("utf-8")))
- #self.__dict__.update(json.loads(self.by)) # In Python 3.6, can read directly binary strings
+ self.__dict__.update(oJSON)
self.byDic = binascii.unhexlify(self.sByDic)
+ self.dCharVal = { v: k for k, v in self.dChar.items() }
def getInfo (self):
return " Language: {0.sLangName} Lang code: {0.sLangCode} Dictionary name: {0.sDicName}" \
" Compression method: {0.nCompressionMethod:>2} Date: {0.sDate} Stemming: {0.cStemming}FX\n" \
" Arcs values: {0.nArcVal:>10,} = {0.nChar:>5,} characters, {0.nAff:>6,} affixes, {0.nTag:>6,} tags\n" \
@@ -186,11 +189,11 @@
"write IBDAWG as a JavaScript object in a JavaScript module"
with open(spfDest, "w", encoding="utf-8", newline="\n") as hDst:
if bInJSModule:
hDst.write('// JavaScript\n// Generated data (do not edit)\n\n"use strict";\n\nconst dictionary = ')
hDst.write(json.dumps({
- "sHeader": "/pyfsa/",
+ "sHeader": "/grammalecte-fsa/",
"sLangCode": self.sLangCode,
"sLangName": self.sLangName,
"sDicName": self.sDicName,
"sFileName": self.sFileName,
"sDate": self.sDate,
@@ -405,36 +408,51 @@
return
if iPos >= 0:
print("\n "+ " " * iPos + "|")
self.drawPath(sWord[1:], iNextNodeAddr)
- def select (self, sPattern=""):
- "generator: returns all entries which morphology fits "
- zPattern = None
- if sPattern:
- try:
- zPattern = re.compile(sPattern)
- except:
- print("# Error in regex pattern")
- traceback.print_exc()
- yield from self._select1(zPattern, 0, "")
+ def getSimilarEntries (self, sWord, nSuggLimit=10):
+ "return a list of tuples (similar word, stem, morphology)"
+ if not sWord:
+ return []
+ lResult = []
+ for sSimilar in self.suggest(sWord, nSuggLimit):
+ for sMorph in self.getMorph(sSimilar):
+ nCut = sMorph.find(" ")
+ lResult.append( (sSimilar, sMorph[1:nCut], sMorph[nCut+1:]) )
+ return lResult
+
+ def select (self, sFlexPattern="", sTagsPattern=""):
+ "generator: returns all entries which flexion fits and morphology fits "
+ zFlexPattern = None
+ zTagsPattern = None
+ try:
+ if sFlexPattern:
+ zFlexPattern = re.compile(sFlexPattern)
+ if sTagsPattern:
+ zTagsPattern = re.compile(sTagsPattern)
+ except:
+ print("# Error in regex pattern")
+ traceback.print_exc()
+ yield from self._select1(zFlexPattern, zTagsPattern, 0, "")
# def morph (self, sWord):
# is defined in __init__
# VERSION 1
- def _select1 (self, zPattern, iAddr, sWord):
+ def _select1 (self, zFlexPattern, zTagsPattern, iAddr, sWord):
# recursive generator
for nVal, jAddr in self._getArcs1(iAddr):
if nVal <= self.nChar:
# simple character
- yield from self._select1(zPattern, jAddr, sWord + self.lArcVal[nVal])
+ yield from self._select1(zFlexPattern, zTagsPattern, jAddr, sWord + self.lArcVal[nVal])
else:
- sEntry = sWord + "\t" + self.funcStemming(sWord, self.lArcVal[nVal])
- for nMorphVal, _ in self._getArcs1(jAddr):
- if not zPattern or zPattern.search(self.lArcVal[nMorphVal]):
- yield sEntry + "\t" + self.lArcVal[nMorphVal]
+ if not zFlexPattern or zFlexPattern.search(sWord):
+ sStem = self.funcStemming(sWord, self.lArcVal[nVal])
+ for nMorphVal, _ in self._getArcs1(jAddr):
+ if not zTagsPattern or zTagsPattern.search(self.lArcVal[nMorphVal]):
+ yield [sWord, sStem, self.lArcVal[nMorphVal]]
def _morph1 (self, sWord):
"returns morphologies of "
iAddr = 0
for c in sWord:
Index: graphspell/spellchecker.py
==================================================================
--- graphspell/spellchecker.py
+++ graphspell/spellchecker.py
@@ -2,11 +2,12 @@
# Wrapper for the IBDAWG class.
# Useful to check several dictionaries at once.
# To avoid iterating over a pile of dictionaries, it is assumed that 3 are enough:
# - the main dictionary, bundled with the package
-# - the extended dictionary, added by an organization
+# - the extended dictionary
+# - the community dictionary, added by an organization
# - the personal dictionary, created by the user for its own convenience
import traceback
@@ -20,30 +21,34 @@
}
class SpellChecker ():
- def __init__ (self, sLangCode, sfMainDic="", sfExtendedDic="", sfPersonalDic=""):
+ def __init__ (self, sLangCode, sfMainDic="", sfExtendedDic="", sfCommunityDic="", sfPersonalDic=""):
"returns True if the main dictionary is loaded"
self.sLangCode = sLangCode
if not sfMainDic:
sfMainDic = dDefaultDictionaries.get(sLangCode, "")
self.oMainDic = self._loadDictionary(sfMainDic, True)
self.oExtendedDic = self._loadDictionary(sfExtendedDic)
+ self.oCommunityDic = self._loadDictionary(sfCommunityDic)
self.oPersonalDic = self._loadDictionary(sfPersonalDic)
+ self.bExtendedDic = bool(self.oExtendedDic)
+ self.bCommunityDic = bool(self.oCommunityDic)
+ self.bPersonalDic = bool(self.oPersonalDic)
self.oTokenizer = None
- def _loadDictionary (self, sfDictionary, bNecessary=False):
+ def _loadDictionary (self, source, bNecessary=False):
"returns an IBDAWG object"
- if not sfDictionary:
+ if not source:
return None
try:
- return ibdawg.IBDAWG(sfDictionary)
+ return ibdawg.IBDAWG(source)
except Exception as e:
if bNecessary:
- raise Exception(str(e), "Error: <" + sfDictionary + "> not loaded.")
- print("Error: <" + sfDictionary + "> not loaded.")
+ raise Exception(str(e), "Error: <" + str(source) + "> not loaded.")
+ print("Error: <" + str(source) + "> not loaded.")
traceback.print_exc()
return None
def loadTokenizer (self):
self.oTokenizer = tokenizer.Tokenizer(self.sLangCode)
@@ -51,24 +56,51 @@
def getTokenizer (self):
if not self.oTokenizer:
self.loadTokenizer()
return self.oTokenizer
- def setMainDictionary (self, sfDictionary):
+ def setMainDictionary (self, source):
"returns True if the dictionary is loaded"
- self.oMainDic = self._loadDictionary(sfDictionary)
+ self.oMainDic = self._loadDictionary(source, True)
return bool(self.oMainDic)
- def setExtendedDictionary (self, sfDictionary):
+ def setExtendedDictionary (self, source, bActivate=True):
"returns True if the dictionary is loaded"
- self.oExtendedDic = self._loadDictionary(sfDictionary)
+ self.oExtendedDic = self._loadDictionary(source)
+ self.bExtendedDic = False if not bActivate else bool(self.oExtendedDic)
return bool(self.oExtendedDic)
- def setPersonalDictionary (self, sfDictionary):
+ def setCommunityDictionary (self, source, bActivate=True):
+ "returns True if the dictionary is loaded"
+ self.oCommunityDic = self._loadDictionary(source)
+ self.bCommunityDic = False if not bActivate else bool(self.oCommunityDic)
+ return bool(self.oCommunityDic)
+
+ def setPersonalDictionary (self, source, bActivate=True):
"returns True if the dictionary is loaded"
- self.oPersonalDic = self._loadDictionary(sfDictionary)
+ self.oPersonalDic = self._loadDictionary(source)
+ self.bPersonalDic = False if not bActivate else bool(self.oPersonalDic)
return bool(self.oPersonalDic)
+
+ def activateExtendedDictionary (self):
+ self.bExtendedDic = bool(self.oExtendedDic)
+
+ def activateCommunityDictionary (self):
+ self.bCommunityDic = bool(self.oCommunityDic)
+
+ def activatePersonalDictionary (self):
+ self.bPersonalDic = bool(self.oPersonalDic)
+
+ def deactivateExtendedDictionary (self):
+ self.bExtendedDic = False
+
+ def deactivateCommunityDictionary (self):
+ self.bCommunityDic = False
+
+ def deactivatePersonalDictionary (self):
+ self.bPersonalDic = False
+
# parse text functions
def parseParagraph (self, sText, bSpellSugg=False):
if not self.oTokenizer:
@@ -103,67 +135,93 @@
def isValidToken (self, sToken):
"checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)"
if self.oMainDic.isValidToken(sToken):
return True
- if self.oExtendedDic and self.oExtendedDic.isValidToken(sToken):
+ if self.bExtendedDic and self.oExtendedDic.isValidToken(sToken):
+ return True
+ if self.bCommunityDic and self.oCommunityDic.isValidToken(sToken):
return True
- if self.oPersonalDic and self.oPersonalDic.isValidToken(sToken):
+ if self.bPersonalDic and self.oPersonalDic.isValidToken(sToken):
return True
return False
def isValid (self, sWord):
"checks if sWord is valid (different casing tested if the first letter is a capital)"
if self.oMainDic.isValid(sWord):
return True
- if self.oExtendedDic and self.oExtendedDic.isValid(sWord):
+ if self.bExtendedDic and self.oExtendedDic.isValid(sWord):
+ return True
+ if self.bCommunityDic and self.oCommunityDic.isValid(sToken):
return True
- if self.oPersonalDic and self.oPersonalDic.isValid(sWord):
+ if self.bPersonalDic and self.oPersonalDic.isValid(sWord):
return True
return False
def lookup (self, sWord):
"checks if sWord is in dictionary as is (strict verification)"
if self.oMainDic.lookup(sWord):
return True
- if self.oExtendedDic and self.oExtendedDic.lookup(sWord):
+ if self.bExtendedDic and self.oExtendedDic.lookup(sWord):
+ return True
+ if self.bCommunityDic and self.oCommunityDic.lookup(sToken):
return True
- if self.oPersonalDic and self.oPersonalDic.lookup(sWord):
+ if self.bPersonalDic and self.oPersonalDic.lookup(sWord):
return True
return False
def getMorph (self, sWord):
"retrieves morphologies list, different casing allowed"
lResult = self.oMainDic.getMorph(sWord)
- if self.oExtendedDic:
+ if self.bExtendedDic:
lResult.extend(self.oExtendedDic.getMorph(sWord))
- if self.oPersonalDic:
+ if self.bCommunityDic:
+ lResult.extend(self.oCommunityDic.getMorph(sWord))
+ if self.bPersonalDic:
lResult.extend(self.oPersonalDic.getMorph(sWord))
return lResult
def getLemma (self, sWord):
return set([ s[1:s.find(" ")] for s in self.getMorph(sWord) ])
def suggest (self, sWord, nSuggLimit=10):
"generator: returns 1, 2 or 3 lists of suggestions"
yield self.oMainDic.suggest(sWord, nSuggLimit)
- if self.oExtendedDic:
+ if self.bExtendedDic:
yield self.oExtendedDic.suggest(sWord, nSuggLimit)
- if self.oPersonalDic:
+ if self.bCommunityDic:
+ yield self.oCommunityDic.suggest(sWord, nSuggLimit)
+ if self.bPersonalDic:
yield self.oPersonalDic.suggest(sWord, nSuggLimit)
- def select (self, sPattern=""):
- "generator: returns all entries which morphology fits "
- yield from self.oMainDic.select(sPattern)
- if self.oExtendedDic:
- yield from self.oExtendedDic.select(sPattern)
- if self.oPersonalDic:
- yield from self.oPersonalDic.select(sPattern)
+ def select (self, sFlexPattern="", sTagsPattern=""):
+ "generator: returns all entries which flexion fits and morphology fits "
+ yield from self.oMainDic.select(sFlexPattern, sTagsPattern)
+ if self.bExtendedDic:
+ yield from self.oExtendedDic.select(sFlexPattern, sTagsPattern)
+ if self.bCommunityDic:
+ yield from self.oCommunityDic.select(sFlexPattern, sTagsPattern)
+ if self.bPersonalDic:
+ yield from self.oPersonalDic.select(sFlexPattern, sTagsPattern)
def drawPath (self, sWord):
self.oMainDic.drawPath(sWord)
- if self.oExtendedDic:
+ if self.bExtendedDic:
print("-----")
self.oExtendedDic.drawPath(sWord)
- if self.oPersonalDic:
+ if self.bCommunityDic:
+ print("-----")
+ self.oCommunityDic.drawPath(sWord)
+ if self.bPersonalDic:
print("-----")
self.oPersonalDic.drawPath(sWord)
+
+ def getSimilarEntries (self, sWord, nSuggLimit=10):
+ "return a list of tuples (similar word, stem, morphology)"
+ lResult = self.oMainDic.getSimilarEntries(sWord, nSuggLimit)
+ if self.bExtendedDic:
+ lResult.extend(self.oExtendedDic.getSimilarEntries(sWord, nSuggLimit))
+ if self.bCommunityDic:
+ lResult.extend(self.oCommunityDic.getSimilarEntries(sWord, nSuggLimit))
+ if self.bPersonalDic:
+ lResult.extend(self.oPersonalDic.getSimilarEntries(sWord, nSuggLimit))
+ return lResult
Index: lex_build.py
==================================================================
--- lex_build.py
+++ lex_build.py
@@ -12,11 +12,11 @@
def build (spfSrc, sLangCode, sLangName, sfDict, bJSON=False, sDicName="", cStemmingMethod="S", nCompressMethod=1):
"transform a text lexicon as a binary indexable dictionary"
oDAWG = fsa.DAWG(spfSrc, cStemmingMethod, sLangCode, sLangName, sDicName)
dir_util.mkpath("graphspell/_dictionaries")
oDAWG.writeInfo("graphspell/_dictionaries/" + sfDict + ".info.txt")
- oDAWG.createBinary("graphspell/_dictionaries/" + sfDict + ".bdic", int(nCompressMethod))
+ oDAWG.writeBinary("graphspell/_dictionaries/" + sfDict + ".bdic", int(nCompressMethod))
if bJSON:
dir_util.mkpath("graphspell-js/_dictionaries")
oDic = IBDAWG(sfDict + ".bdic")
oDic.writeAsJSObject("graphspell-js/_dictionaries/" + sfDict + ".json", bBinaryDictAsHexString=True)
Index: make.py
==================================================================
--- make.py
+++ make.py
@@ -84,10 +84,11 @@
# Extension files
hZip.writestr("META-INF/manifest.xml", helpers.fileFile("gc_core/py/oxt/manifest.xml", dVars))
hZip.writestr("description.xml", helpers.fileFile("gc_core/py/oxt/description.xml", dVars))
hZip.writestr("Linguistic.xcu", helpers.fileFile("gc_core/py/oxt/Linguistic.xcu", dVars))
hZip.writestr("Grammalecte.py", helpers.fileFile("gc_core/py/oxt/Grammalecte.py", dVars))
+ hZip.writestr("pythonpath/helpers.py", helpers.fileFile("gc_core/py/oxt/helpers.py", dVars))
for sf in dVars["extras"].split(","):
hZip.writestr(sf.strip(), helpers.fileFile(spLang + '/' + sf.strip(), dVars))
if "logo" in dVars.keys() and dVars["logo"].strip():
@@ -304,20 +305,24 @@
if not os.path.isdir("graphspell-js/"+sf):
file_util.copy_file("graphspell-js/"+sf, "grammalecte-js/graphspell")
helpers.copyAndFileTemplate("graphspell-js/"+sf, "grammalecte-js/graphspell/"+sf, dVars)
-def copyGraphspellDictionaries (dVars, bJavaScript=False, bExtendedDict=False, bPersonalDict=False):
+def copyGraphspellDictionaries (dVars, bJavaScript=False, bExtendedDict=False, bCommunityDict=False, bPersonalDict=False):
dVars["dic_main_filename_py"] = ""
dVars["dic_main_filename_js"] = ""
dVars["dic_extended_filename_py"] = ""
dVars["dic_extended_filename_js"] = ""
+ dVars["dic_community_filename_py"] = ""
+ dVars["dic_community_filename_js"] = ""
dVars["dic_personal_filename_py"] = ""
dVars["dic_personal_filename_js"] = ""
lDict = [ ("main", dVars['dic_filename']) ]
if bExtendedDict:
lDict.append(("extended", dVars['dic_extended_filename']))
+ if bCommunityDict:
+ lDict.append(("community", dVars['dic_community_filename']))
if bPersonalDict:
lDict.append(("personal", dVars['dic_personal_filename']))
for sType, sFileName in lDict:
spfPyDic = "graphspell/_dictionaries/" + sFileName + ".bdic"
spfJSDic = "graphspell-js/_dictionaries/" + sFileName + ".json"
@@ -338,10 +343,14 @@
sDicName = dVars['dic_name']
elif sType == "extended":
spfLexSrc = dVars['lexicon_extended_src']
sfDictDst = dVars['dic_extended_filename']
sDicName = dVars['dic_extended_name']
+ elif sType == "community":
+ spfLexSrc = dVars['lexicon_community_src']
+ sfDictDst = dVars['dic_community_filename']
+ sDicName = dVars['dic_community_name']
elif sType == "personal":
spfLexSrc = dVars['lexicon_personal_src']
sfDictDst = dVars['dic_personal_filename']
sDicName = dVars['dic_personal_name']
lex_build.build(spfLexSrc, dVars['lang'], dVars['lang_name'], sfDictDst, bJavaScript, sDicName, dVars['stemming_method'], int(dVars['fsa_method']))
@@ -359,10 +368,11 @@
xParser.add_argument("-t", "--tests", help="run unit tests", action="store_true")
xParser.add_argument("-p", "--perf", help="run performance tests", action="store_true")
xParser.add_argument("-pm", "--perf_memo", help="run performance tests and store results in perf_memo.txt", action="store_true")
xParser.add_argument("-js", "--javascript", help="JavaScript build for Firefox", action="store_true")
xParser.add_argument("-aed", "--add_extended_dictionary", help="add extended dictionary to the build", action="store_true")
+ xParser.add_argument("-acd", "--add_community_dictionary", help="add community dictionary to the build", action="store_true")
xParser.add_argument("-apd", "--add_personal_dictionary", help="add personal dictionary to the build", action="store_true")
xParser.add_argument("-fx", "--firefox", help="Launch Firefox Developper for WebExtension testing", action="store_true")
xParser.add_argument("-we", "--web_ext", help="Launch Firefox Nightly for WebExtension testing", action="store_true")
xParser.add_argument("-tb", "--thunderbird", help="Launch Thunderbird", action="store_true")
xParser.add_argument("-i", "--install", help="install the extension in Writer (path of unopkg must be set in config.ini)", action="store_true")
@@ -384,10 +394,12 @@
xConfig = getConfig(sLang)
dVars = xConfig._sections['args']
if not dVars["lexicon_extended_src"]:
xArgs.add_extended_dictionary = False
+ if not dVars["lexicon_community_src"]:
+ xArgs.add_community_dictionary = False
if not dVars["lexicon_personal_src"]:
xArgs.add_personal_dictionary = False
# build data
build_data_module = None
@@ -401,17 +413,19 @@
build_data_module.before('gc_lang/'+sLang, dVars, xArgs.javascript)
if xArgs.dict:
buildDictionary(dVars, "main", xArgs.javascript)
if xArgs.add_extended_dictionary:
buildDictionary(dVars, "extended", xArgs.javascript)
+ if xArgs.add_community_dictionary:
+ buildDictionary(dVars, "community", xArgs.javascript)
if xArgs.add_personal_dictionary:
buildDictionary(dVars, "personal", xArgs.javascript)
if build_data_module and xArgs.build_data_after:
build_data_module.after('gc_lang/'+sLang, dVars, xArgs.javascript)
# copy dictionaries from Graphspell
- copyGraphspellDictionaries(dVars, xArgs.javascript, xArgs.add_extended_dictionary, xArgs.add_personal_dictionary)
+ copyGraphspellDictionaries(dVars, xArgs.javascript, xArgs.add_extended_dictionary, xArgs.add_community_dictionary, xArgs.add_personal_dictionary)
# make
sVersion = create(sLang, xConfig, xArgs.install, xArgs.javascript, )
# tests
Grammalecte remercie
+Grammalecte remercie
et tous ceux qui l’ont soutenu
@@ -87,10 +90,12 @@Raccourcis clavier
CTRL+MAJ+6
Conjugueur (dans un onglet)
CTRL+MAJ+7
Conjugueur (dans une fenêtre)
+CTRL+MAJ+8
+Éditeur lexical
OPTIONS GRAMMATICALES
@@ -97,14 +102,36 @@
${webextOptionsHTML}
OPTIONS ORTHOGRAPHIQUES
-
-
Index: gc_lang/fr/webext/panel/main.js
==================================================================
--- gc_lang/fr/webext/panel/main.js
+++ gc_lang/fr/webext/panel/main.js
@@ -52,10 +52,20 @@
sCommand: "setOption",
dParam: {sOptName: xElem.dataset.option, bValue: xElem.checked},
dInfo: {}
});
}
+ }
+ else if (xElem.id.endsWith("_dic")) {
+ if (xElem.dataset.dictionary) {
+ storeSCOptions();
+ browser.runtime.sendMessage({
+ sCommand: "setDictionaryOnOff",
+ dParam: {sDictionary: xElem.dataset.dictionary, bActivate: xElem.checked},
+ dInfo: {}
+ });
+ }
}
else if (xElem.id.startsWith("ui_option_")) {
storeUIOptions();
}
else if (xElem.id.startsWith("link_")) {
@@ -132,10 +142,13 @@
displayGCOptionsLoadedFromStorage();
}
else if (sPageName == "ui_options_page") {
displayUIOptionsLoadedFromStorage();
}
+ else if (sPageName == "sc_options_page") {
+ displaySCOptionsLoadedFromStorage();
+ }
}
catch (e) {
showError(e);
}
}
@@ -156,15 +169,27 @@
url: browser.extension.getURL("panel/conjugueur.html")
});
xConjTab.then(onCreated, onError);
}
+function openConjugueurTab () {
+ if (bChrome) {
+ browser.tabs.create({
+ url: browser.extension.getURL("panel/conjugueur.html")
+ });
+ return;
+ }
+ let xConjTab = browser.tabs.create({
+ url: browser.extension.getURL("panel/conjugueur.html")
+ });
+ xConjTab.then(onCreated, onError);
+}
+
/*
UI options
*/
-
function displayUIOptionsLoadedFromStorage () {
if (bChrome) {
browser.storage.local.get("ui_options", displayUIOptions);
return;
}
@@ -185,12 +210,44 @@
}
}
function storeUIOptions () {
browser.storage.local.set({"ui_options": {
- textarea: ui_option_textarea.checked,
- editablenode: ui_option_editablenode.checked
+ textarea: document.getElementById("ui_option_textarea").checked,
+ editablenode: document.getElementById("ui_option_editablenode").checked
+ }});
+}
+
+
+/*
+ SC Options
+*/
+function displaySCOptionsLoadedFromStorage () {
+ if (bChrome) {
+ browser.storage.local.get("sc_options", displaySCOptions);
+ return;
+ }
+ let xPromise = browser.storage.local.get("sc_options");
+ xPromise.then(displaySCOptions, showError);
+}
+
+function displaySCOptions (dOptions) {
+ if (!dOptions.hasOwnProperty("sc_options")) {
+ console.log("no sc options found");
+ return;
+ }
+ dOptions = dOptions.sc_options;
+ //document.getElementById("extended_dic").checked = dOptions.extended_dic;
+ //document.getElementById("community_dic").checked = dOptions.community_dic;
+ document.getElementById("personal_dic").checked = dOptions.personal;
+}
+
+function storeSCOptions () {
+ browser.storage.local.set({"sc_options": {
+ extended: false,
+ community: false,
+ personal: document.getElementById("personal_dic").checked
}});
}
/*
Index: grammalecte-cli.py
==================================================================
--- grammalecte-cli.py
+++ grammalecte-cli.py
@@ -188,12 +188,20 @@
for lSugg in oSpellChecker.suggest(sWord):
echo(" | ".join(lSugg))
elif sText.startswith(">"):
oSpellChecker.drawPath(sText[1:].strip())
elif sText.startswith("="):
- for sRes in oSpellChecker.select(sText[1:].strip()):
- echo(sRes)
+ sSearch = sText[1:].strip()
+ if "=" in sSearch:
+ nCut = sSearch.find("=")
+ sFlexPattern = sSearch[0:nCut]
+ sTagsPattern = sSearch[nCut+1:]
+ else:
+ sFlexPattern = sSearch
+ sTagsPattern = ""
+ for aRes in oSpellChecker.select(sFlexPattern, sTagsPattern):
+ echo("\t".join(aRes))
elif sText.startswith("/+ "):
oGrammarChecker.gce.setOptions({ opt:True for opt in sText[3:].strip().split() if opt in oGrammarChecker.gce.getOptions() })
echo("done")
elif sText.startswith("/- "):
oGrammarChecker.gce.setOptions({ opt:False for opt in sText[3:].strip().split() if opt in oGrammarChecker.gce.getOptions() })
Index: graphspell-js/dawg.js
==================================================================
--- graphspell-js/dawg.js
+++ graphspell-js/dawg.js
@@ -78,10 +78,14 @@
lEntry.push([sFlex, dAff.get(sAff), dTag.get(sTag)]);
}
if (lEntry.length == 0) {
throw "Error. Empty lexicon";
}
+
+ lEntry = [...new Set(lEntry.map(e => JSON.stringify(e)))].map(s => JSON.parse(s));
+ // Set can’t distinguish similar lists, so we transform list item in string given to the Set
+ // then we transform items in list a new.
// Preparing DAWG
console.log(" > Preparing list of words");
let lVal = lChar.concat(lAff).concat(lTag);
let lWord = [];
@@ -370,11 +374,11 @@
for (let oNode of this.dMinimizedNodes.values()) {
sByDic += oNode.convToBytes1(this.nBytesArc, this.nBytesNodeAddress);
}
}
let oJSON = {
- "sHeader": "/pyfsa/",
+ "sHeader": "/grammalecte-fsa/",
"sLangCode": this.sLangCode,
"sLangName": this.sLangName,
"sDicName": this.sDicName,
"sFileName": "[none]",
"sDate": this._getDate(),
Index: graphspell-js/ibdawg.js
==================================================================
--- graphspell-js/ibdawg.js
+++ graphspell-js/ibdawg.js
@@ -117,12 +117,12 @@
}
this.byDic = lTemp;
//this.byDic = new Uint8Array(lTemp); // not quicker, even slower
/* end of bug workaround */
- if (!this.sHeader.startsWith("/pyfsa/")) {
- throw TypeError("# Error. Not a pyfsa binary dictionary. Header: " + this.sHeader);
+ if (!this.sHeader.startsWith("/grammalecte-fsa/")) {
+ throw TypeError("# Error. Not a grammalecte-fsa binary dictionary. Header: " + this.sHeader);
}
if (!(this.nCompressionMethod == 1 || this.nCompressionMethod == 2 || this.nCompressionMethod == 3)) {
throw RangeError("# Error. Unknown dictionary compression method: " + this.nCompressionMethod);
}
// Section inactive. Le système d’extension WebExtension ne propose pas encore d’interface de programmation pour le correcteur orthographique.
+
+
+
+
DICTIONNAIRES DE GRAMMALECTE
+Les dictionnaires de Grammalecte ne sont utilisées que lors de l’analyse grammaticale.
+
+
+ +
Environ 83 000 entrées, 500 000 flexions.
Ni éditable, ni désactivable.
+
+ +
Fonctionnalité à venir.
+
+
+ +
Fonctionnalité à venir.
+
+
+ +
Ce dictionnaire est créé et édité via l’éditeur lexical.
+