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.
- checksums.yaml +7 -0
- data/CHANGELOG.md +8 -0
- data/LICENSE +21 -0
- data/README.md +101 -0
- data/bin/scansion +12 -0
- data/docs/scansion_rules.txt +345 -0
- data/lib/phonemizer_ffi.rb +401 -0
- data/lib/scansion/version.rb +5 -0
- data/lib/scansion.rb +1220 -0
- metadata +82 -0
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 ( 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__
|