Grammalecte  Changes On Branch 8959d8c2beb0cdba

Changes In Branch nodejs Through [8959d8c2be] Excluding Merge-Ins

This is equivalent to a diff from 453f4dcb62 to 8959d8c2be

2018-10-22
11:08
[fr] nouvelles règles diverses check-in: 09466339c5 user: olr tags: fr, trunk
2018-10-21
22:10
[njs] cli possibility to change main and personal dictionary check-in: e22e75159b user: IllusionPerdu tags: nodejs
21:45
[njs] core add Set Dictionary for main and personal check-in: 8959d8c2be user: IllusionPerdu tags: nodejs
17:31
[njs] Cli update doc with new command check-in: c4df2bb8f2 user: IllusionPerdu tags: nodejs
14:37
Sync to trunk check-in: 18924f57b4 user: IllusionPerdu tags: nodejs
2018-10-20
12:52
[fr] amélioration: quel +être +det check-in: 453f4dcb62 user: olr tags: fr, trunk
12:37
[fx] update manifest.json check-in: 0927ac4d38 user: olr tags: fx, trunk

Modified gc_core/js/lang_core/gc_engine.js from [5c503d2a3c] to [8734a07c32].

    89     89   
    90     90       getRules: function (bParagraph) {
    91     91           if (!bParagraph) {
    92     92               return gc_rules.lSentenceRules;
    93     93           }
    94     94           return gc_rules.lParagraphRules;
    95     95       },
           96  +
           97  +    getIgnoreRules: function (bParagraph) {
           98  +        return gc_rules._aIgnoredRules;
           99  +    },
    96    100   
    97    101       ignoreRule: function (sRuleId) {
    98    102           _aIgnoredRules.add(sRuleId);
    99    103       },
   100    104   
   101    105       resetIgnoreRules: function () {
   102    106           _aIgnoredRules.clear();
................................................................................
  1413   1417       exports.getSpellChecker = gc_engine.getSpellChecker;
  1414   1418       // sentence
  1415   1419       exports._zEndOfSentence = gc_engine._zEndOfSentence;
  1416   1420       exports._zBeginOfParagraph = gc_engine._zBeginOfParagraph;
  1417   1421       exports._zEndOfParagraph = gc_engine._zEndOfParagraph;
  1418   1422       exports.getSentenceBoundaries = gc_engine.getSentenceBoundaries;
  1419   1423       // rules
         1424  +    exports.getIgnoreRules = gc_engine.getIgnoreRules;
  1420   1425       exports.ignoreRule = gc_engine.ignoreRule;
  1421   1426       exports.resetIgnoreRules = gc_engine.resetIgnoreRules;
  1422   1427       exports.reactivateRule = gc_engine.reactivateRule;
  1423   1428       exports.listRules = gc_engine.listRules;
  1424   1429       exports.getRules = gc_engine.getRules;
  1425   1430       // options
  1426   1431       exports.setOption = gc_engine.setOption;

Modified gc_lang/fr/nodejs/cli/bin/gramma-cli.js from [d5a9326889] to [7a17b93c22].

   107    107       },
   108    108       gceoption: {
   109    109           short: "",
   110    110           arg: "+/-name",
   111    111           description: "Définit les options à utiliser par le correcteur grammatical.",
   112    112           execute: ""
   113    113       },
          114  +    gcerule: {
          115  +        short: "",
          116  +        arg: "+/-name",
          117  +        description: "Définit les règles à exclure par le correcteur grammatical.",
          118  +        execute: ""
          119  +    },
   114    120       tfoption: {
   115    121           short: "",
   116    122           arg: "+/-name",
   117    123           description: "Définit les options à utiliser par le formateur de texte.",
   118    124           execute: ""
   119    125       }
   120    126   };
