Tronque une chaine de caractères en XHTML

                               

                            
/*------------------------------*/
/*
 Titre : Tronque une chaine de caractères en XHTML                                                                       
                                                                                                                          
 Auteur           : KOogar                                                                                                
 Date édition     : 14 Mars 2026                                                                                         
 Date mise a jour : 14 Mars 2026
                                                                                         
 Rapport de la maj:                                                                                                       
  - fonctionnement du code vérifié                                                                                  
*/
/*------------------------------*/

declare(strict_types=1);

const NODE_TYPE_START       = 0;
const NODE_TYPE_ELEMENT     = 1;
const NODE_TYPE_ENDELEMENT  = 2;
const NODE_TYPE_TEXT        = 3;
const NODE_TYPE_COMMENT     = 4;
const NODE_TYPE_DONE        = 5;
const NODE_TYPE_ELEMENT_END = 6;

final class HtmlParser
{
    private int $nodeType = NODE_TYPE_START;
    private string $nodeName = '';
    private string $nodeValue = '';
    /** @var array<string, string> */
    private array $nodeAttributes = [];
    private int $nodeStart = 0;
    private int $nodeEnd = 0;

    private readonly string $htmlText;
    private readonly int $htmlLength;
    private int $index = 0;
    private string $currentChar = '';

    private bool $noComment = false;

    /** @var list<string> Balises auto-fermantes (self-closing) */
    private readonly array $selfClosingTags;

    private const BLANKS           = [' ', "\t", "\r", "\n"];
    private const BLANKS_OR_EQUALS = [' ', "\t", "\r", "\n", '='];
    private const BLANKS_OR_SLASH  = [' ', "\t", "\r", "\n", '/'];

    public function __construct(string $html)
    {
        $this->htmlText   = $html;
        $this->htmlLength = strlen($html);
        $this->selfClosingTags = ['hr', 'br', 'input', 'meta', 'link', 'img', 
'area', 'param'];

        $this->setIndex(0);
    }

    public function parse(): bool
    {
        $this->nodeStart = $this->index;

        $text = $this->skipToElement();
        if ($text !== '') {
            $this->nodeType      = NODE_TYPE_TEXT;
            $this->nodeName      = 'Text';
            $this->nodeValue     = $text;
            $this->nodeEnd       = $this->index;
            return true;
        }

        return $this->readTag();
    }

    public function getNodeType(): int
    {
        return $this->nodeType;
    }

    public function getNodeName(): string
    {
        return $this->nodeName;
    }

    public function getNodeValue(): string
    {
        return $this->nodeValue;
    }

    /** @return array<string, string> */
    public function getAttributes(): array
    {
        return $this->nodeAttributes;
    }

    public function getNodeStart(): int
    {
        return $this->nodeStart;
    }

    public function getNodeEnd(): int
    {
        return $this->nodeEnd;
    }

    private function clearAttributes(): void
    {
        $this->nodeAttributes = [];
    }

