Index: gc_core/js/lang_core/gc_engine.js ================================================================== --- gc_core/js/lang_core/gc_engine.js +++ gc_core/js/lang_core/gc_engine.js @@ -91,10 +91,14 @@ if (!bParagraph) { return gc_rules.lSentenceRules; } return gc_rules.lParagraphRules; }, + + getIgnoreRules: function (bParagraph) { + return gc_rules._aIgnoredRules; + }, ignoreRule: function (sRuleId) { _aIgnoredRules.add(sRuleId); }, @@ -1415,10 +1419,11 @@ exports._zEndOfSentence = gc_engine._zEndOfSentence; exports._zBeginOfParagraph = gc_engine._zBeginOfParagraph; exports._zEndOfParagraph = gc_engine._zEndOfParagraph; exports.getSentenceBoundaries = gc_engine.getSentenceBoundaries; // rules + exports.getIgnoreRules = gc_engine.getIgnoreRules; exports.ignoreRule = gc_engine.ignoreRule; exports.resetIgnoreRules = gc_engine.resetIgnoreRules; exports.reactivateRule = gc_engine.reactivateRule; exports.listRules = gc_engine.listRules; exports.getRules = gc_engine.getRules; Index: gc_lang/fr/nodejs/cli/bin/gramma-cli.js ================================================================== --- gc_lang/fr/nodejs/cli/bin/gramma-cli.js +++ gc_lang/fr/nodejs/cli/bin/gramma-cli.js @@ -14,10 +14,12 @@ https://stackoverflow.com/questions/41058569/what-is-the-difference-between-const-and-const-in-javascript */ const argCmd = require("../lib/minimist.js")(process.argv.slice(2)); const { performance } = require("perf_hooks"); +const path = require("path"); +const fs = require("fs"); //Initialisation des messages const msgStart = "\x1b[31mBienvenue sur Grammalecte pour NodeJS!!!\x1b[0m\n"; const msgPrompt = "\x1b[36mGrammaJS\x1b[33m>\x1b[0m "; const msgSuite = "\x1b[33m…\x1b[0m "; @@ -109,10 +111,16 @@ short: "", arg: "+/-name", description: "Définit les options à utiliser par le correcteur grammatical.", execute: "" }, + gcerule: { + short: "", + arg: "+/-name", + description: "Définit les règles à exclure par le correcteur grammatical.", + execute: "" + }, tfoption: { short: "", arg: "+/-name", description: "Définit les options à utiliser par le formateur de texte.", execute: "" @@ -159,11 +167,11 @@ } function repToText(oRep) { //console.log(oRep); let repText = ""; - for (const action of ["json", "perf", "gceoption", "tfoption"]) { + for (const action of ["json", "perf", "gceoption", "tfoption", "gcerule", "dicomain", "dicoperso"]) { if (action in oRep) { repText += toTitle(action) + " " + oRep[action]; } } @@ -295,11 +303,11 @@ numRep1++; if (numRep1 == replength) { ascii1 = "└"; ascii1a = " "; } - repText += "\n " + ascii1 + " " + gramma.nStart + "->" + gramma.nEnd + " " + gramma.sMessage; + repText += "\n " + ascii1 + " " + gramma.nStart + "->" + gramma.nEnd + " [" + gramma.sRuleId + "]\n " + ascii1a + " " + gramma.sMessage; ascii2 = "├"; numRep2 = 0; for (let suggestion of gramma.aSuggestions) { numRep2++; if (numRep2 == gramma.aSuggestions.length) { @@ -408,13 +416,29 @@ repPreference[action] = getArgVal(aArg, [action]); repAction[action] = repPreference[action] ? "ON" : "OFF"; } } - for (const action of ["gceoption", "tfoption"]) { + if (getArg(aArg, ["dicomain"])) { + let filename = sText.endsWith(".json") ? sText : sText + ".json"; + repAction["dicomain"] = "Chargement du dictionnaire principal " + (oGrammarChecker.setMainDictionary(filename) ? "OK" : "Pas OK"); + } + + if (getArg(aArg, ["dicoperso"])) { + let pathnormalized = path.normalize(sText); + if (fs.existsSync(pathnormalized)) { + let filename = path.basename(pathnormalized); + let dirname = path.dirname(pathnormalized); + repAction["dicoperso"] = "Chargement du dictionnaire personnel " + (oGrammarChecker.setPersonalDictionary(filename, dirname) ? "OK" : "Pas OK"); + } else { + repAction["dicoperso"] = "Le fichier de dictionnaire n'existe pas."; + } + } + + for (const action of ["gceoption", "tfoption", "gcerule"]) { if (getArg(aArg, [action])) { - let sFonction = action == "gceoption" ? "GceOption" : "TfOption"; + let sFonction = action == "gceoption" ? "GceOption" : action == "tfoption" ? "TfOption" : "GceIgnoreRule"; let sOpt = sText.split(" "); if (sOpt[0] == "reset") { oGrammarChecker["reset" + sFonction + "s"](); repAction[action] = "reset"; } else { Index: gc_lang/fr/nodejs/cli/readme.md ================================================================== --- gc_lang/fr/nodejs/cli/readme.md +++ gc_lang/fr/nodejs/cli/readme.md @@ -27,10 +27,11 @@ | spell | mot | Vérifie l’existence d'un mot. | | suggest | mot | Suggestion des orthographes possible d’un mot. | | morph | mot | Affiche les informations pour un mot. | | lemma | mot | Donne le lemme d’un mot. | | gceoption | +/-name | Définit les options à utiliser par le correcteur grammatical. | +| gcerule | +/-name | Définit les règles à exclure par le correcteur grammatical. | | tfoption | +/-name | Définit les options à utiliser par le formateur de texte. | ## Client interactif Le mode interactif est un mode question/réponse. Pour le lancer vous devez saisir `gramma-cli -i`. Index: gc_lang/fr/nodejs/core/api.js ================================================================== --- gc_lang/fr/nodejs/core/api.js +++ gc_lang/fr/nodejs/core/api.js @@ -8,11 +8,10 @@ /* global require, exports, console */ "use strict"; class GrammarChecker { - constructor(aInit, sLangCode = "fr", sContext = "Javascript") { this.sLangCode = sLangCode; this.sContext = sContext; //Importation des fichiers nécessaire @@ -25,22 +24,22 @@ Tokenizer: false, TextFormatter: false, Lexicographer: false }; - if (aInit){ + if (aInit) { this.load(aInit); } } //Auto-chargement avec dépendence - load(aInit = ["Grammalecte", "Graphspell", "TextFormatter", "Lexicographer", "Tokenizer"]){ + load(aInit = ["Grammalecte", "Graphspell", "TextFormatter", "Lexicographer", "Tokenizer"]) { //aInit permet de charger que certain composant // => évite de charger toutes données si par exemple on a besoin que du lexigraphe // => sorte de gestionnaire de dépendence (peut être amélioré) this.isInit = {}; - if ( aInit.indexOf("Grammalecte") !== false ){ + if (aInit.indexOf("Grammalecte") !== false) { //console.log('init Grammalecte'); this._oGce = require(this.sPathRoot + "/fr/gc_engine.js"); this._oGce.load(this.sContext); this.isInit.Grammalecte = true; this.oSpellChecker = this._oGce.getSpellChecker(); @@ -47,34 +46,34 @@ this.isInit.Graphspell = true; this.oTokenizer = this.oSpellChecker.getTokenizer(); this.isInit.Tokenizer = true; } - if ( !this.isInit.Graphspell && (aInit.indexOf("Graphspell") !== false || aInit.indexOf("Lexicographer") !== false)){ + if (!this.isInit.Graphspell && (aInit.indexOf("Graphspell") !== false || aInit.indexOf("Lexicographer") !== false)) { //console.log('init Graphspell'); this._SpellChecker = require(this.sPathRoot + "/graphspell/spellchecker.js"); this.oSpellChecker = new this._SpellChecker.SpellChecker(this.sLangCode, this.sPathRoot + "/graphspell/_dictionaries"); this.isInit.Graphspell = true; this.oTokenizer = this.oSpellChecker.getTokenizer(); this.isInit.Tokenizer = true; } - if ( !this.isInit.Tokenizer && aInit.indexOf("Tokenizer") !== false ){ + if (!this.isInit.Tokenizer && aInit.indexOf("Tokenizer") !== false) { //console.log('init Tokenizer'); this._Tokenizer = require(this.sPathRoot + "/graphspell/tokenizer.js"); this.oTokenizer = new this._Tokenizer.Tokenizer(this.sLangCode); this.isInit.Tokenizer = true; } - if ( aInit.indexOf("TextFormatter") !== false ){ + if (aInit.indexOf("TextFormatter") !== false) { //console.log('init TextFormatter'); this._oText = require(this.sPathRoot + "/fr/textformatter.js"); this.oTextFormatter = new this._oText.TextFormatter(); this.isInit.TextFormatter = true; } - if ( aInit.indexOf("Lexicographer") !== false ){ + if (aInit.indexOf("Lexicographer") !== false) { //console.log('init Lexicographer'); this._oLex = require(this.sPathRoot + "/fr/lexicographe.js"); this.oLexicographer = new this._oLex.Lexicographe( this.oSpellChecker, this.oTokenizer, @@ -83,39 +82,39 @@ this.isInit.Lexicographer = true; } } //Fonctions concernant: Grammalecte - getGrammalecte(){ + getGrammalecte() { if (!this.isInit.Grammalecte) { this.load(["Grammalecte"]); } return this._oGce; } - gramma(sText){ + gramma(sText) { if (!this.isInit.Grammalecte) { this.load(["Grammalecte"]); } return Array.from(this._oGce.parse(sText, this.sLangCode)); } - getGceOptions () { + getGceOptions() { if (!this.isInit.Grammalecte) { this.load(["Grammalecte"]); } return this._helpers.mapToObject(this._oGce.getOptions()); } - getGceDefaultOptions () { + getGceDefaultOptions() { if (!this.isInit.Grammalecte) { this.load(["Grammalecte"]); } return this._helpers.mapToObject(this._oGce.getDefaultOptions()); } - setGceOptions (dOptions) { + setGceOptions(dOptions) { if (!this.isInit.Grammalecte) { this.load(["Grammalecte"]); } if (!(dOptions instanceof Map)) { dOptions = this._helpers.objectToMap(dOptions); @@ -122,11 +121,11 @@ } this._oGce.setOptions(dOptions); return this._helpers.mapToObject(this._oGce.getOptions()); } - setGceOption (sOptName, bValue) { + setGceOption(sOptName, bValue) { if (!this.isInit.Grammalecte) { this.load(["Grammalecte"]); } if (sOptName) { this._oGce.setOption(sOptName, bValue); @@ -133,31 +132,86 @@ return this._helpers.mapToObject(this._oGce.getOptions()); } return false; } - resetGceOptions () { + resetGceOptions() { if (!this.isInit.Grammalecte) { this.load(["Grammalecte"]); } this._oGce.resetOptions(); return this._helpers.mapToObject(this._oGce.getOptions()); } + + getGceRules(bParagraph) { + if (!this.isInit.Grammalecte) { + this.load(["Grammalecte"]); + } + return this._oGce.getRules(bParagraph); + } + + getGceIgnoreRules() { + if (!this.isInit.Grammalecte) { + this.load(["Grammalecte"]); + } + return Array.from(this._oGce.getIgnoreRules()); + } + + setGceIgnoreRules(dRules) { + if (!this.isInit.Grammalecte) { + this.load(["Grammalecte"]); + } + if (!(dRules instanceof Set)) { + dRules = new Set(dRules); + } + this._oGce._aIgnoredRules = dRules; + return Array.from(this._oGce.getIgnoreRules()); + } + + setGceIgnoreRule(sRuleId, bValue) { + if (!this.isInit.Grammalecte) { + this.load(["Grammalecte"]); + } + if (bValue) { + //Add + this._oGce.ignoreRule(sRuleId); + } else { + //Delete + this._oGce.reactivateRule(sRuleId); + } + return Array.from(this._oGce.getIgnoreRules()); + } + + resetGceIgnoreRules() { + if (!this.isInit.Grammalecte) { + this.load(["Grammalecte"]); + } + this._oGce.resetIgnoreRules(); + return Array.from(this._oGce.getIgnoreRules()); + } //Fonctions concernant: Graphspell - getGraphspell(){ + getGraphspell() { if (!this.isInit.Graphspell) { this.load(["Graphspell"]); } return this.oSpellChecker; } - spellParagraph(sText, bSuggest = true){ + setMainDictionary(dictionary, sPath = "") { + return this.oSpellChecker.setMainDictionary(dictionary, sPath); + } + + setPersonalDictionary(dictionary, sPath = "", bActivate = true) { + return this.oSpellChecker.setPersonalDictionary(dictionary, sPath, bActivate); + } + + spellParagraph(sText, bSuggest = true) { if (!this.isInit.Graphspell) { this.load(["Graphspell"]); } - if (bSuggest){ + if (bSuggest) { let lError = this.oSpellChecker.parseParagraph(sText); for (let token of lError) { token.aSuggestions = this.suggest(token.sValue); } return lError; @@ -164,23 +218,23 @@ } else { return this.oSpellChecker.parseParagraph(sText); } } - spell(sWord){ + spell(sWord) { if (!this.isInit.Graphspell) { this.load(["Graphspell"]); } return this.oSpellChecker.isValid(sWord); } - suggest(sWord, nbLimit = 10, bMerge = true){ + suggest(sWord, nbLimit = 10, bMerge = true) { if (!this.isInit.Graphspell) { this.load(["Graphspell"]); } let lSuggest = this.oSpellChecker.suggest(sWord, nbLimit); - if (bMerge){ + if (bMerge) { let lSuggestRep = []; for (let lSuggestTmp of lSuggest) { for (let word of lSuggestTmp) { lSuggestRep.push(word); } @@ -187,51 +241,50 @@ } return lSuggestRep; } else { return Array.from(lSuggest); } - } - lemma(sWord){ + lemma(sWord) { if (!this.isInit.Graphspell) { this.load(["Graphspell"]); } return this.oSpellChecker.getLemma(sWord); } - morph(sWord){ + morph(sWord) { if (!this.isInit.Graphspell) { this.load(["Graphspell"]); } return this.oSpellChecker.getMorph(sWord); } //Fonctions concernant: Lexicographer - getLexicographer(){ + getLexicographer() { if (!this.isInit.Lexicographer) { this.load(["Lexicographer"]); } return this.oLexicographer; } - lexique(sText){ + lexique(sText) { if (!this.isInit.Lexicographer) { this.load(["Lexicographer"]); } return this.oLexicographer.getListOfTokensReduc(sText); } //Fonctions concernant: TextFormatter - getTextFormatter(){ + getTextFormatter() { if (!this.isInit.TextFormatter) { this.load(["TextFormatter"]); } return this.oTextFormatter; } - formatText(sText){ + formatText(sText) { if (!this.isInit.TextFormatter) { this.load(["TextFormatter"]); } return this.oTextFormatter.formatText(sText); } @@ -264,20 +317,19 @@ this.oTextFormatter.setOptions(optionsTF); return this._helpers.mapToObject(this.oTextFormatter.getOptions()); } //fonctions concernant plussieurs parties - verifParagraph(sText, bSuggest = true){ + verifParagraph(sText, bSuggest = true) { if (!this.isInit.Grammalecte || !this.isInit.Graphspell) { this.load(["Grammalecte"]); } return { lGrammarErrors: Array.from(this._oGce.parse(sText, this.sLangCode)), lSpellingErrors: this.spellParagraph(sText, bSuggest) }; } - } if (typeof exports !== "undefined") { exports.GrammarChecker = GrammarChecker; }