................................................................................
   157    163   function toTitle(aStr) {
   158    164       return aStr.charAt(0).toUpperCase() + aStr.slice(1);
   159    165   }
   160    166   
   161    167   function repToText(oRep) {
   162    168       //console.log(oRep);
   163    169       let repText = "";
   164         -    for (const action of ["json", "perf", "gceoption", "tfoption"]) {
          170  +    for (const action of ["json", "perf", "gceoption", "tfoption", "gcerule"]) {
   165    171           if (action in oRep) {
   166    172               repText += toTitle(action) + " " + oRep[action];
   167    173           }
   168    174       }
   169    175   
   170    176       for (const action of ["morph", "lemma"]) {
   171    177           if (action in oRep) {
................................................................................
   293    299                       repText += "\nErreur(s) grammaticale(s)";
   294    300                       for (let gramma of toAff.reponse.lGrammarErrors) {
   295    301                           numRep1++;
   296    302                           if (numRep1 == replength) {
   297    303                               ascii1 = "└";
   298    304                               ascii1a = " ";
   299    305                           }
   300         -                        repText += "\n " + ascii1 + " " + gramma.nStart + "->" + gramma.nEnd + " " + gramma.sMessage;
          306  +                        repText += "\n " + ascii1 + " " + gramma.nStart + "->" + gramma.nEnd + " [" + gramma.sRuleId + "]\n " + ascii1a + " " + gramma.sMessage;
   301    307                           ascii2 = "├";
   302    308                           numRep2 = 0;
   303    309                           for (let suggestion of gramma.aSuggestions) {
   304    310                               numRep2++;
   305    311                               if (numRep2 == gramma.aSuggestions.length) {
   306    312                                   ascii2 = "└";
   307    313                               }
................................................................................
   406    412       for (const action of ["json", "perf"]) {
   407    413           if (getArg(aArg, [action])) {
   408    414               repPreference[action] = getArgVal(aArg, [action]);
   409    415               repAction[action] = repPreference[action] ? "ON" : "OFF";
   410    416           }
   411    417       }
   412    418   
   413         -    for (const action of ["gceoption", "tfoption"]) {
          419  +    for (const action of ["gceoption", "tfoption", "gcerule"]) {
   414    420           if (getArg(aArg, [action])) {
   415         -            let sFonction = action == "gceoption" ? "GceOption" : "TfOption";
          421  +            let sFonction = (action == "gceoption") ? "GceOption" : (action == "tfoption") ? "TfOption" : "GceIgnoreRule";
   416    422               let sOpt = sText.split(" ");
   417    423               if (sOpt[0] == "reset") {
   418    424                   oGrammarChecker["reset" + sFonction + "s"]();
   419    425                   repAction[action] = "reset";
   420    426               } else {
   421    427                   for (const optAction of sOpt) {
   422    428                       let bOptVal = optAction[0] == "+" ? true : false;

Modified gc_lang/fr/nodejs/cli/readme.md from [242a3d44cf] to [4ab9518690].

    25     25   | check     | texte    | Vérifie la grammaire et l’orthographe d'un texte.             |
    26     26   | lexique   | texte    | Affiche le lexique du texte.                                  |
    27     27   | spell     | mot      | Vérifie l’existence d'un mot.                                 |
    28     28   | suggest   | mot      | Suggestion des orthographes possible d’un mot.                |
    29     29   | morph     | mot      | Affiche les informations pour un mot.                         |
    30     30   | lemma     | mot      | Donne le lemme d’un mot.                                      |
    31     31   | gceoption | +/-name  | Définit les options à utiliser par le correcteur grammatical. |
           32  +| gcerule   | +/-name  | Définit les règles à exclure par le correcteur grammatical. |
    32     33   | tfoption  | +/-name  | Définit les options à utiliser par le formateur de texte.     |
    33     34   
    34     35   ## Client interactif
    35     36   
    36     37   Le mode interactif est un mode question/réponse. Pour le lancer vous devez saisir `gramma-cli -i`.
    37     38   
    38     39   Exemple pour les vérifications portant sur un mot:

Modified gc_lang/fr/nodejs/core/api.js from [a782304429] to [df78933803].

     6      6   /* jshint esversion:6, -W097 */
     7      7   /* jslint esversion:6 */
     8      8   /* global require, exports, console */
     9      9   
    10     10   "use strict";
    11     11   
    12     12   class GrammarChecker {
    13         -
    14     13       constructor(aInit, sLangCode = "fr", sContext = "Javascript") {
    15     14           this.sLangCode = sLangCode;
    16     15           this.sContext = sContext;
    17     16   
    18     17           //Importation des fichiers nécessaire
    19     18           this.sPathRoot = __dirname + "/grammalecte";
    20     19           this._helpers = require(this.sPathRoot + "/graphspell/helpers.js");
................................................................................
    23     22               Grammalecte: false,
    24     23               Graphspell: false,
    25     24               Tokenizer: false,
    26     25               TextFormatter: false,
    27     26               Lexicographer: false
    28     27           };
    29     28   
    30         -        if (aInit){
           29  +        if (aInit) {
    31     30               this.load(aInit);
    32     31           }
    33     32       }
    34     33   
    35     34       //Auto-chargement avec dépendence
    36         -    load(aInit = ["Grammalecte", "Graphspell", "TextFormatter", "Lexicographer", "Tokenizer"]){
           35  +    load(aInit = ["Grammalecte", "Graphspell", "TextFormatter", "Lexicographer", "Tokenizer"]) {
    37     36           //aInit permet de charger que certain composant
    38     37           // => évite de charger toutes données si par exemple on a besoin que du lexigraphe
    39     38           // => sorte de gestionnaire de dépendence (peut être amélioré)
    40     39           this.isInit = {};
    41         -        if ( aInit.indexOf("Grammalecte") !== false ){
           40  +        if (aInit.indexOf("Grammalecte") !== false) {
    42     41               //console.log('init Grammalecte');
    43     42               this._oGce = require(this.sPathRoot + "/fr/gc_engine.js");
    44     43               this._oGce.load(this.sContext);
    45     44               this.isInit.Grammalecte = true;
    46     45               this.oSpellChecker = this._oGce.getSpellChecker();
    47     46               this.isInit.Graphspell = true;
    48     47               this.oTokenizer = this.oSpellChecker.getTokenizer();
    49     48               this.isInit.Tokenizer = true;
    50     49           }
    51     50   
    52         -        if ( !this.isInit.Graphspell && (aInit.indexOf("Graphspell") !== false || aInit.indexOf("Lexicographer") !== false)){
           51  +        if (!this.isInit.Graphspell && (aInit.indexOf("Graphspell") !== false || aInit.indexOf("Lexicographer") !== false)) {
    53     52               //console.log('init Graphspell');
    54     53               this._SpellChecker = require(this.sPathRoot + "/graphspell/spellchecker.js");
    55     54               this.oSpellChecker = new this._SpellChecker.SpellChecker(this.sLangCode, this.sPathRoot + "/graphspell/_dictionaries");
    56     55               this.isInit.Graphspell = true;
    57     56               this.oTokenizer = this.oSpellChecker.getTokenizer();
    58     57               this.isInit.Tokenizer = true;
    59     58           }
    60     59   
    61         -        if ( !this.isInit.Tokenizer && aInit.indexOf("Tokenizer") !== false ){
           60  +        if (!this.isInit.Tokenizer && aInit.indexOf("Tokenizer") !== false) {
    62     61               //console.log('init Tokenizer');
    63     62               this._Tokenizer = require(this.sPathRoot + "/graphspell/tokenizer.js");
    64     63               this.oTokenizer = new this._Tokenizer.Tokenizer(this.sLangCode);
    65     64               this.isInit.Tokenizer = true;
    66     65           }
    67     66   
    68         -        if ( aInit.indexOf("TextFormatter") !== false ){
           67  +        if (aInit.indexOf("TextFormatter") !== false) {
    69     68               //console.log('init TextFormatter');
    70     69               this._oText = require(this.sPathRoot + "/fr/textformatter.js");
    71     70               this.oTextFormatter = new this._oText.TextFormatter();
    72     71               this.isInit.TextFormatter = true;
    73     72           }
    74     73   
    75         -        if ( aInit.indexOf("Lexicographer") !== false ){
           74  +        if (aInit.indexOf("Lexicographer") !== false) {
    76     75               //console.log('init Lexicographer');
    77     76               this._oLex = require(this.sPathRoot + "/fr/lexicographe.js");
    78     77               this.oLexicographer = new this._oLex.Lexicographe(
    79     78                   this.oSpellChecker,
    80     79                   this.oTokenizer,
    81     80                   this._helpers.loadFile(this.sPathRoot + "/fr/locutions_data.json")
    82     81               );
    83     82               this.isInit.Lexicographer = true;
    84     83           }
    85     84       }
    86     85   
    87     86       //Fonctions concernant: Grammalecte
    88         -    getGrammalecte(){
           87  +    getGrammalecte() {
    89     88           if (!this.isInit.Grammalecte) {
    90     89               this.load(["Grammalecte"]);
    91     90           }
    92     91           return this._oGce;
    93     92       }
    94     93   
    95         -    gramma(sText){
           94  +    gramma(sText) {
    96     95           if (!this.isInit.Grammalecte) {
    97     96               this.load(["Grammalecte"]);
    98     97           }
    99     98           return Array.from(this._oGce.parse(sText, this.sLangCode));
   100     99       }
   101    100   
   102         -    getGceOptions () {
          101  +    getGceOptions() {
   103    102           if (!this.isInit.Grammalecte) {
   104    103               this.load(["Grammalecte"]);
   105    104           }
   106    105           return this._helpers.mapToObject(this._oGce.getOptions());
   107    106       }
   108    107   
   109         -    getGceDefaultOptions () {
          108  +    getGceDefaultOptions() {
   110    109           if (!this.isInit.Grammalecte) {
   111    110               this.load(["Grammalecte"]);
   112    111           }
   113    112           return this._helpers.mapToObject(this._oGce.getDefaultOptions());
   114    113       }
   115    114   
   116         -    setGceOptions (dOptions) {
          115  +    setGceOptions(dOptions) {
   117    116           if (!this.isInit.Grammalecte) {
   118    117               this.load(["Grammalecte"]);
   119    118           }
   120    119           if (!(dOptions instanceof Map)) {
   121    120               dOptions = this._helpers.objectToMap(dOptions);
   122    121           }
   123    122           this._oGce.setOptions(dOptions);
   124    123           return this._helpers.mapToObject(this._oGce.getOptions());
   125    124       }
   126    125   
   127         -    setGceOption (sOptName, bValue) {
          126  +    setGceOption(sOptName, bValue) {
   128    127           if (!this.isInit.Grammalecte) {
   129    128               this.load(["Grammalecte"]);
   130    129           }
   131    130           if (sOptName) {
   132    131               this._oGce.setOption(sOptName, bValue);
   133    132               return this._helpers.mapToObject(this._oGce.getOptions());
   134    133           }
   135    134           return false;
   136    135       }
   137    136   
   138         -    resetGceOptions () {
          137  +    resetGceOptions() {
   139    138           if (!this.isInit.Grammalecte) {
   140    139               this.load(["Grammalecte"]);
   141    140           }
   142    141           this._oGce.resetOptions();
   143    142           return this._helpers.mapToObject(this._oGce.getOptions());
   144    143       }
          144  +
          145  +    getGceRules(bParagraph) {
          146  +        if (!this.isInit.Grammalecte) {
          147  +            this.load(["Grammalecte"]);
          148  +        }
          149  +        return this._oGce.getRules(bParagraph);
          150  +    }
          151  +
          152  +    getGceIgnoreRules() {
          153  +        if (!this.isInit.Grammalecte) {
          154  +            this.load(["Grammalecte"]);
          155  +        }
          156  +        return Array.from(this._oGce.getIgnoreRules());
          157  +    }
          158  +
          159  +    setGceIgnoreRules(dRules) {
          160  +        if (!this.isInit.Grammalecte) {
          161  +            this.load(["Grammalecte"]);
          162  +        }
          163  +        if (!(dRules instanceof Set)) {
          164  +            dRules = new Set(dRules);
          165  +        }
          166  +        this._oGce._aIgnoredRules = dRules;
          167  +        return Array.from(this._oGce.getIgnoreRules());
          168  +    }
          169  +
          170  +    setGceIgnoreRule(sRuleId, bValue) {
          171  +        if (!this.isInit.Grammalecte) {
          172  +            this.load(["Grammalecte"]);
          173  +        }
          174  +        if (bValue) {
          175  +            //Add
          176  +            this._oGce.ignoreRule(sRuleId);
          177  +        } else {
          178  +            //Delete
          179  +            this._oGce.reactivateRule(sRuleId);
          180  +        }
          181  +        return Array.from(this._oGce.getIgnoreRules());
          182  +    }
          183  +
          184  +    resetGceIgnoreRules() {
          185  +        if (!this.isInit.Grammalecte) {
          186  +            this.load(["Grammalecte"]);
          187  +        }
          188  +        this._oGce.resetIgnoreRules();
          189  +        return Array.from(this._oGce.getIgnoreRules());
          190  +    }
   145    191   
   146    192       //Fonctions concernant: Graphspell
   147         -    getGraphspell(){
          193  +    getGraphspell() {
   148    194           if (!this.isInit.Graphspell) {
   149    195               this.load(["Graphspell"]);
   150    196           }
   151    197           return this.oSpellChecker;
   152    198       }
   153    199   
   154         -    spellParagraph(sText, bSuggest = true){
          200  +    setMainDictionary(dictionary, sPath = "") {
          201  +        return this.oSpellChecker.setMainDictionary(dictionary, sPath);
          202  +    }
          203  +
          204  +    setPersonalDictionary(dictionary, sPath = "", bActivate = true) {
          205  +        return this.oSpellChecker.setPersonalDictionary(dictionary, sPath, bActivate);
          206  +    }
          207  +
          208  +    spellParagraph(sText, bSuggest = true) {
   155    209           if (!this.isInit.Graphspell) {
   156    210               this.load(["Graphspell"]);
   157    211           }
   158         -        if (bSuggest){
          212  +        if (bSuggest) {
   159    213               let lError = this.oSpellChecker.parseParagraph(sText);
   160    214               for (let token of lError) {
   161    215                   token.aSuggestions = this.suggest(token.sValue);
   162    216               }
   163    217               return lError;
   164    218           } else {
   165    219               return this.oSpellChecker.parseParagraph(sText);
   166    220           }
   167    221       }
   168    222   
   169         -    spell(sWord){
          223  +    spell(sWord) {
   170    224           if (!this.isInit.Graphspell) {
   171    225               this.load(["Graphspell"]);
   172    226           }
   173    227           return this.oSpellChecker.isValid(sWord);
   174    228       }
   175    229   
   176         -    suggest(sWord, nbLimit = 10, bMerge = true){
          230  +    suggest(sWord, nbLimit = 10, bMerge = true) {
   177    231           if (!this.isInit.Graphspell) {
   178    232               this.load(["Graphspell"]);
   179    233           }
   180    234           let lSuggest = this.oSpellChecker.suggest(sWord, nbLimit);
   181         -        if (bMerge){
          235  +        if (bMerge) {
   182    236               let lSuggestRep = [];
   183    237               for (let lSuggestTmp of lSuggest) {
   184    238                   for (let word of lSuggestTmp) {
   185    239                       lSuggestRep.push(word);
   186    240                   }
   187    241               }
   188    242               return lSuggestRep;
   189    243           } else {
   190    244               return Array.from(lSuggest);
   191    245           }
   192         -
   193    246       }
   194    247   
   195         -    lemma(sWord){
          248  +    lemma(sWord) {
   196    249           if (!this.isInit.Graphspell) {
   197    250               this.load(["Graphspell"]);
   198    251           }
   199    252           return this.oSpellChecker.getLemma(sWord);
   200    253       }
   201    254   
   202         -    morph(sWord){
          255  +    morph(sWord) {
   203    256           if (!this.isInit.Graphspell) {
   204    257               this.load(["Graphspell"]);
   205    258           }
   206    259           return this.oSpellChecker.getMorph(sWord);
   207    260       }
   208    261   
   209    262       //Fonctions concernant: Lexicographer
   210         -    getLexicographer(){
          263  +    getLexicographer() {
   211    264           if (!this.isInit.Lexicographer) {
   212    265               this.load(["Lexicographer"]);
   213    266           }
   214    267           return this.oLexicographer;
   215    268       }
   216    269   
   217         -    lexique(sText){
          270  +    lexique(sText) {
   218    271           if (!this.isInit.Lexicographer) {
   219    272               this.load(["Lexicographer"]);
   220    273           }
   221    274           return this.oLexicographer.getListOfTokensReduc(sText);
   222    275       }
   223    276   
   224    277       //Fonctions concernant: TextFormatter
   225         -    getTextFormatter(){
          278  +    getTextFormatter() {
   226    279           if (!this.isInit.TextFormatter) {
   227    280               this.load(["TextFormatter"]);
   228    281           }
   229    282           return this.oTextFormatter;
   230    283       }
   231    284   
   232         -    formatText(sText){
          285  +    formatText(sText) {
   233    286           if (!this.isInit.TextFormatter) {
   234    287               this.load(["TextFormatter"]);
   235    288           }
   236    289           return this.oTextFormatter.formatText(sText);
   237    290       }
   238    291   
   239    292       setTfOptions(dOptions) {
................................................................................
   262    315           }
   263    316           let optionsTF = this.oTextFormatter.getDefaultOptions();
   264    317           this.oTextFormatter.setOptions(optionsTF);
   265    318           return this._helpers.mapToObject(this.oTextFormatter.getOptions());
   266    319       }
   267    320   
   268    321       //fonctions concernant plussieurs parties
   269         -    verifParagraph(sText, bSuggest = true){
          322  +    verifParagraph(sText, bSuggest = true) {
   270    323           if (!this.isInit.Grammalecte || !this.isInit.Graphspell) {
   271    324               this.load(["Grammalecte"]);
   272    325           }
   273    326           return {
   274    327               lGrammarErrors: Array.from(this._oGce.parse(sText, this.sLangCode)),
   275    328               lSpellingErrors: this.spellParagraph(sText, bSuggest)
   276    329           };
   277    330       }
   278         -
   279    331   }
   280    332   
   281    333   if (typeof exports !== "undefined") {
   282    334       exports.GrammarChecker = GrammarChecker;
   283    335   }