    private function readTag(): bool
    {
        if ($this->currentChar !== '<') {
            $this->nodeType = NODE_TYPE_DONE;
            return false;
        }

        $this->clearAttributes();
        $this->skipMaxInTag('<', 1);

        if ($this->currentChar === '/') {
            $this->moveNext();
            $name = $this->skipToBlanksInTag();

            if (strtolower($name) === 'script') {
                $this->noComment = false;
            }

            $this->nodeType  = NODE_TYPE_ENDELEMENT;
            $this->nodeName  = $name;
            $this->nodeValue = '';

            $this->skipEndOfTag();
            $this->nodeEnd = $this->index;
            return true;
        }

        $name = $this->skipToBlanksOrSlashInTag();

        if (!$this->isValidTagIdentifier($name)) {
            if (!$this->noComment && str_starts_with($name, '!--')) {
                if (str_ends_with($name, '--')) {
                    $this->nodeType  = NODE_TYPE_COMMENT;
                    $this->nodeName  = 'Comment';
                    $this->nodeValue = '<' . $name . '>';
                    $this->nodeEnd   = $this->index;
                    return true;
                }

                $rest = $this->skipToStringInTag('-->');
                if ($rest !== '') {
                    $this->nodeType  = NODE_TYPE_COMMENT;
                    $this->nodeName  = 'Comment';
                    $this->nodeValue = '<' . $name . $rest;
                    $this->nodeEnd   = $this->index;
                    return true;
                }
            }

            
// Cas fallback : texte qui commence par < mais n'est pas une balise valide
            $this->nodeType  = NODE_TYPE_TEXT;
            $this->nodeName  = 'Text';
            $this->nodeValue = '<' . $name;
            $this->nodeEnd   = $this->index;
            return true;
        }

        if (strtolower($name) === 'script') {
            $this->noComment = true;
        }

        $this->nodeType  = NODE_TYPE_ELEMENT;
        $this->nodeValue = '';
        $this->nodeName  = $name;

        while ($this->skipBlanksInTag()) {
            $attrName = $this->skipToBlanksOrEqualsInTag();

            if ($attrName === '' || $attrName === '/') {
                continue;
            }

            $this->skipBlanksInTag();

            if ($this->currentChar === '=') {
                $this->skipEqualsInTag();
                $this->skipBlanksInTag();
                $value = $this->readValueInTag();
                $this->nodeAttributes[strtolower($attrName)] = $value;
            } else {
                $this->nodeAttributes[strtolower($attrName)] = '';
                $this->setIndex($this->index - 1);
            }
        }

        // Détection balise auto-fermante
        $lastChar = $this->htmlText[$this->index - 1] ?? '';
        if ($lastChar === '/' || in_array(strtolower($this->nodeName), $this->
selfClosingTags, true)) {
            $this->nodeType = NODE_TYPE_ELEMENT_END;
        }

        $this->skipEndOfTag();
        $this->nodeEnd = $this->index;

        return true;
    }

    private function isValidTagIdentifier(string $name): bool
    {
        return preg_match('/^[A-Za-z0-9_\-]+$/', $name) === 1;
    }

    private function skipBlanksInTag(): bool
    {
        return $this->skipInTag(self::BLANKS) !== '';
    }

    private function skipToBlanksOrEqualsInTag(): string
    {
        return $this->skipToInTag(self::BLANKS_OR_EQUALS);
    }

    private function skipToBlanksInTag(): string
    {
        return $this->skipToInTag(self::BLANKS);
    }

    private function skipToBlanksOrSlashInTag(): string
    {
        return $this->skipToInTag(self::BLANKS_OR_SLASH);
    }

    private function skipEqualsInTag(): string
    {
        return $this->skipMaxInTag('=', 1);
    }

    private function readValueInTag(): string
    {
        $ch = $this->currentChar;

        if ($ch === '"') {
            $this->skipMaxInTag('"', 1);
            $value = $this->skipToInTag(['"']);
            $this->skipMaxInTag('"', 1);
            return $value;
        }

        if ($ch === "'") {
            $this->skipMaxInTag("'", 1);
            $value = $this->skipToInTag(["'"]);
            $this->skipMaxInTag("'", 1);
            return $value;
        }

        return $this->skipToBlanksInTag();
    }

    private function setIndex(int $index): void
    {
        $this->index = $index;

        if ($index >= $this->htmlLength) {
            $this->currentChar = '';
        } else {
            $this->currentChar = $this->htmlText[$index];
        }
    }

    private function moveNext(): bool
    {
        if ($this->index < $this->htmlLength) {
            $this->setIndex($this->index + 1);
            return true;
        }
        return false;
    }

    private function skipEndOfTag(): void
    {
        while ($this->currentChar !== '' && $this->currentChar !== '>') {
            $this->moveNext();
        }
        if ($this->currentChar === '>') {
            $this->moveNext();
        }
    }

    private function skipInTag(array $chars): string
    {
        $sb = '';

        while ($this->currentChar !== '' && $this->currentChar !== '>') {
            if (!in_array($this->currentChar, $chars, true)) {
                return $sb;
            }
            $sb .= $this->currentChar;
            $this->moveNext();
        }

        return $sb;
    }

    private function skipMaxInTag(string $char, int $max): string
    {
        $sb = '';
        $count = 0;

        while ($this->currentChar !== '' && $count < $max && $this->currentChar 
!== '>') {
            if ($this->currentChar !== $char) {
                return $sb;
            }
            $sb .= $this->currentChar;
            $this->moveNext();
            $count++;
        }

        return $sb;
    }

    private function skipToInTag(array $chars): string
    {
        $sb = '';

        while ($this->currentChar !== '') {
            if ($this->currentChar === '>' || in_array($this->currentChar, 
$chars, true)) {
                return $sb;
            }
            $sb .= $this->currentChar;
            $this->moveNext();
        }

        return $sb;
    }

