Reconnaître un nom de champ sans guillemet

Version imprimable

Bonjour tout le monde,

J'écris un parser (mon premier parser!) pour reconnaître les chaînes de caractère de ce type : TERM : MATCH_TERM. J'écris ce parser en utilisant Chevrotain, mon code est en TypeScript mais l'erreur que j'ai ne provient pas de l'utilisation du TypeScript.

J'avais initialement permis d'écrire la partie TERM uniquement entre guillemets simples ou doubles ('TERM' ou "TERM"). Je voudrais maintenant permettre d'écrire la partie TERM sans guillemets autour.

Mes regex pour reconnaître la partie TERM entourée de guillemets fonctionnent bien et sont les suivantes :
Code:

1 2 const StringDoubleQuote = createToken({ name: "StringDoubleQuote", pattern: /"[^"\\]*(?:\\.[^"\\]*)*"/ }); const StringSimpleQuote = createToken({ name: "StringSimpleQuote", pattern: /'[^'\\]*(?:\\.[^'\\]*)*'/ });
Pour ces expressions régulières, je n'avais pas besoin de spécifier le caractère : comme marquant la fin du token, car le guillemet avait déjà cet usage.

Pour rendre possible l'écriture de la partie TERM sans guillemets autour, j'ai utilisé l'expression régulière suivante :

Code:

const StringWithoutQuote = createToken({ name: "StringWithoutQuote", pattern: /[\w!@#\$%\^&.-]+/ });

Pour définir la partie lexer du parser créé avec chevrotain j'ai écrit le code suivant qui définit les tokens possibles :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 const StringWithoutQuote = createToken({ name: "StringWithoutQuote", pattern: /[\w!@#\$%\^&.-]+/ }); const StringDoubleQuote = createToken({ name: "StringDoubleQuote", pattern: /"[^"\\]*(?:\\.[^"\\]*)*"/ }); const StringSimpleQuote = createToken({ name: "StringSimpleQuote", pattern: /'[^'\\]*(?:\\.[^'\\]*)*'/ }); const And = createToken({ name: "And", pattern: /(AND|and)/ }); const Or = createToken({ name: "Or", pattern: /(OR|or)/ }); const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /[ \t\n\r]+/, group: Lexer.SKIPPED }); const Colon = createToken({ name: "Colon", pattern: /:/ }); const Star = createToken({ name: "Star", pattern: /\*/ }); //.... Many other token const allTokens = [ WhiteSpace, Colon, Star, And, Or, //À ce niveau, j'ai également essayé de placer StringWithoutQuote après les chaînes de caractères avec guillemets dans le tableau allTokens. StringWithoutQuote, StringDoubleQuote, StringSimpleQuote ];
Mon problème maintenant :
Je vais prendre deux chaînes de caractère d'exemple :
- aggregateType:*

- orderInfo.orderDate:*

Pour la première chaîne de caractère (aggregateType:*) quelle que soit la syntaxe utilisée (avec ou sans guillemets) le parser fonctionne bien et renvoie le résultat attendu.

Mais pour la deuxième chaîne de caractère (orderInfo.orderDate:*), la syntaxe avec guillemets ('orderInfo.orderDate':* ou "orderInfo.orderDate":*) permet au parser de bien fonctionner et de me retourner le résultat attendu.

Mais avec la syntaxe sans guillemets (orderInfo.orderDate:*), le parser me renvoie l'erreur suivante : Error : Failing to parse of string <orderInfo.orderDate:*>. Je ne suis pas sûr, mais j'ai vraiment l'impression que c'est l'ajout d'un point . dans la partie TERM qui cause l'erreur. Pourtant, dans ma regex (/[\w!@#\$%\^&.-]+/) j'ai bien mis que le point . fait partie de mes caractères spéciaux à prendre en compte dans le token créé.

Quelqu'un voit-il ce que j'ai fait de mal et qui provoque ce comportement ?

Merci d'avance si vous prenez le temps de m'aider.

quand j'essaye ce code, il trouve quelque chose. ce n'est pas ce que vous attendez mais ce n'est pas non plus le message d'erreur que vous citez donc je ne sais pas quelle est la différence avec votre code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<script src="https://unpkg.com/chevrotain/lib/chevrotain.js"></script>
<script>
 
console.clear();
 
const createToken = chevrotain.createToken;
const Lexer = chevrotain.Lexer;
 
 
const StringWithoutQuote = createToken({ name: "StringWithoutQuote", pattern: /[\w!@#\$%\^&.-]+/ });
const StringDoubleQuote = createToken({ name: "StringDoubleQuote", pattern: /"[^"\\]*(?:\\.[^"\\]*)*"/ });
const StringSimpleQuote = createToken({ name: "StringSimpleQuote", pattern: /'[^'\\]*(?:\\.[^'\\]*)*'/ });
const And = createToken({ name: "And", pattern: /(AND|and)/ });
const Or = createToken({ name: "Or", pattern: /(OR|or)/ });
const WhiteSpace = createToken({
    name: "WhiteSpace",
    pattern: /[ \t\n\r]+/,
    group: Lexer.SKIPPED
});
const Colon = createToken({ name: "Colon", pattern: /:/ });
const Star = createToken({ name: "Star", pattern: /\*/ });
 
//.... Many other token
 
const allTokens = [
    WhiteSpace,
    Colon,
    Star,
    And,
    Or,
 
    //À ce niveau, j'ai également essayé de placer StringWithoutQuote après les chaînes de caractères avec guillemets dans le tableau allTokens.
 
    StringWithoutQuote,
    StringDoubleQuote,
    StringSimpleQuote
];
 
let SelectLexer = new Lexer(allTokens);
 
 
let inputText = "orderInfo.orderDate:*";
let lexingResult = SelectLexer.tokenize(inputText);
 
console.log(lexingResult["tokens"]);
 
</script>

04/08/2022, 14h33
vincent922

Je vais continuer à regarder mais je pense avoir trouver le problème finalement.

L'erreur se fait à cause de la définition du tableau allTokens je pense.

J'ai un token and et un token or qui servent d'opérateur entre mes différentes expression. Comme le champs orderInfo.orderDate commence par or il doit essayer de construire un token or puis il n'arrive plus à parser la suite de ma chaîne de caractère car elle ne correspond plus alors à la syntaxe que j'ai défini dans mes règles de grammaire.

Je vais donc essayer de placer mes tokens définissant mes termes avant mes tokens définissant les opérateurs or et and et je vous dit si ça marche bien.

Finalement la solution n'était pas de changer l'ordre des tokens dans le tableau de définition des tokens allTokens.

Il fallait en fait définir un "pattern possible plus long" qui permet de dire à chaque fois que je check la présence de ce keyword (ici and ou or) je check aussi s'il ne s'agit pas d'un identifier moins spécifique (ici StringWithoutQuote).
L'explication plus détaillée se trouve à la fin du paragraphe constructor de ce lien https://chevrotain.io/documentation/...ml#constructor

La définition du lexer devient donc:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 const StringWithoutQuote = createToken({ name: "StringWithoutQuote", pattern: /[\w!@#\$%\^&.-]+/ }); const StringDoubleQuote = createToken({ name: "StringDoubleQuote", pattern: /"[^"\\]*(?:\\.[^"\\]*)*"/ }); const StringSimpleQuote = createToken({ name: "StringSimpleQuote", pattern: /'[^'\\]*(?:\\.[^'\\]*)*'/ }); const And = createToken({ name: "And", pattern: /(AND|and)/, longer_alt: StringWithoutQuote }); //ajouter ici le longer_alt const Or = createToken({ name: "Or", pattern: /(OR|or)/, longer_alt: StringWithoutQuote }); //ajouter ici le longer_alt const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /[ \t\n\r]+/, group: Lexer.SKIPPED }); const Colon = createToken({ name: "Colon", pattern: /:/ }); const Star = createToken({ name: "Star", pattern: /\*/ }); const allTokens = [ WhiteSpace, Colon, Star, And, Or, StringWithoutQuote, StringDoubleQuote, StringSimpleQuote ];

04/08/2022, 16h27
CosmoKnacki

Tu pouvais aussi esquiver ce problème en imposant des word boundaries (ou des contraintes plus exigeantes) autour de ta pattern: /\b(or|OR)\b/