Grammalecte  Check-in [ee5d077740]

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:[njs] Add TF option Chg how to set option
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | njs | nodejs
Files: files | file ages | folders
SHA3-256:ee5d07774071340ca0e7cd8abeb77a97ef5ff5bb725eb5e5b5084f05d944bd3d
User & Date: IllusionPerdu 2018-10-16 10:16:56
Original Comment: [js] Add TF option Chg how to set option
Context
2018-10-17
13:30
[graphspell][js] fix time calculation for suggestions check-in: ed091d83b9 user: olr tags: graphspell, nodejs
2018-10-16
10:16
[njs] Add TF option Chg how to set option check-in: ee5d077740 user: IllusionPerdu tags: njs, nodejs
2018-10-15
21:00
[njs] Minor change check-in: c5b6c3d6cb user: IllusionPerdu tags: njs, nodejs
Changes

Changes to gc_lang/fr/nodejs/cli/bin/gramma-cli.js.

    19     19   
    20     20   //Initialisation des messages
    21     21   const msgStart = "\x1b[31mBienvenu sur Grammalecte pour NodeJS!!!\x1b[0m\n";
    22     22   const msgPrompt = "\x1b[36mGrammaJS\x1b[33m>\x1b[0m ";
    23     23   const msgSuite = "\x1b[33m…\x1b[0m ";
    24     24   const msgEnd = "\x1b[31m\x1b[5m\x1b[5mBye bye!\x1b[0m";
    25     25   
    26         -var repJson = false;
    27         -var repPerf = false;
           26  +var repPreference = {
           27  +    json: false,
           28  +    perf: false
           29  +};
    28     30   
    29     31   var sBufferConsole = "";
    30     32   var sCmdToExec = "";
    31     33   var sText = "";
    32     34   
    33     35   var cmdAction = {
    34     36       help: {
    35     37           short: "",
           38  +        arg: "",
    36     39           description: "Affiche les informations que vous lisez ;)",
    37     40           execute: ""
    38     41       },
    39     42       perf: {
    40     43           short: "",
    41         -        description: "(on/off) Permet d'afficher le temps d'exécution des commandes.",
           44  +        arg: "on/off",
           45  +        description: "Permet d'afficher le temps d'exécution des commandes.",
    42     46           execute: ""
    43     47       },
    44     48       json: {
    45     49           short: "",
    46         -        description: "(on/off) Réponse en format format json.",
           50  +        arg: "on/off",
           51  +        description: "Réponse en format format json.",
    47     52           execute: ""
    48     53       },
    49     54       exit: {
    50     55           short: "",
    51         -        description: "Client intéractif: Permet de le quitter.",
           56  +        arg: "",
           57  +        description: "Client interactif: Permet de le quitter.",
    52     58           execute: ""
    53     59       },
    54     60       text: {
    55     61           short: "",
           62  +        arg: "texte",
    56     63           description: "Client / Server: Définir un texte pour plusieurs actions.",
    57     64           execute: ""
    58     65       },
    59         -    gceoption: {
    60         -        short: "",
    61         -        description: "Défini une option a utilisé par le correcteur de grammaire.",
    62         -        execute: ""
    63         -    },
    64     66       format: {
    65     67           short: "",
           68  +        arg: "texte",
    66     69           description: "Permet de mettre en forme le texte.",
    67     70           execute: "formatText"
    68     71       },
    69     72       check: {
    70     73           short: "",
           74  +        arg: "texte",
    71     75           description: "Vérifie la grammaire et l'orthographe d'un texte.",
    72     76           execute: "verifParagraph"
    73     77       },
    74     78       lexique: {
    75     79           short: "",
           80  +        arg: "texte",
    76     81           description: "Affiche le lexique du texte.",
    77     82           execute: "lexique"
    78     83       },
    79     84       spell: {
    80     85           short: "",
           86  +        arg: "mot",
    81     87           description: "Vérifie l'existence d'un mot.",
    82     88           execute: "spell"
    83     89       },
    84     90       suggest: {
    85     91           short: "",
           92  +        arg: "mot",
    86     93           description: "Suggestion des orthographes possible d'un mot.",
    87     94           execute: "suggest"
    88     95       },
    89     96       morph: {
    90     97           short: "",
           98  +        arg: "mot",
    91     99           description: "Affiche les informations pour un mot.",
    92    100           execute: "morph"
    93    101       },
    94    102       lemma: {
    95    103           short: "",
          104  +        arg: "mot",
    96    105           description: "Donne le lemme d'un mot.",
    97    106           execute: "lemma"
          107  +    },
          108  +    gceoption: {
          109  +        short: "",
          110  +        arg: "+/-name",
          111  +        description: "Défini les options à utiliser par le correcteur de grammaire.",
          112  +        execute: ""
          113  +    },
          114  +    tfoption: {
          115  +        short: "",
          116  +        arg: "+/-name",
          117  +        description: "Défini les options à utiliser par le formateur de texte.",
          118  +        execute: ""
    98    119       }
    99    120   };
   100    121   
   101    122   var cmdOne = ["json", "perf", "help", "exit"];
   102    123   var cmdMulti = ["text", "format", "check", "lexique", "spell", "suggest", "morph", "lemma"];
   103    124   
   104    125   var cmdAll = [...cmdOne, ...cmdMulti];
