Sublime Forum

Help me please

#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
#10

Ça serais possible de te parler ? Je pourrais mieux t’expliquer mon problème et j’aurais ma réponse :slightly_smiling_face:

0 Likes
#11

Alors ? :grin:

0 Likes
#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
#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
#14

Super merci :slightly_smiling_face: 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
#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
#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 :worried:

0 Likes
#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
#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 ! :slightly_smiling:

0 Likes
#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 :confused:
EDIT: je vais modifier directement dans mon repository le modifier, d’ailleurs si jamais tu sais comment on l’ajoute

0 Likes
#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 :stuck_out_tongue:

0 Likes
#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 :stuck_out_tongue_winking_eye: 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 :wink:

0 Likes
#22

Hmm. Je suis en train de penser à quelque chose, peut-etre que ca te conviendrait. Tu pourrais peut-être wrapper ta règle entity pour s’assurer qu’elle n’apparaisse qu’une fois.

Ton premier pattern (pour execute) devrait seulement matcher une ligne, donc…

begin: ^execute
end: $
include: entityOnce
include: .*   // invalid chars

Puis, entityOnce est définit comme suit…

begin: (?=\s+@[apre]\[.*\]\s*(\sdetect)?\s*$)
end: $
include: entity

Donc l’idée est que ta règle définit comme begin une assertion positive lookahead qui match une seule fois dans la ligne un skelette de entity.

Le problème, c’est que ca match tout ou rien… Hmm.

EDIT: tu pourrais brisé entity en plusieurs règles qui s’incluent une après l’autre :stuck_out_tongue:

0 Likes
#23

Tu n’as pas fermé le lookahead du regex de entityOnce, tu peux corriger stp ? Je comprendrais mieux puisque j’imagine que seulement une partie est concerné par ça.

0 Likes
#24

Je galère pas mal avec mes syntaxes, je verrais demain. Tu peux m’expliquer ce que ça fais (et ton idée dans l’edit aussi stp) ? En gros entityOnce test si y’a entity et detect et si c’est le cas il applique entity dessus c’est ça ?

0 Likes
#25

Oui, entityOnce s’assure que le reste de la ligne ne contienne entity (en gros) et detect, lequel peut être là 0 ou 1 fois à la fin. Comme begin est seulement un lookahead, il ne match rien, ce qui laisse donc la place à entity pour définir ses scopes.

0 Likes
#26

J’ai fait exactement comme tu as fait mais ça ne marche pas (tout est dans invalid chars après le execute), tu peux re-tester ? Et sinon pour mieux comprendre j’aimerais utiliser YAML, peux-tu me dire comment convertir mes fichiers et comment apprendre à l’utiliser stp ? Merci :slightly_smiling_face:

0 Likes
#27

Hey Aero,
C’est vrai que c’est difficile à résoudre en texte :stuck_out_tongue:

Je viens d’essayer un quick test avec sublime-syntax, et ca semble bien plus simple à réaliser qu’avec tmLanguage. Je te conseille vraiment d’essayer dans ce format là.

1 Like
#28

Hi!

Well, happy that you find your solution but next time, try to

  • write a better title (help me please is the worst I’ve ever seen)
  • speak in english, because this is an english forum, so english people will come and look for answer…

So can you edit the title, so it’s easier to undestand what this topic is about? Because you will not be the only one having this issue.

Mathieu

Au passage, je suis aussi francais

0 Likes