Changeset 109736 in spip-zone


Ignore:
Timestamp:
Mar 30, 2018, 4:06:15 PM (20 months ago)
Author:
cedric@…
Message:

un dossier syndic avec les methodes de syndication chargeables via charger_fonction + inc/syndic contient les include_spip qui vont bien pour ne rien casser

Location:
_core_/plugins/sites
Files:
1 added
2 edited
1 copied

Legend:

Unmodified
Added
Removed
  • _core_/plugins/sites/genie/syndic.php

    r109734 r109736  
    135135                "id_syndic=" . intval($now_id_syndic));
    136136
    137         include_spip('inc/syndic');
    138         $articles = syndic_http_dist($url_syndic);
     137        $methode_syndication = 'http';
     138        $syndic = charger_fonction($methode_syndication, 'syndic');
     139        $articles = $syndic($url_syndic);
    139140
    140141        // Renvoyer l'erreur le cas echeant
  • _core_/plugins/sites/inc/syndic.php

    r109735 r109736  
    2727// Voir un exemple dans action/editer/site
    2828include_spip('genie/syndic');
     29include_spip('syndic/http');
    2930
    30 
    31 /**
    32  * Analyse d'une URL au format RSS/Atom
    33  * @param string $url_syndic
    34  * @return array|string
    35  */
    36 function syndic_http_dist($url_syndic) {
    37 
    38         // Aller chercher les donnees du RSS et les analyser
    39         include_spip('inc/distant');
    40         $res = recuperer_url($url_syndic, array('transcoder' => true));
    41         if (!$res
    42           or !$res['page']
    43           or intval($res['status']/100) != 2) {
    44                 $items = _T('sites:avis_echec_syndication_02');
    45         } else {
    46                 $items = analyser_backend($res['page'], $url_syndic);
    47         }
    48 
    49         return $items;
    50 }
    51 
    52 /**
    53  * Analyse un texte de backend
    54  *
    55  * @param string $rss
    56  *     Texte du fichier de backend
    57  * @param string $url_syndic
    58  *     URL du site d'où à été extrait le texte
    59  * @return array|string
    60  *     - array : tableau des items lus,
    61  *     - string : texte d'erreur
    62  **/
    63 function analyser_backend($rss, $url_syndic = '') {
    64         include_spip('inc/texte'); # pour couper()
    65 
    66         $rss = pipeline('pre_syndication', $rss);
    67 
    68         if (!defined('_SYNDICATION_DEREFERENCER_URL')) {
    69                 /** si true, les URLs de type feedburner sont déréférencées */
    70                 define('_SYNDICATION_DEREFERENCER_URL', false);
    71         }
    72 
    73         // Echapper les CDATA
    74         cdata_echappe($rss, $echappe_cdata);
    75 
    76         // supprimer les commentaires
    77         $rss = preg_replace(',<!--.*-->,Ums', '', $rss);
    78 
    79         // simplifier le backend, en supprimant les espaces de nommage type "dc:"
    80         $rss = preg_replace(',<(/?)(dc):,i', '<\1', $rss);
    81 
    82         // chercher auteur/lang dans le fil au cas ou les items n'en auraient pas
    83         list($header) = preg_split(',<(item|entry)\b,', $rss, 2);
    84         if (preg_match_all(
    85                 ',<(author|creator)\b(.*)</\1>,Uims',
    86                 $header, $regs, PREG_SET_ORDER)) {
    87                 $les_auteurs_du_site = array();
    88                 foreach ($regs as $reg) {
    89                         $nom = $reg[2];
    90                         if (preg_match(',<name>(.*)</name>,Uims', $nom, $reg)) {
    91                                 $nom = $reg[1];
    92                         }
    93                         $les_auteurs_du_site[] = trim(textebrut(filtrer_entites($nom)));
    94                 }
    95                 $les_auteurs_du_site = join(', ', array_unique($les_auteurs_du_site));
    96         } else {
    97                 $les_auteurs_du_site = '';
    98         }
    99 
    100         $langue_du_site = '';
    101 
    102         if ((preg_match(',<([^>]*xml:)?lang(uage)?' . '>([^<>]+)<,i',
    103                                 $header, $match) and $l = $match[3])
    104                 or ($l = extraire_attribut(extraire_balise($header, 'feed'), 'xml:lang'))
    105         ) {
    106                 $langue_du_site = $l;
    107         } // atom
    108         elseif (preg_match(',<feed\s[^>]*xml:lang=[\'"]([^<>\'"]+)[\'"],i', $header, $match)) {
    109                 $langue_du_site = $match[1];
    110         }
    111 
    112         // Recuperer les blocs item et entry
    113         $items = array_merge(extraire_balises($rss, 'item'), extraire_balises($rss, 'entry'));
    114 
    115 
    116         //
    117         // Analyser chaque <item>...</item> du backend et le transformer en tableau
    118         //
    119 
    120         if (!count($items)) {
    121                 return _T('sites:avis_echec_syndication_01');
    122         }
    123 
    124         if (!defined('_SYNDICATION_MAX_ITEMS')) define('_SYNDICATION_MAX_ITEMS',1000);
    125         $nb_items = 0;
    126         foreach ($items as $item) {
    127                 $data = array();
    128                 if ($nb_items++>_SYNDICATION_MAX_ITEMS){
    129                         break;
    130                 }
    131 
    132                 // URL (semi-obligatoire, sert de cle)
    133 
    134                 // guid n'est un URL que si marque de <guid ispermalink="true"> ;
    135                 // attention la valeur par defaut est 'true' ce qui oblige a quelque
    136                 // gymnastique
    137                 if (preg_match(',<guid.*>[[:space:]]*(https?:[^<]*)</guid>,Uims',
    138                                 $item, $regs) and preg_match(',^(true|1)?$,i',
    139                                 extraire_attribut($regs[0], 'ispermalink'))
    140                 ) {
    141                         $data['url'] = $regs[1];
    142                 } // contourner les redirections feedburner
    143                 else {
    144                         if (_SYNDICATION_DEREFERENCER_URL
    145                                 and preg_match(',<feedburner:origLink>(.*)<,Uims',
    146                                         $item, $regs)
    147                         ) {
    148                                 $data['url'] = $regs[1];
    149                         } // <link>, plus classique
    150                         else {
    151                                 if (preg_match(
    152                                         ',<link[^>]*[[:space:]]rel=["\']?alternate[^>]*>(.*)</link>,Uims',
    153                                         $item, $regs)) {
    154                                         $data['url'] = $regs[1];
    155                                 } else {
    156                                         if (preg_match(',<link[^>]*[[:space:]]rel=.alternate[^>]*>,Uims',
    157                                                 $item, $regs)) {
    158                                                 $data['url'] = extraire_attribut($regs[0], 'href');
    159                                         } else {
    160                                                 if (preg_match(',<link[^>]*>\s*([^\s]+)\s*</link>,Uims', $item, $regs)) {
    161                                                         $data['url'] = $regs[1];
    162                                                 } else {
    163                                                         if (preg_match(',<link[^>]*>,Uims', $item, $regs)) {
    164                                                                 $data['url'] = extraire_attribut($regs[0], 'href');
    165                                                         } // Aucun link ni guid, mais une enclosure
    166                                                         else {
    167                                                                 if (preg_match(',<enclosure[^>]*>,ims', $item, $regs)
    168                                                                         and $url = extraire_attribut($regs[0], 'url')
    169                                                                 ) {
    170                                                                         $data['url'] = $url;
    171                                                                 } // pas d'url, c'est genre un compteur...
    172                                                                 else {
    173                                                                         $data['url'] = '';
    174                                                                 }
    175                                                         }
    176                                                 }
    177                                         }
    178                                 }
    179                         }
    180                 }
    181 
    182                 // Titre (semi-obligatoire)
    183                 if (preg_match(",<title[^>]*>(.*?)</title>,ims", $item, $match)) {
    184                         $data['titre'] = $match[1];
    185                 } else {
    186                         if (preg_match(',<link[[:space:]][^>]*>,Uims', $item, $mat)
    187                                 and $title = extraire_attribut($mat[0], 'title')
    188                         ) {
    189                                 $data['titre'] = $title;
    190                         }
    191                 }
    192                 if (!strlen($data['titre'] = trim($data['titre']))) {
    193                         $data['titre'] = _T('ecrire:info_sans_titre');
    194                 }
    195 
    196                 // Date
    197                 $la_date = '';
    198                 if (preg_match(',<(published|modified|issued)>([^<]*)<,Uims',
    199                         $item, $match)) {
    200                         cdata_echappe_retour($match[2], $echappe_cdata);
    201                         $la_date = my_strtotime($match[2], $langue_du_site);
    202                 }
    203                 if (!$la_date and
    204                         preg_match(',<(pubdate)>([^<]*)<,Uims', $item, $match)
    205                 ) {
    206                         cdata_echappe_retour($match[2], $echappe_cdata);
    207                         $la_date = my_strtotime($match[2], $langue_du_site);
    208                 }
    209                 if (!$la_date and
    210                         preg_match(',<([a-z]+:date)>([^<]*)<,Uims', $item, $match)
    211                 ) {
    212                         cdata_echappe_retour($match[2], $echappe_cdata);
    213                         $la_date = my_strtotime($match[2], $langue_du_site);
    214                 }
    215                 if (!$la_date and
    216                         preg_match(',<date>([^<]*)<,Uims', $item, $match)
    217                 ) {
    218                         cdata_echappe_retour($match[1], $echappe_cdata);
    219                         $la_date = my_strtotime($match[1], $langue_du_site);
    220                 }
    221 
    222                 // controle de validite de la date
    223                 // pour eviter qu'un backend errone passe toujours devant
    224                 // (note: ca pourrait etre defini site par site, mais ca risque d'etre
    225                 // plus lourd que vraiment utile)
    226                 if ($GLOBALS['controler_dates_rss']) {
    227                         if (!$la_date
    228                                 or $la_date > time() + 48 * 3600
    229                         ) {
    230                                 $la_date = time();
    231                         }
    232                 }
    233 
    234                 if ($la_date) {
    235                         $data['date'] = $la_date;
    236                 }
    237 
    238                 // Honorer le <lastbuilddate> en forcant la date
    239                 if (preg_match(',<(lastbuilddate|updated|modified)>([^<>]+)</\1>,i',
    240                                 $item, $regs)
    241                         and $lastbuilddate = my_strtotime(trim($regs[2]), $langue_du_site)
    242                         // pas dans le futur
    243                         and $lastbuilddate < time()
    244                 ) {
    245                         $data['lastbuilddate'] = $lastbuilddate;
    246                 }
    247 
    248                 // Auteur(s)
    249                 if (preg_match_all(
    250                         ',<(author|creator)\b[^>]*>(.*)</\1>,Uims',
    251                         $item, $regs, PREG_SET_ORDER)) {
    252                         $auteurs = array();
    253                         foreach ($regs as $reg) {
    254                                 $nom = $reg[2];
    255                                 if (preg_match(',<name\b[^>]*>(.*)</name>,Uims', $nom, $reg)) {
    256                                         $nom = $reg[1];
    257                                 }
    258                                 // Cas particulier d'un auteur Flickr
    259                                 if (preg_match(',nobody@flickr.com \((.*)\),Uims', $nom, $reg)) {
    260                                         $nom = $reg[1];
    261                                 }
    262                                 $auteurs[] = trim(textebrut(filtrer_entites($nom)));
    263                         }
    264                         $data['lesauteurs'] = join(', ', array_unique($auteurs));
    265                 } else {
    266                         $data['lesauteurs'] = $les_auteurs_du_site;
    267                 }
    268 
    269                 // Description
    270                 if (preg_match(',<(description|summary)\b.*'
    271                         . '>(.*)</\1\b,Uims', $item, $match)) {
    272                         $data['descriptif'] = trim($match[2]);
    273                 }
    274                 if (preg_match(',<(content)\b.*'
    275                         . '>(.*)</\1\b,Uims', $item, $match)) {
    276                         $data['content'] = trim($match[2]);
    277                 }
    278 
    279                 // lang
    280                 if (preg_match(',<([^>]*xml:)?lang(uage)?' . '>([^<>]+)<,i',
    281                         $item, $match)) {
    282                         $data['lang'] = trim($match[3]);
    283                 } else {
    284                         if ($lang = trim(extraire_attribut($item, 'xml:lang'))) {
    285                                 $data['lang'] = $lang;
    286                         } else {
    287                                 $data['lang'] = trim($langue_du_site);
    288                         }
    289                 }
    290 
    291                 // source et url_source  (pas trouve d'exemple en ligne !!)
    292                 # <source url="http://www.truc.net/music/uatsap.mp3" length="19917" />
    293                 # <source url="http://www.truc.net/rss">Site source</source>
    294                 if (preg_match(',(<source[^>]*>)(([^<>]+)</source>)?,i',
    295                         $item, $match)) {
    296                         $data['source'] = trim($match[3]);
    297                         $data['url_source'] = str_replace('&amp;', '&',
    298                                 trim(extraire_attribut($match[1], 'url')));
    299                 }
    300 
    301                 // tags
    302                 # a partir de "<dc:subject>", (del.icio.us)
    303                 # ou <media:category> (flickr)
    304                 # ou <itunes:category> (apple)
    305                 # on cree nos tags microformat <a rel="directory" href="url">titre</a>
    306                 # http://microformats.org/wiki/rel-directory-fr
    307                 $tags = array();
    308                 if (preg_match_all(
    309                         ',<(([a-z]+:)?(subject|category|directory|keywords?|tags?|type))[^>]*>'
    310                         . '(.*?)</\1>,ims',
    311                         $item, $matches, PREG_SET_ORDER)) {
    312                         $tags = ajouter_tags($matches, $item);
    313                 } # array()
    314                 elseif (preg_match_all(
    315                         ',<(([a-z]+:)?(subject|category|directory|keywords?|tags?|type))[^>]*/>'
    316                         . ',ims',
    317                         $item, $matches, PREG_SET_ORDER)) {
    318                         $tags = ajouter_tags($matches, $item);
    319                 } # array()
    320                 // Pieces jointes :
    321                 // chercher <enclosure> au format RSS et les passer en microformat
    322                 // ou des microformats relEnclosure,
    323                 // ou encore les media:content
    324                 if (!afficher_enclosures(join(', ', $tags))) {
    325                         // on prend toutes les pièces jointes possibles, et on essaie de les rendre uniques.
    326                         $enclosures = array();
    327                         # rss 2
    328                         if (preg_match_all(',<enclosure[[:space:]][^<>]+>,i',
    329                                 $item, $matches, PREG_PATTERN_ORDER)) {
    330                                 $enclosures += array_map('enclosure2microformat', $matches[0]);
    331                         }
    332                         # atom
    333                         if (preg_match_all(',<link\b[^<>]+rel=["\']?enclosure["\']?[^<>]+>,i',
    334                                 $item, $matches, PREG_PATTERN_ORDER)) {
    335                                 $enclosures += array_map('enclosure2microformat', $matches[0]);
    336                         }
    337                         # media rss
    338                         if (preg_match_all(',<media:content\b[^<>]+>,i',
    339                                 $item, $matches, PREG_PATTERN_ORDER)) {
    340                                 $enclosures += array_map('enclosure2microformat', $matches[0]);
    341                         }
    342                         $data['enclosures'] = join(', ', array_unique($enclosures));
    343                         unset($enclosures);
    344                 }
    345                 $data['item'] = $item;
    346 
    347                 // Nettoyer les donnees et remettre les CDATA en place
    348                 cdata_echappe_retour($data, $echappe_cdata);
    349                 cdata_echappe_retour($tags, $echappe_cdata);
    350 
    351                 // passer l'url en absolue
    352                 $data['url'] = url_absolue(filtrer_entites($data['url']), $url_syndic);
    353 
    354                 // si on demande un dereferencement de l'URL, il faut verifier que ce n'est pas une redirection
    355                 if (_SYNDICATION_DEREFERENCER_URL) {
    356                         $target = $data['url'];
    357                         include_spip("inc/distant");
    358                         for ($i = 0; $i < 10; $i++) {
    359                                 // on fait un GET et pas un HEAD car les vieux SPIP ne repondent pas la redirection avec un HEAD (honte) sur un article virtuel
    360                                 $res = recuperer_lapage($target, false, "GET", 4096);
    361                                 if (!$res) {
    362                                         break;
    363                                 } // c'est pas bon signe car on a pas trouve l'URL...
    364                                 if (is_array($res)) {
    365                                         break;
    366                                 } // on a trouve la page, donc on a l'URL finale
    367                                 $target = $res; // c'est une redirection, on la suit pour voir ou elle mene
    368                         }
    369                         // ici $target est l'URL finale de la page
    370                         $data['url'] = $target;
    371                 }
    372 
    373                 // Trouver les microformats (ecrase les <category> et <dc:subject>)
    374                 if (preg_match_all(
    375                         ',<a[[:space:]]([^>]+[[:space:]])?rel=[^>]+>.*</a>,Uims',
    376                         $data['item'], $regs, PREG_PATTERN_ORDER)) {
    377                         $tags = $regs[0];
    378                 }
    379                 // Cas particulier : tags Connotea sous la forme <a class="postedtag">
    380                 if (preg_match_all(
    381                         ',<a[[:space:]][^>]+ class="postedtag"[^>]*>.*</a>,Uims',
    382                         $data['item'], $regs, PREG_PATTERN_ORDER)) {
    383                         $tags = preg_replace(', class="postedtag",i',
    384                                 ' rel="tag"', $regs[0]);
    385                 }
    386 
    387                 $data['tags'] = $tags;
    388                 // enlever le html des titre pour etre homogene avec les autres objets spip
    389                 $data['titre'] = textebrut($data['titre']);
    390 
    391                 $articles[] = $data;
    392         }
    393 
    394         return $articles;
    395 }
    396 
    397 
    398 /**
    399  * Strtotime même avec le format W3C !
    400  *
    401  * Car hélàs, strtotime ne le reconnait pas tout seul !
    402  *
    403  * @link http://www.w3.org/TR/NOTE-datetime Format datetime du W3C
    404  *
    405  * @param string $la_date
    406  *     Date à parser
    407  * @return int
    408  *     Timestamp
    409  **/
    410 function my_strtotime($la_date, $lang = null) {
    411         // format complet
    412         if (preg_match(
    413                 ',^(\d+-\d+-\d+[T ]\d+:\d+(:\d+)?)(\.\d+)?'
    414                 . '(Z|([-+]\d{2}):\d+)?$,',
    415                 $la_date, $match)) {
    416                 $match = array_pad($match, 6, null);
    417                 $la_date = str_replace("T", " ", $match[1]) . " GMT";
    418 
    419                 return strtotime($la_date) - intval($match[5]) * 3600;
    420         }
    421 
    422         // YYYY
    423         if (preg_match(',^\d{4}$,', $la_date, $match)) {
    424                 return strtotime($match[0] . "-01-01");
    425         }
    426 
    427         // YYYY-MM
    428         if (preg_match(',^\d{4}-\d{2}$,', $la_date, $match)) {
    429                 return strtotime($match[0] . "-01");
    430         }
    431 
    432         // YYYY-MM-DD hh:mm:ss
    433         if (preg_match(',^\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\b,', $la_date, $match)) {
    434                 return strtotime($match[0]);
    435         }
    436 
    437         // utiliser strtotime en dernier ressort
    438         // en nettoyant le jour qui prefixe parfois la date, suivi d'une virgule
    439         // et les UT qui sont en fait des UTC
    440         $la_date_c = preg_replace("/^\w+,\s*/ms", "", $la_date);
    441         $la_date_c = preg_replace("/UT\s*$/ms", "UTC", $la_date_c);
    442         if ($s = strtotime($la_date)
    443                 or $s = strtotime($la_date_c)
    444         ) {
    445                 return $s;
    446         }
    447 
    448         // essayons de voir si le nom du mois est dans la langue du flux et remplacons le
    449         // par la version anglaise avant de faire strtotime
    450         if ($lang) {
    451                 // "fr-fr"
    452                 list($lang) = explode("-", $lang);
    453                 static $months = null;
    454                 if (!isset($months[$lang])) {
    455                         $prev_lang = $GLOBALS['spip_lang'];
    456                         changer_langue($lang);
    457                         foreach (range(1, 12) as $m) {
    458                                 $s = _T("date_mois_$m");
    459                                 $months[$lang][$s] = date("M", strtotime("2013-$m-01"));
    460                                 $s = _T("date_mois_" . $m . "_abbr");
    461                                 $months[$lang][$s] = date("M", strtotime("2013-$m-01"));
    462                                 $months[$lang][trim($s, ".")] = date("M", strtotime("2013-$m-01"));
    463                         }
    464                         changer_langue($prev_lang);
    465                 }
    466                 spip_log($la_date_c, "dbgs");
    467                 foreach ($months[$lang] as $loc => $en) {
    468                         if (stripos($la_date_c, $loc) !== false) {
    469                                 $s = str_ireplace($loc, $en, $la_date_c);
    470                                 if ($s = strtotime($s)) {
    471                                         return $s;
    472                                 }
    473                         }
    474                 }
    475         }
    476 
    477         // erreur
    478         spip_log("Impossible de lire le format de date '$la_date'");
    479 
    480         return false;
    481 }
    482 
    483 // A partir d'un <dc:subject> ou autre essayer de recuperer
    484 // le mot et son url ; on cree <a href="url" rel="tag">mot</a>
    485 // https://code.spip.net/@creer_tag
    486 function creer_tag($mot, $type, $url) {
    487         if (!strlen($mot = trim($mot))) {
    488                 return '';
    489         }
    490         $mot = "<a rel=\"tag\">$mot</a>";
    491         if ($url) {
    492                 $mot = inserer_attribut($mot, 'href', $url);
    493         }
    494         if ($type) {
    495                 $mot = inserer_attribut($mot, 'rel', $type);
    496         }
    497 
    498         return $mot;
    499 }
    500 
    501 
    502 // https://code.spip.net/@ajouter_tags
    503 function ajouter_tags($matches, $item) {
    504         include_spip('inc/filtres');
    505         $tags = array();
    506         foreach ($matches as $match) {
    507                 $type = ($match[3] == 'category' or $match[3] == 'directory')
    508                         ? 'directory' : 'tag';
    509                 $mot = supprimer_tags($match[0]);
    510                 if (!strlen($mot)
    511                         and !strlen($mot = extraire_attribut($match[0], 'label'))
    512                 ) {
    513                         break;
    514                 }
    515                 // rechercher un url
    516                 if ($url = extraire_attribut($match[0], 'domain')) {
    517                         // category@domain est la racine d'une url qui se prolonge
    518                         // avec le contenu text du tag <category> ; mais dans SPIP < 2.0
    519                         // on donnait category@domain = #URL_RUBRIQUE, et
    520                         // text = #TITRE_RUBRIQUE ; d'ou l'heuristique suivante sur le slash
    521                         if (substr($url, -1) == '/') {
    522                                 $url .= rawurlencode($mot);
    523                         }
    524                 } else {
    525                         if ($url = extraire_attribut($match[0], 'resource')
    526                                 or $url = extraire_attribut($match[0], 'url')
    527                         ) {
    528                         } ## cas particuliers
    529                         else {
    530                                 if (extraire_attribut($match[0], 'scheme') == 'urn:flickr:tags') {
    531                                         foreach (explode(' ', $mot) as $petit) {
    532                                                 if ($t = creer_tag($petit, $type,
    533                                                         'http://www.flickr.com/photos/tags/' . rawurlencode($petit) . '/')
    534                                                 ) {
    535                                                         $tags[] = $t;
    536                                                 }
    537                                         }
    538                                         $mot = '';
    539                                 } else {
    540                                         if (
    541                                                 // cas atom1, a faire apres flickr
    542                                         $term = extraire_attribut($match[0], 'term')
    543                                         ) {
    544                                                 if ($scheme = extraire_attribut($match[0], 'scheme')) {
    545                                                         $url = suivre_lien($scheme, $term);
    546                                                 } else {
    547                                                         $url = $term;
    548                                                 }
    549                                         } else {
    550                                                 # type delicious.com
    551                                                 foreach (explode(' ', $mot) as $petit) {
    552                                                         if (preg_match(',<rdf\b[^>]*\bresource=["\']([^>]*/'
    553                                                                 . preg_quote(rawurlencode($petit), ',') . ')["\'],i',
    554                                                                 $item, $m)) {
    555                                                                 $mot = '';
    556                                                                 if ($t = creer_tag($petit, $type, $m[1])) {
    557                                                                         $tags[] = $t;
    558                                                                 }
    559                                                         }
    560                                                 }
    561                                         }
    562                                 }
    563                         }
    564                 }
    565 
    566                 if ($t = creer_tag($mot, $type, $url)) {
    567                         $tags[] = $t;
    568                 }
    569         }
    570 
    571         return $tags;
    572 }
    573 
    574 
    575 // Lit contenu des blocs [[CDATA]] dans un flux
    576 // https://code.spip.net/@cdata_echappe_retour
    577 function cdata_echappe(&$rss, &$echappe_cdata) {
    578         $echappe_cdata = array();
    579         if (preg_match_all(',<!\[CDATA\[(.*)]]>,Uims', $rss,
    580                 $regs, PREG_SET_ORDER)) {
    581                 foreach ($regs as $n => $reg) {
    582                         if (strpos($reg[1],'<')!==false
    583                           or strpos($reg[1],'>')!==false) {
    584                                 // verifier que la chaine est encore dans le flux, car on peut avoir X fois la meme
    585                                 // inutile de (sur)peupler le tableau avec des substitutions identiques
    586                                 if (strpos($rss,$reg[0])!==false){
    587                                         $echappe_cdata["@@@SPIP_CDATA$n@@@"] = $reg[1];
    588                                         $rss = str_replace($reg[0], "@@@SPIP_CDATA$n@@@", $rss);
    589                                 }
    590                         } else {
    591                                 $rss = str_replace($reg[0], $reg[1], $rss);
    592                         }
    593                 }
    594         }
    595 }
    596 
    597 // Retablit le contenu des blocs [[CDATA]] dans une chaine ou un tableau
    598 // https://code.spip.net/@cdata_echappe_retour
    599 function cdata_echappe_retour(&$x, &$echappe_cdata) {
    600         if (is_string($x)) {
    601                 if (strpos($x, '&lt;') !== false){
    602                         $x = filtrer_entites($x);
    603                 }
    604                 if (strpos($x, '@@@SPIP_CDATA') !== false){
    605                         $x = str_replace( array_keys($echappe_cdata), array_values($echappe_cdata), $x);
    606                 }
    607         } else {
    608                 if (is_array($x)) {
    609                         foreach ($x as $k => &$v) {
    610                                 cdata_echappe_retour($v, $echappe_cdata);
    611                         }
    612                 }
    613         }
    614 }
Note: See TracChangeset for help on using the changeset viewer.