................................................................................
   136    157   function toTitle(aStr) {
   137    158       return aStr.charAt(0).toUpperCase() + aStr.slice(1);
   138    159   }
   139    160   
   140    161   function repToText(oRep) {
   141    162       //console.log(oRep);
   142    163       let repText = "";
   143         -    for (const action of ["Json", "Perf", "GceOption"]) {
          164  +    for (const action of ["json", "perf", "gceoption", "tfoption"]) {
   144    165           if (action in oRep) {
   145    166               repText += toTitle(action) + " " + oRep[action];
   146    167           }
   147    168       }
   148    169   
   149    170       for (const action of ["morph", "lemma"]) {
   150    171           if (action in oRep) {
................................................................................
   314    335   
   315    336       if (!isBool(aArg.text)) {
   316    337           sText = aArg.text;
   317    338       }
   318    339   
   319    340       repAction["text"] = sText;
   320    341   
   321         -    if (getArg(aArg, ["json"])) {
   322         -        repJson = getArgVal(aArg, ["json"]);
   323         -        repAction["Json"] = repJson ? "ON" : "OFF";
          342  +    for (const action of ["json", "perf"]) {
          343  +        if (getArg(aArg, [action])) {
          344  +            repPreference[action] = getArgVal(aArg, [action]);
          345  +            repAction[action] = repPreference[action] ? "ON" : "OFF";
          346  +        }
   324    347       }
   325    348   
   326         -    if (getArg(aArg, ["perf"])) {
   327         -        repPerf = getArgVal(aArg, ["perf"]);
   328         -        repAction["Perf"] = repPerf ? "ON" : "OFF";
   329         -    }
   330         -
   331         -    if (repPerf) {
          349  +    if (repPreference.perf) {
   332    350           tStart = performance.now();
   333    351       }
   334    352   
   335         -    if (getArg(aArg, ["gceoption"])) {
   336         -        let sOpt = sText.split(" ");
   337         -        if (sOpt[0] == "reset") {
   338         -            oGrammarChecker.resetGceOptions();
   339         -            repAction["GceOption"] = "reset";
   340         -        } else {
   341         -            let bOptVal = toBool(sOpt[1]);
   342         -            oGrammarChecker.setGceOption(sOpt[0], bOptVal);
   343         -            repAction["GceOption"] = sOpt[0] + " " + (bOptVal ? "ON" : "OFF");
          353  +    for (const action of ["gceoption", "tfoption"]) {
          354  +        if (getArg(aArg, [action])) {
          355  +            let sFonction = action == "gceoption" ? "GceOption" : "TfOption";
          356  +            let sOpt = sText.split(" ");
          357  +            if (sOpt[0] == "reset") {
          358  +                oGrammarChecker["reset"+sFonction+"s"]();
          359  +                repAction[action] = "reset";
          360  +            } else {
          361  +                for (const optAction of sOpt) {
          362  +                    let bOptVal = optAction[0] == '+' ? true : false;
          363  +                    let sOptName = optAction.slice(1, optAction.length);
          364  +                    oGrammarChecker["set"+sFonction](sOptName, bOptVal);
          365  +                    repAction[action] = sText;
          366  +                }
          367  +            }
   344    368           }
   345    369       }
   346    370   
   347    371       for (const action in aArg) {
   348    372           if (cmdAction[action] && cmdAction[action].execute !== "") {
   349    373               if (!isBool(aArg[action]) && aArg[action] !== "") {
   350    374                   repAction.text = aArg[action];
................................................................................
   369    393           repAction["help"].push(" * pour le client exemple: «gramma-cli --command \"mot/texte\"».");
   370    394           repAction["help"].push(" * le serveur se lance avec la commande «gramma-cli --server --port 8085».");
   371    395   
   372    396           repAction["help"].push("");
   373    397           repAction["help"].push("========================= Les commandes/arguments: ========================");
   374    398           repAction["help"].push("");
   375    399           for (const action in cmdAction) {
   376         -            repAction["help"].push(action.padEnd(15, ' ') + ': ' + cmdAction[action].description);
          400  +            repAction["help"].push(action.padEnd(10, ' ') + ': ' + cmdAction[action].arg.padEnd(8, ' ') + ': ' + cmdAction[action].description);
   377    401           }
   378    402           repAction["help"].push("");
   379    403           repAction["help"].push("================================== Note: ==================================");
   380    404           repAction["help"].push("");
   381    405           repAction["help"].push("En mode client: les arguments sont de la forme «--argument» !");
   382    406           repAction["help"].push("En mode client intéractif: pour les commandes concernant un texte, vous");
   383    407           repAction["help"].push("  pouvez taper la commande puis entrer (pour saisir le texte) pour ");
   384    408           repAction["help"].push("  terminer la saisie du texte et exécuter la commande taper /\"commande\"");
   385    409       }
   386    410   
   387         -    if (repPerf) {
          411  +    if (repPreference.perf) {
   388    412           tEnd = performance.now();
   389    413           //On ajoute l"information au résultat
   390    414           repAction["time"] = (Math.round((tEnd - tStart) * 1000) / 1000).toString();
   391    415       }
   392    416   
   393         -    if (repJson) {
          417  +    if (repPreference.json) {
   394    418           return JSON.stringify(repAction);
   395    419       } else {
   396    420           return repToText(repAction);
   397    421       }
   398    422   }
   399    423   
   400    424   function argToExec(aCommand, aText, rl, resetCmd = true){

Changes to gc_lang/fr/nodejs/cli/data/script.gramma.

     1      1   json false
     2      2   perf true
     3      3   spell salut
     4      4   suggest salut
     5      5   morph salut
     6      6   lemma salut
     7         -gceoption typo false
            7  +gceoption -typo
     8      8   check
     9         -salut comment,il vas???bienss et tu!  salut commentss il vas???
            9  +salut comment,il vas???bienss...et tu!  "salut commentss il vas???"
    10     10   /check
    11         -gceoption typo true
           11  +gceoption +typo
    12     12   check/
    13         -lexique/
           13  +#lexique/
           14  +tfoption +nnbsp_before_punctuation -ts_ellipsis
           15  +format/
           16  +tfoption reset
           17  +format/

Changes to gc_lang/fr/nodejs/cli/readme.md.

    10     10   
    11     11   ## Installation
    12     12   
    13     13   > npm install grammalecte-cli -g
    14     14   
    15     15   ## Commandes
    16     16   
    17         -* help           : Affiche les informations que vous lisez ;)
    18         -* perf           : Permet d'afficher le temps d'exécution des commandes.
    19         -* json           : Réponse en format format json.
    20         -* exit           : Client interactif: Permet de le quitter.
    21         -* format         : Permet de mettre en forme le texte.
    22         -* check          : Vérifie la grammaire et l'orthographe d'un texte.
    23         -* lexique        : Affiche le lexique du texte.
    24         -* spell          : Vérifie l'existence d'un mot.
    25         -* suggest        : Suggestion des orthographes possible d'un mot.
    26         -* morph          : Affiche les informations pour un mot.
    27         -* lemma          : Donne le lemme d'un mot.
    28         -* text           : Client / Server: Définir un texte pour plusieurs actions.
    29         -* gceoption      : Défini une option a utilisé par le correcteur de grammaire.
           17  +| Commande  | Argument | Description                                                   |
           18  +| --------- | -------- | ------------------------------------------------------------- |
           19  +| help      |          | Affiche les informations que vous lisez ;)                    |
           20  +| perf      | on/off   | Permet d'afficher le temps d'exécution des commandes.         |
           21  +| json      | on/off   | Réponse en format format json.                                |
           22  +| exit      |          | Client interactif: Permet de le quitter.                      |
           23  +| text      | texte    | Client / Server: Définir un texte pour plusieurs actions.     |
           24  +| format    | texte    | Permet de mettre en forme le texte.                           |
           25  +| check     | texte    | Vérifie la grammaire et l'orthographe d'un texte.             |
           26  +| lexique   | texte    | Affiche le lexique du texte.                                  |
           27  +| spell     | mot      | Vérifie l'existence d'un mot.                                 |
           28  +| suggest   | mot      | Suggestion des orthographes possible d'un mot.                |
           29  +| morph     | mot      | Affiche les informations pour un mot.                         |
           30  +| lemma     | mot      | Donne le lemme d'un mot.                                      |
           31  +| gceoption | +/-name  | Défini les options à utiliser par le correcteur de grammaire. |
           32  +| tfoption  | +/-name  | Défini les options à utiliser par le formateur de texte.      |
    30     33   
    31     34   ## Client interactif
    32     35   
    33     36   Le mode interactif est un mode question/réponse. Pour le lancer vous devez saisir `gramma-cli -i`.
    34     37   
    35     38   Exemple pour les vérifications portant sur un mot:
    36     39   

Changes to gc_lang/fr/nodejs/core/api.js.

   128    128           if (!this.isInit.Grammalecte) {
   129    129               this.load(["Grammalecte"]);
   130    130           }
   131    131           if (sOptName) {
   132    132               this._oGce.setOption(sOptName, bValue);
   133    133               return this._helpers.mapToObject(this._oGce.getOptions());
   134    134           }
          135  +        return false;
   135    136       }
   136    137   
   137         -    resetOptions () {
          138  +    resetGceOptions () {
   138    139           if (!this.isInit.Grammalecte) {
   139    140               this.load(["Grammalecte"]);
   140    141           }
   141    142           this._oGce.resetOptions();
   142    143           return this._helpers.mapToObject(this._oGce.getOptions());
   143    144       }
   144    145   
................................................................................
   230    231   
   231    232       formatText(sText){
   232    233           if (!this.isInit.TextFormatter) {
   233    234               this.load(["TextFormatter"]);
   234    235           }
   235    236           return this.oTextFormatter.formatText(sText);
   236    237       }
          238  +
          239  +    setTfOptions(dOptions) {
          240  +        if (!this.isInit.TextFormatter) {
          241  +            this.load(["TextFormatter"]);
          242  +        }
          243  +        this.oTextFormatter.setUsedOptions(dOptions);
          244  +        return this._helpers.mapToObject(this.oTextFormatter.getUsedOptions());
          245  +    }
          246  +
          247  +    setTfOption(sOptName, bValue) {
          248  +        if (!this.isInit.TextFormatter) {
          249  +            this.load(["TextFormatter"]);
          250  +        }
          251  +        if (sOptName) {
          252  +            let optionsTF = this.oTextFormatter.getUsedOptions();
          253  +            optionsTF.set(sOptName, bValue);
          254  +            return this._helpers.mapToObject(this.oTextFormatter.getUsedOptions());
          255  +        }
          256  +        return false;
          257  +    }
          258  +
          259  +    resetTfOptions() {
          260  +        if (!this.isInit.TextFormatter) {
          261  +            this.load(["TextFormatter"]);
          262  +        }
          263  +        let optionsTF = this.oTextFormatter.getDefaultOptions();
          264  +        this.oTextFormatter.setUsedOptions(optionsTF);
          265  +        return this._helpers.mapToObject(this.oTextFormatter.getUsedOptions());
          266  +    }
   237    267   
   238    268       //fonctions concernant plussieurs parties
   239    269       verifParagraph(sText, bSuggest = true){
   240    270           if (!this.isInit.Grammalecte || !this.isInit.Graphspell) {
   241    271               this.load(["Grammalecte"]);
   242    272           }
   243    273           return {