Grammaire et fichier Org : Propriétés

Version imprimable

Bonjour,

Dans les fichiers Org https://orgmode.org/, on peut avoir des propriétés structurée comme suit :

Code:

1
2
3
4
:PROPERTIES:
:key1:      content
:key2:      content2
:END:

Je ne parviens pas à écrire ma grammaire pour lire cela convenablement.
Dans la grammaire complète, (voir https://github.com/alainbebe/org-mod...rgMode.rakumod ), il y d'autres éléments, mais j'ai simplifié.
Dans mes différents test, je parviens à matcher partiellement, mais soit juste une propriété et le texte, soit 1 ou 2 propriétés si pas de texte,...

Une idée ?

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#!/usr/bin/env perl6
 
use v6;
use lib “lib”;
use Data::Dump;
 
grammar Content {
    token TOP        { ^ <header> \n? <properties>? <text>? $ }
    token header     { .*? $$  };
#    token properties { ^^ ":PROPERTIES:\n" (.*?\n) ":END:\n" } # match just one property with text after, not two
#    token properties { ^^ ":PROPERTIES:\n" (.*?\n) ":END:" $$ } # match just one property, not two
#    token properties { ^^ ":PROPERTIES:\n" ((.*?\n)+?) ":END:\n" } # match just one property, not two
#    token properties { ^^ ":PROPERTIES:\n" (.*?) "\n:END:\n" } # no match
#    token properties { ^^ ":PROPERTIES:\n" (.*?\n.*?\n) ":END:" $$ } # match just two property with text after, not one
#    token properties { ^^ ":PROPERTIES:\n" ((.*?\n)+) ":END:" $$ } # match but if no text after
#    token properties { ^^ ":PROPERTIES:\n" ((.*?\n)+) ":END:" \n? } # match but if no text after
#    token properties { ^^ ":PROPERTIES:\n" ((.*?\n)+) ":END:\n" } # no match
#    token properties { ^^ ":PROPERTIES:\n" ((.*?\n)+) ":END:" } # match but if no text after
    token properties { ^^ ":PROPERTIES:\n" ((.*?\n)+) ":END:" } #
    token text       { .* };
}
class Content-actions {
    method TOP($/) {
    }
    method header($/) {
        say "header : ",$/.Str;
    }
    method properties($/) {
        say "--properties--\n",$0.Str;
    }
    method text($/) {
        say "--text--\n",$/.Str;
    }
}
 
my $file =
"One property, no text
:PROPERTIES:
:key1:      content
:END:";
Content.parse($file,:actions(Content-actions)).made;
say "";
 
$file =
"2 properties, no text
:PROPERTIES:
:key1:      content
:key2:      content2
:END:";
Content.parse($file,:actions(Content-actions)).made;
say "";
 
$file =
"One property, with text
:PROPERTIES:
:key1:      content
:END:
my text";
Content.parse($file,:actions(Content-actions)).made;
say "";
 
$file =
"2 properties with text
:PROPERTIES:
:key1:      content
:key2:      content2
:END:
my text";
Content.parse($file,:actions(Content-actions)).made;

Ca qui donne

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
header : One property, no text
--properties--
:key1:      content
 
--text--
 
 
header : 2 properties, no text
--properties--
:key1:      content
:key2:      content2
 
--text--
 
 
header : One property, with text
--text--
:PROPERTIES:
:key1:      content
:END:
my text
 
header : 2 properties with text
--text--
:PROPERTIES:
:key1:      content
:key2:      content2
:END:
my text

Le derniers cas devrait donner

Code:

1
2
3
4
5
6
7
header : 2 properties, no text
--properties--
:key1:      content
:key2:      content2
 
--text--
my text

25/10/2020, 14h54
CosmoKnacki
Le soucis de token avec les quantificateurs, c'est que tu n'as le droit qu'à un seul essai. Donc si tu tentes d'avoir les propriétés suivi de texte :

Code:

token properties { ^^ ":PROPERTIES:" \n ( [ \N+ \n ]+ ) ":END:" $$ }

ne marchera pas car ":END:" $$ est testé sur la dernière ligne de texte (à cause du quantificateur gourmand) et donc échoue.

Même chose avec un quantificateur non gourmand si j'ai plus d'une propriété:

Code:

token properties { ^^ ":PROPERTIES:" \n ( [ \N+ \n ]+? ) ":END:" $$ }

Là le quantificateur +? ne permettra d'atteindre que la première propriété et ":END:" $$ échouera sur la deuxième propriété.

Pour solutionner ça, je vois deux possibilités:
- soit tu renonces à token et tu optes pour regex qui lui peut laisser jouer les quantificateurs jusqu'à réussite (mais théoriquement tu perds en vitesse) avec:
  
  Code:
  
  regex properties { ^^ ":PROPERTIES:" \n ( [ \N+ \n ]+? ) ":END:" $$ }
- soit tu utilises un quantificateur gourmand tout en vérifiant que tu n'as pas atteint la ligne :END: à l'aide d'un test avant négatif (lookahead):
  
  Code:
  
  token properties { ^^ ":PROPERTIES:" \n ( [ <!before ":END:" $$> \N+ \n ]+ ) ":END:" $$ }
À noter que dans l'esprit d'une grammaire, rien ne t'empêche de décomposer properties:
Code:

1 2 token properties { ^^ ":PROPERTIES:" \n ( <property>+ ) ":END:" $$ } token property { ^^ <!before ":END:" $$> \N+ \n }
25/10/2020, 15h26
alainbb

Bon, ben j'ai pas encore tout compris, mais ça avance.
Je prends évidemment la dernière solution avec "property", c'est évidemment plus clair. Et que je vais rapidement affiner pour limiter à détecter ":key: value".

Un grand merci.