spip /
SPIP
@@ -17,210 +17,210 @@ |
||
| 17 | 17 | * @see extraire_balises() |
| 18 | 18 | */ |
| 19 | 19 | class HtmlTag extends AbstractCollecteur { |
| 20 | - protected static string $markPrefix = 'HTMLTAG'; |
|
| 21 | - |
|
| 22 | - /** |
|
| 23 | - * La preg pour découper et collecter les modèles |
|
| 24 | - * @var string |
|
| 25 | - */ |
|
| 26 | - protected string $preg_openingtag; |
|
| 27 | - protected string $preg_closingtag; |
|
| 28 | - protected string $tag; |
|
| 29 | - |
|
| 30 | - public static array $listeBalisesAProteger = ['html', 'pre', 'code', 'cadre', 'frame', 'script', 'style']; |
|
| 31 | - |
|
| 32 | - public function __construct(string $tag, ?string $preg_openingtag = null, ?string $preg_closingtag = null) { |
|
| 33 | - |
|
| 34 | - $tag = strtolower($tag); |
|
| 35 | - $this->tag = $tag; |
|
| 36 | - $this->preg_openingtag = ($preg_openingtag ?: "@<{$tag}\b([^>]*?)(/?)>@isS"); |
|
| 37 | - $this->preg_closingtag = ($preg_closingtag ?? "@</{$tag}\b[^>]*>@isS"); |
|
| 38 | - } |
|
| 39 | - |
|
| 40 | - /** |
|
| 41 | - * @param string $texte |
|
| 42 | - * @param array $options |
|
| 43 | - * bool $detecter_presence |
|
| 44 | - * bool $nb_max |
|
| 45 | - * int $profondeur |
|
| 46 | - * @return array |
|
| 47 | - */ |
|
| 48 | - public function collecter(string $texte, array $options = []): array { |
|
| 49 | - if (!$texte) { |
|
| 50 | - return []; |
|
| 51 | - } |
|
| 52 | - |
|
| 53 | - $upperTag = strtoupper($this->tag); |
|
| 54 | - $hasUpperCaseTags = ($upperTag !== $this->tag && (str_contains($texte, '<' . $upperTag) || str_contains($texte, '</' . $upperTag))); |
|
| 55 | - |
|
| 56 | - // collecter les balises ouvrantes |
|
| 57 | - $opening = static::collecteur($texte, '', $hasUpperCaseTags ? '<' : '<' . $this->tag, $this->preg_openingtag, empty($options['detecter_presence']) ? 0 : 1); |
|
| 58 | - if (!$opening) { |
|
| 59 | - return []; |
|
| 60 | - } |
|
| 61 | - |
|
| 62 | - // si c'est un tag autofermant ou vide qui se repère avec une seule regexp, on va plus vite |
|
| 63 | - if (!$this->preg_closingtag) { |
|
| 64 | - return $opening; |
|
| 65 | - } |
|
| 66 | - |
|
| 67 | - // collecter les balises fermantes |
|
| 68 | - $closing = static::collecteur($texte, '', $hasUpperCaseTags ? '</' : '</' . $this->tag, $this->preg_closingtag); |
|
| 69 | - |
|
| 70 | - $profondeur = ($options['profondeur'] ?? 1); |
|
| 71 | - $tags = []; |
|
| 72 | - while (!empty($opening)) { |
|
| 73 | - $first_opening = array_shift($opening); |
|
| 74 | - // self closing ? |
|
| 75 | - if (str_contains($first_opening['raw'], '/>')) { |
|
| 76 | - $tag = $first_opening; |
|
| 77 | - $tag['opening'] = $tag['raw']; |
|
| 78 | - $tag['closing'] = ''; |
|
| 79 | - $tag['innerHtml'] = ''; |
|
| 80 | - $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -2)); |
|
| 81 | - $tags[] = $tag; |
|
| 82 | - } |
|
| 83 | - else { |
|
| 84 | - // enlever les closing qui sont avant le premier opening, car ils n'ont pas de sens |
|
| 85 | - while ( |
|
| 86 | - !empty($closing) |
|
| 87 | - && ($first_closing = reset($closing)) |
|
| 88 | - && $first_closing['pos'] < $first_opening['pos'] |
|
| 89 | - ) { |
|
| 90 | - array_shift($closing); |
|
| 91 | - } |
|
| 92 | - |
|
| 93 | - $need_closing = 0; |
|
| 94 | - $next_closing = reset($closing); |
|
| 95 | - $next_opening = reset($opening); |
|
| 96 | - // certaines balises comme <code> neutralisent le contenant, donc tout ce qui est avant le prochain closing doit etre ignoré |
|
| 97 | - if (in_array($this->tag, ['code'])) { |
|
| 98 | - while ($next_opening && $next_closing && $next_opening['pos'] < $next_closing['pos']) { |
|
| 99 | - array_shift($opening); |
|
| 100 | - $next_opening = reset($opening); |
|
| 101 | - } |
|
| 102 | - } |
|
| 103 | - else { |
|
| 104 | - while ($next_opening && $next_closing && $next_opening['pos'] < $next_closing['pos']) { |
|
| 105 | - while ($next_opening && $next_opening['pos'] < $next_closing['pos']) { |
|
| 106 | - // si pas self closing, il faut un closing de plus |
|
| 107 | - if (!str_contains($next_opening['raw'], '/>')) { |
|
| 108 | - $need_closing++; |
|
| 109 | - } |
|
| 110 | - array_shift($opening); |
|
| 111 | - $next_opening = reset($opening); |
|
| 112 | - } |
|
| 113 | - // il faut depiler les balises fermantes autant de fois que nécessaire et tant qu'on a pas une nouvelle balise ouvrante |
|
| 114 | - while ($need_closing && $next_closing && (!$next_opening || $next_closing['pos'] < $next_opening['pos'])) { |
|
| 115 | - array_shift($closing); |
|
| 116 | - $need_closing--; |
|
| 117 | - $next_closing = reset($closing); |
|
| 118 | - } |
|
| 119 | - } |
|
| 120 | - } |
|
| 121 | - // si pas de fermeture, c'est une autofermante mal fermée... |
|
| 122 | - if (!$next_closing || $need_closing) { |
|
| 123 | - $tag = $first_opening; |
|
| 124 | - $tag['opening'] = $tag['raw']; |
|
| 125 | - $tag['closing'] = ''; |
|
| 126 | - $tag['innerHtml'] = ''; |
|
| 127 | - $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -1)); |
|
| 128 | - $tags[] = $tag; |
|
| 129 | - } |
|
| 130 | - else { |
|
| 131 | - $tag = $first_opening; |
|
| 132 | - $next_closing = array_shift($closing); |
|
| 133 | - $innerHtml = substr($texte, $tag['pos'] + $tag['length'], $next_closing['pos'] - $tag['pos'] - $tag['length']); |
|
| 134 | - $tag['length'] = $next_closing['pos'] - $tag['pos'] + $next_closing['length']; |
|
| 135 | - $tag['opening'] = $tag['raw']; |
|
| 136 | - $tag['raw'] = substr($texte, $tag['pos'], $tag['length']); |
|
| 137 | - $tag['innerHtml'] = $innerHtml; |
|
| 138 | - $tag['closing'] = $next_closing['raw']; |
|
| 139 | - $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -1)); |
|
| 140 | - $tags[] = $tag; |
|
| 141 | - } |
|
| 142 | - } |
|
| 143 | - if ((!empty($options['detecter_presence']) && count($tags))) { |
|
| 144 | - return $tags; |
|
| 145 | - } |
|
| 146 | - if (($profondeur == 1 && !empty($options['nb_max']) && count($tags) >= $options['nb_max'])) { |
|
| 147 | - break; |
|
| 148 | - } |
|
| 149 | - } |
|
| 150 | - |
|
| 151 | - while (--$profondeur > 0) { |
|
| 152 | - $outerTags = $tags; |
|
| 153 | - $tags = []; |
|
| 154 | - $options['profondeur'] = 1; |
|
| 155 | - foreach ($outerTags as $outerTag) { |
|
| 156 | - if (!empty($outerTag['innerHtml'])) { |
|
| 157 | - $offsetPos = $outerTag['pos'] + strlen($outerTag['opening']); |
|
| 158 | - $innerTags = $this->collecter($outerTag['innerHtml'], $options); |
|
| 159 | - if (!empty($innerTags)) { |
|
| 160 | - foreach ($innerTags as $tag) { |
|
| 161 | - $tag['pos'] += $offsetPos; |
|
| 162 | - $tags[] = $tag; |
|
| 163 | - } |
|
| 164 | - if (($profondeur == 1 && !empty($options['nb_max']) && count($tags) >= $options['nb_max'])) { |
|
| 165 | - return $tags; |
|
| 166 | - } |
|
| 167 | - } |
|
| 168 | - } |
|
| 169 | - } |
|
| 170 | - } |
|
| 171 | - |
|
| 172 | - |
|
| 173 | - return $tags; |
|
| 174 | - } |
|
| 175 | - |
|
| 176 | - /** |
|
| 177 | - * @param callable|null $callback_function |
|
| 178 | - */ |
|
| 179 | - public function echapper_enHtmlBase64(string $texte, string $source = '', $callback_function = null, array $callback_options = []): string { |
|
| 180 | - if ($callback_function) { |
|
| 181 | - $legacy_callback = $callback_function; |
|
| 182 | - // si on est dans un cas evident de preg perso, ne pas essayer de mapper le match car on ne sait pas ce qu'il contient |
|
| 183 | - // et on aura pas non plus de innerHtml si pas de preg_closingtag |
|
| 184 | - if ($this->preg_closingtag) { |
|
| 185 | - $tag = $this->tag; |
|
| 186 | - $legacy_callback = function ($c, $options) use ($tag, $callback_function) { |
|
| 187 | - // legacy : renseigner les infos correspondantes aux matchs de l'ancienne regexp |
|
| 188 | - $regs = [ |
|
| 189 | - 0 => $c['raw'], |
|
| 190 | - 1 => $tag, |
|
| 191 | - 2 => $c['match'][1] . $c['match'][2], |
|
| 192 | - 3 => $c['innerHtml'], |
|
| 193 | - 'tag' => $this->tag, |
|
| 194 | - ] + $c; |
|
| 195 | - return $callback_function($regs, $options); |
|
| 196 | - }; |
|
| 197 | - } |
|
| 198 | - } |
|
| 199 | - return parent::echapper_enHtmlBase64($texte, $source, $callback_function ? $legacy_callback : null, $callback_options); |
|
| 200 | - } |
|
| 201 | - |
|
| 202 | - |
|
| 203 | - /** |
|
| 204 | - * pour $source voir commentaire infra (echappe_retour) |
|
| 205 | - * pour $no_transform voir le filtre post_autobr dans inc/filtres |
|
| 206 | - */ |
|
| 207 | - public static function proteger_balisesHtml(string $texte, string $source = '', ?array $html_tags = null, array $callbacks_function = [], array $callback_options = []): string { |
|
| 208 | - if ($texte === '') { |
|
| 209 | - return ''; |
|
| 210 | - } |
|
| 211 | - |
|
| 212 | - $html_tags = $html_tags ?: self::$listeBalisesAProteger; |
|
| 213 | - |
|
| 214 | - $tags_todo = $html_tags; |
|
| 215 | - while ( |
|
| 216 | - !empty($tags_todo) |
|
| 217 | - && ($tag = array_shift($tags_todo)) |
|
| 218 | - && str_contains($texte, '<') |
|
| 219 | - ) { |
|
| 220 | - $htmlTagCollecteur = new self($tag); |
|
| 221 | - $texte = $htmlTagCollecteur->echapper_enHtmlBase64($texte, $source, $callbacks_function[$tag] ?? null, $callback_options); |
|
| 222 | - } |
|
| 223 | - |
|
| 224 | - return $texte; |
|
| 225 | - } |
|
| 20 | + protected static string $markPrefix = 'HTMLTAG'; |
|
| 21 | + |
|
| 22 | + /** |
|
| 23 | + * La preg pour découper et collecter les modèles |
|
| 24 | + * @var string |
|
| 25 | + */ |
|
| 26 | + protected string $preg_openingtag; |
|
| 27 | + protected string $preg_closingtag; |
|
| 28 | + protected string $tag; |
|
| 29 | + |
|
| 30 | + public static array $listeBalisesAProteger = ['html', 'pre', 'code', 'cadre', 'frame', 'script', 'style']; |
|
| 31 | + |
|
| 32 | + public function __construct(string $tag, ?string $preg_openingtag = null, ?string $preg_closingtag = null) { |
|
| 33 | + |
|
| 34 | + $tag = strtolower($tag); |
|
| 35 | + $this->tag = $tag; |
|
| 36 | + $this->preg_openingtag = ($preg_openingtag ?: "@<{$tag}\b([^>]*?)(/?)>@isS"); |
|
| 37 | + $this->preg_closingtag = ($preg_closingtag ?? "@</{$tag}\b[^>]*>@isS"); |
|
| 38 | + } |
|
| 39 | + |
|
| 40 | + /** |
|
| 41 | + * @param string $texte |
|
| 42 | + * @param array $options |
|
| 43 | + * bool $detecter_presence |
|
| 44 | + * bool $nb_max |
|
| 45 | + * int $profondeur |
|
| 46 | + * @return array |
|
| 47 | + */ |
|
| 48 | + public function collecter(string $texte, array $options = []): array { |
|
| 49 | + if (!$texte) { |
|
| 50 | + return []; |
|
| 51 | + } |
|
| 52 | + |
|
| 53 | + $upperTag = strtoupper($this->tag); |
|
| 54 | + $hasUpperCaseTags = ($upperTag !== $this->tag && (str_contains($texte, '<' . $upperTag) || str_contains($texte, '</' . $upperTag))); |
|
| 55 | + |
|
| 56 | + // collecter les balises ouvrantes |
|
| 57 | + $opening = static::collecteur($texte, '', $hasUpperCaseTags ? '<' : '<' . $this->tag, $this->preg_openingtag, empty($options['detecter_presence']) ? 0 : 1); |
|
| 58 | + if (!$opening) { |
|
| 59 | + return []; |
|
| 60 | + } |
|
| 61 | + |
|
| 62 | + // si c'est un tag autofermant ou vide qui se repère avec une seule regexp, on va plus vite |
|
| 63 | + if (!$this->preg_closingtag) { |
|
| 64 | + return $opening; |
|
| 65 | + } |
|
| 66 | + |
|
| 67 | + // collecter les balises fermantes |
|
| 68 | + $closing = static::collecteur($texte, '', $hasUpperCaseTags ? '</' : '</' . $this->tag, $this->preg_closingtag); |
|
| 69 | + |
|
| 70 | + $profondeur = ($options['profondeur'] ?? 1); |
|
| 71 | + $tags = []; |
|
| 72 | + while (!empty($opening)) { |
|
| 73 | + $first_opening = array_shift($opening); |
|
| 74 | + // self closing ? |
|
| 75 | + if (str_contains($first_opening['raw'], '/>')) { |
|
| 76 | + $tag = $first_opening; |
|
| 77 | + $tag['opening'] = $tag['raw']; |
|
| 78 | + $tag['closing'] = ''; |
|
| 79 | + $tag['innerHtml'] = ''; |
|
| 80 | + $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -2)); |
|
| 81 | + $tags[] = $tag; |
|
| 82 | + } |
|
| 83 | + else { |
|
| 84 | + // enlever les closing qui sont avant le premier opening, car ils n'ont pas de sens |
|
| 85 | + while ( |
|
| 86 | + !empty($closing) |
|
| 87 | + && ($first_closing = reset($closing)) |
|
| 88 | + && $first_closing['pos'] < $first_opening['pos'] |
|
| 89 | + ) { |
|
| 90 | + array_shift($closing); |
|
| 91 | + } |
|
| 92 | + |
|
| 93 | + $need_closing = 0; |
|
| 94 | + $next_closing = reset($closing); |
|
| 95 | + $next_opening = reset($opening); |
|
| 96 | + // certaines balises comme <code> neutralisent le contenant, donc tout ce qui est avant le prochain closing doit etre ignoré |
|
| 97 | + if (in_array($this->tag, ['code'])) { |
|
| 98 | + while ($next_opening && $next_closing && $next_opening['pos'] < $next_closing['pos']) { |
|
| 99 | + array_shift($opening); |
|
| 100 | + $next_opening = reset($opening); |
|
| 101 | + } |
|
| 102 | + } |
|
| 103 | + else { |
|
| 104 | + while ($next_opening && $next_closing && $next_opening['pos'] < $next_closing['pos']) { |
|
| 105 | + while ($next_opening && $next_opening['pos'] < $next_closing['pos']) { |
|
| 106 | + // si pas self closing, il faut un closing de plus |
|
| 107 | + if (!str_contains($next_opening['raw'], '/>')) { |
|
| 108 | + $need_closing++; |
|
| 109 | + } |
|
| 110 | + array_shift($opening); |
|
| 111 | + $next_opening = reset($opening); |
|
| 112 | + } |
|
| 113 | + // il faut depiler les balises fermantes autant de fois que nécessaire et tant qu'on a pas une nouvelle balise ouvrante |
|
| 114 | + while ($need_closing && $next_closing && (!$next_opening || $next_closing['pos'] < $next_opening['pos'])) { |
|
| 115 | + array_shift($closing); |
|
| 116 | + $need_closing--; |
|
| 117 | + $next_closing = reset($closing); |
|
| 118 | + } |
|
| 119 | + } |
|
| 120 | + } |
|
| 121 | + // si pas de fermeture, c'est une autofermante mal fermée... |
|
| 122 | + if (!$next_closing || $need_closing) { |
|
| 123 | + $tag = $first_opening; |
|
| 124 | + $tag['opening'] = $tag['raw']; |
|
| 125 | + $tag['closing'] = ''; |
|
| 126 | + $tag['innerHtml'] = ''; |
|
| 127 | + $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -1)); |
|
| 128 | + $tags[] = $tag; |
|
| 129 | + } |
|
| 130 | + else { |
|
| 131 | + $tag = $first_opening; |
|
| 132 | + $next_closing = array_shift($closing); |
|
| 133 | + $innerHtml = substr($texte, $tag['pos'] + $tag['length'], $next_closing['pos'] - $tag['pos'] - $tag['length']); |
|
| 134 | + $tag['length'] = $next_closing['pos'] - $tag['pos'] + $next_closing['length']; |
|
| 135 | + $tag['opening'] = $tag['raw']; |
|
| 136 | + $tag['raw'] = substr($texte, $tag['pos'], $tag['length']); |
|
| 137 | + $tag['innerHtml'] = $innerHtml; |
|
| 138 | + $tag['closing'] = $next_closing['raw']; |
|
| 139 | + $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -1)); |
|
| 140 | + $tags[] = $tag; |
|
| 141 | + } |
|
| 142 | + } |
|
| 143 | + if ((!empty($options['detecter_presence']) && count($tags))) { |
|
| 144 | + return $tags; |
|
| 145 | + } |
|
| 146 | + if (($profondeur == 1 && !empty($options['nb_max']) && count($tags) >= $options['nb_max'])) { |
|
| 147 | + break; |
|
| 148 | + } |
|
| 149 | + } |
|
| 150 | + |
|
| 151 | + while (--$profondeur > 0) { |
|
| 152 | + $outerTags = $tags; |
|
| 153 | + $tags = []; |
|
| 154 | + $options['profondeur'] = 1; |
|
| 155 | + foreach ($outerTags as $outerTag) { |
|
| 156 | + if (!empty($outerTag['innerHtml'])) { |
|
| 157 | + $offsetPos = $outerTag['pos'] + strlen($outerTag['opening']); |
|
| 158 | + $innerTags = $this->collecter($outerTag['innerHtml'], $options); |
|
| 159 | + if (!empty($innerTags)) { |
|
| 160 | + foreach ($innerTags as $tag) { |
|
| 161 | + $tag['pos'] += $offsetPos; |
|
| 162 | + $tags[] = $tag; |
|
| 163 | + } |
|
| 164 | + if (($profondeur == 1 && !empty($options['nb_max']) && count($tags) >= $options['nb_max'])) { |
|
| 165 | + return $tags; |
|
| 166 | + } |
|
| 167 | + } |
|
| 168 | + } |
|
| 169 | + } |
|
| 170 | + } |
|
| 171 | + |
|
| 172 | + |
|
| 173 | + return $tags; |
|
| 174 | + } |
|
| 175 | + |
|
| 176 | + /** |
|
| 177 | + * @param callable|null $callback_function |
|
| 178 | + */ |
|
| 179 | + public function echapper_enHtmlBase64(string $texte, string $source = '', $callback_function = null, array $callback_options = []): string { |
|
| 180 | + if ($callback_function) { |
|
| 181 | + $legacy_callback = $callback_function; |
|
| 182 | + // si on est dans un cas evident de preg perso, ne pas essayer de mapper le match car on ne sait pas ce qu'il contient |
|
| 183 | + // et on aura pas non plus de innerHtml si pas de preg_closingtag |
|
| 184 | + if ($this->preg_closingtag) { |
|
| 185 | + $tag = $this->tag; |
|
| 186 | + $legacy_callback = function ($c, $options) use ($tag, $callback_function) { |
|
| 187 | + // legacy : renseigner les infos correspondantes aux matchs de l'ancienne regexp |
|
| 188 | + $regs = [ |
|
| 189 | + 0 => $c['raw'], |
|
| 190 | + 1 => $tag, |
|
| 191 | + 2 => $c['match'][1] . $c['match'][2], |
|
| 192 | + 3 => $c['innerHtml'], |
|
| 193 | + 'tag' => $this->tag, |
|
| 194 | + ] + $c; |
|
| 195 | + return $callback_function($regs, $options); |
|
| 196 | + }; |
|
| 197 | + } |
|
| 198 | + } |
|
| 199 | + return parent::echapper_enHtmlBase64($texte, $source, $callback_function ? $legacy_callback : null, $callback_options); |
|
| 200 | + } |
|
| 201 | + |
|
| 202 | + |
|
| 203 | + /** |
|
| 204 | + * pour $source voir commentaire infra (echappe_retour) |
|
| 205 | + * pour $no_transform voir le filtre post_autobr dans inc/filtres |
|
| 206 | + */ |
|
| 207 | + public static function proteger_balisesHtml(string $texte, string $source = '', ?array $html_tags = null, array $callbacks_function = [], array $callback_options = []): string { |
|
| 208 | + if ($texte === '') { |
|
| 209 | + return ''; |
|
| 210 | + } |
|
| 211 | + |
|
| 212 | + $html_tags = $html_tags ?: self::$listeBalisesAProteger; |
|
| 213 | + |
|
| 214 | + $tags_todo = $html_tags; |
|
| 215 | + while ( |
|
| 216 | + !empty($tags_todo) |
|
| 217 | + && ($tag = array_shift($tags_todo)) |
|
| 218 | + && str_contains($texte, '<') |
|
| 219 | + ) { |
|
| 220 | + $htmlTagCollecteur = new self($tag); |
|
| 221 | + $texte = $htmlTagCollecteur->echapper_enHtmlBase64($texte, $source, $callbacks_function[$tag] ?? null, $callback_options); |
|
| 222 | + } |
|
| 223 | + |
|
| 224 | + return $texte; |
|
| 225 | + } |
|
| 226 | 226 | } |
@@ -51,10 +51,10 @@ discard block |
||
| 51 | 51 | } |
| 52 | 52 | |
| 53 | 53 | $upperTag = strtoupper($this->tag); |
| 54 | - $hasUpperCaseTags = ($upperTag !== $this->tag && (str_contains($texte, '<' . $upperTag) || str_contains($texte, '</' . $upperTag))); |
|
| 54 | + $hasUpperCaseTags = ($upperTag !== $this->tag && (str_contains($texte, '<'.$upperTag) || str_contains($texte, '</'.$upperTag))); |
|
| 55 | 55 | |
| 56 | 56 | // collecter les balises ouvrantes |
| 57 | - $opening = static::collecteur($texte, '', $hasUpperCaseTags ? '<' : '<' . $this->tag, $this->preg_openingtag, empty($options['detecter_presence']) ? 0 : 1); |
|
| 57 | + $opening = static::collecteur($texte, '', $hasUpperCaseTags ? '<' : '<'.$this->tag, $this->preg_openingtag, empty($options['detecter_presence']) ? 0 : 1); |
|
| 58 | 58 | if (!$opening) { |
| 59 | 59 | return []; |
| 60 | 60 | } |
@@ -65,7 +65,7 @@ discard block |
||
| 65 | 65 | } |
| 66 | 66 | |
| 67 | 67 | // collecter les balises fermantes |
| 68 | - $closing = static::collecteur($texte, '', $hasUpperCaseTags ? '</' : '</' . $this->tag, $this->preg_closingtag); |
|
| 68 | + $closing = static::collecteur($texte, '', $hasUpperCaseTags ? '</' : '</'.$this->tag, $this->preg_closingtag); |
|
| 69 | 69 | |
| 70 | 70 | $profondeur = ($options['profondeur'] ?? 1); |
| 71 | 71 | $tags = []; |
@@ -183,12 +183,12 @@ discard block |
||
| 183 | 183 | // et on aura pas non plus de innerHtml si pas de preg_closingtag |
| 184 | 184 | if ($this->preg_closingtag) { |
| 185 | 185 | $tag = $this->tag; |
| 186 | - $legacy_callback = function ($c, $options) use ($tag, $callback_function) { |
|
| 186 | + $legacy_callback = function($c, $options) use ($tag, $callback_function) { |
|
| 187 | 187 | // legacy : renseigner les infos correspondantes aux matchs de l'ancienne regexp |
| 188 | 188 | $regs = [ |
| 189 | 189 | 0 => $c['raw'], |
| 190 | 190 | 1 => $tag, |
| 191 | - 2 => $c['match'][1] . $c['match'][2], |
|
| 191 | + 2 => $c['match'][1].$c['match'][2], |
|
| 192 | 192 | 3 => $c['innerHtml'], |
| 193 | 193 | 'tag' => $this->tag, |
| 194 | 194 | ] + $c; |
@@ -79,8 +79,7 @@ discard block |
||
| 79 | 79 | $tag['innerHtml'] = ''; |
| 80 | 80 | $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -2)); |
| 81 | 81 | $tags[] = $tag; |
| 82 | - } |
|
| 83 | - else { |
|
| 82 | + } else { |
|
| 84 | 83 | // enlever les closing qui sont avant le premier opening, car ils n'ont pas de sens |
| 85 | 84 | while ( |
| 86 | 85 | !empty($closing) |
@@ -99,8 +98,7 @@ discard block |
||
| 99 | 98 | array_shift($opening); |
| 100 | 99 | $next_opening = reset($opening); |
| 101 | 100 | } |
| 102 | - } |
|
| 103 | - else { |
|
| 101 | + } else { |
|
| 104 | 102 | while ($next_opening && $next_closing && $next_opening['pos'] < $next_closing['pos']) { |
| 105 | 103 | while ($next_opening && $next_opening['pos'] < $next_closing['pos']) { |
| 106 | 104 | // si pas self closing, il faut un closing de plus |
@@ -126,8 +124,7 @@ discard block |
||
| 126 | 124 | $tag['innerHtml'] = ''; |
| 127 | 125 | $tag['attributs'] = trim(substr($tag['opening'], strlen($this->tag) + 1, -1)); |
| 128 | 126 | $tags[] = $tag; |
| 129 | - } |
|
| 130 | - else { |
|
| 127 | + } else { |
|
| 131 | 128 | $tag = $first_opening; |
| 132 | 129 | $next_closing = array_shift($closing); |
| 133 | 130 | $innerHtml = substr($texte, $tag['pos'] + $tag['length'], $next_closing['pos'] - $tag['pos'] - $tag['length']); |
@@ -12,60 +12,60 @@ |
||
| 12 | 12 | */ |
| 13 | 13 | class Factory |
| 14 | 14 | { |
| 15 | - public static function create($iterateur, $command, $info = null) { |
|
| 16 | - $iter = null; |
|
| 17 | - // cas des SI {si expression} analises tres tot |
|
| 18 | - // pour eviter le chargement de tout iterateur |
|
| 19 | - if (isset($command['si'])) { |
|
| 20 | - foreach ($command['si'] as $si) { |
|
| 21 | - if (!$si) { |
|
| 22 | - // $command pour boucle SQL peut generer des erreurs de compilation |
|
| 23 | - // s'il est transmis alors qu'on est dans un iterateur vide |
|
| 24 | - return new Decorator(new EmptyIterator(), [], $info); |
|
| 25 | - } |
|
| 26 | - } |
|
| 27 | - } |
|
| 15 | + public static function create($iterateur, $command, $info = null) { |
|
| 16 | + $iter = null; |
|
| 17 | + // cas des SI {si expression} analises tres tot |
|
| 18 | + // pour eviter le chargement de tout iterateur |
|
| 19 | + if (isset($command['si'])) { |
|
| 20 | + foreach ($command['si'] as $si) { |
|
| 21 | + if (!$si) { |
|
| 22 | + // $command pour boucle SQL peut generer des erreurs de compilation |
|
| 23 | + // s'il est transmis alors qu'on est dans un iterateur vide |
|
| 24 | + return new Decorator(new EmptyIterator(), [], $info); |
|
| 25 | + } |
|
| 26 | + } |
|
| 27 | + } |
|
| 28 | 28 | |
| 29 | - // chercher un iterateur PHP existant (par exemple dans SPL) |
|
| 30 | - // (il faudrait passer l'argument ->sql_serveur |
|
| 31 | - // pour etre certain qu'on est sur un "php:") |
|
| 32 | - if (class_exists($iterateur)) { |
|
| 33 | - $a = $command['args'] ?? []; |
|
| 29 | + // chercher un iterateur PHP existant (par exemple dans SPL) |
|
| 30 | + // (il faudrait passer l'argument ->sql_serveur |
|
| 31 | + // pour etre certain qu'on est sur un "php:") |
|
| 32 | + if (class_exists($iterateur)) { |
|
| 33 | + $a = $command['args'] ?? []; |
|
| 34 | 34 | |
| 35 | - // permettre de passer un Iterateur directement {args #ITERATEUR} : |
|
| 36 | - // si on recoit deja un iterateur en argument, on l'utilise |
|
| 37 | - if ((is_countable($a) ? count($a) : 0) == 1 && is_object($a[0]) && is_subclass_of($a[0], \Iterator::class)) { |
|
| 38 | - $iter = $a[0]; |
|
| 39 | - } else { |
|
| 40 | - // sinon, on cree un iterateur du type donne |
|
| 41 | - // arguments de creation de l'iterateur... |
|
| 42 | - try { |
|
| 43 | - $iter = new $iterateur(...$a); |
|
| 44 | - } catch (Exception $e) { |
|
| 45 | - spip_log("Erreur de chargement de l'iterateur {$iterateur}"); |
|
| 46 | - spip_log($e->getMessage()); |
|
| 47 | - $iter = new EmptyIterator(); |
|
| 48 | - } |
|
| 49 | - } |
|
| 50 | - } else { |
|
| 51 | - // chercher la classe d'iterateur Iterateur/XXX |
|
| 52 | - // definie dans le fichier src/Compilateur/Iterateur/xxx.php |
|
| 53 | - // FIXME: déclarer quelque part les iterateurs supplémentaires |
|
| 54 | - $class = __NAMESPACE__ . '\\' . ucfirst(strtolower((string) $iterateur)); |
|
| 55 | - if (!class_exists($class)) { |
|
| 56 | - // historique |
|
| 57 | - // Chercher IterateurXXX |
|
| 58 | - include_spip('iterateur/' . strtolower($iterateur)); |
|
| 59 | - $class = 'Iterateur' . $iterateur; |
|
| 60 | - if (!class_exists($class)) { |
|
| 61 | - exit("Iterateur {$iterateur} non trouvé"); |
|
| 62 | - // si l'iterateur n'existe pas, on se rabat sur le generique |
|
| 63 | - // $iter = new EmptyIterator(); |
|
| 64 | - } |
|
| 65 | - } |
|
| 66 | - $iter = new $class($command, $info); |
|
| 67 | - } |
|
| 35 | + // permettre de passer un Iterateur directement {args #ITERATEUR} : |
|
| 36 | + // si on recoit deja un iterateur en argument, on l'utilise |
|
| 37 | + if ((is_countable($a) ? count($a) : 0) == 1 && is_object($a[0]) && is_subclass_of($a[0], \Iterator::class)) { |
|
| 38 | + $iter = $a[0]; |
|
| 39 | + } else { |
|
| 40 | + // sinon, on cree un iterateur du type donne |
|
| 41 | + // arguments de creation de l'iterateur... |
|
| 42 | + try { |
|
| 43 | + $iter = new $iterateur(...$a); |
|
| 44 | + } catch (Exception $e) { |
|
| 45 | + spip_log("Erreur de chargement de l'iterateur {$iterateur}"); |
|
| 46 | + spip_log($e->getMessage()); |
|
| 47 | + $iter = new EmptyIterator(); |
|
| 48 | + } |
|
| 49 | + } |
|
| 50 | + } else { |
|
| 51 | + // chercher la classe d'iterateur Iterateur/XXX |
|
| 52 | + // definie dans le fichier src/Compilateur/Iterateur/xxx.php |
|
| 53 | + // FIXME: déclarer quelque part les iterateurs supplémentaires |
|
| 54 | + $class = __NAMESPACE__ . '\\' . ucfirst(strtolower((string) $iterateur)); |
|
| 55 | + if (!class_exists($class)) { |
|
| 56 | + // historique |
|
| 57 | + // Chercher IterateurXXX |
|
| 58 | + include_spip('iterateur/' . strtolower($iterateur)); |
|
| 59 | + $class = 'Iterateur' . $iterateur; |
|
| 60 | + if (!class_exists($class)) { |
|
| 61 | + exit("Iterateur {$iterateur} non trouvé"); |
|
| 62 | + // si l'iterateur n'existe pas, on se rabat sur le generique |
|
| 63 | + // $iter = new EmptyIterator(); |
|
| 64 | + } |
|
| 65 | + } |
|
| 66 | + $iter = new $class($command, $info); |
|
| 67 | + } |
|
| 68 | 68 | |
| 69 | - return new Decorator($iter, $command, $info); |
|
| 70 | - } |
|
| 69 | + return new Decorator($iter, $command, $info); |
|
| 70 | + } |
|
| 71 | 71 | } |
@@ -51,12 +51,12 @@ |
||
| 51 | 51 | // chercher la classe d'iterateur Iterateur/XXX |
| 52 | 52 | // definie dans le fichier src/Compilateur/Iterateur/xxx.php |
| 53 | 53 | // FIXME: déclarer quelque part les iterateurs supplémentaires |
| 54 | - $class = __NAMESPACE__ . '\\' . ucfirst(strtolower((string) $iterateur)); |
|
| 54 | + $class = __NAMESPACE__.'\\'.ucfirst(strtolower((string) $iterateur)); |
|
| 55 | 55 | if (!class_exists($class)) { |
| 56 | 56 | // historique |
| 57 | 57 | // Chercher IterateurXXX |
| 58 | - include_spip('iterateur/' . strtolower($iterateur)); |
|
| 59 | - $class = 'Iterateur' . $iterateur; |
|
| 58 | + include_spip('iterateur/'.strtolower($iterateur)); |
|
| 59 | + $class = 'Iterateur'.$iterateur; |
|
| 60 | 60 | if (!class_exists($class)) { |
| 61 | 61 | exit("Iterateur {$iterateur} non trouvé"); |
| 62 | 62 | // si l'iterateur n'existe pas, on se rabat sur le generique |
@@ -11,187 +11,187 @@ |
||
| 11 | 11 | */ |
| 12 | 12 | class Sql extends AbstractIterateur implements Iterator |
| 13 | 13 | { |
| 14 | - /** |
|
| 15 | - * Ressource sql. |
|
| 16 | - * |
|
| 17 | - * @var bool|object |
|
| 18 | - */ |
|
| 19 | - protected $sqlresult = false; |
|
| 14 | + /** |
|
| 15 | + * Ressource sql. |
|
| 16 | + * |
|
| 17 | + * @var bool|object |
|
| 18 | + */ |
|
| 19 | + protected $sqlresult = false; |
|
| 20 | 20 | |
| 21 | - /** |
|
| 22 | - * row sql courante. |
|
| 23 | - * |
|
| 24 | - * @var null|array |
|
| 25 | - */ |
|
| 26 | - protected $row; |
|
| 21 | + /** |
|
| 22 | + * row sql courante. |
|
| 23 | + * |
|
| 24 | + * @var null|array |
|
| 25 | + */ |
|
| 26 | + protected $row; |
|
| 27 | 27 | |
| 28 | - protected bool $firstseek = false; |
|
| 28 | + protected bool $firstseek = false; |
|
| 29 | 29 | |
| 30 | - protected int $pos = -1; |
|
| 30 | + protected int $pos = -1; |
|
| 31 | 31 | |
| 32 | - /* |
|
| 32 | + /* |
|
| 33 | 33 | * array command: les commandes d'initialisation |
| 34 | 34 | * array info: les infos sur le squelette |
| 35 | 35 | */ |
| 36 | - public function __construct(array $command, array $info = []) { |
|
| 37 | - $this->type = 'SQL'; |
|
| 38 | - parent::__construct($command, $info); |
|
| 39 | - |
|
| 40 | - $this->select(); |
|
| 41 | - } |
|
| 42 | - |
|
| 43 | - /** |
|
| 44 | - * Rembobiner. |
|
| 45 | - * |
|
| 46 | - * @return bool |
|
| 47 | - */ |
|
| 48 | - public function rewind(): void { |
|
| 49 | - if ($this->pos > 0) { |
|
| 50 | - $this->seek(0); |
|
| 51 | - } |
|
| 52 | - } |
|
| 53 | - |
|
| 54 | - /** |
|
| 55 | - * Verifier l'etat de l'iterateur. |
|
| 56 | - */ |
|
| 57 | - public function valid(): bool { |
|
| 58 | - if ($this->err) { |
|
| 59 | - return false; |
|
| 60 | - } |
|
| 61 | - if (!$this->firstseek) { |
|
| 62 | - $this->next(); |
|
| 63 | - } |
|
| 64 | - |
|
| 65 | - return is_array($this->row); |
|
| 66 | - } |
|
| 67 | - |
|
| 68 | - /** |
|
| 69 | - * Valeurs sur la position courante. |
|
| 70 | - * |
|
| 71 | - * @return array |
|
| 72 | - */ |
|
| 73 | - public function current(): ?array { |
|
| 74 | - return $this->row; |
|
| 75 | - } |
|
| 76 | - |
|
| 77 | - public function key(): int { |
|
| 78 | - return $this->pos; |
|
| 79 | - } |
|
| 80 | - |
|
| 81 | - /** |
|
| 82 | - * Sauter a une position absolue. |
|
| 83 | - * |
|
| 84 | - * @param int $n |
|
| 85 | - * @param null|string $continue |
|
| 86 | - */ |
|
| 87 | - public function seek($n = 0, $continue = null): bool { |
|
| 88 | - if (!sql_seek($this->sqlresult, $n, $this->command['connect'], $continue)) { |
|
| 89 | - // SQLite ne sait pas seek(), il faut relancer la query |
|
| 90 | - // si la position courante est apres la position visee |
|
| 91 | - // il faut relancer la requete |
|
| 92 | - if ($this->pos > $n) { |
|
| 93 | - $this->free(); |
|
| 94 | - $this->select(); |
|
| 95 | - $this->valid(); |
|
| 96 | - } |
|
| 97 | - // et utiliser la methode par defaut pour se deplacer au bon endroit |
|
| 98 | - // (sera fait en cas d'echec de cette fonction) |
|
| 99 | - return false; |
|
| 100 | - } |
|
| 101 | - $this->row = sql_fetch($this->sqlresult, $this->command['connect']); |
|
| 102 | - $this->pos = min($n, $this->count()); |
|
| 103 | - |
|
| 104 | - return true; |
|
| 105 | - } |
|
| 106 | - |
|
| 107 | - /** |
|
| 108 | - * Avancer d'un cran. |
|
| 109 | - */ |
|
| 110 | - public function next(): void { |
|
| 111 | - $this->row = sql_fetch($this->sqlresult, $this->command['connect']); |
|
| 112 | - ++$this->pos; |
|
| 113 | - $this->firstseek = true; |
|
| 114 | - } |
|
| 115 | - |
|
| 116 | - /** |
|
| 117 | - * Avancer et retourner les donnees pour le nouvel element. |
|
| 118 | - * |
|
| 119 | - * @return null|array|bool |
|
| 120 | - */ |
|
| 121 | - public function fetch() { |
|
| 122 | - if ($this->valid()) { |
|
| 123 | - $r = $this->current(); |
|
| 124 | - $this->next(); |
|
| 125 | - } else { |
|
| 126 | - $r = false; |
|
| 127 | - } |
|
| 128 | - |
|
| 129 | - return $r; |
|
| 130 | - } |
|
| 131 | - |
|
| 132 | - /** |
|
| 133 | - * liberer les ressources. |
|
| 134 | - * |
|
| 135 | - * @return bool |
|
| 136 | - */ |
|
| 137 | - public function free() { |
|
| 138 | - if (!$this->sqlresult) { |
|
| 139 | - return true; |
|
| 140 | - } |
|
| 141 | - $a = sql_free($this->sqlresult, $this->command['connect']); |
|
| 142 | - $this->sqlresult = null; |
|
| 143 | - |
|
| 144 | - return $a; |
|
| 145 | - } |
|
| 146 | - |
|
| 147 | - /** |
|
| 148 | - * Compter le nombre de resultats. |
|
| 149 | - */ |
|
| 150 | - public function count(): int { |
|
| 151 | - if (is_null($this->total)) { |
|
| 152 | - if (!$this->sqlresult) { |
|
| 153 | - $this->total = 0; |
|
| 154 | - } else { |
|
| 155 | - // cas count(*) |
|
| 156 | - if (in_array('count(*)', $this->command['select'])) { |
|
| 157 | - $this->valid(); |
|
| 158 | - $s = $this->current(); |
|
| 159 | - $this->total = (int) $s['count(*)']; |
|
| 160 | - } else { |
|
| 161 | - $this->total = (int) sql_count($this->sqlresult, $this->command['connect']); |
|
| 162 | - } |
|
| 163 | - } |
|
| 164 | - } |
|
| 165 | - |
|
| 166 | - return $this->total; |
|
| 167 | - } |
|
| 168 | - |
|
| 169 | - /** |
|
| 170 | - * selectionner les donnees, ie faire la requete SQL. |
|
| 171 | - */ |
|
| 172 | - protected function select() { |
|
| 173 | - $this->row = null; |
|
| 174 | - $v = &$this->command; |
|
| 175 | - $this->sqlresult = calculer_select( |
|
| 176 | - $v['select'], |
|
| 177 | - $v['from'], |
|
| 178 | - $v['type'], |
|
| 179 | - $v['where'], |
|
| 180 | - $v['join'], |
|
| 181 | - $v['groupby'], |
|
| 182 | - $v['orderby'], |
|
| 183 | - $v['limit'], |
|
| 184 | - $v['having'], |
|
| 185 | - $v['table'], |
|
| 186 | - $v['id'], |
|
| 187 | - $v['connect'], |
|
| 188 | - $this->info |
|
| 189 | - ); |
|
| 190 | - $this->err = !$this->sqlresult; |
|
| 191 | - $this->firstseek = false; |
|
| 192 | - $this->pos = -1; |
|
| 193 | - |
|
| 194 | - // pas d'init a priori, le calcul ne sera fait qu'en cas de besoin (provoque une double requete souvent inutile en sqlite) |
|
| 195 | - //$this->total = $this->count(); |
|
| 196 | - } |
|
| 36 | + public function __construct(array $command, array $info = []) { |
|
| 37 | + $this->type = 'SQL'; |
|
| 38 | + parent::__construct($command, $info); |
|
| 39 | + |
|
| 40 | + $this->select(); |
|
| 41 | + } |
|
| 42 | + |
|
| 43 | + /** |
|
| 44 | + * Rembobiner. |
|
| 45 | + * |
|
| 46 | + * @return bool |
|
| 47 | + */ |
|
| 48 | + public function rewind(): void { |
|
| 49 | + if ($this->pos > 0) { |
|
| 50 | + $this->seek(0); |
|
| 51 | + } |
|
| 52 | + } |
|
| 53 | + |
|
| 54 | + /** |
|
| 55 | + * Verifier l'etat de l'iterateur. |
|
| 56 | + */ |
|
| 57 | + public function valid(): bool { |
|
| 58 | + if ($this->err) { |
|
| 59 | + return false; |
|
| 60 | + } |
|
| 61 | + if (!$this->firstseek) { |
|
| 62 | + $this->next(); |
|
| 63 | + } |
|
| 64 | + |
|
| 65 | + return is_array($this->row); |
|
| 66 | + } |
|
| 67 | + |
|
| 68 | + /** |
|
| 69 | + * Valeurs sur la position courante. |
|
| 70 | + * |
|
| 71 | + * @return array |
|
| 72 | + */ |
|
| 73 | + public function current(): ?array { |
|
| 74 | + return $this->row; |
|
| 75 | + } |
|
| 76 | + |
|
| 77 | + public function key(): int { |
|
| 78 | + return $this->pos; |
|
| 79 | + } |
|
| 80 | + |
|
| 81 | + /** |
|
| 82 | + * Sauter a une position absolue. |
|
| 83 | + * |
|
| 84 | + * @param int $n |
|
| 85 | + * @param null|string $continue |
|
| 86 | + */ |
|
| 87 | + public function seek($n = 0, $continue = null): bool { |
|
| 88 | + if (!sql_seek($this->sqlresult, $n, $this->command['connect'], $continue)) { |
|
| 89 | + // SQLite ne sait pas seek(), il faut relancer la query |
|
| 90 | + // si la position courante est apres la position visee |
|
| 91 | + // il faut relancer la requete |
|
| 92 | + if ($this->pos > $n) { |
|
| 93 | + $this->free(); |
|
| 94 | + $this->select(); |
|
| 95 | + $this->valid(); |
|
| 96 | + } |
|
| 97 | + // et utiliser la methode par defaut pour se deplacer au bon endroit |
|
| 98 | + // (sera fait en cas d'echec de cette fonction) |
|
| 99 | + return false; |
|
| 100 | + } |
|
| 101 | + $this->row = sql_fetch($this->sqlresult, $this->command['connect']); |
|
| 102 | + $this->pos = min($n, $this->count()); |
|
| 103 | + |
|
| 104 | + return true; |
|
| 105 | + } |
|
| 106 | + |
|
| 107 | + /** |
|
| 108 | + * Avancer d'un cran. |
|
| 109 | + */ |
|
| 110 | + public function next(): void { |
|
| 111 | + $this->row = sql_fetch($this->sqlresult, $this->command['connect']); |
|
| 112 | + ++$this->pos; |
|
| 113 | + $this->firstseek = true; |
|
| 114 | + } |
|
| 115 | + |
|
| 116 | + /** |
|
| 117 | + * Avancer et retourner les donnees pour le nouvel element. |
|
| 118 | + * |
|
| 119 | + * @return null|array|bool |
|
| 120 | + */ |
|
| 121 | + public function fetch() { |
|
| 122 | + if ($this->valid()) { |
|
| 123 | + $r = $this->current(); |
|
| 124 | + $this->next(); |
|
| 125 | + } else { |
|
| 126 | + $r = false; |
|
| 127 | + } |
|
| 128 | + |
|
| 129 | + return $r; |
|
| 130 | + } |
|
| 131 | + |
|
| 132 | + /** |
|
| 133 | + * liberer les ressources. |
|
| 134 | + * |
|
| 135 | + * @return bool |
|
| 136 | + */ |
|
| 137 | + public function free() { |
|
| 138 | + if (!$this->sqlresult) { |
|
| 139 | + return true; |
|
| 140 | + } |
|
| 141 | + $a = sql_free($this->sqlresult, $this->command['connect']); |
|
| 142 | + $this->sqlresult = null; |
|
| 143 | + |
|
| 144 | + return $a; |
|
| 145 | + } |
|
| 146 | + |
|
| 147 | + /** |
|
| 148 | + * Compter le nombre de resultats. |
|
| 149 | + */ |
|
| 150 | + public function count(): int { |
|
| 151 | + if (is_null($this->total)) { |
|
| 152 | + if (!$this->sqlresult) { |
|
| 153 | + $this->total = 0; |
|
| 154 | + } else { |
|
| 155 | + // cas count(*) |
|
| 156 | + if (in_array('count(*)', $this->command['select'])) { |
|
| 157 | + $this->valid(); |
|
| 158 | + $s = $this->current(); |
|
| 159 | + $this->total = (int) $s['count(*)']; |
|
| 160 | + } else { |
|
| 161 | + $this->total = (int) sql_count($this->sqlresult, $this->command['connect']); |
|
| 162 | + } |
|
| 163 | + } |
|
| 164 | + } |
|
| 165 | + |
|
| 166 | + return $this->total; |
|
| 167 | + } |
|
| 168 | + |
|
| 169 | + /** |
|
| 170 | + * selectionner les donnees, ie faire la requete SQL. |
|
| 171 | + */ |
|
| 172 | + protected function select() { |
|
| 173 | + $this->row = null; |
|
| 174 | + $v = &$this->command; |
|
| 175 | + $this->sqlresult = calculer_select( |
|
| 176 | + $v['select'], |
|
| 177 | + $v['from'], |
|
| 178 | + $v['type'], |
|
| 179 | + $v['where'], |
|
| 180 | + $v['join'], |
|
| 181 | + $v['groupby'], |
|
| 182 | + $v['orderby'], |
|
| 183 | + $v['limit'], |
|
| 184 | + $v['having'], |
|
| 185 | + $v['table'], |
|
| 186 | + $v['id'], |
|
| 187 | + $v['connect'], |
|
| 188 | + $this->info |
|
| 189 | + ); |
|
| 190 | + $this->err = !$this->sqlresult; |
|
| 191 | + $this->firstseek = false; |
|
| 192 | + $this->pos = -1; |
|
| 193 | + |
|
| 194 | + // pas d'init a priori, le calcul ne sera fait qu'en cas de besoin (provoque une double requete souvent inutile en sqlite) |
|
| 195 | + //$this->total = $this->count(); |
|
| 196 | + } |
|
| 197 | 197 | } |
@@ -7,368 +7,368 @@ |
||
| 7 | 7 | */ |
| 8 | 8 | class Boucle |
| 9 | 9 | { |
| 10 | - /** Type de noeud */ |
|
| 11 | - public string $type = 'boucle'; |
|
| 12 | - |
|
| 13 | - /** Identifiant de la boucle */ |
|
| 14 | - public string $id_boucle; |
|
| 15 | - |
|
| 16 | - /** Identifiant de la boucle parente */ |
|
| 17 | - public string $id_parent = ''; |
|
| 18 | - |
|
| 19 | - /** Un nom explicite qui peut être affecté manuellement à certaines boucles générées */ |
|
| 20 | - public string $nom = ''; |
|
| 21 | - |
|
| 22 | - /** |
|
| 23 | - * Partie avant toujours affichee |
|
| 24 | - * |
|
| 25 | - * @var string|array |
|
| 26 | - */ |
|
| 27 | - public $preaff = ''; |
|
| 28 | - |
|
| 29 | - /** |
|
| 30 | - * Partie optionnelle avant |
|
| 31 | - * |
|
| 32 | - * @var string|array |
|
| 33 | - */ |
|
| 34 | - public $avant = ''; |
|
| 35 | - |
|
| 36 | - /** |
|
| 37 | - * Pour chaque élément |
|
| 38 | - * |
|
| 39 | - * @var string|array |
|
| 40 | - */ |
|
| 41 | - public $milieu = ''; |
|
| 42 | - |
|
| 43 | - /** |
|
| 44 | - * Partie optionnelle après |
|
| 45 | - * |
|
| 46 | - * @var string|array |
|
| 47 | - */ |
|
| 48 | - public $apres = ''; |
|
| 49 | - |
|
| 50 | - /** |
|
| 51 | - * Partie alternative, si pas de résultat dans la boucle |
|
| 52 | - * |
|
| 53 | - * @var string|array |
|
| 54 | - */ |
|
| 55 | - public $altern = ''; |
|
| 56 | - |
|
| 57 | - /** |
|
| 58 | - * Partie apres toujours affichee |
|
| 59 | - * |
|
| 60 | - * @var string|array |
|
| 61 | - */ |
|
| 62 | - public $postaff = ''; |
|
| 63 | - |
|
| 64 | - |
|
| 65 | - /** |
|
| 66 | - * La boucle doit-elle sélectionner la langue ? |
|
| 67 | - * |
|
| 68 | - * Valeurs : '', 'oui', 'non' |
|
| 69 | - */ |
|
| 70 | - public string $lang_select = ''; |
|
| 71 | - |
|
| 72 | - /** |
|
| 73 | - * Alias de table d'application de la requête ou nom complet de la table SQL |
|
| 74 | - * |
|
| 75 | - * FIXME: un seul typage (string ?) |
|
| 76 | - * |
|
| 77 | - * @var string|false|null |
|
| 78 | - */ |
|
| 79 | - public $type_requete = null; |
|
| 80 | - |
|
| 81 | - /** |
|
| 82 | - * La table est elle optionnelle ? |
|
| 83 | - * |
|
| 84 | - * Si oui, aucune erreur ne sera générée si la table demandée n'est pas présente |
|
| 85 | - */ |
|
| 86 | - public bool $table_optionnelle = false; |
|
| 87 | - public string $type_table_optionnelle = ''; |
|
| 88 | - |
|
| 89 | - /** |
|
| 90 | - * Nom du fichier de connexion |
|
| 91 | - */ |
|
| 92 | - public string $sql_serveur = ''; |
|
| 93 | - |
|
| 94 | - /** |
|
| 95 | - * Paramètres de la boucle |
|
| 96 | - * |
|
| 97 | - * Description des paramètres passés à la boucle, qui servent ensuite |
|
| 98 | - * au calcul des critères |
|
| 99 | - * |
|
| 100 | - * FIXME: type unique. |
|
| 101 | - * @var false|array |
|
| 102 | - * - false: erreur de syntaxe |
|
| 103 | - */ |
|
| 104 | - public $param = []; |
|
| 105 | - |
|
| 106 | - /** |
|
| 107 | - * Critères de la boucle |
|
| 108 | - * |
|
| 109 | - * FIXME: type array unique. |
|
| 110 | - * |
|
| 111 | - * @var string|Critere[] |
|
| 112 | - * - string: phrasage (code brut). Il reste si erreur de critère |
|
| 113 | - * - array: analyse correcte des critères... |
|
| 114 | - */ |
|
| 115 | - public $criteres = []; |
|
| 116 | - |
|
| 117 | - /** |
|
| 118 | - * Textes insérés entre 2 éléments de boucle (critère inter) |
|
| 119 | - * |
|
| 120 | - * @var string[] |
|
| 121 | - */ |
|
| 122 | - public array $separateur = []; |
|
| 123 | - |
|
| 124 | - /** |
|
| 125 | - * Liste des jointures possibles avec cette table |
|
| 126 | - * |
|
| 127 | - * Les jointures par défaut de la table sont complétées en priorité |
|
| 128 | - * des jointures déclarées explicitement sur la boucle |
|
| 129 | - * |
|
| 130 | - * @see base_trouver_table_dist() |
|
| 131 | - */ |
|
| 132 | - public array $jointures = []; |
|
| 133 | - |
|
| 134 | - /** |
|
| 135 | - * Jointures explicites avec cette table |
|
| 136 | - * |
|
| 137 | - * Ces jointures sont utilisées en priorité par rapport aux jointures |
|
| 138 | - * normales possibles pour retrouver les colonnes demandées extérieures |
|
| 139 | - * à la boucle. |
|
| 140 | - * |
|
| 141 | - * @var string|bool |
|
| 142 | - */ |
|
| 143 | - public $jointures_explicites = false; |
|
| 144 | - |
|
| 145 | - /** |
|
| 146 | - * Nom de la variable PHP stockant le noms de doublons utilisés "$doublons_index" |
|
| 147 | - */ |
|
| 148 | - public string $doublons = ''; |
|
| 149 | - |
|
| 150 | - /** |
|
| 151 | - * Code PHP ajouté au début de chaque itération de boucle. |
|
| 152 | - * |
|
| 153 | - * Utilisé entre autre par les critères {pagination}, {n-a,b}, {a/b}... |
|
| 154 | - */ |
|
| 155 | - public string $partie = ''; |
|
| 156 | - |
|
| 157 | - /** |
|
| 158 | - * Nombre de divisions de la boucle, d'éléments à afficher, |
|
| 159 | - * ou de soustractions d'éléments à faire |
|
| 160 | - * |
|
| 161 | - * Dans les critères limitant le nombre d'éléments affichés |
|
| 162 | - * {a,b}, {a,n-b}, {a/b}, {pagination b}, b est affecté à total_parties. |
|
| 163 | - */ |
|
| 164 | - public string $total_parties = ''; |
|
| 165 | - |
|
| 166 | - /** |
|
| 167 | - * Code PHP ajouté avant l'itération de boucle. |
|
| 168 | - * |
|
| 169 | - * Utilisé entre autre par les critères {pagination}, {a,b}, {a/b} |
|
| 170 | - * pour initialiser les variables de début et de fin d'itération. |
|
| 171 | - */ |
|
| 172 | - public string $mode_partie = ''; |
|
| 173 | - |
|
| 174 | - /** |
|
| 175 | - * Identifiant d'une boucle qui appelle celle-ci de manière récursive |
|
| 176 | - * |
|
| 177 | - * Si une boucle est appelée de manière récursive quelque part par |
|
| 178 | - * une autre boucle comme <BOUCLE_rec(boucle_identifiant) />, cette |
|
| 179 | - * boucle (identifiant) reçoit dans cette propriété l'identifiant |
|
| 180 | - * de l'appelant (rec) |
|
| 181 | - */ |
|
| 182 | - public string $externe = ''; |
|
| 183 | - |
|
| 184 | - // champs pour la construction de la requete SQL |
|
| 185 | - |
|
| 186 | - /** |
|
| 187 | - * Liste des champs à récupérer par la boucle |
|
| 188 | - * |
|
| 189 | - * Expression 'table.nom_champ' ou calculée 'nom_champ AS x' |
|
| 190 | - * |
|
| 191 | - * @var string[] |
|
| 192 | - */ |
|
| 193 | - public array $select = []; |
|
| 194 | - |
|
| 195 | - /** |
|
| 196 | - * Liste des alias / tables SQL utilisées dans la boucle |
|
| 197 | - * |
|
| 198 | - * L'index est un identifiant (xx dans spip_xx assez souvent) qui servira |
|
| 199 | - * d'alias au nom de la table ; la valeur est le nom de la table SQL désirée. |
|
| 200 | - * |
|
| 201 | - * L'index 0 peut définir le type de sources de données de l'itérateur DATA |
|
| 202 | - * |
|
| 203 | - * @var string[] |
|
| 204 | - */ |
|
| 205 | - public array $from = []; |
|
| 206 | - |
|
| 207 | - /** |
|
| 208 | - * Liste des alias / type de jointures utilisées dans la boucle |
|
| 209 | - * |
|
| 210 | - * L'index est le nom d'alias (comme pour la propriété $from), et la valeur |
|
| 211 | - * un type de jointure parmi 'INNER', 'LEFT', 'RIGHT', 'OUTER'. |
|
| 212 | - * |
|
| 213 | - * Lorsque le type n'est pas déclaré pour un alias, c'est 'INNER' |
|
| 214 | - * qui sera utilisé par défaut (créant donc un INNER JOIN). |
|
| 215 | - * |
|
| 216 | - * @var string[] |
|
| 217 | - */ |
|
| 218 | - public array $from_type = []; |
|
| 219 | - |
|
| 220 | - /** |
|
| 221 | - * Liste des conditions WHERE de la boucle |
|
| 222 | - * |
|
| 223 | - * Permet de restreindre les éléments retournés par une boucle |
|
| 224 | - * en fonctions des conditions transmises dans ce tableau. |
|
| 225 | - * |
|
| 226 | - * Ce tableau peut avoir plusieurs niveaux de profondeur. |
|
| 227 | - * |
|
| 228 | - * Les éléments du premier niveau sont reliés par des AND, donc |
|
| 229 | - * chaque élément ajouté directement au where par |
|
| 230 | - * $boucle->where[] = array(...) ou $boucle->where[] = "'expression'" |
|
| 231 | - * est une condition AND en plus. |
|
| 232 | - * |
|
| 233 | - * Par contre, lorsqu'on indique un tableau, il peut décrire des relations |
|
| 234 | - * internes différentes. Soit $expr un tableau d'expressions quelconques de 3 valeurs : |
|
| 235 | - * $expr = array(operateur, val1, val2) |
|
| 236 | - * |
|
| 237 | - * Ces 3 valeurs sont des expressions PHP. L'index 0 désigne l'opérateur |
|
| 238 | - * à réaliser tel que : |
|
| 239 | - * |
|
| 240 | - * - "'='" , "'>='", "'<'", "'IN'", "'REGEXP'", "'LIKE'", ... : |
|
| 241 | - * val1 et val2 sont des champs et valeurs à utiliser dans la comparaison |
|
| 242 | - * suivant cet ordre : "val1 operateur val2". |
|
| 243 | - * Exemple : $boucle->where[] = array("'='", "'articles.statut'", "'\"publie\"'"); |
|
| 244 | - * - "'AND'", "'OR'", "'NOT'" : |
|
| 245 | - * dans ce cas val1 et val2 sont également des expressions |
|
| 246 | - * de comparaison complètes, et peuvent être eux-même des tableaux comme $expr |
|
| 247 | - * Exemples : |
|
| 248 | - * $boucle->where[] = array("'OR'", $expr1, $expr2); |
|
| 249 | - * $boucle->where[] = array("'NOT'", $expr); // val2 n'existe pas avec NOT |
|
| 250 | - * |
|
| 251 | - * D'autres noms sont possibles pour l'opérateur (le nombre de valeurs diffère) : |
|
| 252 | - * - "'SELF'", "'SUBSELECT'" : indiquent des sous requêtes |
|
| 253 | - * - "'?'" : indique une condition à faire évaluer (val1 ? val2 : val3) |
|
| 254 | - */ |
|
| 255 | - public array $where = []; |
|
| 256 | - |
|
| 257 | - public array $join = []; |
|
| 258 | - public array $having = []; |
|
| 259 | - public $limit = ''; |
|
| 260 | - public array $group = []; |
|
| 261 | - public array $order = []; |
|
| 262 | - public array $default_order = []; |
|
| 263 | - public string $date = 'date'; |
|
| 264 | - public string $hash = ''; |
|
| 265 | - public $in = ''; |
|
| 266 | - public bool $sous_requete = false; |
|
| 267 | - |
|
| 268 | - /** |
|
| 269 | - * Code PHP qui sera ajouté en tout début de la fonction de boucle |
|
| 270 | - * |
|
| 271 | - * Il sert à insérer le code calculant une hierarchie |
|
| 272 | - */ |
|
| 273 | - public string $hierarchie = ''; |
|
| 274 | - |
|
| 275 | - // champs pour la construction du corps PHP |
|
| 276 | - |
|
| 277 | - /** |
|
| 278 | - * Description des sources de données de la boucle |
|
| 279 | - * |
|
| 280 | - * Description des données de la boucle issu de trouver_table |
|
| 281 | - * dans le cadre de l'itérateur SQL et contenant au moins l'index 'field'. |
|
| 282 | - * |
|
| 283 | - * @see base_trouver_table_dist() |
|
| 284 | - */ |
|
| 285 | - public array $show = []; |
|
| 286 | - |
|
| 287 | - /** |
|
| 288 | - * Nom de la table SQL principale de la boucle, sans son préfixe |
|
| 289 | - */ |
|
| 290 | - public string $id_table = ''; |
|
| 291 | - |
|
| 292 | - /** |
|
| 293 | - * Nom de la clé primaire de la table SQL principale de la boucle |
|
| 294 | - */ |
|
| 295 | - public string $primary = ''; |
|
| 296 | - |
|
| 297 | - /** |
|
| 298 | - * Code PHP compilé de la boucle |
|
| 299 | - * |
|
| 300 | - * FIXME: un seul type (string ?) |
|
| 301 | - * |
|
| 302 | - * - false: boucle fautive ? |
|
| 303 | - * |
|
| 304 | - * @var string|false |
|
| 305 | - */ |
|
| 306 | - public $return = ''; |
|
| 307 | - |
|
| 308 | - public $numrows = false; |
|
| 309 | - public $cptrows = false; |
|
| 310 | - |
|
| 311 | - /** |
|
| 312 | - * Description du squelette |
|
| 313 | - * |
|
| 314 | - * Sert pour la gestion d'erreur et la production de code dependant du contexte |
|
| 315 | - * |
|
| 316 | - * Peut contenir les index : |
|
| 317 | - * |
|
| 318 | - * - nom : Nom du fichier de cache |
|
| 319 | - * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser) |
|
| 320 | - * - sourcefile : Chemin du squelette |
|
| 321 | - * - squelette : Code du squelette |
|
| 322 | - * - id_mere : Identifiant de la boucle parente |
|
| 323 | - * - documents : Pour embed et img dans les textes |
|
| 324 | - * - session : Pour un cache sessionné par auteur |
|
| 325 | - * - niv : Niveau de tabulation |
|
| 326 | - */ |
|
| 327 | - public array $descr = []; |
|
| 328 | - |
|
| 329 | - /** Numéro de ligne dans le code source du squelette */ |
|
| 330 | - public int $ligne = 0; |
|
| 331 | - |
|
| 332 | - |
|
| 333 | - /** |
|
| 334 | - * table pour stocker les modificateurs de boucle tels que tout, plat ..., |
|
| 335 | - * utilisable par les plugins egalement |
|
| 336 | - * |
|
| 337 | - * @var array<string, mixed> |
|
| 338 | - */ |
|
| 339 | - public array $modificateur = []; |
|
| 340 | - |
|
| 341 | - /** |
|
| 342 | - * Type d'itérateur utilisé pour cette boucle |
|
| 343 | - * |
|
| 344 | - * - 'SQL' dans le cadre d'une boucle sur une table SQL |
|
| 345 | - * - 'DATA' pour l'itérateur DATA, ... |
|
| 346 | - * |
|
| 347 | - * @var string |
|
| 348 | - */ |
|
| 349 | - public string $iterateur = ''; // type d'iterateur |
|
| 350 | - |
|
| 351 | - /** |
|
| 352 | - * @var array $debug Textes qui seront insérés dans l’entête de boucle du mode debug |
|
| 353 | - */ |
|
| 354 | - public array $debug = []; |
|
| 355 | - |
|
| 356 | - /** |
|
| 357 | - * Index de la boucle dont le champ présent dans cette boucle est originaire, |
|
| 358 | - * notamment si le champ a été trouve dans une boucle parente |
|
| 359 | - * |
|
| 360 | - * Tableau nom du champ => index de boucle |
|
| 361 | - */ |
|
| 362 | - public array $index_champ = []; |
|
| 363 | - |
|
| 364 | - /** Résultat de la compilation (?) (sert au débusqueur) */ |
|
| 365 | - public string $code = ''; |
|
| 366 | - |
|
| 367 | - /** Source des filtres (compatibilité) (?) */ |
|
| 368 | - public array $fonctions = []; |
|
| 369 | - |
|
| 370 | - // obsoletes, conserves provisoirement pour compatibilite |
|
| 371 | - public $tout = false; |
|
| 372 | - public $plat = false; |
|
| 373 | - public $lien = false; |
|
| 10 | + /** Type de noeud */ |
|
| 11 | + public string $type = 'boucle'; |
|
| 12 | + |
|
| 13 | + /** Identifiant de la boucle */ |
|
| 14 | + public string $id_boucle; |
|
| 15 | + |
|
| 16 | + /** Identifiant de la boucle parente */ |
|
| 17 | + public string $id_parent = ''; |
|
| 18 | + |
|
| 19 | + /** Un nom explicite qui peut être affecté manuellement à certaines boucles générées */ |
|
| 20 | + public string $nom = ''; |
|
| 21 | + |
|
| 22 | + /** |
|
| 23 | + * Partie avant toujours affichee |
|
| 24 | + * |
|
| 25 | + * @var string|array |
|
| 26 | + */ |
|
| 27 | + public $preaff = ''; |
|
| 28 | + |
|
| 29 | + /** |
|
| 30 | + * Partie optionnelle avant |
|
| 31 | + * |
|
| 32 | + * @var string|array |
|
| 33 | + */ |
|
| 34 | + public $avant = ''; |
|
| 35 | + |
|
| 36 | + /** |
|
| 37 | + * Pour chaque élément |
|
| 38 | + * |
|
| 39 | + * @var string|array |
|
| 40 | + */ |
|
| 41 | + public $milieu = ''; |
|
| 42 | + |
|
| 43 | + /** |
|
| 44 | + * Partie optionnelle après |
|
| 45 | + * |
|
| 46 | + * @var string|array |
|
| 47 | + */ |
|
| 48 | + public $apres = ''; |
|
| 49 | + |
|
| 50 | + /** |
|
| 51 | + * Partie alternative, si pas de résultat dans la boucle |
|
| 52 | + * |
|
| 53 | + * @var string|array |
|
| 54 | + */ |
|
| 55 | + public $altern = ''; |
|
| 56 | + |
|
| 57 | + /** |
|
| 58 | + * Partie apres toujours affichee |
|
| 59 | + * |
|
| 60 | + * @var string|array |
|
| 61 | + */ |
|
| 62 | + public $postaff = ''; |
|
| 63 | + |
|
| 64 | + |
|
| 65 | + /** |
|
| 66 | + * La boucle doit-elle sélectionner la langue ? |
|
| 67 | + * |
|
| 68 | + * Valeurs : '', 'oui', 'non' |
|
| 69 | + */ |
|
| 70 | + public string $lang_select = ''; |
|
| 71 | + |
|
| 72 | + /** |
|
| 73 | + * Alias de table d'application de la requête ou nom complet de la table SQL |
|
| 74 | + * |
|
| 75 | + * FIXME: un seul typage (string ?) |
|
| 76 | + * |
|
| 77 | + * @var string|false|null |
|
| 78 | + */ |
|
| 79 | + public $type_requete = null; |
|
| 80 | + |
|
| 81 | + /** |
|
| 82 | + * La table est elle optionnelle ? |
|
| 83 | + * |
|
| 84 | + * Si oui, aucune erreur ne sera générée si la table demandée n'est pas présente |
|
| 85 | + */ |
|
| 86 | + public bool $table_optionnelle = false; |
|
| 87 | + public string $type_table_optionnelle = ''; |
|
| 88 | + |
|
| 89 | + /** |
|
| 90 | + * Nom du fichier de connexion |
|
| 91 | + */ |
|
| 92 | + public string $sql_serveur = ''; |
|
| 93 | + |
|
| 94 | + /** |
|
| 95 | + * Paramètres de la boucle |
|
| 96 | + * |
|
| 97 | + * Description des paramètres passés à la boucle, qui servent ensuite |
|
| 98 | + * au calcul des critères |
|
| 99 | + * |
|
| 100 | + * FIXME: type unique. |
|
| 101 | + * @var false|array |
|
| 102 | + * - false: erreur de syntaxe |
|
| 103 | + */ |
|
| 104 | + public $param = []; |
|
| 105 | + |
|
| 106 | + /** |
|
| 107 | + * Critères de la boucle |
|
| 108 | + * |
|
| 109 | + * FIXME: type array unique. |
|
| 110 | + * |
|
| 111 | + * @var string|Critere[] |
|
| 112 | + * - string: phrasage (code brut). Il reste si erreur de critère |
|
| 113 | + * - array: analyse correcte des critères... |
|
| 114 | + */ |
|
| 115 | + public $criteres = []; |
|
| 116 | + |
|
| 117 | + /** |
|
| 118 | + * Textes insérés entre 2 éléments de boucle (critère inter) |
|
| 119 | + * |
|
| 120 | + * @var string[] |
|
| 121 | + */ |
|
| 122 | + public array $separateur = []; |
|
| 123 | + |
|
| 124 | + /** |
|
| 125 | + * Liste des jointures possibles avec cette table |
|
| 126 | + * |
|
| 127 | + * Les jointures par défaut de la table sont complétées en priorité |
|
| 128 | + * des jointures déclarées explicitement sur la boucle |
|
| 129 | + * |
|
| 130 | + * @see base_trouver_table_dist() |
|
| 131 | + */ |
|
| 132 | + public array $jointures = []; |
|
| 133 | + |
|
| 134 | + /** |
|
| 135 | + * Jointures explicites avec cette table |
|
| 136 | + * |
|
| 137 | + * Ces jointures sont utilisées en priorité par rapport aux jointures |
|
| 138 | + * normales possibles pour retrouver les colonnes demandées extérieures |
|
| 139 | + * à la boucle. |
|
| 140 | + * |
|
| 141 | + * @var string|bool |
|
| 142 | + */ |
|
| 143 | + public $jointures_explicites = false; |
|
| 144 | + |
|
| 145 | + /** |
|
| 146 | + * Nom de la variable PHP stockant le noms de doublons utilisés "$doublons_index" |
|
| 147 | + */ |
|
| 148 | + public string $doublons = ''; |
|
| 149 | + |
|
| 150 | + /** |
|
| 151 | + * Code PHP ajouté au début de chaque itération de boucle. |
|
| 152 | + * |
|
| 153 | + * Utilisé entre autre par les critères {pagination}, {n-a,b}, {a/b}... |
|
| 154 | + */ |
|
| 155 | + public string $partie = ''; |
|
| 156 | + |
|
| 157 | + /** |
|
| 158 | + * Nombre de divisions de la boucle, d'éléments à afficher, |
|
| 159 | + * ou de soustractions d'éléments à faire |
|
| 160 | + * |
|
| 161 | + * Dans les critères limitant le nombre d'éléments affichés |
|
| 162 | + * {a,b}, {a,n-b}, {a/b}, {pagination b}, b est affecté à total_parties. |
|
| 163 | + */ |
|
| 164 | + public string $total_parties = ''; |
|
| 165 | + |
|
| 166 | + /** |
|
| 167 | + * Code PHP ajouté avant l'itération de boucle. |
|
| 168 | + * |
|
| 169 | + * Utilisé entre autre par les critères {pagination}, {a,b}, {a/b} |
|
| 170 | + * pour initialiser les variables de début et de fin d'itération. |
|
| 171 | + */ |
|
| 172 | + public string $mode_partie = ''; |
|
| 173 | + |
|
| 174 | + /** |
|
| 175 | + * Identifiant d'une boucle qui appelle celle-ci de manière récursive |
|
| 176 | + * |
|
| 177 | + * Si une boucle est appelée de manière récursive quelque part par |
|
| 178 | + * une autre boucle comme <BOUCLE_rec(boucle_identifiant) />, cette |
|
| 179 | + * boucle (identifiant) reçoit dans cette propriété l'identifiant |
|
| 180 | + * de l'appelant (rec) |
|
| 181 | + */ |
|
| 182 | + public string $externe = ''; |
|
| 183 | + |
|
| 184 | + // champs pour la construction de la requete SQL |
|
| 185 | + |
|
| 186 | + /** |
|
| 187 | + * Liste des champs à récupérer par la boucle |
|
| 188 | + * |
|
| 189 | + * Expression 'table.nom_champ' ou calculée 'nom_champ AS x' |
|
| 190 | + * |
|
| 191 | + * @var string[] |
|
| 192 | + */ |
|
| 193 | + public array $select = []; |
|
| 194 | + |
|
| 195 | + /** |
|
| 196 | + * Liste des alias / tables SQL utilisées dans la boucle |
|
| 197 | + * |
|
| 198 | + * L'index est un identifiant (xx dans spip_xx assez souvent) qui servira |
|
| 199 | + * d'alias au nom de la table ; la valeur est le nom de la table SQL désirée. |
|
| 200 | + * |
|
| 201 | + * L'index 0 peut définir le type de sources de données de l'itérateur DATA |
|
| 202 | + * |
|
| 203 | + * @var string[] |
|
| 204 | + */ |
|
| 205 | + public array $from = []; |
|
| 206 | + |
|
| 207 | + /** |
|
| 208 | + * Liste des alias / type de jointures utilisées dans la boucle |
|
| 209 | + * |
|
| 210 | + * L'index est le nom d'alias (comme pour la propriété $from), et la valeur |
|
| 211 | + * un type de jointure parmi 'INNER', 'LEFT', 'RIGHT', 'OUTER'. |
|
| 212 | + * |
|
| 213 | + * Lorsque le type n'est pas déclaré pour un alias, c'est 'INNER' |
|
| 214 | + * qui sera utilisé par défaut (créant donc un INNER JOIN). |
|
| 215 | + * |
|
| 216 | + * @var string[] |
|
| 217 | + */ |
|
| 218 | + public array $from_type = []; |
|
| 219 | + |
|
| 220 | + /** |
|
| 221 | + * Liste des conditions WHERE de la boucle |
|
| 222 | + * |
|
| 223 | + * Permet de restreindre les éléments retournés par une boucle |
|
| 224 | + * en fonctions des conditions transmises dans ce tableau. |
|
| 225 | + * |
|
| 226 | + * Ce tableau peut avoir plusieurs niveaux de profondeur. |
|
| 227 | + * |
|
| 228 | + * Les éléments du premier niveau sont reliés par des AND, donc |
|
| 229 | + * chaque élément ajouté directement au where par |
|
| 230 | + * $boucle->where[] = array(...) ou $boucle->where[] = "'expression'" |
|
| 231 | + * est une condition AND en plus. |
|
| 232 | + * |
|
| 233 | + * Par contre, lorsqu'on indique un tableau, il peut décrire des relations |
|
| 234 | + * internes différentes. Soit $expr un tableau d'expressions quelconques de 3 valeurs : |
|
| 235 | + * $expr = array(operateur, val1, val2) |
|
| 236 | + * |
|
| 237 | + * Ces 3 valeurs sont des expressions PHP. L'index 0 désigne l'opérateur |
|
| 238 | + * à réaliser tel que : |
|
| 239 | + * |
|
| 240 | + * - "'='" , "'>='", "'<'", "'IN'", "'REGEXP'", "'LIKE'", ... : |
|
| 241 | + * val1 et val2 sont des champs et valeurs à utiliser dans la comparaison |
|
| 242 | + * suivant cet ordre : "val1 operateur val2". |
|
| 243 | + * Exemple : $boucle->where[] = array("'='", "'articles.statut'", "'\"publie\"'"); |
|
| 244 | + * - "'AND'", "'OR'", "'NOT'" : |
|
| 245 | + * dans ce cas val1 et val2 sont également des expressions |
|
| 246 | + * de comparaison complètes, et peuvent être eux-même des tableaux comme $expr |
|
| 247 | + * Exemples : |
|
| 248 | + * $boucle->where[] = array("'OR'", $expr1, $expr2); |
|
| 249 | + * $boucle->where[] = array("'NOT'", $expr); // val2 n'existe pas avec NOT |
|
| 250 | + * |
|
| 251 | + * D'autres noms sont possibles pour l'opérateur (le nombre de valeurs diffère) : |
|
| 252 | + * - "'SELF'", "'SUBSELECT'" : indiquent des sous requêtes |
|
| 253 | + * - "'?'" : indique une condition à faire évaluer (val1 ? val2 : val3) |
|
| 254 | + */ |
|
| 255 | + public array $where = []; |
|
| 256 | + |
|
| 257 | + public array $join = []; |
|
| 258 | + public array $having = []; |
|
| 259 | + public $limit = ''; |
|
| 260 | + public array $group = []; |
|
| 261 | + public array $order = []; |
|
| 262 | + public array $default_order = []; |
|
| 263 | + public string $date = 'date'; |
|
| 264 | + public string $hash = ''; |
|
| 265 | + public $in = ''; |
|
| 266 | + public bool $sous_requete = false; |
|
| 267 | + |
|
| 268 | + /** |
|
| 269 | + * Code PHP qui sera ajouté en tout début de la fonction de boucle |
|
| 270 | + * |
|
| 271 | + * Il sert à insérer le code calculant une hierarchie |
|
| 272 | + */ |
|
| 273 | + public string $hierarchie = ''; |
|
| 274 | + |
|
| 275 | + // champs pour la construction du corps PHP |
|
| 276 | + |
|
| 277 | + /** |
|
| 278 | + * Description des sources de données de la boucle |
|
| 279 | + * |
|
| 280 | + * Description des données de la boucle issu de trouver_table |
|
| 281 | + * dans le cadre de l'itérateur SQL et contenant au moins l'index 'field'. |
|
| 282 | + * |
|
| 283 | + * @see base_trouver_table_dist() |
|
| 284 | + */ |
|
| 285 | + public array $show = []; |
|
| 286 | + |
|
| 287 | + /** |
|
| 288 | + * Nom de la table SQL principale de la boucle, sans son préfixe |
|
| 289 | + */ |
|
| 290 | + public string $id_table = ''; |
|
| 291 | + |
|
| 292 | + /** |
|
| 293 | + * Nom de la clé primaire de la table SQL principale de la boucle |
|
| 294 | + */ |
|
| 295 | + public string $primary = ''; |
|
| 296 | + |
|
| 297 | + /** |
|
| 298 | + * Code PHP compilé de la boucle |
|
| 299 | + * |
|
| 300 | + * FIXME: un seul type (string ?) |
|
| 301 | + * |
|
| 302 | + * - false: boucle fautive ? |
|
| 303 | + * |
|
| 304 | + * @var string|false |
|
| 305 | + */ |
|
| 306 | + public $return = ''; |
|
| 307 | + |
|
| 308 | + public $numrows = false; |
|
| 309 | + public $cptrows = false; |
|
| 310 | + |
|
| 311 | + /** |
|
| 312 | + * Description du squelette |
|
| 313 | + * |
|
| 314 | + * Sert pour la gestion d'erreur et la production de code dependant du contexte |
|
| 315 | + * |
|
| 316 | + * Peut contenir les index : |
|
| 317 | + * |
|
| 318 | + * - nom : Nom du fichier de cache |
|
| 319 | + * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser) |
|
| 320 | + * - sourcefile : Chemin du squelette |
|
| 321 | + * - squelette : Code du squelette |
|
| 322 | + * - id_mere : Identifiant de la boucle parente |
|
| 323 | + * - documents : Pour embed et img dans les textes |
|
| 324 | + * - session : Pour un cache sessionné par auteur |
|
| 325 | + * - niv : Niveau de tabulation |
|
| 326 | + */ |
|
| 327 | + public array $descr = []; |
|
| 328 | + |
|
| 329 | + /** Numéro de ligne dans le code source du squelette */ |
|
| 330 | + public int $ligne = 0; |
|
| 331 | + |
|
| 332 | + |
|
| 333 | + /** |
|
| 334 | + * table pour stocker les modificateurs de boucle tels que tout, plat ..., |
|
| 335 | + * utilisable par les plugins egalement |
|
| 336 | + * |
|
| 337 | + * @var array<string, mixed> |
|
| 338 | + */ |
|
| 339 | + public array $modificateur = []; |
|
| 340 | + |
|
| 341 | + /** |
|
| 342 | + * Type d'itérateur utilisé pour cette boucle |
|
| 343 | + * |
|
| 344 | + * - 'SQL' dans le cadre d'une boucle sur une table SQL |
|
| 345 | + * - 'DATA' pour l'itérateur DATA, ... |
|
| 346 | + * |
|
| 347 | + * @var string |
|
| 348 | + */ |
|
| 349 | + public string $iterateur = ''; // type d'iterateur |
|
| 350 | + |
|
| 351 | + /** |
|
| 352 | + * @var array $debug Textes qui seront insérés dans l’entête de boucle du mode debug |
|
| 353 | + */ |
|
| 354 | + public array $debug = []; |
|
| 355 | + |
|
| 356 | + /** |
|
| 357 | + * Index de la boucle dont le champ présent dans cette boucle est originaire, |
|
| 358 | + * notamment si le champ a été trouve dans une boucle parente |
|
| 359 | + * |
|
| 360 | + * Tableau nom du champ => index de boucle |
|
| 361 | + */ |
|
| 362 | + public array $index_champ = []; |
|
| 363 | + |
|
| 364 | + /** Résultat de la compilation (?) (sert au débusqueur) */ |
|
| 365 | + public string $code = ''; |
|
| 366 | + |
|
| 367 | + /** Source des filtres (compatibilité) (?) */ |
|
| 368 | + public array $fonctions = []; |
|
| 369 | + |
|
| 370 | + // obsoletes, conserves provisoirement pour compatibilite |
|
| 371 | + public $tout = false; |
|
| 372 | + public $plat = false; |
|
| 373 | + public $lien = false; |
|
| 374 | 374 | } |
@@ -9,22 +9,22 @@ discard block |
||
| 9 | 9 | |
| 10 | 10 | // pas en cli ? passe ton chemin ! (ce script est un vilain trou de securite) |
| 11 | 11 | if (PHP_SAPI !== 'cli') { |
| 12 | - throw new RuntimeException('Operation not allowed.'); |
|
| 12 | + throw new RuntimeException('Operation not allowed.'); |
|
| 13 | 13 | } |
| 14 | 14 | |
| 15 | 15 | // let's go spip |
| 16 | 16 | if (!defined('_SPIP_TEST_INC')) { |
| 17 | - define('_SPIP_TEST_INC', dirname(__FILE__, 2)); |
|
| 17 | + define('_SPIP_TEST_INC', dirname(__FILE__, 2)); |
|
| 18 | 18 | } |
| 19 | 19 | |
| 20 | 20 | // si rien defini on va dans le public |
| 21 | 21 | |
| 22 | 22 | if (!defined('_SPIP_TEST_CHDIR')) { |
| 23 | - define('_SPIP_TEST_CHDIR', dirname(_SPIP_TEST_INC)); |
|
| 23 | + define('_SPIP_TEST_CHDIR', dirname(_SPIP_TEST_INC)); |
|
| 24 | 24 | } |
| 25 | 25 | |
| 26 | 26 | if (!defined('_DIR_TESTS')) { |
| 27 | - define('_DIR_TESTS', substr(_SPIP_TEST_INC, strlen(_SPIP_TEST_CHDIR) + 1) . '/'); |
|
| 27 | + define('_DIR_TESTS', substr(_SPIP_TEST_INC, strlen(_SPIP_TEST_CHDIR) + 1) . '/'); |
|
| 28 | 28 | } |
| 29 | 29 | |
| 30 | 30 | // chdir pour charger SPIP |
@@ -34,8 +34,8 @@ discard block |
||
| 34 | 34 | |
| 35 | 35 | // pour notice sur recuperer_fond() |
| 36 | 36 | if (!isset($GLOBALS['spip_lang'])) { |
| 37 | - include_spip('inc/lang'); |
|
| 38 | - utiliser_langue_visiteur(); |
|
| 37 | + include_spip('inc/lang'); |
|
| 38 | + utiliser_langue_visiteur(); |
|
| 39 | 39 | } |
| 40 | 40 | |
| 41 | 41 | $GLOBALS['taille_des_logs'] = 1024; |
@@ -46,16 +46,16 @@ discard block |
||
| 46 | 46 | @error_reporting(E_ALL); |
| 47 | 47 | |
| 48 | 48 | function spip_tests_loger_webmestre() { |
| 49 | - // il faut charger une session webmestre |
|
| 50 | - include_spip('base/abstract_sql'); |
|
| 51 | - $webmestre = sql_fetsel('*', 'spip_auteurs', "statut='0minirezo' AND webmestre='oui'", '', 'id_auteur', '0,1'); |
|
| 52 | - include_spip('inc/auth'); |
|
| 53 | - auth_loger($webmestre); |
|
| 49 | + // il faut charger une session webmestre |
|
| 50 | + include_spip('base/abstract_sql'); |
|
| 51 | + $webmestre = sql_fetsel('*', 'spip_auteurs', "statut='0minirezo' AND webmestre='oui'", '', 'id_auteur', '0,1'); |
|
| 52 | + include_spip('inc/auth'); |
|
| 53 | + auth_loger($webmestre); |
|
| 54 | 54 | } |
| 55 | 55 | |
| 56 | 56 | function spip_tests_deloger_webmestre() { |
| 57 | - if (!empty($GLOBALS['visiteur_session']['id_auteur'])) { |
|
| 58 | - supprimer_sessions($GLOBALS['visiteur_session']['id_auteur'], false); |
|
| 59 | - } |
|
| 60 | - $GLOBALS['visiteur_session'] = []; |
|
| 57 | + if (!empty($GLOBALS['visiteur_session']['id_auteur'])) { |
|
| 58 | + supprimer_sessions($GLOBALS['visiteur_session']['id_auteur'], false); |
|
| 59 | + } |
|
| 60 | + $GLOBALS['visiteur_session'] = []; |
|
| 61 | 61 | } |
@@ -24,13 +24,13 @@ |
||
| 24 | 24 | } |
| 25 | 25 | |
| 26 | 26 | if (!defined('_DIR_TESTS')) { |
| 27 | - define('_DIR_TESTS', substr(_SPIP_TEST_INC, strlen(_SPIP_TEST_CHDIR) + 1) . '/'); |
|
| 27 | + define('_DIR_TESTS', substr(_SPIP_TEST_INC, strlen(_SPIP_TEST_CHDIR) + 1).'/'); |
|
| 28 | 28 | } |
| 29 | 29 | |
| 30 | 30 | // chdir pour charger SPIP |
| 31 | 31 | chdir(_SPIP_TEST_CHDIR); |
| 32 | 32 | |
| 33 | -require_once _SPIP_TEST_CHDIR . '/ecrire/inc_version.php'; |
|
| 33 | +require_once _SPIP_TEST_CHDIR.'/ecrire/inc_version.php'; |
|
| 34 | 34 | |
| 35 | 35 | // pour notice sur recuperer_fond() |
| 36 | 36 | if (!isset($GLOBALS['spip_lang'])) { |
@@ -10,35 +10,35 @@ |
||
| 10 | 10 | |
| 11 | 11 | class Templating |
| 12 | 12 | { |
| 13 | - public function __construct( |
|
| 14 | - private readonly LoaderInterface $loader |
|
| 15 | - ) { |
|
| 16 | - } |
|
| 17 | - |
|
| 18 | - public static function fromString(array $options = []): self { |
|
| 19 | - return new static(new StringLoader($options)); |
|
| 20 | - } |
|
| 21 | - |
|
| 22 | - public static function fromFile(): self { |
|
| 23 | - return new static(new FileLoader()); |
|
| 24 | - } |
|
| 25 | - |
|
| 26 | - public function getLoader(): LoaderInterface { |
|
| 27 | - return $this->loader; |
|
| 28 | - } |
|
| 29 | - |
|
| 30 | - public function load(string $name): Template { |
|
| 31 | - $source = $this->loader->getSourceFile($name); |
|
| 32 | - return new Template($source); |
|
| 33 | - } |
|
| 34 | - |
|
| 35 | - public function render(string $name, array $contexte = [], string $connect = ''): string { |
|
| 36 | - return $this->load($name) |
|
| 37 | - ->render($contexte, $connect); |
|
| 38 | - } |
|
| 39 | - |
|
| 40 | - public function rawRender(string $name, array $contexte = [], string $connect = ''): array { |
|
| 41 | - return $this->load($name) |
|
| 42 | - ->rawRender($contexte, $connect); |
|
| 43 | - } |
|
| 13 | + public function __construct( |
|
| 14 | + private readonly LoaderInterface $loader |
|
| 15 | + ) { |
|
| 16 | + } |
|
| 17 | + |
|
| 18 | + public static function fromString(array $options = []): self { |
|
| 19 | + return new static(new StringLoader($options)); |
|
| 20 | + } |
|
| 21 | + |
|
| 22 | + public static function fromFile(): self { |
|
| 23 | + return new static(new FileLoader()); |
|
| 24 | + } |
|
| 25 | + |
|
| 26 | + public function getLoader(): LoaderInterface { |
|
| 27 | + return $this->loader; |
|
| 28 | + } |
|
| 29 | + |
|
| 30 | + public function load(string $name): Template { |
|
| 31 | + $source = $this->loader->getSourceFile($name); |
|
| 32 | + return new Template($source); |
|
| 33 | + } |
|
| 34 | + |
|
| 35 | + public function render(string $name, array $contexte = [], string $connect = ''): string { |
|
| 36 | + return $this->load($name) |
|
| 37 | + ->render($contexte, $connect); |
|
| 38 | + } |
|
| 39 | + |
|
| 40 | + public function rawRender(string $name, array $contexte = [], string $connect = ''): array { |
|
| 41 | + return $this->load($name) |
|
| 42 | + ->rawRender($contexte, $connect); |
|
| 43 | + } |
|
| 44 | 44 | } |
@@ -13,160 +13,160 @@ |
||
| 13 | 13 | |
| 14 | 14 | class ProtegeChampTest extends TestCase |
| 15 | 15 | { |
| 16 | - public static function setUpBeforeClass(): void { |
|
| 17 | - find_in_path('./balise/formulaire_.php', '', true); |
|
| 18 | - } |
|
| 16 | + public static function setUpBeforeClass(): void { |
|
| 17 | + find_in_path('./balise/formulaire_.php', '', true); |
|
| 18 | + } |
|
| 19 | 19 | |
| 20 | - #[DataProvider('providerFormulaireProtegeChamp')] |
|
| 21 | - public function testFormulaireProtegeChamp($expected, ...$args): void { |
|
| 22 | - $actual = protege_champ(...$args); |
|
| 23 | - $this->assertSame($expected, $actual); |
|
| 24 | - } |
|
| 20 | + #[DataProvider('providerFormulaireProtegeChamp')] |
|
| 21 | + public function testFormulaireProtegeChamp($expected, ...$args): void { |
|
| 22 | + $actual = protege_champ(...$args); |
|
| 23 | + $this->assertSame($expected, $actual); |
|
| 24 | + } |
|
| 25 | 25 | |
| 26 | - public static function providerFormulaireProtegeChamp(): array { |
|
| 27 | - return [ |
|
| 28 | - 0 => [ |
|
| 29 | - 0 => 'i:1;', |
|
| 30 | - 1 => 'i:1;', |
|
| 31 | - ], |
|
| 32 | - 1 => [ |
|
| 33 | - 0 => 's:4:"toto";', |
|
| 34 | - 1 => 's:4:"toto";', |
|
| 35 | - ], |
|
| 36 | - 2 => [ |
|
| 37 | - 0 => 'b:1;', |
|
| 38 | - 1 => 'b:1;', |
|
| 39 | - ], |
|
| 40 | - 3 => [ |
|
| 41 | - 0 => 'b:0;', |
|
| 42 | - 1 => 'b:0;', |
|
| 43 | - ], |
|
| 44 | - 4 => [ |
|
| 45 | - 0 => 'a:1:{i:0;s:4:"toto";}', |
|
| 46 | - 1 => 'a:1:{i:0;s:4:"toto";}', |
|
| 47 | - ], |
|
| 48 | - 5 => [ |
|
| 49 | - 0 => '', |
|
| 50 | - 1 => '', |
|
| 51 | - ], |
|
| 52 | - 6 => [ |
|
| 53 | - 0 => '0', |
|
| 54 | - 1 => '0', |
|
| 55 | - ], |
|
| 56 | - 7 => [ |
|
| 57 | - 0 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 58 | - 1 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 59 | - ], |
|
| 60 | - 8 => [ |
|
| 61 | - 0 => 'Un texte avec des entit&eacute;s &amp;&lt;&gt;&quot;', |
|
| 62 | - 1 => 'Un texte avec des entités &<>"', |
|
| 63 | - ], |
|
| 64 | - 9 => [ |
|
| 65 | - 0 => 'Un texte sans entites &<>"'', |
|
| 66 | - 1 => 'Un texte sans entites &<>"\'', |
|
| 67 | - ], |
|
| 68 | - 10 => [ |
|
| 69 | - 0 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 70 | - 1 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 71 | - ], |
|
| 72 | - 11 => [ |
|
| 73 | - 0 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 74 | - 1 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 75 | - ], |
|
| 76 | - 12 => [ |
|
| 77 | - 0 => 'Un texte avec des retour |
|
| 26 | + public static function providerFormulaireProtegeChamp(): array { |
|
| 27 | + return [ |
|
| 28 | + 0 => [ |
|
| 29 | + 0 => 'i:1;', |
|
| 30 | + 1 => 'i:1;', |
|
| 31 | + ], |
|
| 32 | + 1 => [ |
|
| 33 | + 0 => 's:4:"toto";', |
|
| 34 | + 1 => 's:4:"toto";', |
|
| 35 | + ], |
|
| 36 | + 2 => [ |
|
| 37 | + 0 => 'b:1;', |
|
| 38 | + 1 => 'b:1;', |
|
| 39 | + ], |
|
| 40 | + 3 => [ |
|
| 41 | + 0 => 'b:0;', |
|
| 42 | + 1 => 'b:0;', |
|
| 43 | + ], |
|
| 44 | + 4 => [ |
|
| 45 | + 0 => 'a:1:{i:0;s:4:"toto";}', |
|
| 46 | + 1 => 'a:1:{i:0;s:4:"toto";}', |
|
| 47 | + ], |
|
| 48 | + 5 => [ |
|
| 49 | + 0 => '', |
|
| 50 | + 1 => '', |
|
| 51 | + ], |
|
| 52 | + 6 => [ |
|
| 53 | + 0 => '0', |
|
| 54 | + 1 => '0', |
|
| 55 | + ], |
|
| 56 | + 7 => [ |
|
| 57 | + 0 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 58 | + 1 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 59 | + ], |
|
| 60 | + 8 => [ |
|
| 61 | + 0 => 'Un texte avec des entit&eacute;s &amp;&lt;&gt;&quot;', |
|
| 62 | + 1 => 'Un texte avec des entités &<>"', |
|
| 63 | + ], |
|
| 64 | + 9 => [ |
|
| 65 | + 0 => 'Un texte sans entites &<>"'', |
|
| 66 | + 1 => 'Un texte sans entites &<>"\'', |
|
| 67 | + ], |
|
| 68 | + 10 => [ |
|
| 69 | + 0 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 70 | + 1 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 71 | + ], |
|
| 72 | + 11 => [ |
|
| 73 | + 0 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 74 | + 1 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 75 | + ], |
|
| 76 | + 12 => [ |
|
| 77 | + 0 => 'Un texte avec des retour |
|
| 78 | 78 | a la ligne et meme des |
| 79 | 79 | |
| 80 | 80 | paragraphes', |
| 81 | - 1 => 'Un texte avec des retour |
|
| 81 | + 1 => 'Un texte avec des retour |
|
| 82 | 82 | a la ligne et meme des |
| 83 | 83 | |
| 84 | 84 | paragraphes', |
| 85 | - ], |
|
| 86 | - 13 => [ |
|
| 87 | - 0 => [], |
|
| 88 | - 1 => [], |
|
| 89 | - ], |
|
| 90 | - 14 => [ |
|
| 91 | - 0 => [ |
|
| 92 | - 0 => '', |
|
| 93 | - 1 => '0', |
|
| 94 | - 2 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 95 | - 3 => 'Un texte avec des entit&eacute;s &amp;&lt;&gt;&quot;', |
|
| 96 | - 4 => 'Un texte sans entites &<>"'', |
|
| 97 | - 5 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 98 | - 6 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 99 | - 7 => 'Un texte avec des retour |
|
| 85 | + ], |
|
| 86 | + 13 => [ |
|
| 87 | + 0 => [], |
|
| 88 | + 1 => [], |
|
| 89 | + ], |
|
| 90 | + 14 => [ |
|
| 91 | + 0 => [ |
|
| 92 | + 0 => '', |
|
| 93 | + 1 => '0', |
|
| 94 | + 2 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 95 | + 3 => 'Un texte avec des entit&eacute;s &amp;&lt;&gt;&quot;', |
|
| 96 | + 4 => 'Un texte sans entites &<>"'', |
|
| 97 | + 5 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 98 | + 6 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 99 | + 7 => 'Un texte avec des retour |
|
| 100 | 100 | a la ligne et meme des |
| 101 | 101 | |
| 102 | 102 | paragraphes', |
| 103 | - ], |
|
| 104 | - 1 => [ |
|
| 105 | - 0 => '', |
|
| 106 | - 1 => '0', |
|
| 107 | - 2 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 108 | - 3 => 'Un texte avec des entités &<>"', |
|
| 109 | - 4 => 'Un texte sans entites &<>"\'', |
|
| 110 | - 5 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 111 | - 6 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 112 | - 7 => 'Un texte avec des retour |
|
| 103 | + ], |
|
| 104 | + 1 => [ |
|
| 105 | + 0 => '', |
|
| 106 | + 1 => '0', |
|
| 107 | + 2 => 'Un texte avec des <a href="http://spip.net">liens</a> [Article 1->art1] [spip->http://www.spip.net] http://www.spip.net', |
|
| 108 | + 3 => 'Un texte avec des entités &<>"', |
|
| 109 | + 4 => 'Un texte sans entites &<>"\'', |
|
| 110 | + 5 => '{{{Des raccourcis}}} {italique} {{gras}} <code>du code</code>', |
|
| 111 | + 6 => 'Un modele <modeleinexistant|lien=[->http://www.spip.net]>', |
|
| 112 | + 7 => 'Un texte avec des retour |
|
| 113 | 113 | a la ligne et meme des |
| 114 | 114 | |
| 115 | 115 | paragraphes', |
| 116 | - ], |
|
| 117 | - ], |
|
| 118 | - 15 => [ |
|
| 119 | - 0 => [ |
|
| 120 | - 0 => 0, |
|
| 121 | - 1 => -1, |
|
| 122 | - 2 => 1, |
|
| 123 | - 3 => 2, |
|
| 124 | - 4 => 3, |
|
| 125 | - 5 => 4, |
|
| 126 | - 6 => 5, |
|
| 127 | - 7 => 6, |
|
| 128 | - 8 => 7, |
|
| 129 | - 9 => 10, |
|
| 130 | - 10 => 20, |
|
| 131 | - 11 => 30, |
|
| 132 | - 12 => 50, |
|
| 133 | - 13 => 100, |
|
| 134 | - 14 => 1000, |
|
| 135 | - 15 => 10000, |
|
| 136 | - ], |
|
| 137 | - 1 => [ |
|
| 138 | - 0 => 0, |
|
| 139 | - 1 => -1, |
|
| 140 | - 2 => 1, |
|
| 141 | - 3 => 2, |
|
| 142 | - 4 => 3, |
|
| 143 | - 5 => 4, |
|
| 144 | - 6 => 5, |
|
| 145 | - 7 => 6, |
|
| 146 | - 8 => 7, |
|
| 147 | - 9 => 10, |
|
| 148 | - 10 => 20, |
|
| 149 | - 11 => 30, |
|
| 150 | - 12 => 50, |
|
| 151 | - 13 => 100, |
|
| 152 | - 14 => 1000, |
|
| 153 | - 15 => 10000, |
|
| 154 | - ], |
|
| 155 | - ], |
|
| 156 | - 16 => [ |
|
| 157 | - 0 => [ |
|
| 158 | - 0 => '1', |
|
| 159 | - 1 => '', |
|
| 160 | - ], |
|
| 161 | - 1 => [ |
|
| 162 | - 0 => true, |
|
| 163 | - 1 => false, |
|
| 164 | - ], |
|
| 165 | - ], |
|
| 166 | - 17 => [ |
|
| 167 | - 0 => null, |
|
| 168 | - 1 => null, |
|
| 169 | - ], |
|
| 170 | - ]; |
|
| 171 | - } |
|
| 116 | + ], |
|
| 117 | + ], |
|
| 118 | + 15 => [ |
|
| 119 | + 0 => [ |
|
| 120 | + 0 => 0, |
|
| 121 | + 1 => -1, |
|
| 122 | + 2 => 1, |
|
| 123 | + 3 => 2, |
|
| 124 | + 4 => 3, |
|
| 125 | + 5 => 4, |
|
| 126 | + 6 => 5, |
|
| 127 | + 7 => 6, |
|
| 128 | + 8 => 7, |
|
| 129 | + 9 => 10, |
|
| 130 | + 10 => 20, |
|
| 131 | + 11 => 30, |
|
| 132 | + 12 => 50, |
|
| 133 | + 13 => 100, |
|
| 134 | + 14 => 1000, |
|
| 135 | + 15 => 10000, |
|
| 136 | + ], |
|
| 137 | + 1 => [ |
|
| 138 | + 0 => 0, |
|
| 139 | + 1 => -1, |
|
| 140 | + 2 => 1, |
|
| 141 | + 3 => 2, |
|
| 142 | + 4 => 3, |
|
| 143 | + 5 => 4, |
|
| 144 | + 6 => 5, |
|
| 145 | + 7 => 6, |
|
| 146 | + 8 => 7, |
|
| 147 | + 9 => 10, |
|
| 148 | + 10 => 20, |
|
| 149 | + 11 => 30, |
|
| 150 | + 12 => 50, |
|
| 151 | + 13 => 100, |
|
| 152 | + 14 => 1000, |
|
| 153 | + 15 => 10000, |
|
| 154 | + ], |
|
| 155 | + ], |
|
| 156 | + 16 => [ |
|
| 157 | + 0 => [ |
|
| 158 | + 0 => '1', |
|
| 159 | + 1 => '', |
|
| 160 | + ], |
|
| 161 | + 1 => [ |
|
| 162 | + 0 => true, |
|
| 163 | + 1 => false, |
|
| 164 | + ], |
|
| 165 | + ], |
|
| 166 | + 17 => [ |
|
| 167 | + 0 => null, |
|
| 168 | + 1 => null, |
|
| 169 | + ], |
|
| 170 | + ]; |
|
| 171 | + } |
|
| 172 | 172 | } |
@@ -19,276 +19,276 @@ |
||
| 19 | 19 | |
| 20 | 20 | class EditerLiensTest extends TestCase |
| 21 | 21 | { |
| 22 | - public static function setUpBeforeClass(): void { |
|
| 23 | - include_spip('action/editer_liens'); |
|
| 24 | - } |
|
| 22 | + public static function setUpBeforeClass(): void { |
|
| 23 | + include_spip('action/editer_liens'); |
|
| 24 | + } |
|
| 25 | 25 | |
| 26 | - public static function tearDownAfterClass(): void { |
|
| 27 | - include_spip('base/abstract_sql'); |
|
| 28 | - sql_delete('spip_auteurs_liens', "objet='spirou'"); |
|
| 29 | - sql_delete('spip_auteurs_liens', "objet='zorglub'"); |
|
| 30 | - } |
|
| 26 | + public static function tearDownAfterClass(): void { |
|
| 27 | + include_spip('base/abstract_sql'); |
|
| 28 | + sql_delete('spip_auteurs_liens', "objet='spirou'"); |
|
| 29 | + sql_delete('spip_auteurs_liens', "objet='zorglub'"); |
|
| 30 | + } |
|
| 31 | 31 | |
| 32 | - public function testObjetAssociable() { |
|
| 33 | - $essais = [ |
|
| 34 | - [ |
|
| 35 | - 0 => false, |
|
| 36 | - 1 => 'article', |
|
| 37 | - ], |
|
| 38 | - [ |
|
| 39 | - 0 => ['id_auteur', 'spip_auteurs_liens'], |
|
| 40 | - 1 => 'auteur', |
|
| 41 | - ], |
|
| 42 | - [ |
|
| 43 | - 0 => ['id_mot', 'spip_mots_liens'], |
|
| 44 | - 1 => 'mot', |
|
| 45 | - ], |
|
| 46 | - [ |
|
| 47 | - 0 => ['id_document', 'spip_documents_liens'], |
|
| 48 | - 1 => 'document', |
|
| 49 | - ], |
|
| 50 | - [ |
|
| 51 | - 0 => false, |
|
| 52 | - 1 => "mot' OR 1=1'", |
|
| 53 | - ], |
|
| 54 | - ]; |
|
| 32 | + public function testObjetAssociable() { |
|
| 33 | + $essais = [ |
|
| 34 | + [ |
|
| 35 | + 0 => false, |
|
| 36 | + 1 => 'article', |
|
| 37 | + ], |
|
| 38 | + [ |
|
| 39 | + 0 => ['id_auteur', 'spip_auteurs_liens'], |
|
| 40 | + 1 => 'auteur', |
|
| 41 | + ], |
|
| 42 | + [ |
|
| 43 | + 0 => ['id_mot', 'spip_mots_liens'], |
|
| 44 | + 1 => 'mot', |
|
| 45 | + ], |
|
| 46 | + [ |
|
| 47 | + 0 => ['id_document', 'spip_documents_liens'], |
|
| 48 | + 1 => 'document', |
|
| 49 | + ], |
|
| 50 | + [ |
|
| 51 | + 0 => false, |
|
| 52 | + 1 => "mot' OR 1=1'", |
|
| 53 | + ], |
|
| 54 | + ]; |
|
| 55 | 55 | |
| 56 | - foreach ($essais as $k => $essai) { |
|
| 57 | - $expected = array_shift($essai); |
|
| 58 | - $this->assertEquals($expected, objet_associable(...$essai), "Echec {$k} : objet_associable " . end($essai)); |
|
| 59 | - } |
|
| 60 | - } |
|
| 56 | + foreach ($essais as $k => $essai) { |
|
| 57 | + $expected = array_shift($essai); |
|
| 58 | + $this->assertEquals($expected, objet_associable(...$essai), "Echec {$k} : objet_associable " . end($essai)); |
|
| 59 | + } |
|
| 60 | + } |
|
| 61 | 61 | |
| 62 | - #[Depends('testObjetAssociable')] |
|
| 63 | - public function testObjetAssocier() { |
|
| 64 | - $essais = [ |
|
| 65 | - [ |
|
| 66 | - 0 => false, |
|
| 67 | - 1 => [ |
|
| 68 | - 'article' => 1, |
|
| 69 | - ], |
|
| 70 | - 2 => [ |
|
| 71 | - 'spirou' => 1, |
|
| 72 | - ], |
|
| 73 | - ], |
|
| 74 | - [ |
|
| 75 | - 0 => 1, |
|
| 76 | - 1 => [ |
|
| 77 | - 'auteur' => 1, |
|
| 78 | - ], |
|
| 79 | - 2 => [ |
|
| 80 | - 'spirou' => 1, |
|
| 81 | - ], |
|
| 82 | - ], |
|
| 83 | - [ |
|
| 84 | - 0 => 0, |
|
| 85 | - 1 => [ |
|
| 86 | - 'auteur' => 1, |
|
| 87 | - ], |
|
| 88 | - 2 => [ |
|
| 89 | - 'spirou' => 1, |
|
| 90 | - ], |
|
| 91 | - ], |
|
| 92 | - [ |
|
| 93 | - 0 => 2, |
|
| 94 | - 1 => [ |
|
| 95 | - 'auteur' => 1, |
|
| 96 | - ], |
|
| 97 | - 2 => [ |
|
| 98 | - 'spirou' => [2, 3], |
|
| 99 | - ], |
|
| 100 | - ], |
|
| 101 | - [ |
|
| 102 | - 0 => 1, |
|
| 103 | - 1 => [ |
|
| 104 | - 'auteur' => 1, |
|
| 105 | - ], |
|
| 106 | - 2 => [ |
|
| 107 | - 'spirou' => [2, 3, 4], |
|
| 108 | - ], |
|
| 109 | - ], |
|
| 110 | - [ |
|
| 111 | - 10, |
|
| 112 | - [ |
|
| 113 | - 'auteur' => 1, |
|
| 114 | - ], |
|
| 115 | - [ |
|
| 116 | - 'zorglub' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], |
|
| 117 | - ], |
|
| 118 | - ], |
|
| 119 | - [ |
|
| 120 | - 6, |
|
| 121 | - [ |
|
| 122 | - 'auteur' => 1, |
|
| 123 | - ], |
|
| 124 | - [ |
|
| 125 | - 'spirou' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], |
|
| 126 | - ], |
|
| 127 | - ], |
|
| 128 | - ]; |
|
| 62 | + #[Depends('testObjetAssociable')] |
|
| 63 | + public function testObjetAssocier() { |
|
| 64 | + $essais = [ |
|
| 65 | + [ |
|
| 66 | + 0 => false, |
|
| 67 | + 1 => [ |
|
| 68 | + 'article' => 1, |
|
| 69 | + ], |
|
| 70 | + 2 => [ |
|
| 71 | + 'spirou' => 1, |
|
| 72 | + ], |
|
| 73 | + ], |
|
| 74 | + [ |
|
| 75 | + 0 => 1, |
|
| 76 | + 1 => [ |
|
| 77 | + 'auteur' => 1, |
|
| 78 | + ], |
|
| 79 | + 2 => [ |
|
| 80 | + 'spirou' => 1, |
|
| 81 | + ], |
|
| 82 | + ], |
|
| 83 | + [ |
|
| 84 | + 0 => 0, |
|
| 85 | + 1 => [ |
|
| 86 | + 'auteur' => 1, |
|
| 87 | + ], |
|
| 88 | + 2 => [ |
|
| 89 | + 'spirou' => 1, |
|
| 90 | + ], |
|
| 91 | + ], |
|
| 92 | + [ |
|
| 93 | + 0 => 2, |
|
| 94 | + 1 => [ |
|
| 95 | + 'auteur' => 1, |
|
| 96 | + ], |
|
| 97 | + 2 => [ |
|
| 98 | + 'spirou' => [2, 3], |
|
| 99 | + ], |
|
| 100 | + ], |
|
| 101 | + [ |
|
| 102 | + 0 => 1, |
|
| 103 | + 1 => [ |
|
| 104 | + 'auteur' => 1, |
|
| 105 | + ], |
|
| 106 | + 2 => [ |
|
| 107 | + 'spirou' => [2, 3, 4], |
|
| 108 | + ], |
|
| 109 | + ], |
|
| 110 | + [ |
|
| 111 | + 10, |
|
| 112 | + [ |
|
| 113 | + 'auteur' => 1, |
|
| 114 | + ], |
|
| 115 | + [ |
|
| 116 | + 'zorglub' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], |
|
| 117 | + ], |
|
| 118 | + ], |
|
| 119 | + [ |
|
| 120 | + 6, |
|
| 121 | + [ |
|
| 122 | + 'auteur' => 1, |
|
| 123 | + ], |
|
| 124 | + [ |
|
| 125 | + 'spirou' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], |
|
| 126 | + ], |
|
| 127 | + ], |
|
| 128 | + ]; |
|
| 129 | 129 | |
| 130 | - foreach ($essais as $k => $essai) { |
|
| 131 | - $expected = array_shift($essai); |
|
| 132 | - $this->assertEquals( |
|
| 133 | - $expected, |
|
| 134 | - objet_associer(...$essai), |
|
| 135 | - "Echec {$k} : objet_associer " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 136 | - ); |
|
| 137 | - } |
|
| 138 | - } |
|
| 130 | + foreach ($essais as $k => $essai) { |
|
| 131 | + $expected = array_shift($essai); |
|
| 132 | + $this->assertEquals( |
|
| 133 | + $expected, |
|
| 134 | + objet_associer(...$essai), |
|
| 135 | + "Echec {$k} : objet_associer " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 136 | + ); |
|
| 137 | + } |
|
| 138 | + } |
|
| 139 | 139 | |
| 140 | - #[Depends('testObjetAssocier')] |
|
| 141 | - public function testObjetQualifierLiens() { |
|
| 142 | - $essais = [ |
|
| 143 | - [ |
|
| 144 | - 0 => false, |
|
| 145 | - 1 => [ |
|
| 146 | - 'article' => 1, |
|
| 147 | - ], |
|
| 148 | - 2 => [ |
|
| 149 | - 'zorglub' => 1, |
|
| 150 | - ], |
|
| 151 | - 3 => [ |
|
| 152 | - 'vu' => 'oui', |
|
| 153 | - ], |
|
| 154 | - ], |
|
| 155 | - [ |
|
| 156 | - 0 => 1, |
|
| 157 | - 1 => [ |
|
| 158 | - 'auteur' => 1, |
|
| 159 | - ], |
|
| 160 | - 2 => [ |
|
| 161 | - 'zorglub' => 1, |
|
| 162 | - ], |
|
| 163 | - 3 => [ |
|
| 164 | - 'vu' => 'oui', |
|
| 165 | - ], |
|
| 166 | - ], |
|
| 167 | - [ |
|
| 168 | - 0 => 1, |
|
| 169 | - 1 => [ |
|
| 170 | - 'auteur' => 1, |
|
| 171 | - ], |
|
| 172 | - 2 => [ |
|
| 173 | - 'zorglub' => 1, |
|
| 174 | - ], |
|
| 175 | - 3 => [ |
|
| 176 | - 'vu' => 'oui', |
|
| 177 | - ], |
|
| 178 | - ], |
|
| 179 | - [ |
|
| 180 | - 0 => false, |
|
| 181 | - 1 => [ |
|
| 182 | - 'auteur' => 1, |
|
| 183 | - ], |
|
| 184 | - 2 => [ |
|
| 185 | - 'zorglub' => 1, |
|
| 186 | - ], |
|
| 187 | - 3 => [ |
|
| 188 | - 'veraer' => 'oui', |
|
| 189 | - ], |
|
| 190 | - ], |
|
| 191 | - [ |
|
| 192 | - 0 => 2, |
|
| 193 | - 1 => [ |
|
| 194 | - 'auteur' => 1, |
|
| 195 | - ], |
|
| 196 | - 2 => [ |
|
| 197 | - 'zorglub' => [2, 3], |
|
| 198 | - ], |
|
| 199 | - 3 => [ |
|
| 200 | - 'vu' => 'oui', |
|
| 201 | - ], |
|
| 202 | - ], |
|
| 203 | - ]; |
|
| 140 | + #[Depends('testObjetAssocier')] |
|
| 141 | + public function testObjetQualifierLiens() { |
|
| 142 | + $essais = [ |
|
| 143 | + [ |
|
| 144 | + 0 => false, |
|
| 145 | + 1 => [ |
|
| 146 | + 'article' => 1, |
|
| 147 | + ], |
|
| 148 | + 2 => [ |
|
| 149 | + 'zorglub' => 1, |
|
| 150 | + ], |
|
| 151 | + 3 => [ |
|
| 152 | + 'vu' => 'oui', |
|
| 153 | + ], |
|
| 154 | + ], |
|
| 155 | + [ |
|
| 156 | + 0 => 1, |
|
| 157 | + 1 => [ |
|
| 158 | + 'auteur' => 1, |
|
| 159 | + ], |
|
| 160 | + 2 => [ |
|
| 161 | + 'zorglub' => 1, |
|
| 162 | + ], |
|
| 163 | + 3 => [ |
|
| 164 | + 'vu' => 'oui', |
|
| 165 | + ], |
|
| 166 | + ], |
|
| 167 | + [ |
|
| 168 | + 0 => 1, |
|
| 169 | + 1 => [ |
|
| 170 | + 'auteur' => 1, |
|
| 171 | + ], |
|
| 172 | + 2 => [ |
|
| 173 | + 'zorglub' => 1, |
|
| 174 | + ], |
|
| 175 | + 3 => [ |
|
| 176 | + 'vu' => 'oui', |
|
| 177 | + ], |
|
| 178 | + ], |
|
| 179 | + [ |
|
| 180 | + 0 => false, |
|
| 181 | + 1 => [ |
|
| 182 | + 'auteur' => 1, |
|
| 183 | + ], |
|
| 184 | + 2 => [ |
|
| 185 | + 'zorglub' => 1, |
|
| 186 | + ], |
|
| 187 | + 3 => [ |
|
| 188 | + 'veraer' => 'oui', |
|
| 189 | + ], |
|
| 190 | + ], |
|
| 191 | + [ |
|
| 192 | + 0 => 2, |
|
| 193 | + 1 => [ |
|
| 194 | + 'auteur' => 1, |
|
| 195 | + ], |
|
| 196 | + 2 => [ |
|
| 197 | + 'zorglub' => [2, 3], |
|
| 198 | + ], |
|
| 199 | + 3 => [ |
|
| 200 | + 'vu' => 'oui', |
|
| 201 | + ], |
|
| 202 | + ], |
|
| 203 | + ]; |
|
| 204 | 204 | |
| 205 | - foreach ($essais as $k => $essai) { |
|
| 206 | - $expected = array_shift($essai); |
|
| 207 | - $this->assertEquals( |
|
| 208 | - $expected, |
|
| 209 | - objet_qualifier_liens(...$essai), |
|
| 210 | - "Echec {$k} : objet_qualifier_liens " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 211 | - ); |
|
| 212 | - } |
|
| 213 | - } |
|
| 205 | + foreach ($essais as $k => $essai) { |
|
| 206 | + $expected = array_shift($essai); |
|
| 207 | + $this->assertEquals( |
|
| 208 | + $expected, |
|
| 209 | + objet_qualifier_liens(...$essai), |
|
| 210 | + "Echec {$k} : objet_qualifier_liens " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 211 | + ); |
|
| 212 | + } |
|
| 213 | + } |
|
| 214 | 214 | |
| 215 | - #[Depends('testObjetQualifierLiens')] |
|
| 216 | - public function testObjetDissocier() { |
|
| 217 | - $essais = [ |
|
| 218 | - [ |
|
| 219 | - 0 => false, |
|
| 220 | - 1 => [ |
|
| 221 | - 'article' => 1, |
|
| 222 | - ], |
|
| 223 | - 2 => [ |
|
| 224 | - 'zorglub' => 1, |
|
| 225 | - ], |
|
| 226 | - ], |
|
| 227 | - [ |
|
| 228 | - 0 => 1, |
|
| 229 | - 1 => [ |
|
| 230 | - 'auteur' => 1, |
|
| 231 | - ], |
|
| 232 | - 2 => [ |
|
| 233 | - 'zorglub' => 1, |
|
| 234 | - ], |
|
| 235 | - ], |
|
| 236 | - [ |
|
| 237 | - 0 => 0, |
|
| 238 | - 1 => [ |
|
| 239 | - 'auteur' => 1, |
|
| 240 | - ], |
|
| 241 | - 2 => [ |
|
| 242 | - 'zorglub' => 1, |
|
| 243 | - ], |
|
| 244 | - ], |
|
| 245 | - [ |
|
| 246 | - 0 => 2, |
|
| 247 | - 1 => [ |
|
| 248 | - 'auteur' => 1, |
|
| 249 | - ], |
|
| 250 | - 2 => [ |
|
| 251 | - 'zorglub' => [2, 3], |
|
| 252 | - ], |
|
| 253 | - ], |
|
| 254 | - [ |
|
| 255 | - 0 => 1, |
|
| 256 | - 1 => [ |
|
| 257 | - 'auteur' => 1, |
|
| 258 | - ], |
|
| 259 | - 2 => [ |
|
| 260 | - 'zorglub' => [2, 3, 4], |
|
| 261 | - ], |
|
| 262 | - ], |
|
| 263 | - [ |
|
| 264 | - 0 => 4, |
|
| 265 | - 1 => [ |
|
| 266 | - 'auteur' => 1, |
|
| 267 | - ], |
|
| 268 | - 2 => [ |
|
| 269 | - 'zorglub' => [5], |
|
| 270 | - 'spirou' => [2, 3, 4], |
|
| 271 | - ], |
|
| 272 | - ], |
|
| 273 | - [ |
|
| 274 | - 0 => 12, |
|
| 275 | - 1 => [ |
|
| 276 | - 'auteur' => 1, |
|
| 277 | - ], |
|
| 278 | - 2 => [ |
|
| 279 | - 'zorglub' => '*', |
|
| 280 | - 'spirou' => '*', |
|
| 281 | - ], |
|
| 282 | - ], |
|
| 283 | - ]; |
|
| 215 | + #[Depends('testObjetQualifierLiens')] |
|
| 216 | + public function testObjetDissocier() { |
|
| 217 | + $essais = [ |
|
| 218 | + [ |
|
| 219 | + 0 => false, |
|
| 220 | + 1 => [ |
|
| 221 | + 'article' => 1, |
|
| 222 | + ], |
|
| 223 | + 2 => [ |
|
| 224 | + 'zorglub' => 1, |
|
| 225 | + ], |
|
| 226 | + ], |
|
| 227 | + [ |
|
| 228 | + 0 => 1, |
|
| 229 | + 1 => [ |
|
| 230 | + 'auteur' => 1, |
|
| 231 | + ], |
|
| 232 | + 2 => [ |
|
| 233 | + 'zorglub' => 1, |
|
| 234 | + ], |
|
| 235 | + ], |
|
| 236 | + [ |
|
| 237 | + 0 => 0, |
|
| 238 | + 1 => [ |
|
| 239 | + 'auteur' => 1, |
|
| 240 | + ], |
|
| 241 | + 2 => [ |
|
| 242 | + 'zorglub' => 1, |
|
| 243 | + ], |
|
| 244 | + ], |
|
| 245 | + [ |
|
| 246 | + 0 => 2, |
|
| 247 | + 1 => [ |
|
| 248 | + 'auteur' => 1, |
|
| 249 | + ], |
|
| 250 | + 2 => [ |
|
| 251 | + 'zorglub' => [2, 3], |
|
| 252 | + ], |
|
| 253 | + ], |
|
| 254 | + [ |
|
| 255 | + 0 => 1, |
|
| 256 | + 1 => [ |
|
| 257 | + 'auteur' => 1, |
|
| 258 | + ], |
|
| 259 | + 2 => [ |
|
| 260 | + 'zorglub' => [2, 3, 4], |
|
| 261 | + ], |
|
| 262 | + ], |
|
| 263 | + [ |
|
| 264 | + 0 => 4, |
|
| 265 | + 1 => [ |
|
| 266 | + 'auteur' => 1, |
|
| 267 | + ], |
|
| 268 | + 2 => [ |
|
| 269 | + 'zorglub' => [5], |
|
| 270 | + 'spirou' => [2, 3, 4], |
|
| 271 | + ], |
|
| 272 | + ], |
|
| 273 | + [ |
|
| 274 | + 0 => 12, |
|
| 275 | + 1 => [ |
|
| 276 | + 'auteur' => 1, |
|
| 277 | + ], |
|
| 278 | + 2 => [ |
|
| 279 | + 'zorglub' => '*', |
|
| 280 | + 'spirou' => '*', |
|
| 281 | + ], |
|
| 282 | + ], |
|
| 283 | + ]; |
|
| 284 | 284 | |
| 285 | - foreach ($essais as $k => $essai) { |
|
| 286 | - $expected = array_shift($essai); |
|
| 287 | - $this->assertEquals( |
|
| 288 | - $expected, |
|
| 289 | - objet_dissocier(...$essai), |
|
| 290 | - "Echec {$k} : objet_dissocier " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 291 | - ); |
|
| 292 | - } |
|
| 293 | - } |
|
| 285 | + foreach ($essais as $k => $essai) { |
|
| 286 | + $expected = array_shift($essai); |
|
| 287 | + $this->assertEquals( |
|
| 288 | + $expected, |
|
| 289 | + objet_dissocier(...$essai), |
|
| 290 | + "Echec {$k} : objet_dissocier " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 291 | + ); |
|
| 292 | + } |
|
| 293 | + } |
|
| 294 | 294 | } |
@@ -55,7 +55,7 @@ discard block |
||
| 55 | 55 | |
| 56 | 56 | foreach ($essais as $k => $essai) { |
| 57 | 57 | $expected = array_shift($essai); |
| 58 | - $this->assertEquals($expected, objet_associable(...$essai), "Echec {$k} : objet_associable " . end($essai)); |
|
| 58 | + $this->assertEquals($expected, objet_associable(...$essai), "Echec {$k} : objet_associable ".end($essai)); |
|
| 59 | 59 | } |
| 60 | 60 | } |
| 61 | 61 | |
@@ -132,7 +132,7 @@ discard block |
||
| 132 | 132 | $this->assertEquals( |
| 133 | 133 | $expected, |
| 134 | 134 | objet_associer(...$essai), |
| 135 | - "Echec {$k} : objet_associer " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 135 | + "Echec {$k} : objet_associer ".json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 136 | 136 | ); |
| 137 | 137 | } |
| 138 | 138 | } |
@@ -207,7 +207,7 @@ discard block |
||
| 207 | 207 | $this->assertEquals( |
| 208 | 208 | $expected, |
| 209 | 209 | objet_qualifier_liens(...$essai), |
| 210 | - "Echec {$k} : objet_qualifier_liens " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 210 | + "Echec {$k} : objet_qualifier_liens ".json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 211 | 211 | ); |
| 212 | 212 | } |
| 213 | 213 | } |
@@ -287,7 +287,7 @@ discard block |
||
| 287 | 287 | $this->assertEquals( |
| 288 | 288 | $expected, |
| 289 | 289 | objet_dissocier(...$essai), |
| 290 | - "Echec {$k} : objet_dissocier " . json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 290 | + "Echec {$k} : objet_dissocier ".json_encode($essai, JSON_THROW_ON_ERROR) |
|
| 291 | 291 | ); |
| 292 | 292 | } |
| 293 | 293 | } |
@@ -12,262 +12,262 @@ |
||
| 12 | 12 | |
| 13 | 13 | abstract class SquelettesTestCase extends TestCase |
| 14 | 14 | { |
| 15 | - /** |
|
| 16 | - * Determine si une chaine débute par 'NA' (non applicable) |
|
| 17 | - */ |
|
| 18 | - public static function isNa(string $chaine): bool { |
|
| 19 | - return str_starts_with(strtolower(trim($chaine)), 'na'); |
|
| 20 | - } |
|
| 21 | - |
|
| 22 | - /** |
|
| 23 | - * Retourne le chemin relatif depuis la racine de SPIP |
|
| 24 | - */ |
|
| 25 | - public static function relativePath(string $fullDirectory): string { |
|
| 26 | - if (!defined('_SPIP_TEST_CHDIR')) { |
|
| 27 | - throw new RuntimeException('_SPIP_TEST_CHDIR needs to be defined'); |
|
| 28 | - } |
|
| 29 | - |
|
| 30 | - return substr($fullDirectory, strlen(_SPIP_TEST_CHDIR) + 1); |
|
| 31 | - } |
|
| 32 | - |
|
| 33 | - /** |
|
| 34 | - * Determine si une chaine débute par 'OK' |
|
| 35 | - */ |
|
| 36 | - public static function assertOk($actual, string $message = ''): void { |
|
| 37 | - $constraint = new IsOk($actual); |
|
| 38 | - |
|
| 39 | - static::assertThat($actual, $constraint, $message); |
|
| 40 | - } |
|
| 41 | - |
|
| 42 | - /** |
|
| 43 | - * Determine si une chaine ne débute pas par 'OK' |
|
| 44 | - */ |
|
| 45 | - public static function assertNotOk($actual, string $message = ''): void { |
|
| 46 | - $constraint = new LogicalNot(new IsOk($actual)); |
|
| 47 | - |
|
| 48 | - static::assertThat($actual, $constraint, $message); |
|
| 49 | - } |
|
| 50 | - |
|
| 51 | - /** |
|
| 52 | - * Assertion qui vérifie que le résultat d’un template est 'OK' |
|
| 53 | - * |
|
| 54 | - * @example |
|
| 55 | - * $templating = new Templating(new StringLoader()); |
|
| 56 | - * $this->assertOkTemplate($templating, '[(#CONFIG{pasla}|non)ok]'); |
|
| 57 | - * |
|
| 58 | - * $templating = new Templating(new FileLoader()); |
|
| 59 | - * $this->assertOkTemplate($templating, __DIR__ . '/data/truc.html'); |
|
| 60 | - * |
|
| 61 | - * @param string $code Code ou chemin du squelette |
|
| 62 | - * @param array $contexte Contexte de calcul du squelette |
|
| 63 | - * @param string $message Message pour une eventuelle erreur |
|
| 64 | - */ |
|
| 65 | - public static function assertOkTemplate( |
|
| 66 | - Templating $templating, |
|
| 67 | - string $code, |
|
| 68 | - array $contexte = [], |
|
| 69 | - string $message = '' |
|
| 70 | - ): void { |
|
| 71 | - $actual = $templating->render($code, $contexte); |
|
| 72 | - |
|
| 73 | - static::assertOk($actual, $message); |
|
| 74 | - } |
|
| 75 | - |
|
| 76 | - /** |
|
| 77 | - * Assertion qui vérifie que le résultat d’un template est vide |
|
| 78 | - * |
|
| 79 | - * @see assertOkTemplate() |
|
| 80 | - */ |
|
| 81 | - public static function assertNotOkTemplate( |
|
| 82 | - Templating $templating, |
|
| 83 | - string $code, |
|
| 84 | - array $contexte = [], |
|
| 85 | - string $message = '' |
|
| 86 | - ): void { |
|
| 87 | - $actual = $templating->render($code, $contexte); |
|
| 88 | - |
|
| 89 | - static::assertNotOk($actual, $message); |
|
| 90 | - } |
|
| 91 | - |
|
| 92 | - /** |
|
| 93 | - * Assertion qui vérifie que le résultat d’un template est vide |
|
| 94 | - * |
|
| 95 | - * @see assertOkTemplate() |
|
| 96 | - */ |
|
| 97 | - public static function assertEmptyTemplate( |
|
| 98 | - Templating $templating, |
|
| 99 | - string $code, |
|
| 100 | - array $contexte = [], |
|
| 101 | - string $message = '' |
|
| 102 | - ): void { |
|
| 103 | - $actual = $templating->render($code, $contexte); |
|
| 104 | - |
|
| 105 | - static::assertEmpty($actual, $message); |
|
| 106 | - } |
|
| 107 | - |
|
| 108 | - /** |
|
| 109 | - * Assertion qui vérifie que le résultat d’un template n’est pas vide |
|
| 110 | - * |
|
| 111 | - * @see assertOkTemplate() |
|
| 112 | - */ |
|
| 113 | - public static function assertNotEmptyTemplate( |
|
| 114 | - Templating $templating, |
|
| 115 | - string $code, |
|
| 116 | - array $contexte = [], |
|
| 117 | - string $message = '' |
|
| 118 | - ): void { |
|
| 119 | - $actual = $templating->render($code, $contexte); |
|
| 120 | - |
|
| 121 | - static::assertNotEmpty($actual, $message); |
|
| 122 | - } |
|
| 123 | - |
|
| 124 | - /** |
|
| 125 | - * Assertion qui vérifie le résultat d’un template |
|
| 126 | - * |
|
| 127 | - * @see assertOkTemplate() |
|
| 128 | - */ |
|
| 129 | - public static function assertEqualsTemplate( |
|
| 130 | - string $expected, |
|
| 131 | - Templating $templating, |
|
| 132 | - string $code, |
|
| 133 | - array $contexte = [], |
|
| 134 | - string $message = '' |
|
| 135 | - ): void { |
|
| 136 | - $actual = $templating->render($code, $contexte); |
|
| 137 | - |
|
| 138 | - static::assertEquals($expected, $actual, $message); |
|
| 139 | - } |
|
| 140 | - |
|
| 141 | - /** |
|
| 142 | - * Assertion qui vérifie le résultat d’un template |
|
| 143 | - * |
|
| 144 | - * @see assertOkTemplate() |
|
| 145 | - */ |
|
| 146 | - public static function assertNotEqualsTemplate( |
|
| 147 | - string $expected, |
|
| 148 | - Templating $templating, |
|
| 149 | - string $code, |
|
| 150 | - array $contexte = [], |
|
| 151 | - string $message = '' |
|
| 152 | - ): void { |
|
| 153 | - $actual = $templating->render($code, $contexte); |
|
| 154 | - |
|
| 155 | - static::assertNotEquals($expected, $actual, $message); |
|
| 156 | - } |
|
| 157 | - |
|
| 158 | - /** |
|
| 159 | - * Assertion qui vérifie que le résultat d’un code de squelette est 'OK' |
|
| 160 | - * |
|
| 161 | - * @example $this->assertOkCode('[(#CONFIG{pasla}|non)ok]'); |
|
| 162 | - * |
|
| 163 | - * @param string $code Code ou chemin du squelette |
|
| 164 | - * @param array $contexte Contexte de calcul du squelette |
|
| 165 | - * @param string $message Message pour une eventuelle erreur |
|
| 166 | - */ |
|
| 167 | - public static function assertOkCode(string $code, array $contexte = [], string $message = ''): void { |
|
| 168 | - static::assertOkTemplate(Templating::fromString(), $code, $contexte); |
|
| 169 | - } |
|
| 170 | - |
|
| 171 | - /** |
|
| 172 | - * Assertion qui vérifie que le résultat d’un code de squelette n’est pas 'OK' |
|
| 173 | - * |
|
| 174 | - * @see assertOkCode() |
|
| 175 | - */ |
|
| 176 | - public function assertNotOkCode(string $code, array $contexte = [], $message = ''): void { |
|
| 177 | - static::assertNotOkTemplate(Templating::fromString(), $code, $contexte); |
|
| 178 | - } |
|
| 179 | - |
|
| 180 | - /** |
|
| 181 | - * Assertion qui vérifie que le résultat d’un code de squelette est vide |
|
| 182 | - * |
|
| 183 | - * @see assertOkCode() |
|
| 184 | - */ |
|
| 185 | - public static function assertEmptyCode(string $code, array $contexte = [], string $message = ''): void { |
|
| 186 | - static::assertEmptyTemplate(Templating::fromString(), $code, $contexte); |
|
| 187 | - } |
|
| 188 | - |
|
| 189 | - /** |
|
| 190 | - * Assertion qui vérifie que le résultat d’un code de squelette n’est pas vide |
|
| 191 | - * |
|
| 192 | - * @see assertOkCode() |
|
| 193 | - */ |
|
| 194 | - public static function assertNotEmptyCode(string $code, array $contexte = [], string $message = ''): void { |
|
| 195 | - static::assertNotEmptyTemplate(Templating::fromString(), $code, $contexte); |
|
| 196 | - } |
|
| 197 | - |
|
| 198 | - /** |
|
| 199 | - * Assertion qui vérifie le résultat d’un code de squelette |
|
| 200 | - * |
|
| 201 | - * @see assertOkCode() |
|
| 202 | - */ |
|
| 203 | - public function assertEqualsCode(string $expected, string $code, array $contexte = [], $message = ''): void { |
|
| 204 | - static::assertEqualsTemplate($expected, Templating::fromString(), $code, $contexte); |
|
| 205 | - } |
|
| 206 | - |
|
| 207 | - /** |
|
| 208 | - * Assertion qui vérifie le résultat d’un code de squelette |
|
| 209 | - * |
|
| 210 | - * @see assertOkCode() |
|
| 211 | - */ |
|
| 212 | - public function assertNotEqualsCode(string $expected, string $code, array $contexte = [], $message = '') { |
|
| 213 | - static::assertNotEqualsTemplate($expected, Templating::fromString(), $code, $contexte); |
|
| 214 | - } |
|
| 215 | - |
|
| 216 | - /** |
|
| 217 | - * Assertion qui vérifie que le résultat d’un fichier de squelette est 'OK' |
|
| 218 | - * |
|
| 219 | - * @example $this->assertOkSquelette(__DIR__ . '/data/squelette.html'); |
|
| 220 | - * |
|
| 221 | - * @param string $code Code ou chemin du squelette |
|
| 222 | - * @param array $contexte Contexte de calcul du squelette |
|
| 223 | - * @param string $message Message pour une eventuelle erreur |
|
| 224 | - */ |
|
| 225 | - public static function assertOkSquelette(string $code, array $contexte = [], string $message = ''): void { |
|
| 226 | - static::assertOkTemplate(Templating::fromFile(), $code, $contexte); |
|
| 227 | - } |
|
| 228 | - |
|
| 229 | - /** |
|
| 230 | - * Assertion qui vérifie que le résultat d’un fichier de squelette n’est pas 'OK' |
|
| 231 | - * |
|
| 232 | - * @see assertOkSquelette() |
|
| 233 | - */ |
|
| 234 | - public function assertNotOkSquelette(string $code, array $contexte = [], $message = ''): void { |
|
| 235 | - static::assertNotOkTemplate(Templating::fromFile(), $code, $contexte); |
|
| 236 | - } |
|
| 237 | - |
|
| 238 | - /** |
|
| 239 | - * Assertion qui vérifie que le résultat d’un fichier de squelette est vide |
|
| 240 | - * |
|
| 241 | - * @see assertOkSquelette() |
|
| 242 | - */ |
|
| 243 | - public static function assertEmptySquelette(string $code, array $contexte = [], string $message = ''): void { |
|
| 244 | - static::assertEmptyTemplate(Templating::fromFile(), $code, $contexte); |
|
| 245 | - } |
|
| 246 | - |
|
| 247 | - /** |
|
| 248 | - * Assertion qui vérifie que le résultat d’un fichier de squelette n’est pas vide |
|
| 249 | - * |
|
| 250 | - * @see assertOkSquelette() |
|
| 251 | - */ |
|
| 252 | - public static function assertNotEmptySquelette(string $code, array $contexte = [], string $message = ''): void { |
|
| 253 | - static::assertNotEmptyTemplate(Templating::fromFile(), $code, $contexte); |
|
| 254 | - } |
|
| 255 | - |
|
| 256 | - /** |
|
| 257 | - * Assertion qui vérifie le résultat d’un fichier de squelette |
|
| 258 | - * |
|
| 259 | - * @see assertOkSquelette() |
|
| 260 | - */ |
|
| 261 | - public function assertEqualsSquelette(string $expected, string $code, array $contexte = [], $message = ''): void { |
|
| 262 | - static::assertEqualsTemplate($expected, Templating::fromFile(), $code, $contexte); |
|
| 263 | - } |
|
| 264 | - |
|
| 265 | - /** |
|
| 266 | - * Assertion qui vérifie le résultat d’un fichier de squelette |
|
| 267 | - * |
|
| 268 | - * @see assertOkSquelette() |
|
| 269 | - */ |
|
| 270 | - public function assertNotEqualsSquelette(string $expected, string $code, array $contexte = [], $message = '') { |
|
| 271 | - static::assertNotEqualsTemplate($expected, Templating::fromFile(), $code, $contexte); |
|
| 272 | - } |
|
| 15 | + /** |
|
| 16 | + * Determine si une chaine débute par 'NA' (non applicable) |
|
| 17 | + */ |
|
| 18 | + public static function isNa(string $chaine): bool { |
|
| 19 | + return str_starts_with(strtolower(trim($chaine)), 'na'); |
|
| 20 | + } |
|
| 21 | + |
|
| 22 | + /** |
|
| 23 | + * Retourne le chemin relatif depuis la racine de SPIP |
|
| 24 | + */ |
|
| 25 | + public static function relativePath(string $fullDirectory): string { |
|
| 26 | + if (!defined('_SPIP_TEST_CHDIR')) { |
|
| 27 | + throw new RuntimeException('_SPIP_TEST_CHDIR needs to be defined'); |
|
| 28 | + } |
|
| 29 | + |
|
| 30 | + return substr($fullDirectory, strlen(_SPIP_TEST_CHDIR) + 1); |
|
| 31 | + } |
|
| 32 | + |
|
| 33 | + /** |
|
| 34 | + * Determine si une chaine débute par 'OK' |
|
| 35 | + */ |
|
| 36 | + public static function assertOk($actual, string $message = ''): void { |
|
| 37 | + $constraint = new IsOk($actual); |
|
| 38 | + |
|
| 39 | + static::assertThat($actual, $constraint, $message); |
|
| 40 | + } |
|
| 41 | + |
|
| 42 | + /** |
|
| 43 | + * Determine si une chaine ne débute pas par 'OK' |
|
| 44 | + */ |
|
| 45 | + public static function assertNotOk($actual, string $message = ''): void { |
|
| 46 | + $constraint = new LogicalNot(new IsOk($actual)); |
|
| 47 | + |
|
| 48 | + static::assertThat($actual, $constraint, $message); |
|
| 49 | + } |
|
| 50 | + |
|
| 51 | + /** |
|
| 52 | + * Assertion qui vérifie que le résultat d’un template est 'OK' |
|
| 53 | + * |
|
| 54 | + * @example |
|
| 55 | + * $templating = new Templating(new StringLoader()); |
|
| 56 | + * $this->assertOkTemplate($templating, '[(#CONFIG{pasla}|non)ok]'); |
|
| 57 | + * |
|
| 58 | + * $templating = new Templating(new FileLoader()); |
|
| 59 | + * $this->assertOkTemplate($templating, __DIR__ . '/data/truc.html'); |
|
| 60 | + * |
|
| 61 | + * @param string $code Code ou chemin du squelette |
|
| 62 | + * @param array $contexte Contexte de calcul du squelette |
|
| 63 | + * @param string $message Message pour une eventuelle erreur |
|
| 64 | + */ |
|
| 65 | + public static function assertOkTemplate( |
|
| 66 | + Templating $templating, |
|
| 67 | + string $code, |
|
| 68 | + array $contexte = [], |
|
| 69 | + string $message = '' |
|
| 70 | + ): void { |
|
| 71 | + $actual = $templating->render($code, $contexte); |
|
| 72 | + |
|
| 73 | + static::assertOk($actual, $message); |
|
| 74 | + } |
|
| 75 | + |
|
| 76 | + /** |
|
| 77 | + * Assertion qui vérifie que le résultat d’un template est vide |
|
| 78 | + * |
|
| 79 | + * @see assertOkTemplate() |
|
| 80 | + */ |
|
| 81 | + public static function assertNotOkTemplate( |
|
| 82 | + Templating $templating, |
|
| 83 | + string $code, |
|
| 84 | + array $contexte = [], |
|
| 85 | + string $message = '' |
|
| 86 | + ): void { |
|
| 87 | + $actual = $templating->render($code, $contexte); |
|
| 88 | + |
|
| 89 | + static::assertNotOk($actual, $message); |
|
| 90 | + } |
|
| 91 | + |
|
| 92 | + /** |
|
| 93 | + * Assertion qui vérifie que le résultat d’un template est vide |
|
| 94 | + * |
|
| 95 | + * @see assertOkTemplate() |
|
| 96 | + */ |
|
| 97 | + public static function assertEmptyTemplate( |
|
| 98 | + Templating $templating, |
|
| 99 | + string $code, |
|
| 100 | + array $contexte = [], |
|
| 101 | + string $message = '' |
|
| 102 | + ): void { |
|
| 103 | + $actual = $templating->render($code, $contexte); |
|
| 104 | + |
|
| 105 | + static::assertEmpty($actual, $message); |
|
| 106 | + } |
|
| 107 | + |
|
| 108 | + /** |
|
| 109 | + * Assertion qui vérifie que le résultat d’un template n’est pas vide |
|
| 110 | + * |
|
| 111 | + * @see assertOkTemplate() |
|
| 112 | + */ |
|
| 113 | + public static function assertNotEmptyTemplate( |
|
| 114 | + Templating $templating, |
|
| 115 | + string $code, |
|
| 116 | + array $contexte = [], |
|
| 117 | + string $message = '' |
|
| 118 | + ): void { |
|
| 119 | + $actual = $templating->render($code, $contexte); |
|
| 120 | + |
|
| 121 | + static::assertNotEmpty($actual, $message); |
|
| 122 | + } |
|
| 123 | + |
|
| 124 | + /** |
|
| 125 | + * Assertion qui vérifie le résultat d’un template |
|
| 126 | + * |
|
| 127 | + * @see assertOkTemplate() |
|
| 128 | + */ |
|
| 129 | + public static function assertEqualsTemplate( |
|
| 130 | + string $expected, |
|
| 131 | + Templating $templating, |
|
| 132 | + string $code, |
|
| 133 | + array $contexte = [], |
|
| 134 | + string $message = '' |
|
| 135 | + ): void { |
|
| 136 | + $actual = $templating->render($code, $contexte); |
|
| 137 | + |
|
| 138 | + static::assertEquals($expected, $actual, $message); |
|
| 139 | + } |
|
| 140 | + |
|
| 141 | + /** |
|
| 142 | + * Assertion qui vérifie le résultat d’un template |
|
| 143 | + * |
|
| 144 | + * @see assertOkTemplate() |
|
| 145 | + */ |
|
| 146 | + public static function assertNotEqualsTemplate( |
|
| 147 | + string $expected, |
|
| 148 | + Templating $templating, |
|
| 149 | + string $code, |
|
| 150 | + array $contexte = [], |
|
| 151 | + string $message = '' |
|
| 152 | + ): void { |
|
| 153 | + $actual = $templating->render($code, $contexte); |
|
| 154 | + |
|
| 155 | + static::assertNotEquals($expected, $actual, $message); |
|
| 156 | + } |
|
| 157 | + |
|
| 158 | + /** |
|
| 159 | + * Assertion qui vérifie que le résultat d’un code de squelette est 'OK' |
|
| 160 | + * |
|
| 161 | + * @example $this->assertOkCode('[(#CONFIG{pasla}|non)ok]'); |
|
| 162 | + * |
|
| 163 | + * @param string $code Code ou chemin du squelette |
|
| 164 | + * @param array $contexte Contexte de calcul du squelette |
|
| 165 | + * @param string $message Message pour une eventuelle erreur |
|
| 166 | + */ |
|
| 167 | + public static function assertOkCode(string $code, array $contexte = [], string $message = ''): void { |
|
| 168 | + static::assertOkTemplate(Templating::fromString(), $code, $contexte); |
|
| 169 | + } |
|
| 170 | + |
|
| 171 | + /** |
|
| 172 | + * Assertion qui vérifie que le résultat d’un code de squelette n’est pas 'OK' |
|
| 173 | + * |
|
| 174 | + * @see assertOkCode() |
|
| 175 | + */ |
|
| 176 | + public function assertNotOkCode(string $code, array $contexte = [], $message = ''): void { |
|
| 177 | + static::assertNotOkTemplate(Templating::fromString(), $code, $contexte); |
|
| 178 | + } |
|
| 179 | + |
|
| 180 | + /** |
|
| 181 | + * Assertion qui vérifie que le résultat d’un code de squelette est vide |
|
| 182 | + * |
|
| 183 | + * @see assertOkCode() |
|
| 184 | + */ |
|
| 185 | + public static function assertEmptyCode(string $code, array $contexte = [], string $message = ''): void { |
|
| 186 | + static::assertEmptyTemplate(Templating::fromString(), $code, $contexte); |
|
| 187 | + } |
|
| 188 | + |
|
| 189 | + /** |
|
| 190 | + * Assertion qui vérifie que le résultat d’un code de squelette n’est pas vide |
|
| 191 | + * |
|
| 192 | + * @see assertOkCode() |
|
| 193 | + */ |
|
| 194 | + public static function assertNotEmptyCode(string $code, array $contexte = [], string $message = ''): void { |
|
| 195 | + static::assertNotEmptyTemplate(Templating::fromString(), $code, $contexte); |
|
| 196 | + } |
|
| 197 | + |
|
| 198 | + /** |
|
| 199 | + * Assertion qui vérifie le résultat d’un code de squelette |
|
| 200 | + * |
|
| 201 | + * @see assertOkCode() |
|
| 202 | + */ |
|
| 203 | + public function assertEqualsCode(string $expected, string $code, array $contexte = [], $message = ''): void { |
|
| 204 | + static::assertEqualsTemplate($expected, Templating::fromString(), $code, $contexte); |
|
| 205 | + } |
|
| 206 | + |
|
| 207 | + /** |
|
| 208 | + * Assertion qui vérifie le résultat d’un code de squelette |
|
| 209 | + * |
|
| 210 | + * @see assertOkCode() |
|
| 211 | + */ |
|
| 212 | + public function assertNotEqualsCode(string $expected, string $code, array $contexte = [], $message = '') { |
|
| 213 | + static::assertNotEqualsTemplate($expected, Templating::fromString(), $code, $contexte); |
|
| 214 | + } |
|
| 215 | + |
|
| 216 | + /** |
|
| 217 | + * Assertion qui vérifie que le résultat d’un fichier de squelette est 'OK' |
|
| 218 | + * |
|
| 219 | + * @example $this->assertOkSquelette(__DIR__ . '/data/squelette.html'); |
|
| 220 | + * |
|
| 221 | + * @param string $code Code ou chemin du squelette |
|
| 222 | + * @param array $contexte Contexte de calcul du squelette |
|
| 223 | + * @param string $message Message pour une eventuelle erreur |
|
| 224 | + */ |
|
| 225 | + public static function assertOkSquelette(string $code, array $contexte = [], string $message = ''): void { |
|
| 226 | + static::assertOkTemplate(Templating::fromFile(), $code, $contexte); |
|
| 227 | + } |
|
| 228 | + |
|
| 229 | + /** |
|
| 230 | + * Assertion qui vérifie que le résultat d’un fichier de squelette n’est pas 'OK' |
|
| 231 | + * |
|
| 232 | + * @see assertOkSquelette() |
|
| 233 | + */ |
|
| 234 | + public function assertNotOkSquelette(string $code, array $contexte = [], $message = ''): void { |
|
| 235 | + static::assertNotOkTemplate(Templating::fromFile(), $code, $contexte); |
|
| 236 | + } |
|
| 237 | + |
|
| 238 | + /** |
|
| 239 | + * Assertion qui vérifie que le résultat d’un fichier de squelette est vide |
|
| 240 | + * |
|
| 241 | + * @see assertOkSquelette() |
|
| 242 | + */ |
|
| 243 | + public static function assertEmptySquelette(string $code, array $contexte = [], string $message = ''): void { |
|
| 244 | + static::assertEmptyTemplate(Templating::fromFile(), $code, $contexte); |
|
| 245 | + } |
|
| 246 | + |
|
| 247 | + /** |
|
| 248 | + * Assertion qui vérifie que le résultat d’un fichier de squelette n’est pas vide |
|
| 249 | + * |
|
| 250 | + * @see assertOkSquelette() |
|
| 251 | + */ |
|
| 252 | + public static function assertNotEmptySquelette(string $code, array $contexte = [], string $message = ''): void { |
|
| 253 | + static::assertNotEmptyTemplate(Templating::fromFile(), $code, $contexte); |
|
| 254 | + } |
|
| 255 | + |
|
| 256 | + /** |
|
| 257 | + * Assertion qui vérifie le résultat d’un fichier de squelette |
|
| 258 | + * |
|
| 259 | + * @see assertOkSquelette() |
|
| 260 | + */ |
|
| 261 | + public function assertEqualsSquelette(string $expected, string $code, array $contexte = [], $message = ''): void { |
|
| 262 | + static::assertEqualsTemplate($expected, Templating::fromFile(), $code, $contexte); |
|
| 263 | + } |
|
| 264 | + |
|
| 265 | + /** |
|
| 266 | + * Assertion qui vérifie le résultat d’un fichier de squelette |
|
| 267 | + * |
|
| 268 | + * @see assertOkSquelette() |
|
| 269 | + */ |
|
| 270 | + public function assertNotEqualsSquelette(string $expected, string $code, array $contexte = [], $message = '') { |
|
| 271 | + static::assertNotEqualsTemplate($expected, Templating::fromFile(), $code, $contexte); |
|
| 272 | + } |
|
| 273 | 273 | } |
