scansion 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/lib/scansion.rb ADDED
@@ -0,0 +1,1220 @@
1
+ #!/usr/bin/env ruby
2
+ # frozen_string_literal: true
3
+ #
4
+ # scansion.rb — phonétise des vers français en restaurant le e muet
5
+ # (e caduc) selon les règles de la scansion classique.
6
+ #
7
+ # Règles implémentées :
8
+ # * un e muet interne suivi d'une consonne est prononcé (compté)
9
+ # * un e muet final est prononcé devant un mot à initiale consonantique,
10
+ # élidé devant un mot à initiale vocalique (élision / h muet)
11
+ # * le e muet en fin de vers n'est pas compté, ni devant une pause
12
+ # graphique (, ; : ! ? … —) : rêche, -> ʁɛʃ
13
+ # (--keep-line-end-e pour le compter en fin de vers, p. ex. rime féminine)
14
+ # * la terminaison -ent est prononcée devant une consonne ou un h aspiré
15
+ # à l'intérieur d'un vers, élidée devant une voyelle / un h muet / en fin
16
+ # de vers (avec liaison du t devant une voyelle : peuplent à -> pœplt-a) ;
17
+ # mais après une lettre voyelle (-uent, -ient) le e n'est jamais restauré
18
+ # (perpétuent le -> pɛʁpetylə, 8 syll.)
19
+ # * un e muet final devant un s muet est restauré (tables -> tablə)
20
+ #
21
+ # La liste complète des règles, avec exemples travaillés, est dans
22
+ # docs/scansion_rules.txt.
23
+ #
24
+ # Note de conception : la restauration passe par l'alignement des lettres
25
+ # orthographiques sur les segments phonétiques d'espeak-ng (voir Aligner).
26
+ # Si l'alignement échoue pour un mot, le vers entier retombe sur la sortie
27
+ # brute d'espeak-ng (préfixe de ligne « ~ ») : le script préfère manquer des
28
+ # schwas plutôt que d'en inventer.
29
+ # Limites : petite liste de h aspiré (les autres mots en h élident), pas de
30
+ # dictionnaire d'exceptions, consonnes finales muettes approximatives.
31
+ #
32
+ # Dépendances : espeak-ng sur le $PATH. Backend préféré : phonemizer_ffi.rb
33
+ # (dans ce répertoire) appelant libespeak-ng directement via le gem `ffi` —
34
+ # gem install ffi && apt install libespeak-ng1
35
+ # (sur macOS avec un espeak-ng Homebrew « keg-only », définir
36
+ # PHONEMIZER_ESPEAK_LIB).
37
+ # Replis, dans l'ordre : l'API du gem phonemizer (`gem install phonemizer`),
38
+ # le CLI `phonemize` qu'il fournit, puis espeak-ng directement. Le backend FFI
39
+ # produit une IPA identique octet par octet au gem pour notre usage (asserté
40
+ # dans spec/scansion_spec.rb).
41
+ #
42
+ # Structure : le module Scansion est une bibliothèque pure (le require de ce
43
+ # fichier est sans effet de bord — pas d'OptionParser sur l'ARGV de l'hôte) ;
44
+ # le CLI vit dans Scansion.main et ne tourne que si le fichier est exécuté
45
+ # comme script. process_lines mémoïse scan_line par (ligne, options) pour ne
46
+ # pas relancer espeak-ng à chaque vers lors de la détection de diérèse en
47
+ # deux passes.
48
+ #
49
+ # Utilisation :
50
+ # scansion [--keep-line-end-e] [--no-dierese] [-s|--syllables] [FILE|-]
51
+ #
52
+ # Exemple (un alexandrin de 12 syllabes — e muet interne restauré dans
53
+ # « langueur » -> lɑ̃-gœʁ et « rêveries » -> ʁɛ-və-ʁi ; le -e final de
54
+ # « rêveries » n'est pas compté car il suit une voyelle, comme « gravée ») :
55
+ # $ echo "Au coin du feu, dans la langueur des rêveries!" | scansion
56
+ # Au coin du feu, dans la langueur des rêveries!
57
+ # ⇒ o-kwɛ̃-dy-fø-dɑ̃-la-lɑ̃-gœʁ-de-ʁɛ-və-ʁi (12 syll.)
58
+
59
+ require "optparse"
60
+ require "open3"
61
+ require_relative "scansion/version"
62
+
63
+ module Scansion
64
+ SCHWA = "ə"
65
+
66
+ VOWEL_PHONE = /[aeiouyɛɔəɑøœæɒʌɪ]/
67
+ VOWEL_LETTER = /[aeiouyàâäéèêëîïoôöùûüœ]/
68
+ # lettres voyelles par lesquelles un mot SUIVANT peut commencer, pour le
69
+ # test du « e oral » dans elidable_final_e? (remet à -> ʁəmɛta n'est pas
70
+ # une élision)
71
+ NEXT_VOWELISH = /\A[àaâäiîïoôöuùûüywœ]/u
72
+ GLIDE_PHONE = /\A[jɥw]/
73
+ SOFT_NEXT = %w[e i y é è ê].freeze # lettres qui adoucissent c/g
74
+
75
+ CONSONANT_DIGRAPHS = {
76
+ "ch" => "ʃ", "ph" => "f", "th" => "t",
77
+ "qu" => "k", "ss" => "s", "ck" => "k", "gn" => "ɲ",
78
+ }.freeze
79
+
80
+ CONSONANT_LETTERS = {
81
+ "b" => "b", "d" => "d", "f" => "f", "j" => "ʒ", "k" => "k",
82
+ "l" => "l", "m" => "m", "n" => "n", "p" => "p", "q" => "k",
83
+ "r" => "ʁ", "s" => "s", "t" => "t", "v" => "v", "w" => "w",
84
+ "z" => "z", "h" => nil, # h est muet
85
+ }.freeze
86
+
87
+ # Suites de lettres finales qui peuvent rester non prononcées une fois tous
88
+ # les segments phonétiques consommés. Toute autre chose fait échouer
89
+ # l'alignement (repli sur la sortie brute). Liste littérale (SILENT_TAIL_LIST)
90
+ # pour rester lisible ; l'expression régulière en est déduite. Ancrage aux
91
+ # deux extrémités, donc l'ordre des alternatives est sans importance.
92
+ SILENT_TAIL_LIST = %w[
93
+ ent ents nt nts nte ntes ns nc ms cs gts ct s t ts d x z p ps g gt
94
+ st ut ôt u au aux eau eaux eux ux ous r n it ds rs c f ufs oeufs m
95
+ ].freeze
96
+ SILENT_TAILS = /\A(?:#{SILENT_TAIL_LIST.map { |t| Regexp.escape(t) }.join("|")})\z/
97
+
98
+ # ce qui peut suivre un e muet quasi final avant la terminaison muette :
99
+ # « s » (tables), « ts » (sifflets), « ps », « x » (silex), ou rien (Philippe)
100
+ E_MUET_TAIL = /\A(?:s|ts?|ps|x)?\z/
101
+ # la terminaison après le e de la désinence verbale -ent : « nt » / « nts »
102
+ ENT_TAIL = /\A(?:nts?)\z/
103
+
104
+ # digrammes qu'espeak-ng peut rendre par un phone alternatif
105
+ DIGRAPH_ALT = { "gn" => "n" }.freeze
106
+
107
+ # digrammes de voyelles prononcés comme un seul noyau syllabique, associés
108
+ # au nombre de voyelles (lettres) qu'espeak-ng émet pour eux (absorber la
109
+ # 2e lettre ; ne pas la laisser manger la voyelle du mot suivant :
110
+ # ou entendre ; ui -> yi)
111
+ DIGRAPH_ONE_PHONE = { "ai" => 1, "au" => 1, "ou" => 1, "eu" => 1,
112
+ "ei" => 1, "ay" => 1, "ey" => 1, "ui" => 2,
113
+ "ue" => 1, "oe" => 2 }.freeze # boeufs -> b-øo
114
+
115
+ # lettres dont la consonne finale fait liaison devant un mot à initiale
116
+ # vocalique (elle reste donc l'ATTAQUE de la syllabe suivante :
117
+ # les amis -> lɛ-za-mi)
118
+ LIAISON_LETTERS = %w[s x z d g b n m].freeze
119
+
120
+ # consonne finale prononcée avec sa valeur de liaison devant une voyelle
121
+ # (les amis -> lɛzami, quand il -> kɑ̃til, grand ami -> gʁɑ̃tami...)
122
+ LIAISON_FINAL = { "s" => "z", "z" => "s", "d" => "t", "g" => "k", "b" => "p" }.freeze
123
+
124
+ # dévoisement final tel que le rend espeak-ng (Austerlitz -> ...lits)
125
+ FINAL_DEVOICE = { "z" => "s", "d" => "t", "b" => "p", "g" => "k", "v" => "f" }.freeze
126
+
127
+ # Petite liste de mots fréquents à h aspiré (correspondance par préfixe :
128
+ # « hisser » couvre aussi hissera, hissons, hissé...). Un mot à h aspiré
129
+ # est PHONÉTIQUEMENT à initiale vocalique (le h est muet : « hasard » ->
130
+ # /a-zaʁ/) mais BLOQUE l'élision/la liaison du mot précédent :
131
+ # « le hasard » -> lə-a-zaʁ, jamais *la-zaʁ ; « se hisser » -> sə-i-se,
132
+ # jamais *sise. À contraster avec le h muet : « l'homme » -> lɔm (élision).
133
+ # Voir h_aspiré? / elides_before?.
134
+ H_ASPIRE = %w[haie haine hache honte héros hérisson harpe halle
135
+ hurler heaume hocher hibou hisser hasard].freeze
136
+
137
+ # Exceptions à la règle « -Cr- + e muet » (docs/scansion_rules.txt 1.5d) :
138
+ # dans ces mots, le e final EST prononcé devant une consonne
139
+ # (entre -> ɑ̃-tʁə, ventre -> vɑ̃-tʁə), contrairement à arbre -> aʁbʁ,
140
+ # mettre -> mɛtʁ, fièvre -> fjɛvʁ. Devant une voyelle ou en fin de vers,
141
+ # l'élagage normal s'applique toujours (élision / non compté).
142
+ CR_E_PRONOUNCED = %w[entre ventre].freeze
143
+
144
+ Result = Struct.new(:text, :raw, :phones, :syllables, :aligned, :dierese,
145
+ keyword_init: true) do
146
+ # true si le vers est retombé sur la sortie brute d'espeak-ng (pas d'alignement)
147
+ def fallback? = !aligned
148
+ end
149
+
150
+ # État mutable de l'alignement d'UN mot orthographique sur les segments
151
+ # phonétiques (voir align_word). Un Struct pour que les méthodes step
152
+ # partagent et modifient l'index de lettre / le curseur de segments sans
153
+ # longue liste de paramètres. step renvoie true (lettre consommée, on
154
+ # continue), :done (arrêt : alignement réussi tôt — terminaison muette alors
155
+ # que les segments sont épuisés) ou false (alignement impossible → le vers
156
+ # entier retombe sur espeak brut).
157
+ Aligner = Struct.new(
158
+ :word, :segs, :out, :i, :cursor, :n,
159
+ :prev_cons, :prev_vowel_phone, :run_split,
160
+ :next_vowel_initial, :next_word, :prev_fragment, :dierese,
161
+ keyword_init: true
162
+ ) do
163
+ def run
164
+ while i < n
165
+ r = step
166
+ return false if r == false
167
+ break if r == :done
168
+ end
169
+ true
170
+ end
171
+
172
+ # Consomme une lettre du mot. Aiguille vers step_vowel / step_consonant.
173
+ def step
174
+ ch = word[i]
175
+ two = word[i, 2]
176
+
177
+ if cursor >= segs.size
178
+ rest = word[i..]
179
+ if rest.match?(/\Aents?\z/)
180
+ self.i = n # désinence -ent : jamais restaurée
181
+ elsif rest.match?(SILENT_TAILS)
182
+ return :done
183
+ elsif i.positive? && rest[0] == word[i - 1]
184
+ self.i += 1 # lettre redoublée en toute fin (pierre -> pjɛʁ)
185
+ elsif rest.match?(/\Aes?\z/)
186
+ if i.positive? && word[i - 1].match?(VOWEL_LETTER)
187
+ self.i += 1 # e après une lettre voyelle : jamais restauré (gravée)
188
+ else
189
+ out << [SCHWA, true] # e muet final : on le restaure
190
+ self.i += 1
191
+ end
192
+ else
193
+ # plus de phones : les lettres restantes ne peuvent être que muettes
194
+ # (fin de vers) ; on les absorbe plutôt que de faire échouer tout
195
+ # le vers
196
+ self.i = n
197
+ end
198
+ return true
199
+ end
200
+
201
+ head = segs[cursor]
202
+ head_vowel = head[0].match?(VOWEL_PHONE)
203
+
204
+ # digrammes de consonnes
205
+ if CONSONANT_DIGRAPHS[two] &&
206
+ (head[0] == CONSONANT_DIGRAPHS[two] ||
207
+ (DIGRAPH_ALT[two] && head[0] == DIGRAPH_ALT[two]))
208
+ out << [head, false]
209
+ self.cursor += 1
210
+ # espeak-ng peut rendre ɲ par n+j (éteignent -> etɛnj...)
211
+ if two == "gn" && head[0] == "n" && segs[cursor] &&
212
+ segs[cursor][0] == "j"
213
+ out << [segs[cursor], false]
214
+ self.cursor += 1
215
+ end
216
+ self.i += 2
217
+ self.prev_cons = two
218
+ return true
219
+ end
220
+
221
+ ch.match?(VOWEL_LETTER) ? step_vowel(ch, head, head_vowel)
222
+ : step_consonant(ch, head, head_vowel)
223
+ end
224
+
225
+ # Une lettre voyelle face à la tête de segment courante.
226
+ def step_vowel(ch, head, head_vowel)
227
+ # une lettre voyelle qui amorce une terminaison muette de plusieurs
228
+ # lettres devant un phone consonne n'est pas prononcée du tout
229
+ # (boeufs -> bø, le « ufs » est muet ; les terminaisons d'une seule
230
+ # lettre, comme le u de « tu », sont laissées à la branche glide)
231
+ if !head_vowel && !head.match?(GLIDE_PHONE) &&
232
+ word[i..].to_s.length >= 2 &&
233
+ Scansion.silent_tail_from?(word, i) &&
234
+ !word[i..].to_s.end_with?("x") && # le x de -aux/-eux peut faire liaison (beaux yeux)
235
+ !Scansion.ent_tail?(word, i) # -ent a sa propre règle
236
+ self.i = n
237
+ return true
238
+ end
239
+
240
+ # u muet après g/q suivi d'une voyelle (guerre, qui)
241
+ if ch == "u" && %w[g q].include?(prev_cons) &&
242
+ Scansion.vowel_letter?(word[i + 1])
243
+ self.i += 1
244
+ self.prev_cons = nil
245
+ return true
246
+ end
247
+
248
+ # e muet final devant un mot suivant à initiale vocalique : espeak-ng
249
+ # l'a élidé, donc on restaure un schwa SANS consommer la tête de segment
250
+ # (conditions exactes dans elidable_final_e?) ; l'élagage de scansion
251
+ # ci-dessous retire à nouveau ce schwa restauré (élision).
252
+ if Scansion.elidable_final_e?(word, i, head, out, next_vowel_initial, next_word)
253
+ out << [SCHWA, true]
254
+ self.i += 1
255
+ return true
256
+ end
257
+
258
+ # terminaison -ent (chantent, mélangent...) : le e muet avant -nt EST
259
+ # prononcé quand le mot suivant commence par une consonne ou un h
260
+ # aspiré, à l'intérieur d'un vers — MAIS seulement si le e suit une
261
+ # consonne. Après une lettre voyelle, il appartient au groupe voyelle
262
+ # et n'est jamais restauré (-uent, -ient : perpétuent -> pɛʁpety,
263
+ # criaient -> kʁiɛ). On restaure le schwa et on laisse l'élagage de
264
+ # scansion le supprimer devant une voyelle / un h muet / en fin de vers.
265
+ # Devant une voyelle, espeak-ng peut garder la liaison t
266
+ # (peuplent à -> pœplt-a). Une voyelle nasale en tête signifie que le e
267
+ # n'est pas muet (violent -> vjolɑ̃) : on laisse alors la branche voyelle.
268
+ if ch == "e" && Scansion.ent_tail?(word, i) &&
269
+ head[0] != SCHWA && !head.match?(/̃/)
270
+ if next_vowel_initial && head[0] == "t"
271
+ out << [head, false] # liaison du t
272
+ self.cursor += 1
273
+ self.i = n
274
+ elsif i.positive? && word[i - 1].match?(VOWEL_LETTER)
275
+ self.i += 1 # -uent/-ient : le e fait partie du groupe voyelle précédent
276
+ else
277
+ out << [SCHWA, true]
278
+ self.i = n
279
+ end
280
+ return true
281
+ end
282
+
283
+ # e après un g/c adouci est muet (vengeance -> vɑ̃ʒɑ̃s, le « ge » ne
284
+ # vaut que ʒ ; pages -> paʒ) — quand il est suivi d'une voyelle, ou
285
+ # d'un s/x final après une voyelle (mais c'est garde son e : c initial)
286
+ if ch == "e" && i >= 1 && %w[c g].include?(word[i - 1]) &&
287
+ (Scansion.vowel_letter?(word[i + 1]) ||
288
+ (i >= 2 && word[i - 2].match?(VOWEL_LETTER) &&
289
+ Scansion.e_muet_tail?(word, i)))
290
+ self.i += 1
291
+ self.prev_vowel_phone = true
292
+ return true
293
+ end
294
+
295
+ if head_vowel &&
296
+ !Scansion.final_e_before_vowel?(word, i, head, out, next_vowel_initial)
297
+ # (un e quasi final devant un mot SUIVANT à initiale vocalique ne
298
+ # consomme jamais de segment voyelle : si la tête est une voyelle
299
+ # autre que le schwa, elle appartient au mot suivant — la branche
300
+ # elidable_final_e? ci-dessus restaure sans consommer (ou la branche
301
+ # ch == "e" ci-dessous le fait, quand la tête est une consonne).
302
+ # Devant un mot à initiale consonantique, une tête voyelle est celle
303
+ # de ce mot (bouquet de -> bu-kɛ) et doit être consommée.)
304
+ # digramme de voyelles en une syllabe (ou, ai, ui -> yi...) :
305
+ # consommer toute la suite et absorber la deuxième lettre — sauf si
306
+ # la suite chevauche une frontière de mot (ou entendre -> suite
307
+ # « uɑ̃ » : ne garder que 'u')
308
+ # un digramme ne se déclenche que si la lettre n'est pas déjà la
309
+ # deuxième lettre d'un digramme précédent (alouettes : ou+e -> le e
310
+ # compte encore)
311
+ digraph = DIGRAPH_ONE_PHONE[ch + word[i + 1].to_s]
312
+ run_vowels = head.each_char.count { |c| c.match?(VOWEL_PHONE) }
313
+ # supprimé quand la lettre courante est déjà la 2e lettre d'un
314
+ # digramme avec la précédente (alouettes : ou+e -> le e compte
315
+ # encore ; mais yeux : y est le glide j, donc eu EST un digramme)
316
+ # — SAUF si la suite contient 2 voyelles (aiguille -> ɛ-g-yi-j :
317
+ # le « ui » EST ici un digramme à 2 voyelles, contrairement à alouettes)
318
+ digraph = nil if i.positive? &&
319
+ DIGRAPH_ONE_PHONE.key?(word[i - 1].to_s + ch) &&
320
+ run_vowels <= 1
321
+ # la lettre courante est la 2e d'un digramme ET la suite contient
322
+ # 2 voyelles : le digramme est la paire PRÉCÉDENTE (aiguille ->
323
+ # ɛ-g-yi-j, le « ui » = 2 lettres u+i rendues par la suite « yi »)
324
+ if digraph.nil? && i.positive? && run_vowels > 1 &&
325
+ DIGRAPH_ONE_PHONE.key?(word[i - 1].to_s + ch)
326
+ digraph = DIGRAPH_ONE_PHONE[word[i - 1].to_s + ch]
327
+ end
328
+ # un digramme dont la suite est une paire glide+voyelle (muette -> yɛ,
329
+ # tuer -> ye) est prononcé comme la suite ENTIÈRE, pas coupée en deux
330
+ glide_run = run_vowels == 2 && head[0].match?(/[ɥyjw]/)
331
+ # un digramme à 2 voyelles (oe -> øo : Noël) dont la suite contient
332
+ # exactement 2 voyelles devant un mot suivant à initiale vocalique
333
+ # est ambigu : la suite peut chevaucher la frontière de mot
334
+ # (boeufs au -> ø+o). Dans ce cas, ne prendre qu'UNE voyelle et
335
+ # laisser le reste au mot suivant.
336
+ boundary_run = next_vowel_initial && digraph.to_i > 1 &&
337
+ run_vowels == digraph && !glide_run
338
+ if digraph && !boundary_run && (run_vowels <= digraph || glide_run)
339
+ out << [head, false]
340
+ self.cursor += 1
341
+ eat = 2
342
+ # la 2e lettre du digramme peut encore être prononcée comme un
343
+ # glide dans son propre segment (ay -> ɛ+j : rayonner -> ʁɛ-jɔn)
344
+ # — seulement en milieu de mot, donc un digramme final (fou, tout)
345
+ # ne vole jamais le glide initial du mot suivant
346
+ if i + 2 < n && word[i + 1] == "y" && word[i + 2] != "l" &&
347
+ segs[cursor] && segs[cursor][0].match?(GLIDE_PHONE)
348
+ out << [segs[cursor], false]
349
+ self.cursor += 1
350
+ end
351
+ else
352
+ # consommer la part du digramme dans la suite (ou UNE voyelle quand
353
+ # il n'y a pas de digramme) : une suite peut chevaucher une frontière
354
+ # de mot (violent héros -> segment « ɑ̃e » = ɑ̃ + é de héros ;
355
+ # nuit est -> segment « yiɛ » = yi de nuit + ɛ de est)
356
+ take = digraph ? [run_vowels, digraph].min : 1
357
+ take = 1 if boundary_run
358
+ units = head.scan(/#{VOWEL_PHONE.source}\p{Mn}*/)
359
+ consumed = units.first(take).join
360
+ rest = head[consumed.length..].to_s
361
+ # espeak-ng fait parfois écho à la 2e lettre du digramme
362
+ # (pays -> p-ɛ-i, paysage -> p-ɛ-i-zaʒ) : on avale cet écho quand
363
+ # le mot se termine juste après le digramme, ou en milieu de mot
364
+ # avant une consonne (mais ou entendre garde la voyelle du mot
365
+ # suivant : mot suivant à initiale vocalique)
366
+ if digraph && rest.length == 1 && rest.match?(VOWEL_PHONE) &&
367
+ (word[(i + 2)..].to_s.match?(/\A(?:s|x)?\z/) ||
368
+ (!Scansion.vowel_letter?(word[i + 2]) && word[i + 2])) &&
369
+ !next_vowel_initial
370
+ rest = ""
371
+ end
372
+ if rest.empty?
373
+ out << [head, false]
374
+ self.cursor += 1
375
+ else
376
+ out << [consumed, false]
377
+ segs[cursor] = rest
378
+ self.run_split = true
379
+ end
380
+ eat = 1
381
+ eat += 1 if digraph
382
+ end
383
+ # absorber un n/m fermé, éventuellement à travers un digramme de
384
+ # voyelles (maintenant : a+i+n -> ɛ̃) — mais pas le e muet de -ent
385
+ absorbed_nasal = false
386
+ j = i + eat
387
+ nxt = segs[cursor].to_s[0]
388
+ if word[j].to_s.match?(/[nm]/) &&
389
+ !Scansion.vowel_letter?(word[j + 1]) &&
390
+ !(nxt == word[j] && %w[n m].include?(nxt)) # hymne : le phone m est encore en attente
391
+ eat = j - i + 1
392
+ absorbed_nasal = true
393
+ end
394
+ self.i += eat
395
+ # quand une suite chevauchant une frontière a été coupée
396
+ # (boeufs au -> ø+o), les lettres restantes après le digramme peuvent
397
+ # former une terminaison muette (boeufs -> bø, le « ufs » est muet)
398
+ self.i = n if boundary_run && Scansion.silent_tail_from?(word, i)
399
+ # liaison de ce n/m devant une voyelle (un art -> œ̃naʁt)
400
+ # — seulement quand le nasal est la dernière lettre du mot, pas une
401
+ # lettre interne (montmartre ne doit pas faire liaison avec son propre m)
402
+ if absorbed_nasal && next_vowel_initial && j == n - 1 &&
403
+ segs[cursor] && segs[cursor][0].match?(/[nm]/)
404
+ out << [segs[cursor], false]
405
+ self.cursor += 1
406
+ end
407
+ self.prev_cons = nil
408
+ self.prev_vowel_phone = true
409
+ return true
410
+ elsif head.match?(GLIDE_PHONE) &&
411
+ (%w[i u o y].include?(ch) ||
412
+ (ch == "a" && i.positive? && word[i - 1].match?(VOWEL_LETTER)) ||
413
+ # e de eu/ei rendu comme un glide (joyeuse -> ʒwa-jøz)
414
+ (ch == "e" && DIGRAPH_ONE_PHONE.key?("e" + word[i + 1].to_s)))
415
+ # glide devant une voyelle (vieux, huit, oi...)
416
+ # DIÉRÈSE : un « i » devant une voyelle pleine qu'espeak-ng a rendu
417
+ # comme un glide compte pour DEUX syllabes en vers (lion -> li-jɔ̃,
418
+ # violent -> vi-jɔ-lɑ̃, dieu -> di-jø) — sauf « hier » [jɛʁ]
419
+ if dierese && ch == "i" && word != "hier" &&
420
+ word[i + 1].to_s.match?(/[aàâäeéèêoôöœ]/) &&
421
+ segs[cursor + 1] && segs[cursor + 1][0].match?(VOWEL_PHONE)
422
+ out << ["i", true] # voyelle restaurée : diérèse
423
+ end
424
+ out << [head, false]
425
+ self.cursor += 1
426
+ self.i += 1
427
+ # -il/-ill fait partie du glide (œil, soleil, jaillisse...) ;
428
+ # idem pour une voyelle avalée quand aucun phone voyelle ne suit
429
+ # (feuilles)
430
+ self.i += 1 while word[i] == "l" ||
431
+ (Scansion.vowel_letter?(word[i]) && word[i] != "e" &&
432
+ !(segs[cursor] && segs[cursor][0].match?(VOWEL_PHONE)))
433
+ # un segment voyelle juste après le glide, en milieu de mot, est le
434
+ # noyau de la lettre courante (a -> j+a : effroyable, voyage)
435
+ # — mais jamais une voyelle NASALE : elle appartient à un n/m suivant
436
+ # (voyant -> vwa-jɑ̃-t, pas vwa-ja-nt)
437
+ if i < n && segs[cursor] && segs[cursor][0].match?(VOWEL_PHONE) &&
438
+ !segs[cursor].match?(/̃/) &&
439
+ word[i] != "l" && !word[i].match?(VOWEL_LETTER)
440
+ out << [segs[cursor], false]
441
+ self.cursor += 1
442
+ end
443
+ self.prev_cons = nil
444
+ self.prev_vowel_phone = false
445
+ return true
446
+ elsif ch == "e"
447
+ if i.positive? && word[i - 1].match?(VOWEL_LETTER) &&
448
+ Scansion.e_muet_tail?(word, i)
449
+ # le e FINAL après une lettre voyelle appartient au groupe voyelle
450
+ # et n'est jamais compté (gravée -> gʁav, suivie -> syi-vi) ; un e
451
+ # interne avant une consonne est compté (alouettes -> a-lou-e-tte)
452
+ self.i += 1
453
+ self.prev_vowel_phone = true
454
+ return true
455
+ end
456
+ if i >= 2 && word[i - 1] == "r" &&
457
+ !word[i - 2].match?(VOWEL_LETTER) &&
458
+ Scansion.e_muet_tail?(word, i) &&
459
+ !CR_E_PRONOUNCED.include?(word)
460
+ # e muet après un cluster -Cr- est MUET même devant une consonne :
461
+ # sombre -> sɔ̃bʁ, nombre -> nɔ̃bʁ, mettre -> mɛtʁ, fièvre -> fjɛvʁ
462
+ # (mais tables -> tablə : le -l- est conservé).
463
+ # SAUF entre/ventre (CR_E_PRONOUNCED) : leur e final est prononcé
464
+ # devant une consonne -> ɑ̃-tʁə, vɑ̃-tʁə, donc on laisse passer à
465
+ # la restauration normale ci-dessous.
466
+ self.i += 1
467
+ self.prev_vowel_phone = true
468
+ return true
469
+ end
470
+ # e muet : c'est ici la restauration
471
+ out << [SCHWA, true]
472
+ self.i += 1
473
+ self.prev_vowel_phone = true
474
+ return true
475
+ elsif i.positive? && (word[i - 1].match?(VOWEL_LETTER) || word[i - 1] == "h")
476
+ # deuxième lettre d'un digramme de voyelles (ai, au, ou, ui, eu...) :
477
+ # un phone pour deux lettres, absorbée en silence ; aussi la voyelle
478
+ # d'un mot à h muet après élision (l'homme -> lɔm)
479
+ self.i += 1
480
+ self.prev_cons = nil
481
+ self.prev_vowel_phone = true
482
+ return true
483
+ elsif i.zero?
484
+ # voyelle initiale muette (alors -> lɔʁ)
485
+ self.i += 1
486
+ self.prev_cons = nil
487
+ self.prev_vowel_phone = false
488
+ return true
489
+ else
490
+ return false
491
+ end
492
+ end
493
+
494
+ # Une lettre consonne face à la tête de segment courante.
495
+ def step_consonant(ch, head, head_vowel)
496
+ self.prev_vowel_phone = false
497
+ exp = Scansion.expected_consonant(ch, word[i + 1].to_s)
498
+ # s intervocalique sonorisé en z (gueuse, désormais... ; aussi devant
499
+ # un h muet : déshonneur -> de-zɔ-nœʁ)
500
+ exp = "z" if ch == "s" && i.positive? &&
501
+ word[i - 1].match?(VOWEL_LETTER) &&
502
+ (Scansion.vowel_letter?(word[i + 1]) || word[i + 1] == "h")
503
+ # s initial sonorisé en z devant une consonne voisée quand espeak-ng
504
+ # l'a fait (sveltesse -> zvɛltɛs)
505
+ exp = "z" if ch == "s" && i.zero? && head[0] == "z"
506
+ # le mot c' devant une voyelle -> s (c'est, c'était...)
507
+ exp = "s" if ch == "c" && word == "c" && next_vowel_initial
508
+ # c muet dans sc- devant une voyelle douce (scellé -> sɛle, scintille)
509
+ if ch == "c" && i.positive? && word[i - 1] == "s" &&
510
+ SOFT_NEXT.include?(word[i + 1].to_s)
511
+ self.i += 1
512
+ return true
513
+ end
514
+ # -tion/-tieux -> sjon (dilatation, captieux), mais question -> kɛstjɔ̃
515
+ # et -tié/-tier gardent leur t (pitié -> pitje, sentier -> sɑ̃tje) :
516
+ # ne se déclenche que si espeak-ng a réellement supprimé le t pour un s
517
+ exp = "s" if ch == "t" && word[i + 1] == "i" &&
518
+ Scansion.vowel_letter?(word[i + 2]) &&
519
+ word[i - 1] != "s" && head[0] == "s"
520
+ # second(e) se prononce avec un g dur (seconde -> səgɔ̃d)
521
+ exp = "g" if ch == "c" && word.start_with?("second")
522
+
523
+ if exp.nil? && ch != "x" # h muet (x traité plus bas)
524
+ if ch == "h" && head[0] == "h"
525
+ # h qu'espeak-ng a réellement prononcé (hier -> hiəʁ)
526
+ out << [head, false]
527
+ self.cursor += 1
528
+ end
529
+ self.i += 1
530
+ self.prev_cons = "h"
531
+ return true
532
+ end
533
+
534
+ if Scansion.silent_tail_from?(word, i) && next_word &&
535
+ Scansion.expected_consonant(next_word[0].to_s, next_word[1].to_s) == head[0] &&
536
+ !(segs[cursor + 1] && segs[cursor + 1][0] == head[0])
537
+ # terminaison muette : le segment unique est le phone initial du mot
538
+ # suivant (noms célestes -> nɔ̃selɛst, est son -> ɛsɔ̃, nœud de ->
539
+ # nødə, vieux sperme -> vjøspɛʁm). Mais quand espeak-ng a dupliqué le
540
+ # phone (cher raison -> ʁʁɛz), chaque mot prend le sien.
541
+ self.i = n
542
+ return true
543
+ end
544
+
545
+ # g muet après n devant une consonne (longtemps -> lɔ̃tɑ̃)
546
+ if ch == "g" && i.positive? && word[i - 1] == "n" &&
547
+ !%w[ɲ n g ʒ].include?(head[0])
548
+ self.i += 1
549
+ return true
550
+ end
551
+
552
+ # p muet après m (compte -> kɔ̃t)
553
+ if ch == "p" && i.positive? && word[i - 1] == "m" && head[0] != "p"
554
+ self.i += 1
555
+ return true
556
+ end
557
+
558
+ # p muet devant t (sept -> sɛt)
559
+ if ch == "p" && word[i + 1] == "t" && head[0] == "t"
560
+ self.i += 1
561
+ return true
562
+ end
563
+
564
+ # t muet devant m (montmartre -> mɔ̃-maʁ-tʁ)
565
+ if ch == "t" && word[i + 1] == "m" && head[0] != "t"
566
+ self.i += 1
567
+ return true
568
+ end
569
+
570
+ # r muet devant l quand espeak l'a supprimé (waterloo -> wɔ-tə-lu)
571
+ if ch == "r" && word[i + 1] == "l" && head[0] == "l"
572
+ self.i += 1
573
+ return true
574
+ end
575
+
576
+ # l muet devant un s final que espeak A bien sonorisé
577
+ # (fils -> fis, mais ils -> il)
578
+ if ch == "l" && word[i + 1] == "s" && i + 2 == n && head[0] == "s"
579
+ out << [head, false]
580
+ self.cursor += 1
581
+ self.i = n
582
+ self.prev_cons = "s"
583
+ return true
584
+ end
585
+
586
+ if ch == "x" && (head[0] == "k" || %w[s z g].include?(head[0]))
587
+ if head[0] == "k" # x -> ks
588
+ out << [head, false]
589
+ self.cursor += 1
590
+ if segs[cursor] && segs[cursor][0] == "s"
591
+ out << [segs[cursor], false]
592
+ self.cursor += 1
593
+ end
594
+ else # six, dix, existe -> gz...
595
+ out << [head, false]
596
+ self.cursor += 1
597
+ if head[0] == "g" && segs[cursor] && segs[cursor][0] == "z"
598
+ out << [segs[cursor], false]
599
+ self.cursor += 1
600
+ end
601
+ end
602
+ self.i += 1
603
+ return true
604
+ end
605
+
606
+ # -ll- après une voyelle se rend par j (aiguille -> ɛgij)
607
+ if ch == "l" && i.positive? && word[i - 1].match?(VOWEL_LETTER) &&
608
+ head[0] == "j"
609
+ out << [head, false]
610
+ self.cursor += 1
611
+ self.i += 1 while word[i] == "l"
612
+ self.prev_cons = "l"
613
+ return true
614
+ end
615
+
616
+ # t initial fondu dans la liaison du mot précédent
617
+ # (et toi -> etwa : le t est celui de et)
618
+ if i.zero? && ch == "t" && head[0] != "t" &&
619
+ (head_vowel || head.match?(GLIDE_PHONE))
620
+ self.i += 1
621
+ return true
622
+ end
623
+
624
+ if head[0] == exp || (ch == "w" && head[0] == "v") || # wagon -> vagɔ̃
625
+ (i == n - 1 && FINAL_DEVOICE[ch] == head[0]) # dévoisement final (Austerlitz -> ...lits)
626
+ out << [head, false]
627
+ self.cursor += 1
628
+ self.i += 1
629
+ self.prev_cons = ch
630
+ elsif next_vowel_initial && word[i..].to_s.match?(/[sdzgb]\z/) &&
631
+ head[0] == LIAISON_FINAL[word[i..][-1].to_s]
632
+ # liaison d'une consonne finale devant une voyelle (les amis -> lɛzami,
633
+ # fronts étoilés -> fʁɔ̃zetwal, quand il -> kɑ̃til, grand ami...)
634
+ out << [head, false]
635
+ self.cursor += 1
636
+ self.i = n
637
+ self.prev_cons = ch
638
+ elsif next_vowel_initial && word[i..].to_s.match?(/\A(?:n?sts?|x)\z/) &&
639
+ head[0] == "t"
640
+ # liaison d'un -st / -x final devant une voyelle (est autre -> ɛtotʁ)
641
+ out << [head, false]
642
+ self.cursor += 1
643
+ self.i = n
644
+ self.prev_cons = ch
645
+ elsif i == n - 1 && ch == "r" && next_vowel_initial && head[0] != "ʁ"
646
+ # liaison r supprimée par espeak-ng (qu'amer aucun -> ka-meʁ-o)
647
+ out << ["ʁ", true]
648
+ self.i += 1
649
+ elsif prev_fragment && run_split && word[i..].to_s.size >= 2 &&
650
+ head[0].match?(VOWEL_PHONE) &&
651
+ Scansion.silent_tail_from?(word, i) &&
652
+ segs[cursor + 1] &&
653
+ !segs[cursor + 1][0].match?(VOWEL_PHONE) &&
654
+ Scansion.expected_consonant(word[i..][-1], nil) == segs[cursor + 1][0]
655
+ # le reste de la suite voyelle appartient au mot précédent
656
+ # (fragment d'apostrophe : c' est -> se|ɛ) : on l'émet ici pour que
657
+ # le curseur avance au-delà de la suite et que la terminaison muette
658
+ # puisse correspondre
659
+ out << [head, false]
660
+ self.cursor += 1
661
+ self.prev_vowel_phone = true
662
+ elsif %w[n m].include?(ch) && head.match?(/̃/) &&
663
+ head[0].match?(/[ɑɛɔœ]/) &&
664
+ word[(i + 1)..].to_s.match?(SILENT_TAILS) # NB : depuis i+1, pas i (soyons, diligently...)
665
+
666
+ # n/m fermé par une terminaison muette, rendu comme une voyelle nasale
667
+ # (soyons -> swa-jɔ̃, le s final est muet). Avancer seulement après la
668
+ # lettre nasale : un -t final devant un mot à initiale vocalique est une
669
+ # liaison et doit encore être consommé (voyant à -> vwa-jɑ̃-ta)
670
+ out << [head, false]
671
+ self.cursor += 1
672
+ self.i += 1
673
+ elsif Scansion.silent_tail_from?(word, i)
674
+ # terminaison muette quel que soit le segment suivant (et, tables,
675
+ # dont, fronts, coups...) : les lettres restantes ne sont pas prononcées
676
+ self.i = n
677
+ elsif i.positive? && word[i - 1] == ch
678
+ # consonne redoublée prononcée une seule fois (belle, bonne, mettra...)
679
+ self.i += 1
680
+ self.prev_cons = ch
681
+ else
682
+ return false
683
+ end
684
+ true
685
+ end
686
+ end
687
+
688
+ class << self
689
+ # -- petits prédicats sur les lettres (partagés avec Aligner) ------
690
+
691
+ def vowel_letter?(ch) = ch.to_s.match?(VOWEL_LETTER)
692
+ def silent_tail_from?(word, i) = word[i..].to_s.match?(SILENT_TAILS)
693
+ def e_muet_tail?(word, i) = word[(i + 1)..].to_s.match?(E_MUET_TAIL)
694
+ def ent_tail?(word, i) = word[(i + 1)..].to_s.match?(ENT_TAIL)
695
+
696
+ # Forme courte : word[i] est un e muet quasi final devant un mot suivant
697
+ # à initiale vocalique, la tête n'est pas un schwa prononcé, et le mot a
698
+ # déjà une voyelle à lui. Sert à empêcher un tel e de consommer le segment
699
+ # voyelle de tête (la voyelle appartient au mot suivant).
700
+ def final_e_before_vowel?(word, i, head, out, next_vowel_initial)
701
+ word[i] == "e" && next_vowel_initial && head[0] != SCHWA &&
702
+ e_muet_tail?(word, i) &&
703
+ out.any? { |ph, _| ph[0].match?(VOWEL_PHONE) }
704
+ end
705
+
706
+ # Forme longue (ajoute la garde du « e oral ») : le e muet est vraiment
707
+ # élidé par espeak-ng parce que le mot suivant est à initiale vocalique,
708
+ # donc on restaure un schwa ici (l'élagage de scansion le retire ensuite).
709
+ # PAS une élision quand la tête est un e/ɛ ORAL que le mot suivant ne peut
710
+ # pas produire : c'est la voyelle propre de ce mot (remet à -> ʁəmɛta) ;
711
+ # un ɛ̃ nasal appartient au mot suivant (encore informe -> ...kɔʁɛ̃f...).
712
+ # PAS non plus une élision pour les mots en -Cr- à e muet (sombre,
713
+ # mettre) : leur e est muet de toute façon, même devant un h aspiré
714
+ # (sombre héros -> sɔ̃-bʁe-ʁo, pas sɔ̃-bʁə-...) ; CR_E_PRONOUNCED
715
+ # (entre, ventre) est exempté.
716
+ def elidable_final_e?(word, i, head, out, next_vowel_initial, next_word)
717
+ return false unless final_e_before_vowel?(word, i, head, out, next_vowel_initial)
718
+ # un e FINAL en -Cr- (sombre, mettre — terminaison vide/x, PAS avant un
719
+ # s muet) est muet même devant un h aspiré (sombre héros ->
720
+ # sɔ̃-bʁe-ʁo), donc ne jamais le restaurer comme élision ; la branche
721
+ # -Cr- de step_vowel s'en charge. Les mots en -es (propres airs ->
722
+ # pʁɔ-pʁə-zɛʁ) gardent leur e via la règle 1.5. CR_E_PRONOUNCED
723
+ # (entre, ventre) exempté.
724
+ return false if cr_mute_final_e?(word, i)
725
+ return false if %w[e ɛ].include?(head[0]) && !head.match?(/̃/) &&
726
+ next_word.to_s.match?(NEXT_VOWELISH)
727
+ true
728
+ end
729
+
730
+ # word[i] est un e strictement final (terminaison vide ou x) après un
731
+ # cluster -Cr- dont le e est muet (sombre -> sɔ̃bʁ, mettre -> mɛtʁ) —
732
+ # SAUF CR_E_PRONOUNCED (entre -> ɑ̃-tʁə, ventre -> vɑ̃-tʁə).
733
+ def cr_mute_final_e?(word, i)
734
+ i >= 2 && word[i - 1] == "r" && !word[i - 2].match?(VOWEL_LETTER) &&
735
+ word[(i + 1)..].to_s.match?(/\A(?:x)?\z/) && !CR_E_PRONOUNCED.include?(word)
736
+ end
737
+
738
+ # -- phonétisation -------------------------------------------------
739
+
740
+ # Normalise la ligne d'entrée pour words_of ET espeak, afin que lettres et
741
+ # phones restent cohérents : entités HTML (&nbsp; etc.) et chiffres
742
+ # (espeak lit « 31 » comme « trente et un », words_of les ignore).
743
+ # Idempotent : scan_line normalise une fois et passe la ligne nettoyée en
744
+ # aval ; espeak normalise à nouveau seulement pour rester sûr comme point
745
+ # d'entrée autonome.
746
+ def normalize_input(line)
747
+ line.gsub(/&[a-zA-Z#0-9]+;/, " ").gsub(/\d+/, " ")
748
+ end
749
+
750
+ # Phonétise, en essayant dans l'ordre : le backend FFI en processus
751
+ # (phonemizer_ffi.rb, appelle libespeak-ng directement — pas de
752
+ # fork/exec par mot, sortie identique octet par octet au gem, voir
753
+ # spec/scansion_spec), puis l'API du gem phonemizer (son nom de require),
754
+ # puis le CLI `phonemize` qu'il fournit, puis espeak-ng directement.
755
+ # Chaque stratégie renvoie nil en cas d'échec (LoadError compris), sauf le
756
+ # dernier recours qui laisse l'erreur d'espeak-ng se propager.
757
+ def espeak(line)
758
+ line = normalize_input(line)
759
+ raw = phonemizer_ffi(line)
760
+ raw = phonemizer_gem(line) if raw.nil?
761
+ raw = cli_phonemize_safe(line) if raw.nil?
762
+ raw = espeak_ng(line) if raw.nil?
763
+ clean_ipa(raw.to_s)
764
+ end
765
+
766
+ # Le backend FFI (phonemizer_ffi.rb dans ce répertoire) : même API
767
+ # Phonemizer.phonemize, mais en processus. Mémoïsé comme indisponible
768
+ # après le premier échec (gem ffi ou libespeak-ng manquants) pour ne pas
769
+ # retenter toute la chaîne de repli à chaque mot.
770
+ def phonemizer_ffi(line)
771
+ return nil if @ffi_unavailable
772
+ require_relative "phonemizer_ffi"
773
+ Phonemizer.phonemize(line, language: "fr")
774
+ rescue StandardError, LoadError
775
+ @ffi_unavailable = true
776
+ nil
777
+ end
778
+
779
+ # L'API du gem phonemizer.
780
+ def phonemizer_gem(line)
781
+ require "phonemizer"
782
+ begin
783
+ Phonemizer.phonemize(line, language: "fr")
784
+ rescue ArgumentError, NoMethodError
785
+ Phonemizer.phonemize(line, "fr")
786
+ end
787
+ rescue StandardError, LoadError
788
+ nil
789
+ end
790
+
791
+ def cli_phonemize_safe(line)
792
+ cli_phonemize(line)
793
+ rescue StandardError
794
+ nil
795
+ end
796
+
797
+ # espeak-ng directement (dernier recours).
798
+ def espeak_ng(line)
799
+ Open3.capture3("espeak-ng", "-q", "--ipa", "-v", "fr",
800
+ stdin_data: line)[0]
801
+ end
802
+
803
+ # L'exécutable `phonemize` fourni par le gem phonemizer.
804
+ # Les flags exacts du CLI peuvent varier, donc on essaie les formes
805
+ # plausibles à tour de rôle.
806
+ def cli_phonemize(line)
807
+ [["--lang", "fr"], ["-l", "fr"], []].each do |flags|
808
+ out, _err, status = Open3.capture3("phonemize", *flags, stdin_data: line)
809
+ return out if status.success? && !out.strip.empty?
810
+ end
811
+ raise "la commande `phonemize` n'a pas fonctionné"
812
+ end
813
+
814
+ # Nettoie le flux IPA brut : supprime les marqueurs de changement de langue
815
+ # d'espeak-ng « (en) »/« (fr) » EN ENTIER — ne retirer que les parenthèses
816
+ # laisserait des segments parasites « en »/« fr » qui cassent l'alignement
817
+ # (qu'hier -> (en)kwhˈiə(fr)). Puis supprime espaces, accents de stress,
818
+ # marques de liaison ET ponctuation : espeak-ng garde « , » (et parfois
819
+ # « . ») dans le flux IPA, alors que words_of() la supprime, donc un
820
+ # segment « , » parasite casserait l'alignement. Supprime aussi les
821
+ # caractères de largeur nulle/BOM, normalise U+0261 en g ASCII, et
822
+ # « dé-anglicise » l'API anglaise d'espeak (ɹ→ʁ, θ→t, ð→d, ɪ→i, ʌ→a,
823
+ # æ→a, ɒ→ɔ : rythme, macbeth, punch).
824
+ def clean_ipa(raw)
825
+ raw.to_s.gsub(/\([a-z]{2,3}\)/i, "")
826
+ .gsub(/[\uFEFF\u200B-\u200D\u00AD]/, "")
827
+ .gsub(/[\s\"()_ˈˌ‿ːˑ|[[:punct:]]]/, "")
828
+ .tr("ɡɹθðɪʌæɒ", "gʁtdiaaɔ")
829
+ end
830
+
831
+ # Ce cluster de consonnes est-il une attaque de syllabe française valide ?
832
+ # consonne seule ; obstruente+liquide(+glide) ; obstruente+glide ;
833
+ # liquide+glide ; nasale+glide ; s+obstruente seulement dans les clusters
834
+ # de 3+ (respiration -> ʁɛs-pi..., mais abstinente -> ab-sti...)
835
+ def valid_onset?(chars, big = false)
836
+ return false if chars.empty?
837
+ return true if chars.size == 1
838
+ ob = "ptkbdgvfʃzʒ"
839
+ li = "lʁ"
840
+ gl = "jɥw"
841
+ na = "mn"
842
+ chars.match?(/\A[#{ob}][#{li}][#{gl}]?\z/) ||
843
+ chars.match?(/\A[#{ob}][#{gl}]\z/) ||
844
+ chars.match?(/\A[#{li}][#{gl}]\z/) ||
845
+ chars.match?(/\A[#{na}][#{gl}]\z/) ||
846
+ chars.match?(/\As[#{gl}]\z/) || # -sion -> sjɔ̃
847
+ (big && chars.match?(/\As[#{ob}][#{li}]?[#{gl}]?\z/))
848
+ end
849
+
850
+ # Insère un séparateur « - » à chaque frontière de syllabe dans une liste
851
+ # de segments phonétiques. barriers = [index, mot_précédent, pause_précédente]
852
+ # pour chaque début de mot. Règles :
853
+ # - un cluster de consonnes chevauchant une frontière de mot est coupé
854
+ # À la première frontière (la consonne finale du mot précédent devient
855
+ # coda : mer en -> mɛʁ-ɑ̃, par moi -> paʁ-mwa, l'envol est -> vɔl-ɛ...);
856
+ # - exception : une lettre de liaison devant un mot à initiale vocalique
857
+ # reste l'attaque (les amis -> lɛ-za-mi), sauf si une pause la bloque
858
+ # (inutiles, enfant -> til-ɑ̃), et les articles élidés l'/j' fusionnent
859
+ # (l'abstinente -> lab-sti...);
860
+ # - sinon, le tiret va devant le plus long cluster d'attaque VALIDE
861
+ # (per-clus -> pɛʁ-kly, re-tourne -> ʁə-tuʁn).
862
+ # Une coda finale ne reçoit pas de séparateur ; un hiatus (pas de
863
+ # consonne) est coupé.
864
+ def mark_syllables(phones, barriers = [])
865
+ cuts = {}
866
+ prev_vowel = nil
867
+ phones.each_with_index do |ph, k|
868
+ next unless ph[0].match?(VOWEL_PHONE)
869
+ if prev_vowel
870
+ cut = nil
871
+ inside = barriers.select { |b, _| b > prev_vowel && b < k }
872
+ if inside.any?
873
+ cut = inside.first[0]
874
+ elsif (info = barriers.find { |b, _| b == k })
875
+ prev_word, prev_paused = info[1].to_s, info[2]
876
+ unless %w[l j].include?(prev_word) ||
877
+ (!prev_paused && LIAISON_LETTERS.include?(prev_word[-1].to_s))
878
+ cut = k # coda du mot précédent, coupure à la frontière
879
+ end
880
+ end
881
+ if cut.nil?
882
+ cluster = phones[(prev_vowel + 1)...k].map { |p| p[0] }.join
883
+ onset = cluster.size.downto(1).find do |len|
884
+ valid_onset?(cluster[-len..], cluster.size >= 3)
885
+ end || 0
886
+ cut = k - onset
887
+ end
888
+ cuts[cut] = true
889
+ end
890
+ prev_vowel = k
891
+ end
892
+ out = +""
893
+ phones.each_with_index do |ph, k|
894
+ out << "-" if cuts[k] && !out.empty?
895
+ out << ph
896
+ end
897
+ out
898
+ end
899
+
900
+ # Découpe l'IPA brute en segments suite-de-voyelles / consonne.
901
+ def segments(phones)
902
+ segs = []
903
+ vowel = false
904
+ phones.each_char do |ch|
905
+ if ch.match?(/\p{Mn}/u)
906
+ segs.last << ch unless segs.empty?
907
+ elsif ch.match?(VOWEL_PHONE)
908
+ if vowel && segs.any?
909
+ segs.last << ch
910
+ else
911
+ segs << ch.dup
912
+ end
913
+ vowel = true
914
+ else
915
+ segs << ch.dup
916
+ vowel = false
917
+ end
918
+ end
919
+ segs
920
+ end
921
+
922
+ # -- alignement lettres/phones --------------------------------------
923
+
924
+ def expected_consonant(ch, nxt)
925
+ case ch
926
+ when "c" then SOFT_NEXT.include?(nxt) ? "s" : "k"
927
+ when "g" then SOFT_NEXT.include?(nxt) ? "ʒ" : "g"
928
+ when "ç" then "s"
929
+ when "h" then nil
930
+ else CONSONANT_LETTERS[ch]
931
+ end
932
+ end
933
+
934
+ # Aligne un mot orthographique sur segs à partir de cursor.
935
+ # next_vowel_initial : si le mot suivant commence par une voyelle (ou un
936
+ # h muet), ce qui indique qu'espeak-ng a élidé un schwa final.
937
+ # Renvoie [pairs, new_cursor] avec des paires [phone, restauré ?],
938
+ # ou nil quand le mot ne peut pas être aligné sûrement.
939
+ def align_word(word, segs, cursor, next_vowel_initial: false, next_word: nil,
940
+ prev_fragment: false, dierese: false)
941
+ a = Aligner.new(word: word, segs: segs, out: [], i: 0, cursor: cursor,
942
+ n: word.size, prev_cons: nil, prev_vowel_phone: false,
943
+ run_split: false, next_vowel_initial: next_vowel_initial,
944
+ next_word: next_word, prev_fragment: prev_fragment,
945
+ dierese: dierese)
946
+ a.run ? [a.out, a.cursor] : nil
947
+ end
948
+
949
+ # -- scansion ------------------------------------------------------
950
+
951
+ # Initial voyelle phonétique : commence par une lettre voyelle, ou par h
952
+ # suivi d'une voyelle (le h est toujours muet en français, muet ou aspiré,
953
+ # donc le mot commence quand même par un SON voyelle : hasard -> /azaʁ/).
954
+ # Sert au découpage des suites / aux frontières (au hasard -> o-a-zaʁ).
955
+ def vowel_initial?(word)
956
+ first = word[0].to_s
957
+ return true if first.match?(VOWEL_LETTER)
958
+ first == "h" && word[1].to_s.match?(VOWEL_LETTER)
959
+ end
960
+
961
+ # h aspiré (petite liste, familles par préfixe) : bloque élision/liaison.
962
+ def h_aspiré?(word)
963
+ return false unless word[0].to_s == "h" && word[1].to_s.match?(VOWEL_LETTER)
964
+ H_ASPIRE.any? { |h| word == h || word.start_with?(h) }
965
+ end
966
+
967
+ # L'élision/la liaison a lieu devant une voyelle ou un h MUET — jamais
968
+ # devant un h aspiré (« le hasard » n'élide pas, « l'homme » élide).
969
+ def elides_before?(word) = vowel_initial?(word) && !h_aspiré?(word)
970
+
971
+ def words_of(line)
972
+ line.downcase.gsub(/&[a-zA-Z#0-9]+;/, " ").gsub(/['’-]/, " ")
973
+ .scan(/[a-zà-ÿœ]+/u)
974
+ end
975
+
976
+ # Pour chaque mot de la ligne, indique s'il est directement suivi d'une
977
+ # pause graphique (, ; : ! ? … —). Le e muet d'un tel mot n'est pas
978
+ # compté (rêche, -> ʁɛʃ), comme en fin de vers.
979
+ def pause_flags(line, words)
980
+ toks = line.downcase.gsub(/&[a-zA-Z#0-9]+;/, " ")
981
+ .scan(/([a-zà-ÿœ]+)([^a-zà-ÿœ\s]*)/u)
982
+ flags = toks.map { |_w, tail| tail.match?(/[.,;:!?…—]/) }
983
+ flags.fill(false, words.size...flags.size) if flags.size < words.size
984
+ flags.first(words.size)
985
+ end
986
+
987
+ # Mètres de vers attendus (utilisés par dierese: :auto)
988
+ METER = [6, 8, 10, 12].freeze
989
+
990
+ # Décompte des syllabes : chaque phone voyelle compte, SAUF un glide
991
+ # rendu « y » (ɥ) directement suivi d'une voyelle — fuyait -> f-yi-jɛ fait
992
+ # 2 syllabes, pas 3 (le y est le glide de « ui », pas un noyau)
993
+ def count_syllables(phones)
994
+ count = 0
995
+ phones.each_with_index do |ph, k|
996
+ next unless ph[0].match?(VOWEL_PHONE)
997
+ if (ph[0] == "y" || ph[0] == "ɥ") && phones[k + 1] &&
998
+ phones[k + 1][0].match?(VOWEL_PHONE)
999
+ next
1000
+ end
1001
+ count += 1
1002
+ end
1003
+ count
1004
+ end
1005
+
1006
+ # Détection de contexte de poésie classique : true quand les lignes
1007
+ # voisines (fenêtre autour de idx) tombent majoritairement dans la bande
1008
+ # alexandrine 10-13 (11/13 sont eux-mêmes des candidats diérèse/surcompte,
1009
+ # donc ils appartiennent à la bande). La diérèse ne peut être inférée que
1010
+ # dans un contexte aussi régulier — JAMAIS en poésie contemporaine
1011
+ # (samples/), où elle ne peut pas être déduite d'un nombre de syllabes
1012
+ # cible. counts : décomptes de syllabes par ligne (nil pour les lignes
1013
+ # vides ou non alignées).
1014
+ def classical_context?(counts, idx, window: 5, threshold: 0.7)
1015
+ lo = [idx - window, 0].max
1016
+ hi = [idx + window, counts.size - 1].min
1017
+ neigh = counts[lo..hi].compact
1018
+ neigh.delete_at(idx - lo) if idx >= lo && idx <= hi
1019
+ return false if neigh.empty?
1020
+ neigh.count { |c| (10..13).cover?(c) }.to_f / neigh.size >= threshold
1021
+ end
1022
+
1023
+ # Point d'entrée public. dierese: :auto re-scanne avec des diérèses quand
1024
+ # le compte brut ne tombe pas sur un mètre de vers (11 -> 12, etc.).
1025
+ # cache : Hash optionnel partagé entre appels (utilisé par process_lines)
1026
+ # pour que chaque paire (ligne, options) ne soit scannée — et espeak-ng
1027
+ # relancé — qu'une fois.
1028
+ def process_line(line, keep_line_end_e:, dierese: false, cache: nil)
1029
+ r = scan_line(line, keep_line_end_e: keep_line_end_e, dierese: false, cache: cache)
1030
+ if dierese == true
1031
+ r = scan_line(line, keep_line_end_e: keep_line_end_e, dierese: true, cache: cache)
1032
+ elsif dierese == :auto && r.aligned && !METER.include?(r.syllables)
1033
+ r2 = scan_line(line, keep_line_end_e: keep_line_end_e, dierese: true, cache: cache)
1034
+ r = r2 if r2.aligned && METER.include?(r2.syllables)
1035
+ end
1036
+ r
1037
+ end
1038
+
1039
+ # Point d'entrée par lot (deux passes). Avec dierese: :auto, la diérèse
1040
+ # n'est appliquée que là où le contexte alentour est classique
1041
+ # (classical_context?) — jamais en poésie contemporaine.
1042
+ def process_lines(lines, keep_line_end_e:, dierese: :auto)
1043
+ cache = {}
1044
+ counts = lines.map do |l|
1045
+ next nil if l.strip.empty?
1046
+ r = scan_line(l, keep_line_end_e: keep_line_end_e, dierese: false, cache: cache)
1047
+ r.aligned ? r.syllables : nil
1048
+ end
1049
+ lines.each_with_index.map do |l, i|
1050
+ d = case dierese
1051
+ when :auto then (classical_context?(counts, i) ? :auto : false)
1052
+ else dierese
1053
+ end
1054
+ process_line(l, keep_line_end_e: keep_line_end_e, dierese: d, cache: cache)
1055
+ end
1056
+ end
1057
+
1058
+ # Enveloppe mémoïsante autour de compute_scan_line : avec un cache partagé
1059
+ # (voir process_lines), chaque triplet (ligne, keep_line_end_e, dierese)
1060
+ # n'est calculé — et espeak-ng relancé — qu'une fois.
1061
+ def scan_line(line, keep_line_end_e:, dierese: false, cache: nil)
1062
+ if cache
1063
+ key = [line, keep_line_end_e, dierese]
1064
+ return cache[key] if cache.key?(key)
1065
+ return cache[key] = compute_scan_line(line, keep_line_end_e: keep_line_end_e,
1066
+ dierese: dierese)
1067
+ end
1068
+ compute_scan_line(line, keep_line_end_e: keep_line_end_e, dierese: dierese)
1069
+ end
1070
+
1071
+ def compute_scan_line(line, keep_line_end_e:, dierese: false)
1072
+ # normalise une fois pour que words_of et espeak voient les mêmes lettres
1073
+ clean = normalize_input(line)
1074
+ words = words_of(clean)
1075
+ if words.empty?
1076
+ return Result.new(text: line, raw: "", phones: "",
1077
+ syllables: 0, aligned: true, dierese: 0)
1078
+ end
1079
+
1080
+ raw = espeak(clean)
1081
+ segs = segments(raw)
1082
+
1083
+ words_out = []
1084
+ cursor = 0
1085
+ aligned = true
1086
+
1087
+ words.each_with_index do |w, k|
1088
+ res = align_word(w, segs, cursor,
1089
+ next_vowel_initial: vowel_initial?(words[k + 1].to_s),
1090
+ next_word: words[k + 1],
1091
+ prev_fragment: k.positive? &&
1092
+ %w[c j l d n s t m qu].include?(words[k - 1]),
1093
+ dierese: dierese)
1094
+ if res.nil?
1095
+ aligned = false
1096
+ break
1097
+ end
1098
+ words_out << { word: w, pairs: res[0] }
1099
+ cursor = res[1]
1100
+ end
1101
+ aligned &&= (cursor == segs.size)
1102
+
1103
+ unless aligned
1104
+ # repli sûr : sortie brute d'espeak, sans restauration
1105
+ syll = count_syllables(segs)
1106
+ return Result.new(text: line, raw: raw, phones: mark_syllables(segs),
1107
+ syllables: syll, aligned: false, dierese: 0)
1108
+ end
1109
+
1110
+ # élagage de scansion des schwas finaux restaurés
1111
+ paused = pause_flags(clean, words)
1112
+ words_out.each_with_index do |w, k|
1113
+ pairs = w[:pairs]
1114
+ next unless pairs.last && pairs.last[0] == SCHWA
1115
+
1116
+ next_word = (words_out[k + 1] || {})[:word]
1117
+ if next_word.nil? # fin de vers : e muet non compté
1118
+ pairs.pop unless keep_line_end_e
1119
+ elsif elides_before?(next_word) # élision devant une voyelle / un h muet (pas un h aspiré)
1120
+ pairs.pop
1121
+ elsif paused[k] # devant une pause (, ; : ! ? … —)
1122
+ pairs.pop
1123
+ end
1124
+ end
1125
+
1126
+ flat = []
1127
+ barriers = []
1128
+ words_out.each_with_index do |w, k|
1129
+ barriers << [flat.size, words[k - 1], paused[k - 1]]
1130
+ w[:pairs].each { |ph, _| flat << ph }
1131
+ end
1132
+ phones = mark_syllables(flat, barriers)
1133
+ syllables = count_syllables(flat)
1134
+
1135
+ dier = words_out.sum do |w|
1136
+ w[:pairs].count { |ph, restored| restored && ph == "i" }
1137
+ end
1138
+ Result.new(text: line, raw: raw, phones: phones,
1139
+ syllables: syllables, aligned: aligned, dierese: dier)
1140
+ end
1141
+
1142
+ # -- CLI -------------------------------------------------------------
1143
+
1144
+ # Point d'entrée, invoqué seulement quand le fichier est exécuté comme
1145
+ # script ($PROGRAM_NAME == __FILE__), afin que le require de ce fichier
1146
+ # reste sans effet de bord : pas d'OptionParser qui consommerait l'ARGV de
1147
+ # l'hôte, pas de mutation d'encodage global.
1148
+ def main(argv = ARGV)
1149
+ options = { keep_line_end_e: false, syllables_only: false, dierese: :auto }
1150
+ OptionParser.new do |opts|
1151
+ opts.banner = "Utilisation : #{File.basename($PROGRAM_NAME)} [options] [FILE|-]"
1152
+ opts.on("--keep-line-end-e", "Compter l'e muet en fin de vers") do
1153
+ options[:keep_line_end_e] = true
1154
+ end
1155
+ opts.on("--no-dierese", "Désactiver la diérèse contextuelle (corpus contemporain)") do
1156
+ options[:dierese] = false
1157
+ end
1158
+ opts.on("-s", "--syllables", "Afficher seulement le décompte des syllabes") do
1159
+ options[:syllables_only] = true
1160
+ end
1161
+ opts.on("-h", "--help", "Afficher cette aide") do
1162
+ puts opts
1163
+ exit
1164
+ end
1165
+ end.parse!(argv)
1166
+
1167
+ Encoding.default_external = Encoding::UTF_8
1168
+
1169
+ fallbacks = 0
1170
+
1171
+ # Accepte des chemins de fichiers ou du texte de vers en argument :
1172
+ # scansion poeme.txt
1173
+ # scansion "Au coin du feu, dans la langueur des rêveries!"
1174
+ inline = []
1175
+ ARGV.replace(argv.flat_map do |arg|
1176
+ if arg == "-" || File.exist?(arg)
1177
+ arg
1178
+ else
1179
+ inline.concat(arg.split(/[\r\n]+/))
1180
+ nil
1181
+ end
1182
+ end.compact)
1183
+
1184
+ lines =
1185
+ if inline.any? && ARGV.empty?
1186
+ inline.each
1187
+ elsif inline.any?
1188
+ # mélange de texte en ligne et de chemins de fichiers : traiter
1189
+ # d'abord les lignes passées en ligne
1190
+ Enumerator.new do |y|
1191
+ inline.each { |l| y << l }
1192
+ ARGF.each_line { |l| y << l }
1193
+ end
1194
+ else
1195
+ ARGF.each_line
1196
+ end
1197
+
1198
+ lines = lines.to_a.map(&:chomp)
1199
+ process_lines(lines, keep_line_end_e: options[:keep_line_end_e],
1200
+ dierese: options[:dierese]).each do |res|
1201
+ next if res.text.strip.empty?
1202
+
1203
+ if options[:syllables_only]
1204
+ puts format("%3d %s", res.syllables, res.text.to_s.strip)
1205
+ else
1206
+ puts res.text.to_s.rstrip
1207
+ puts format(" %s %s (%d syll.)", res.aligned ? "⇒" : "~", res.phones, res.syllables)
1208
+ puts " (espeak seul : #{res.raw})" unless res.aligned
1209
+ puts ""
1210
+ end
1211
+
1212
+ fallbacks += 1 unless res.aligned
1213
+ end
1214
+
1215
+ warn "scansion : #{fallbacks} vers non alignés (sortie espeak brute)" if fallbacks.positive?
1216
+ end
1217
+ end
1218
+ end
1219
+
1220
+ Scansion.main if $PROGRAM_NAME == __FILE__