source: spip-zone/_core_/plugins/compresseur/inc/compresseur.php

Last change on this file was 113294, checked in by spip.franck@…, 9 months ago

Il parait que le futur c'est maintenant :-D

File size: 14.6 KB
Line 
1<?php
2
3/***************************************************************************\
4 *  SPIP, Systeme de publication pour l'internet                           *
5 *                                                                         *
6 *  Copyright (c) 2001-2019                                                *
7 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
8 *                                                                         *
9 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
10 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
11\***************************************************************************/
12
13/**
14 * Fonctions d'aide pour le compresseur
15 *
16 * @package SPIP\Compresseur\Fonctions
17 */
18if (!defined("_ECRIRE_INC_VERSION")) {
19        return;
20}
21
22/**
23 * Ecrire la balise javascript pour insérer le fichier compressé
24 *
25 * C'est cette fonction qui décide où il est le plus pertinent
26 * d'insérer le fichier, et dans quelle forme d'ecriture
27 *
28 * @param string $flux
29 *   Contenu du head nettoyé des fichiers qui ont été compressé
30 * @param int $pos
31 *   Position initiale du premier fichier inclu dans le fichier compressé
32 * @param string $src
33 *   Nom du fichier compressé
34 * @param string $comments
35 *   Commentaires à insérer devant
36 * @return string
37 *   Code HTML de la balise <script>
38 */
39function compresseur_ecrire_balise_js_dist(&$flux, $pos, $src, $comments = "") {
40        $src = timestamp($src);
41        // option chargement JS async par jQl
42        if (defined('_JS_ASYNC_LOAD') and !test_espace_prive()) {
43                lire_fichier(find_in_path("lib/jQl/jQl.min.js"), $jQl);
44                if ($jQl) {
45                        $comments .= "<script type='text/javascript'>\n$jQl\njQl.loadjQ('$src')\n</script>";
46                } else {
47                        $comments .= "<script type='text/javascript' src='$src'></script>";
48                }
49        } else {
50                $comments .= "<script type='text/javascript' src='$src'></script>";
51        }
52
53        $flux = substr_replace($flux, $comments, $pos, 0);
54
55        return $flux;
56}
57
58/**
59 * Ecrire la balise CSS pour insérer le fichier compressé
60 *
61 * C'est cette fonction qui décide ou il est le plus pertinent
62 * d'insérer le fichier, et dans quelle forme d'écriture
63 *
64 * @param string $flux
65 *   Contenu du head nettoyé des fichiers qui ont ete compressé
66 * @param int $pos
67 *   Position initiale du premier fichier inclu dans le fichier compressé
68 * @param string $src
69 *   Nom du fichier compressé
70 * @param string $comments
71 *   Commentaires à insérer devant
72 * @param string $media
73 *   Type de media si précisé (print|screen...)
74 * @return string
75 *   Code HTML de la balise <link>
76 */
77function compresseur_ecrire_balise_css_dist(&$flux, $pos, $src, $comments = "", $media = "") {
78        $src = timestamp($src);
79        $comments .= "<link rel='stylesheet'" . ($media ? " media='$media'" : "") . " href='$src' type='text/css' />";
80        // Envoyer aussi un entete http pour demarer le chargement de la CSS plus tot
81        // Link: <http://href.here/to/resource.html>;rel="stylesheet prefetch"
82        $comments .= "<" . "?php header('Link: <' . url_de_base() . (_DIR_RACINE ? _DIR_RESTREINT_ABS : '') . '$src>;rel=\"stylesheet prefetch\"'); ?>";
83        $flux = substr_replace($flux, $comments, $pos, 0);
84
85        return $flux;
86}
87
88/**
89 * Extraire les balises CSS à compacter
90 *
91 * @param string $flux
92 *     Contenu HTML dont on extrait les balises CSS
93 * @param string $url_base
94 * @return array
95 *     Couples (balise => src)
96 */
97function compresseur_extraire_balises_css_dist($flux, $url_base) {
98        $balises = extraire_balises($flux, 'link');
99        $files = array();
100        foreach ($balises as $s) {
101                if (extraire_attribut($s, 'rel') === 'stylesheet'
102                        and (!($type = extraire_attribut($s, 'type'))
103                                or $type == 'text/css')
104                        and is_null(extraire_attribut($s, 'name')) # css nommee : pas touche
105                        and is_null(extraire_attribut($s, 'id'))   # idem
106                        and !strlen(strip_tags($s))
107                        and $src = preg_replace(",^$url_base,", _DIR_RACINE, extraire_attribut($s, 'href'))
108                ) {
109                        $files[$s] = $src;
110                }
111        }
112
113        return $files;
114}
115
116/**
117 * Extraire les balises JS à compacter
118 *
119 * @param string $flux
120 *     Contenu HTML dont on extrait les balises CSS
121 * @param string $url_base
122 * @return array
123 *     Couples (balise => src)
124 */
125function compresseur_extraire_balises_js_dist($flux, $url_base) {
126        $balises = extraire_balises($flux, 'script');
127        $files = array();
128        foreach ($balises as $s) {
129                if (extraire_attribut($s, 'type') === 'text/javascript'
130                        and is_null(extraire_attribut($s, 'id')) # script avec un id : pas touche
131                        and $src = extraire_attribut($s, 'src')
132                        and !strlen(strip_tags($s))
133                ) {
134                        $files[$s] = $src;
135                }
136        }
137
138        return $files;
139}
140
141/**
142 * Compacter (concaténer+minifier) les fichiers format CSS ou JS
143 * du head.
144 *
145 * Repérer fichiers statiques vs. url squelettes
146 * Compacte le tout dans un fichier statique posé dans local/
147 *
148 * @param string $flux
149 *    Contenu du <head> de la page html
150 * @param string $format
151 *    css ou js
152 * @return string
153 *    Contenu compressé du <head> de la page html
154 */
155function compacte_head_files($flux, $format) {
156        $url_base = url_de_base();
157        $url_page = substr(generer_url_public('A'), 0, -1);
158        $dir = preg_quote($url_page, ',') . '|' . preg_quote(preg_replace(",^$url_base,", _DIR_RACINE, $url_page), ',');
159
160        if (!$extraire_balises = charger_fonction("compresseur_extraire_balises_$format", '', true)) {
161                return $flux;
162        }
163
164        $files = array();
165        $flux_nocomment = preg_replace(",<!--.*-->,Uims", "", $flux);
166        foreach ($extraire_balises($flux_nocomment, $url_base) as $s => $src) {
167                if (
168                        preg_match(',^(' . $dir . ')(.*)$,', $src, $r)
169                        or (
170                                // ou si c'est un fichier
171                                $src = preg_replace(',^' . preg_quote(url_de_base(), ',') . ',', '', $src)
172                                // enlever un timestamp eventuel derriere un nom de fichier statique
173                                and $src2 = preg_replace(",[.]{$format}[?].+$,", ".$format", $src)
174                                // verifier qu'il n'y a pas de ../ ni / au debut (securite)
175                                and !preg_match(',(^/|\.\.),', substr($src, strlen(_DIR_RACINE)))
176                                // et si il est lisible
177                                and @is_readable($src2)
178                        )
179                ) {
180                        if ($r) {
181                                $files[$s] = explode('&', str_replace('&amp;', '&', $r[2]), 2);
182                        } else {
183                                $files[$s] = $src;
184                        }
185                }
186        }
187
188        $callbacks = array('each_min' => 'callback_minifier_' . $format . '_file');
189
190        if ($format == "css") {
191                $callbacks['each_pre'] = 'compresseur_callback_prepare_css';
192                $callbacks['all_min'] = 'css_regroup_atimport';
193                // ce n'est pas une callback, mais en injectant l'url de base ici
194                // on differencie les caches quand l'url de base change
195                // puisque la css compresse inclue l'url courante du site (en url absolue)
196                // on exclue le protocole car la compression se fait en url relative au protocole
197                $callbacks[] = protocole_implicite($url_base);
198                // et l'URL des ressources statiques si configuree
199                if (isset($GLOBALS['meta']['url_statique_ressources']) and $GLOBALS['meta']['url_statique_ressources']){
200                        $callbacks[] = protocole_implicite($GLOBALS['meta']['url_statique_ressources']);
201                }
202        }
203
204        include_spip('inc/compresseur_concatener');
205        include_spip('inc/compresseur_minifier');
206        if (list($src, $comms) = concatener_fichiers($files, $format, $callbacks)
207                and $src
208        ) {
209                $compacte_ecrire_balise = charger_fonction("compresseur_ecrire_balise_$format", '');
210                $files = array_keys($files);
211                // retrouver la position du premier fichier compacte
212                $pos = strpos($flux, reset($files));
213                // supprimer tous les fichiers compactes du flux
214                $flux = str_replace($files, "", $flux);
215                // inserer la balise (deleguer a la fonction, en lui donnant le necessaire)
216                $flux = $compacte_ecrire_balise($flux, $pos, $src, $comms);
217        }
218
219        return $flux;
220}
221
222
223/**
224 * Lister les fonctions de préparation des feuilles css
225 * avant minification
226 *
227 * @return array
228 *     Liste des fonctions à appliquer sur les feuilles CSS
229 */
230function compresseur_liste_fonctions_prepare_css() {
231        static $fonctions = null;
232
233        if (is_null($fonctions)) {
234                $fonctions = array('css_resolve_atimport', 'urls_absolues_css', 'css_url_statique_ressources');
235                // les fonctions de preparation aux CSS peuvent etre personalisees
236                // via la globale $compresseur_filtres_css sous forme de tableau de fonctions ordonnees
237                if (isset($GLOBALS['compresseur_filtres_css']) and is_array($GLOBALS['compresseur_filtres_css'])) {
238                        $fonctions = $GLOBALS['compresseur_filtres_css'] + $fonctions;
239                }
240        }
241
242        return $fonctions;
243}
244
245
246/**
247 * Préparer un fichier CSS avant sa minification
248 *
249 * @param string $css
250 * @param bool|string $is_inline
251 * @param string $fonctions
252 * @return bool|int|null|string
253 */
254function &compresseur_callback_prepare_css(&$css, $is_inline = false, $fonctions = null) {
255        if ($is_inline) {
256                return compresseur_callback_prepare_css_inline($css, $is_inline);
257        }
258        if (!preg_match(',\.css$,i', $css, $r)) {
259                return $css;
260        }
261
262        $url_absolue_css = url_absolue($css);
263        // retirer le protocole de $url_absolue_css
264        $url_absolue_css_implicite = protocole_implicite($url_absolue_css);
265
266        if (!$fonctions) {
267                $fonctions = compresseur_liste_fonctions_prepare_css();
268        } elseif (is_string($fonctions)) {
269                $fonctions = array($fonctions);
270        }
271
272        $sign = implode(",", $fonctions);
273        $sign = substr(md5("$url_absolue_css_implicite-$sign"), 0, 8);
274
275        $file = basename($css, '.css');
276        $file = sous_repertoire(_DIR_VAR, 'cache-css')
277                . preg_replace(",(.*?)(_rtl|_ltr)?$,", "\\1-f-" . $sign . "\\2", $file)
278                . '.css';
279
280        if ((@filemtime($file) > @filemtime($css))
281                and (!defined('_VAR_MODE') or _VAR_MODE != 'recalcul')
282        ) {
283                return $file;
284        }
285
286        if ($url_absolue_css == $css) {
287                if (strncmp($GLOBALS['meta']['adresse_site'] . "/", $css, $l = strlen($GLOBALS['meta']['adresse_site'] . "/")) != 0
288                        or !lire_fichier(_DIR_RACINE . substr($css, $l), $contenu)
289                ) {
290                        include_spip('inc/distant');
291                        if (!$contenu = recuperer_page($css)) {
292                                return $css;
293                        }
294                }
295        } elseif (!lire_fichier($css, $contenu)) {
296                return $css;
297        }
298
299        $contenu = compresseur_callback_prepare_css_inline($contenu, $url_absolue_css_implicite, $css, $fonctions);
300
301        // ecrire la css
302        if (!ecrire_fichier($file, $contenu)) {
303                return $css;
304        }
305
306        return $file;
307}
308
309/**
310 * Préparer du contenu CSS inline avant minification
311 *
312 * @param string $contenu
313 *   contenu de la CSS
314 * @param string $url_base
315 *   url de la CSS ou de la page si c'est un style inline
316 * @param string $filename
317 *   nom du fichier de la CSS (ou vide si c'est un style inline)
318 * @param array $fonctions
319 *   liste des fonctions appliquees a la CSS
320 * @return string
321 */
322function &compresseur_callback_prepare_css_inline(&$contenu, $url_base, $filename = '', $fonctions = null) {
323        if (!$fonctions) {
324                $fonctions = compresseur_liste_fonctions_prepare_css();
325        } elseif (is_string($fonctions)) {
326                $fonctions = array($fonctions);
327        }
328
329        // retirer le protocole de $url_base
330        $url_base = protocole_implicite(url_absolue($url_base));
331
332        foreach ($fonctions as $f) {
333                if (!function_exists($f)) {
334                        $f = chercher_filtre($f);
335                }
336                if ($f and function_exists($f)) {
337                        $contenu = $f($contenu, $url_base, $filename);
338                }
339        }
340
341        return $contenu;
342}
343
344/**
345 * Resoudre et inliner les @import
346 * ceux-ci ne peuvent etre presents qu'en debut de CSS et on ne veut pas changer l'ordre des directives
347 *
348 * @param string $contenu
349 * @param string $url_base
350 * @param string $filename
351 * @return string
352 */
353function css_resolve_atimport($contenu, $url_base, $filename) {
354        // vite si rien a faire
355        if (strpos($contenu, "@import") === false) {
356                return $contenu;
357        }
358
359        $imports_non_resolvables = array();
360        preg_match_all(",@import ([^;]*);,UmsS", $contenu, $matches, PREG_SET_ORDER);
361
362        if ($matches and count($matches)) {
363                foreach ($matches as $m) {
364                        $url = $media = $erreur = "";
365                        if (preg_match(",^\s*url\s*\(\s*['\"]?([^'\"]*)['\"]?\s*\),Ums", $m[1], $r)) {
366                                $url = $r[1];
367                                $media = trim(substr($m[1], strlen($r[0])));
368                        } elseif (preg_match(",^\s*['\"]([^'\"]+)['\"],Ums", $m[1], $r)) {
369                                $url = $r[1];
370                                $media = trim(substr($m[1], strlen($r[0])));
371                        }
372                        if (!$url) {
373                                $erreur = "Compresseur : <tt>" . $m[0] . ";</tt> non resolu dans <tt>$url_base</tt>";
374                        } else {
375                                $url = suivre_lien($url_base, $url);
376                                // url relative ?
377                                $root = protocole_implicite($GLOBALS['meta']['adresse_site'] . "/");
378                                if (strncmp($url, $root, strlen($root)) == 0) {
379                                        $url = _DIR_RACINE . substr($url, strlen($root));
380                                } else {
381                                        // si l'url a un protocole http(s):// on ne considère qu'on ne peut pas
382                                        // résoudre le stockage. Par exemple
383                                        // @import url(https://fonts.googleapis.com/css?family=Ubuntu);
384                                        // retournant un contenu différent en fonction navigateur
385                                        // tous les @import restant seront remontes en tete de CSS en fin de concatenation
386                                        if (preg_match(',^https?://,', $url)) {
387                                                $url = "";
388                                        } else {
389                                                // protocole implicite //
390                                                $url = "http:$url";
391                                        }
392                                }
393
394                                if ($url) {
395                                        // on renvoit dans la boucle pour que le fichier inclus
396                                        // soit aussi processe (@import, url absolue etc...)
397                                        $css = compresseur_callback_prepare_css($url);
398                                        if ($css == $url
399                                                or !lire_fichier($css, $contenu_imported)
400                                        ) {
401                                                $erreur = "Compresseur : url $url de <tt>" . $m[0] . ";</tt> non resolu dans <tt>$url_base</tt>";
402                                        } else {
403                                                if ($media) {
404                                                        $contenu_imported = "@media $media{\n$contenu_imported\n}\n";
405                                                }
406                                                $contenu = str_replace($m[0], $contenu_imported, $contenu);
407                                        }
408                                }
409                        }
410
411                        if ($erreur) {
412                                $contenu = str_replace($m[0], "/* erreur @ import " . $m[1] . "*/", $contenu);
413                                erreur_squelette($erreur);
414                        }
415                }
416        }
417
418        return $contenu;
419}
420
421/**
422 * Regrouper les @import restants dans la CSS concatenee en debut de celle-ci
423 *
424 * @param string $nom_tmp
425 * @param string $nom
426 * @return bool|string
427 */
428function css_regroup_atimport($nom_tmp, $nom) {
429        lire_fichier($nom_tmp, $contenu);
430        if (!$contenu or strpos($contenu, "@import") === false) {
431                return false;
432        } // rien a faire
433
434        preg_match_all(",@import ([^;]*);,UmsS", $contenu, $matches, PREG_SET_ORDER);
435        $imports = array_map("reset", $matches);
436        $contenu = str_replace($imports, "", $contenu);
437        $contenu = implode("\n", $imports) . "\n" . $contenu;
438        ecrire_fichier($nom, $contenu, true);
439
440        return $nom;
441}
442
443/**
444 * Remplacer l'URL du site par une url de ressource genre static.example.org
445 * qui evite les echanges de cookie pour les ressources images
446 * (peut aussi etre l'URL d'un CDN ou autre provider de ressources statiques)
447 *
448 * @param string $contenu
449 * @param string $url_base
450 * @param string $filename
451 * @return mixed
452 */
453function css_url_statique_ressources($contenu, $url_base, $filename){
454
455        if (isset($GLOBALS['meta']['url_statique_ressources'])
456          and $url_statique = $GLOBALS['meta']['url_statique_ressources']) {
457                $url_statique = rtrim(protocole_implicite($url_statique),"/")."/";
458                $url_site = rtrim(protocole_implicite($GLOBALS['meta']['adresse_site']),"/")."/";
459                $contenu = str_replace($url_site, $url_statique, $contenu);
460        }
461        return $contenu;
462}
Note: See TracBrowser for help on using the repository browser.