I’m sick of trying to explain something simple that nobody understand… Does someone can give me his Skype name ? Please 
Help me please
Aerosmite
#1
0 Likes
Aerosmite
#3
Ok, let’s try again… How I 'm supposed to do to insert an include in a regex ?
Like the regex “banana”, after I include an element and right after it I match the regex “cool”. Maybe Begin/end patterns can do the job but seems difficult with that.
0 Likes
dubeg
#5
Tu veux insérer un regex définit précédemment dans le milieu d’un autre regex?
EDIT: si tu veux utiliser un regex dans plusieurs autres, tu peux utiliser les variables.
0 Likes
Aerosmite
#6
Oh mon dieu un Francais, merci !!
Je cherche en effet à intégrer un regex, mais sous forme d’un élément contenant un regex défini auparavant, pour pouvoir l’appliquer à plusieurs reprises facilement. Donc il m’est nécéssaire de pouvoir passer par plusieurs regex: le début de mon match, l’élément que j’importe grace à “include” et la fin de mon regex. Serais-ce possible ? Et qu’entend-tu par variables ?
0 Likes
dubeg
#7
Les variables définissent des regex qu’on peut réutiliser dans d’autres regex par la suite. L’example donné dans la doc est…
variables:
ident: '[A-Za-z_][A-Za-z_0-9]*'
contexts:
main:
- match: '\b{{ident}}\b'
scope: keyword.control
Mais ça n’a pas vraiment l’air d’être ce que tu recherches finalement.
As-tu un example de ce que tu veux matcher? Ca m’aiderait à bien comprendre.
0 Likes
Aerosmite
#8
OH SI c’est exactement ça ! 
Pourrais-tu me le réécrire en XML stp ? Ca sera plus simple pour moi à comprendre (c’est du YAML là c’est bien ça ?)
Et quel est la syntaxe pour l’ajouter dans un regex ? Merci d’avance 
1 Like
dubeg
#9
Hmm. Je n’ai rien trouvé à propos de tmLanguage qui m’indique qu’elle définit une fonctionnalité similaire aux variables de sublime-syntax.
Je sais que le format tmLanguage est supporté dans plusieurs éditeurs, alors si tu tiens à garder le garder je te comprends mais je ne sais pas quoi te dire… Par contre, si tu ne te concernes que de SublimeText, je te suggère de convertir ton fichier en format sublime-syntax.
EDIT: si tu as ruby d’installer, tu peux essayer d’installer ce gem-ci qu’un utilisateur à créer pour la conversion.
Sinon, tu peux utiliser la commande inclut avec ST3 (à partir de la verion 3100 je crois). Ouvre ton fichier tmLanguage dans Sublime, ouvre la palette de commande et tape convert to sublime-syntax.
0 Likes
Aerosmite
#10
Ça serais possible de te parler ? Je pourrais mieux t’expliquer mon problème et j’aurais ma réponse 
0 Likes
Aerosmite
#12
Ok si tu ne veux pas, pas de problème. Donc une exemple concret de ce qu’il faudrait que je sache faire: Prenons le match “abc”, je rajoute des captures pour qua a soit en rouge, b en bleu et c en vert. Maintenant, je souhaite faire un match contenant “1abc2” avec abc coloré SANS que je n’ai a spécifier les captures (ce que include pourrait faire si je trouvais un moyen de séparer le regex), seulement celle de 1 et 2. Car dans mon exemple c’est abc mais en réalité ce sont des blocs de regex bien plus long, contenant souvent plus de 15 captures. Donc voilà le problème, pouvoir intégrer un bloc de regex avec ses captures dans un match sans avoir à tout re-citer.
0 Likes
dubeg
#13
Désolé Aero, je n’ai pas vraiment le temps de skyper durant le jour…
Tout dépend des règles de ta syntaxe. C’est difficile à dire avec un exemple simple. Voici une manière de colorer ton example avec sublime-syntax:
%YAML 1.2
---
# See http://www.sublimetext.com/docs/3/syntax.html
file_extensions:
- abc
scope: source.abc
contexts:
main:
- include: abc
- include: 1abc2
abc:
- match: 'abc'
scope: abc
pop: true
1abc2:
- match: '1'
scope: begin
push: abc
- match: '2'
scope: end
pop: true
Comme tu peux le voir, on peut définir des contextes, que j’ai nommé litéralement comme leur match, abc et 1abc2. Je réutilise abc dans 1abc1 en poussant le context abc après avoir matché 1.
Dans le format tmLanguage:
<key>patterns</key>
<array>
<dict>
<key>include</key>
<string>#1abc2</string>
</dict>
<dict>
<key>include</key>
<string>#abc</string>
</dict>
</array>
Puis, …
<key>repository</key>
<dict>
<key>abc</key>
<dict>
<key>patterns</key>
<array>
<dict>
<key>match</key>
<string>abc</string>
<key>name</key>
<string>abc</string>
</dict>
</array>
</dict>
<!-- ========= -->
<key>1abc2</key>
<dict>
<key>name</key>
<string>1abc2</string>
<!-- ~~~~~~~~~ -->
<key>begin</key>
<string>1</string>
<!-- ~~~~~~~~~ -->
<key>beginCaptures</key>
<dict>
<key>0</key>
<dict>
<key>name</key>
<string>begin</string>
</dict>
</dict>
<!-- ~~~~~~~~~ -->
<key>patterns</key>
<array>
<dict>
<key>include</key>
<string>#abc</string>
</dict>
</array>
<!-- ~~~~~~~~~ -->
<key>end</key>
<string>2</string>
<!-- ~~~~~~~~~ -->
<key>endCaptures</key>
<dict>
<key>0</key>
<dict>
<key>name</key>
<string>end</string>
</dict>
</dict>
</dict>
</dict>
0 Likes
Aerosmite
#14
Super merci Je vais donc faire comme tu dis et essayer de feinter avec le begin/end.
Une dernière petite question: Puisque les lookbehind non aucun poids, es-ce possible de les utiliser dans un pattern d’une structure begin/end (entre les deux) pour “détecter” le regex du begin afin d’être juste après ?
0 Likes
dubeg
#15
Hm. Si on prend un exemple…
1abc
Tu demandes s’il est possible d’avoir un begin avec le regex ‘(?<=1 )abc’ pour matcher seulement les ‘abc’ suivant 1? Hmm.
Je viens de faire un test avec tmLanguage et ca semble fonctionner. Je ne suis pas certain de ce que veut dire un lookbehind sans poids par contre…
En ce qui concerne sublime-syntax, je crois que c’est problematique puisque que si ‘1’ est matché précédemment, alors il est déjà consommé (et donc il n’est plus disponible aux autres patterns). Tu dois alors jouer avec les contextes pour arriver à un résultat similaire.
Mais, tu dois bien avoir tes fichiers sur lesquels tu travailles pour tester tes hypothèses, non? Tu peux toujours vérifier par toi même :^)
EDIT: je me demande bien quels cas t’ont donnés de la misère. Rien de ce qu’on vient de parler n’est bien compliqué… non?
0 Likes
Aerosmite
#16
Oui je sais désolé, ça fait longtemps que j’y ai pas touché c’est un peu le bordel, mais je vais vérifier.
En fait j’avais deja pensé dès le début à faire comme toi, et le fait que tu m’ai expliqué ca m’a permis de le revoir avec mes nouvelles connaissances. Ce qui me donne misère, c’est que je n’arrive pas à intégrer proprement un include (assez complexe) entre 2 regex donnés sans le laisser tomber, copier/coller le regex complexe dedans pour n’en former qu’un seul et galerer avec les captures des 3 regex réunis (devant, milieu (le include précédent) et derrière)… Le begin/end ne convient pas vraiment, car non seulement le end est optionnel mais en plus les patterns peuvent être zapés, alors que je veux que ça suivent un ordre précis. En gros un il faudrait un regex, suivit d’un include puis d’un autre regex, de manière à ce que les 3 match ensemble en même temps s’ils sont dans l’ordre. C’est ce que je cherchais à te faire comprendre plus simplement avant avec 1 le premier regex, abc le include relativement complexe avec chaque lettre de couleur différente et 2 le regex de fin. Alors voilà je te déballe tout, j’espère que tu arriveras à comprendre une partie, j’explique affreusement mal 
0 Likes
dubeg
#17
Si 2 est optionel, et tu peux assumer que 1 abc 2 se situe sur une seule ligne, alors tu peux considérer (2|$) pour le regex de end. On assure donc que cette règle-ci ne matche qu’une seule ligne.
Tu peux même définir un pattern in-between qui matcherait tout sauf le regex de end, et y mettre un scope d’erreur pour être capable de colorier en rouge les caractères invalides.
Donc, on a…
begin: 1
patterns:
- include: #abc
- match: // un regex qui match tout sauf le regex du end.
scope: something.invalid
end: (2|$)
Si 1 est utiliser dans d’autres patterns, alors tu peux peut-être ajouter des lookahead/lookbehind dans ton regex begin pour s’assurer que ton pattern ne cause pas de problemes avec les autres cas.
Exemple: 1(?=abc)
0 Likes
Aerosmite
#18
Ahah j’avais déjà un peu réfléchi à utiliser $ mais ca me semble une bonne manière, même s’il y aura quelque petites subtilités. Donc je vais tester tout ça ! 
0 Likes
Aerosmite
#19
J’ai rencontré quelques problèmes: je ne sais pas comment faire pour que mon include ne puisse n’être matché qu’une seule fois dans mes patterns et les lookbehind m’affiche erreur dès que j’en utilisent 
EDIT: je vais modifier directement dans mon repository le modifier, d’ailleurs si jamais tu sais comment on l’ajoute
0 Likes
dubeg
#20
Hmm. Tu ne voudrais pas poster tes règles? Ca me donnerait quelque de spécifique sur quoi essayer des solutions, au lieu d’utiliser des examples bidons.
EDIT: je ne comprends pas ton edit non plus 
0 Likes
Aerosmite
#21
Ok je te passe un exemple plus représentatif:
<key>repository</key>
<dict>
<key>entity</key>
<dict>
<key>patterns</key>
<array>
<dict>
<key>begin</key>
<string>(@[apre])(\[)</string>
<key>beginCaptures</key>
<dict>
<key>1</key>
<dict>
<key>name</key>
<string>entity.other.attribute-name</string>
</dict>
<key>2</key>
<dict>
<key>name</key>
<string>punctuation.definition.dictionary.begin.json</string>
</dict>
</dict>
<key>end</key>
<string>\]</string>
<key>endCaptures</key>
<dict>
<key>0</key>
<dict>
<key>name</key>
<string>punctuation.definition.dictionary.end.json</string>
</dict>
</dict>
<key>patterns</key>
<array>
<dict>
<key>match</key>
<string>(x|y|z|dx|dy|dz|r|rm|rx|rxm|ry|rym|m|c|l|lm|team|name|type|tag|id|score_[^\s_,=]+(_min)?)(=)(!)?((-?\d*)|([^,=\]]*))(,)*</string>
<key>captures</key>
<dict>
<key>1</key>
<dict>
<key>name</key>
<string>entity.name.tag</string>
</dict>
<key>3</key>
<dict>
<key>name</key>
<string>keyword.operator</string>
</dict>
<key>4</key>
<dict>
<key>name</key>
<string>keyword.operator</string>
</dict>
<key>6</key>
<dict>
<key>name</key>
<string>constant.numeric</string>
</dict>
<key>7</key>
<dict>
<key>name</key>
<string>variable.parameter</string>
</dict>
<key>8</key>
<dict>
<key>name</key>
<string>punctuation.separator.dictionary.pair.json</string>
</dict>
</dict>
</dict>
<dict>
<key>match</key>
<string>,</string>
<key>name</key>
<string>punctuation.separator.dictionary.pair.json</string>
</dict>
</array>
</dict>
<dict>
<key>name</key>
<string>entity.other.attribute-name</string>
<key>match</key>
<string>\B(@[apre])\b</string>
</dict>
<dict>
<key>comment</key>
<string>nom d'un joueur</string>
<key>name</key>
<string>entity.other.attribute-name</string>
<key>match</key>
<string>\b(\w){1,16}\b</string>
</dict>
</array>
</dict>
</dict>
Voilà le gros bloc “entity” à utiliser avec include, tu comprend mieux pourquoi 
Déjà, j’aimerais bien savoir comment appliquer le “modifier” (les lettres qui change les règles comme lazy par ex) qui fait que ce texte ne peut matcher qu’une fois, et pas plusieurs fois comme c’est de base.
Ensuite, j’ai besoin que ce regex soit intégré directement après le regex ^execute séparé par un espace et suivi d’un nouvel espace puis du regex detect. Voilà ce que j’ai essayé de faire, ce qui comporte de nombreux problèmes:
<dict>
<key>begin</key>
<string>\b(^execute)\b</string>
<key>beginCaptures</key>
<dict>
<key>0</key>
<dict>
<key>name</key>
<string>keyword.control</string>
</dict>
</dict>
<key>end</key>
<string>($|detect)</string>
<key>endCaptures</key>
<dict>
<key>0</key>
<dict>
<key>name</key>
<string>keyword.control</string>
</dict>
</dict>
<key>patterns</key>
<array>
<dict>
<key>include</key>
<string>#entity</string>
</dict>
<dict>
<key>match</key>
<string> {2,}|[^ ]</string>
<key>captures</key>
<dict>
<key>0</key>
<dict>
<key>name</key>
<string>invalid.illegal</string>
</dict>
</dict>
</dict>
</array>
</dict>
Sans lister tout les problèmes, il y a le fait que le bloc “entity” peut très bien match sans être précédé d’un espace et de ^execute et que, comme énoncé précédemment, il peut être utilisé plusieurs fois.
Merci encore pour ton intérêt et ton aide 
0 Likes