HtmlFormatter.php

Go to the documentation of this file.

<?php

namespace Elgg\Views;

use Elgg\Exceptions\InvalidArgumentException;
use Elgg\PluginHooksService;
use Elgg\Traits\Loggable;
use Elgg\ViewsService;
use Pelago\Emogrifier\CssInliner;

class HtmlFormatter {

    use Loggable;

    protected $views;

    protected $hooks;

    protected $autop;

    public function __construct(
        ViewsService $views,
        PluginHooksService $hooks,
        \ElggAutoP $autop
    ) {
        $this->views = $views;
        $this->hooks = $hooks;
        $this->autop = $autop;
    }

    public function formatBlock($html, array $options = []) {
        if (!is_string($html)) {
            return '';
        }

        $options = array_merge([
            'parse_urls' => true,
            'parse_emails' => true,
            'sanitize' => true,
            'autop' => true,
        ], $options);

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

        $params = $this->hooks->trigger('prepare', 'html', null, $params);

        $html = elgg_extract('html', $params);
        $options = 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('sanitize', $options)) {
            $html = filter_tags($html);
        }

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

        return $html;
    }

    public function parseUrls($text) {

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

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

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

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

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

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

        $attributes = [];

        foreach ($attrs as $attr => $val) {
            if (0 !== strpos($attr, 'data-') && false !== strpos($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($tag_name, array $attributes = [], $text = '', array $options = []) {
        if (is_array($tag_name)) {
            $args = $tag_name;

            if ($attributes !== [] || $text !== '' || $options !== []) {
                throw new InvalidArgumentException('If $tag_name is an array, the other arguments must not be set');
            }

            if (isset($args['#tag_name'])) {
                $tag_name = $args['#tag_name'];
            }
            if (isset($args['#text'])) {
                $text = $args['#text'];
            }
            if (isset($args['#options'])) {
                $options = $args['#options'];
            }

            unset($args['#tag_name'], $args['#text'], $args['#options']);
            $attributes = $args;
        }

        if (!is_string($tag_name) || $tag_name === '') {
            throw new InvalidArgumentException('$tag_name is required');
        }

        if (isset($options['is_void'])) {
            $is_void = $options['is_void'];
        } else {
            // from http://www.w3.org/TR/html-markup/syntax.html#syntax-elements
            $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']) ? false : true;
            $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, $allowable_tags = null) {
        if (!isset($string)) {
            return '';
        }

        $params = [
            'original_string' => $string,
            'allowable_tags' => $allowable_tags,
        ];

        $string = strip_tags($string, $allowable_tags);
        $string = $this->hooks->trigger('format', 'strip_tags', $params, $string);

        return $string;
    }

    public function decode($string) {
        if (!isset($string)) {
            return '';
        }
        
        $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');
        $string = str_replace(
            ['&amp;gt;', '&amp;lt;', '&amp;amp;', '&amp;quot;', '&amp;#039;'],
            ['&gt;', '&lt;', '&amp;', '&quot;', '&#039;'],
            $string
        );
        return $string;
    }
    
    public function inlineCss(string $html, string $css, bool $body_only = false): string {
        if (empty($html) || empty($css)) {
            return $html;
        }
        
        $inliner = CssInliner::fromHtml($html)->disableStyleBlocksParsing()->inlineCss($css);
        
        return $body_only ? $inliner->renderBodyContent() : $inliner->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;
    }
}