HtmlFormatter.php

Go to the documentation of this file.

<?php

namespace Elgg\Views;

use Elgg\EventsService;
use Elgg\Exceptions\Configuration\RegistrationException;
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Traits\Loggable;
use Elgg\ViewsService;
use Pelago\Emogrifier\CssInliner;
use Pelago\Emogrifier\HtmlProcessor\CssToAttributeConverter;

class HtmlFormatter {

    use Loggable;
    
    public const MENTION_REGEX = '/<a[^>]*?>.*?<\/a>|<.*?>|(^|\s|\!|\.|\?|>|\G)+(@([^\s<&]+))/iu';

    public function __construct(
        protected ViewsService $views,
        protected EventsService $events,
        protected AutoParagraph $autop
    ) {
    }

    public function formatBlock(string $html, array $options = []): string {
        $options = array_merge([
            'parse_urls' => true,
            'parse_emails' => true,
            'parse_mentions' => true,
            'sanitize' => true,
            'autop' => true,
        ], $options);

        $params = [
            'options' => $options,
            'html' => $html,
        ];

        $params = $this->events->triggerResults('prepare', 'html', [], $params);

        $html = (string) elgg_extract('html', $params);
        $options = (array) elgg_extract('options', $params);

        if (elgg_extract('parse_urls', $options)) {
            $html = $this->parseUrls($html);
        }

        if (elgg_extract('parse_emails', $options)) {
            $html = $this->parseEmails($html);
        }
        
        if (elgg_extract('parse_mentions', $options)) {
            $html = $this->parseMentions($html);
        }

        if (elgg_extract('sanitize', $options)) {
            $html = elgg_sanitize_input($html);
        }

        if (elgg_extract('autop', $options)) {
            $html = $this->addParagaraphs($html);
        }

        return $html;
    }

    public function parseUrls(string $text): string {

        $linkify = new \Misd\Linkify\Linkify();

        return $linkify->processUrls($text, ['attr' => ['rel' => 'nofollow']]);
    }

    public function parseEmails(string $text): string {
        $linkify = new \Misd\Linkify\Linkify();

        return $linkify->processEmails($text, ['attr' => ['rel' => 'nofollow']]);
    }
    
    public function parseMentions(string $text): string {
        $callback = function (array $matches) {
            $source = elgg_extract(0, $matches);
            $preceding_char = elgg_extract(1, $matches);
            $username = elgg_extract(3, $matches);
            
            if (empty($username)) {
                return $source;
            }
            
            try {
                _elgg_services()->accounts->assertValidUsername($username);
            } catch (RegistrationException $e) {
                return $source;
            }
            
            $user = elgg_get_user_by_username($username);
            
            // Catch the trailing period when used as punctuation and not a username.
            $period = '';
            if (!$user && str_ends_with($username, '.')) {
                $user = elgg_get_user_by_username(substr($username, 0, -1));
                $period = '.';
            }
            
            if (!$user) {
                return $source;
            }
            
            if (elgg_get_config('mentions_display_format') === 'username') {
                $replacement = elgg_view_url($user->getURL(), "@{$user->username}");
            } else {
                $replacement = elgg_view_url($user->getURL(), $user->getDisplayName());
            }
            
            return $preceding_char . $replacement . $period;
        };
        
        return preg_replace_callback(self::MENTION_REGEX, $callback, $text) ?? $text;
    }

    public function addParagaraphs(string $string): string {
        try {
            $result = $this->autop->process($string);
            if ($result !== false) {
                return $result;
            }
        } catch (\RuntimeException $e) {
            $this->getLogger()->warning('AutoParagraph failed to process the string: ' . $e->getMessage());
        }
        
        return $string;
    }