    private function skipToElement(): string
    {
        $sb = '';

        while ($this->currentChar !== '') {
            if ($this->currentChar === '<') {
                return $sb;
            }
            $sb .= $this->currentChar;
            $this->moveNext();
        }

        return $sb;
    }

    private function skipToStringInTag(string $needle): string
    {
        $pos = strpos($this->htmlText, $needle, $this->index);

        if ($pos === false) {
            return '';
        }

        $length = strlen($needle);
        $top    = $pos + $length;
        $result = substr($this->htmlText, $this->index, $top - $this->index);

        $this->setIndex($top);

        return $result;
    }
}

/**
 * Crée un HtmlParser à partir d'un fichier local ou distant
 */
function htmlParserFromFile(string $filename): HtmlParser
{
    return htmlParserFromUrl($filename);
}

function htmlParserFromUrl(string $url): HtmlParser
{
    $content = file_get_contents($url);
    if ($content === false) {
        throw new RuntimeException("Impossible de lire le contenu depuis : $url"
);
    }
    return new HtmlParser($content);
}

/**

 * Tronque du HTML en respectant les balises et en coupant au plus près de la longueur souhaitée
 * (en comptant les caractères visibles, hors balises).
 *
 * @param string $html      HTML source

 * @param int    $maxLength Longueur maximale cible du texte visible (hors balises)

 * @param string $separator Caractère(s) sur lequel préférer couper (espace par défaut)
 * @param string $suffix    Suffixe ajouté à la fin (" ..." par défaut)
 * @return string           HTML tronqué avec balises correctement fermées
 */
function tronqueHtml(string $html, int $maxLength, string $separator = ' ', 
string $suffix = ' ...'): string
{
    $visibleLength = mb_strlen(strip_tags($html), 'UTF-8');
    if ($visibleLength <= $maxLength) {
        return $html;
    }

    $openedTags = [];           // pile des balises ouvertes
    $currentVisible = 0;        // compteur de caractères visibles cumulés
    $cutPosition = 0;           // position octet où couper dans $html
    $parser = new HtmlParser($html);

    while ($parser->parse()) {
        $type = $parser->getNodeType();
        $nodeStart = $parser->getNodeStart();
        $nodeEnd   = $parser->getNodeEnd();

        if ($type === NODE_TYPE_ELEMENT) {
            $openedTags[] = $parser->getNodeName();
        } elseif ($type === NODE_TYPE_ENDELEMENT) {
            // On pop même si pas exactement la bonne balise (tolérance)
            if ($openedTags) {
                array_pop($openedTags);
            }
        } elseif ($type === NODE_TYPE_TEXT) {
            $text = $parser->getNodeValue();
            $textVisibleLen = mb_strlen($text, 'UTF-8');

            if ($currentVisible + $textVisibleLen > $maxLength) {
                // On va devoir couper dans ce nœud texte
                $remaining = $maxLength - $currentVisible;

                
// On cherche la dernière occurrence du séparateur dans les $remaining
// caractères
                $safeText = mb_substr($text, 0, $remaining + mb_strlen(
$separator, 'UTF-8'), 'UTF-8');
                $lastSepPos = mb_strrpos($safeText, $separator, 0, 'UTF-8');

                if ($lastSepPos !== false && $lastSepPos > 0) {
                    $cutVisibleOffset = $lastSepPos;
                } else {
                    // Pas de séparateur ? on coupe au caractère près
                    $cutVisibleOffset = $remaining;
                }

                // Position octet dans le HTML original
                $cutPosition = $nodeStart + mb_strlen(
                    mb_substr($text, 0, $cutVisibleOffset, 'UTF-8'),
                    'UTF-8'
                );

                // On arrête ici
                break;
            }

            // On continue : tout le texte est pris
            $currentVisible += $textVisibleLen;
            $cutPosition = $nodeEnd;
        }
        // Les commentaires, etc. ? on ignore pour le comptage visible
    }

    // Si on n'a pas coupé (cas limite), on prend tout
    if ($cutPosition === 0) {
        $cutPosition = strlen($html);
    }

    $result = substr($html, 0, $cutPosition) . $suffix;

    // Fermeture des balises encore ouvertes (LIFO)
    while ($openedTags) {
        $tag = array_pop($openedTags);
        $result .= '</' . $tag . '>';
    }

    return $result;
}
?>