    public function formatAttributes(array $attrs = []): string {
        if (empty($attrs)) {
            return '';
        }

        $attributes = [];

        foreach ($attrs as $attr => $val) {
            if (!str_starts_with($attr, 'data-') && str_contains($attr, '_')) {
                // this is probably a view $vars variable not meant for output
                continue;
            }

            $attr = strtolower($attr);

            if (!isset($val) || $val === false) {
                continue;
            }

            if ($val === true) {
                $val = $attr; //e.g. checked => true ==> checked="checked"
            }

            if (is_array($val) && empty($val)) {
                //e.g. ['class' => []]
                continue;
            }
            
            if (is_scalar($val)) {
                $val = [$val];
            }

            if (!is_array($val)) {
                continue;
            }

            // Check if array contains non-scalar values and bail if so
            $filtered_val = array_filter($val, function($e) {
                return is_scalar($e);
            });

            if (count($val) != count($filtered_val)) {
                continue;
            }

            $val = implode(' ', $val);

            $val = htmlspecialchars($val, ENT_QUOTES, 'UTF-8', false);
            $attributes[] = "$attr=\"$val\"";
        }

        return implode(' ', $attributes);
    }

    public function formatElement(string $tag_name, array $attributes = [], string $text = '', array $options = []): string {
        if ($tag_name === '') {
            throw new InvalidArgumentException('$tag_name is required');
        }
        
        // from http://www.w3.org/TR/html-markup/syntax.html#syntax-elements
        $is_void = $options['is_void'] ?? in_array(strtolower($tag_name), [
            'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem',
            'meta', 'param', 'source', 'track', 'wbr'
        ]);

        if (!empty($options['encode_text']) && is_string($text)) {
            $double_encode = !empty($options['double_encode']);
            $text = htmlspecialchars($text, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8', $double_encode);
        }

        $attrs = '';
        if (!empty($attributes)) {
            $attrs = $this->formatAttributes($attributes);
            if ($attrs !== '') {
                $attrs = " $attrs";
            }
        }

        if ($is_void) {
            return empty($options['is_xml']) ? "<{$tag_name}{$attrs}>" : "<{$tag_name}{$attrs} />";
        }
        
        return "<{$tag_name}{$attrs}>$text</$tag_name>";
    }

    public function stripTags(string $string, ?string $allowable_tags = null): string {
        $params = [
            'original_string' => $string,
            'allowable_tags' => $allowable_tags,
        ];

        $string = strip_tags($string, $allowable_tags);
        return (string) $this->events->triggerResults('format', 'strip_tags', $params, $string);
    }

    public function decode(string $string): string {
        $string = str_replace(
            ['&gt;', '&lt;', '&amp;', '&quot;', '&#039;'],
            ['&amp;gt;', '&amp;lt;', '&amp;amp;', '&amp;quot;', '&amp;#039;'],
            $string
        );
        $string = html_entity_decode($string, ENT_NOQUOTES, 'UTF-8');
        return str_replace(
            ['&amp;gt;', '&amp;lt;', '&amp;amp;', '&amp;quot;', '&amp;#039;'],
            ['&gt;', '&lt;', '&amp;', '&quot;', '&#039;'],
            $string
        );
    }
    
    public function inlineCss(string $html, string $css, bool $body_only = false): string {
        if (empty($html) || empty($css)) {
            return $html;
        }
        
        $html_with_inlined_css = CssInliner::fromHtml($html)->disableStyleBlocksParsing()->inlineCss($css)->render();
        $inlined_attribute_converter = CssToAttributeConverter::fromHtml($html_with_inlined_css)->convertCssToVisualAttributes();
        
        return $body_only ? $inlined_attribute_converter->renderBodyContent() : $inlined_attribute_converter->render();
    }
    
    public function normalizeUrls(string $text): string {
        $pattern = '/\s(?:href|src)=([\'"]\S+[\'"])/i';
        
        // find all matches
        $matches = [];
        preg_match_all($pattern, $text, $matches);
        
        if (empty($matches) || !isset($matches[1])) {
            return $text;
        }
        
        // go through all the matches
        $urls = $matches[1];
        $urls = array_unique($urls);
        
        foreach ($urls as $url) {
            // remove wrapping quotes from the url
            $real_url = substr($url, 1, -1);
            // normalize url
            $new_url = elgg_normalize_url($real_url);
            // make the correct replacement string
            $replacement = str_replace($real_url, $new_url, $url);
            
            // replace the url in the content
            $text = str_replace($url, $replacement, $text);
        }
        
        return $text;
    }
}