remove autoload section in composer.json

[github/wallabag/wallabag.git] / inc / 3rdparty / htmlpurifier / HTMLPurifier / HTMLDefinition.php

<?php\r
\r
/**\r
 * Definition of the purified HTML that describes allowed children,\r
 * attributes, and many other things.\r
 *\r
 * Conventions:\r
 *\r
 * All member variables that are prefixed with info\r
 * (including the main $info array) are used by HTML Purifier internals\r
 * and should not be directly edited when customizing the HTMLDefinition.\r
 * They can usually be set via configuration directives or custom\r
 * modules.\r
 *\r
 * On the other hand, member variables without the info prefix are used\r
 * internally by the HTMLDefinition and MUST NOT be used by other HTML\r
 * Purifier internals. Many of them, however, are public, and may be\r
 * edited by userspace code to tweak the behavior of HTMLDefinition.\r
 *\r
 * @note This class is inspected by Printer_HTMLDefinition; please\r
 *       update that class if things here change.\r
 *\r
 * @warning Directives that change this object's structure must be in\r
 *          the HTML or Attr namespace!\r
 */\r
class HTMLPurifier_HTMLDefinition extends HTMLPurifier_Definition\r
{\r
\r
    // FULLY-PUBLIC VARIABLES ---------------------------------------------\r
\r
    /**\r
     * Associative array of element names to HTMLPurifier_ElementDef.\r
     * @type HTMLPurifier_ElementDef[]\r
     */\r
    public $info = array();\r
\r
    /**\r
     * Associative array of global attribute name to attribute definition.\r
     * @type array\r
     */\r
    public $info_global_attr = array();\r
\r
    /**\r
     * String name of parent element HTML will be going into.\r
     * @type string\r
     */\r
    public $info_parent = 'div';\r
\r
    /**\r
     * Definition for parent element, allows parent element to be a\r
     * tag that's not allowed inside the HTML fragment.\r
     * @type HTMLPurifier_ElementDef\r
     */\r
    public $info_parent_def;\r
\r
    /**\r
     * String name of element used to wrap inline elements in block context.\r
     * @type string\r
     * @note This is rarely used except for BLOCKQUOTEs in strict mode\r
     */\r
    public $info_block_wrapper = 'p';\r
\r
    /**\r
     * Associative array of deprecated tag name to HTMLPurifier_TagTransform.\r
     * @type array\r
     */\r
    public $info_tag_transform = array();\r
\r
    /**\r
     * Indexed list of HTMLPurifier_AttrTransform to be performed before validation.\r
     * @type HTMLPurifier_AttrTransform[]\r
     */\r
    public $info_attr_transform_pre = array();\r
\r
    /**\r
     * Indexed list of HTMLPurifier_AttrTransform to be performed after validation.\r
     * @type HTMLPurifier_AttrTransform[]\r
     */\r
    public $info_attr_transform_post = array();\r
\r
    /**\r
     * Nested lookup array of content set name (Block, Inline) to\r
     * element name to whether or not it belongs in that content set.\r
     * @type array\r
     */\r
    public $info_content_sets = array();\r
\r
    /**\r
     * Indexed list of HTMLPurifier_Injector to be used.\r
     * @type HTMLPurifier_Injector[]\r
     */\r
    public $info_injector = array();\r
\r
    /**\r
     * Doctype object\r
     * @type HTMLPurifier_Doctype\r
     */\r
    public $doctype;\r
\r
\r
\r
    // RAW CUSTOMIZATION STUFF --------------------------------------------\r
\r
    /**\r
     * Adds a custom attribute to a pre-existing element\r
     * @note This is strictly convenience, and does not have a corresponding\r
     *       method in HTMLPurifier_HTMLModule\r
     * @param string $element_name Element name to add attribute to\r
     * @param string $attr_name Name of attribute\r
     * @param mixed $def Attribute definition, can be string or object, see\r
     *             HTMLPurifier_AttrTypes for details\r
     */\r
    public function addAttribute($element_name, $attr_name, $def)\r
    {\r
        $module = $this->getAnonymousModule();\r
        if (!isset($module->info[$element_name])) {\r
            $element = $module->addBlankElement($element_name);\r
        } else {\r
            $element = $module->info[$element_name];\r
        }\r
        $element->attr[$attr_name] = $def;\r
    }\r
\r
    /**\r
     * Adds a custom element to your HTML definition\r
     * @see HTMLPurifier_HTMLModule::addElement() for detailed\r
     *       parameter and return value descriptions.\r
     */\r
    public function addElement($element_name, $type, $contents, $attr_collections, $attributes = array())\r
    {\r
        $module = $this->getAnonymousModule();\r
        // assume that if the user is calling this, the element\r
        // is safe. This may not be a good idea\r
        $element = $module->addElement($element_name, $type, $contents, $attr_collections, $attributes);\r
        return $element;\r
    }\r
\r
    /**\r
     * Adds a blank element to your HTML definition, for overriding\r
     * existing behavior\r
     * @param string $element_name\r
     * @return HTMLPurifier_ElementDef\r
     * @see HTMLPurifier_HTMLModule::addBlankElement() for detailed\r
     *       parameter and return value descriptions.\r
     */\r
    public function addBlankElement($element_name)\r
    {\r
        $module  = $this->getAnonymousModule();\r
        $element = $module->addBlankElement($element_name);\r
        return $element;\r
    }\r
\r
    /**\r
     * Retrieves a reference to the anonymous module, so you can\r
     * bust out advanced features without having to make your own\r
     * module.\r
     * @return HTMLPurifier_HTMLModule\r
     */\r
    public function getAnonymousModule()\r
    {\r
        if (!$this->_anonModule) {\r
            $this->_anonModule = new HTMLPurifier_HTMLModule();\r
            $this->_anonModule->name = 'Anonymous';\r
        }\r
        return $this->_anonModule;\r
    }\r
\r
    private $_anonModule = null;\r
\r
    // PUBLIC BUT INTERNAL VARIABLES --------------------------------------\r
\r
    /**\r
     * @type string\r
     */\r
    public $type = 'HTML';\r
\r
    /**\r
     * @type HTMLPurifier_HTMLModuleManager\r
     */\r
    public $manager;\r
\r
    /**\r
     * Performs low-cost, preliminary initialization.\r
     */\r
    public function __construct()\r
    {\r
        $this->manager = new HTMLPurifier_HTMLModuleManager();\r
    }\r
\r
    /**\r
     * @param HTMLPurifier_Config $config\r
     */\r
    protected function doSetup($config)\r
    {\r
        $this->processModules($config);\r
        $this->setupConfigStuff($config);\r
        unset($this->manager);\r
\r
        // cleanup some of the element definitions\r
        foreach ($this->info as $k => $v) {\r
            unset($this->info[$k]->content_model);\r
            unset($this->info[$k]->content_model_type);\r
        }\r
    }\r
\r
    /**\r
     * Extract out the information from the manager\r
     * @param HTMLPurifier_Config $config\r
     */\r
    protected function processModules($config)\r
    {\r
        if ($this->_anonModule) {\r
            // for user specific changes\r
            // this is late-loaded so we don't have to deal with PHP4\r
            // reference wonky-ness\r
            $this->manager->addModule($this->_anonModule);\r
            unset($this->_anonModule);\r
        }\r
\r
        $this->manager->setup($config);\r
        $this->doctype = $this->manager->doctype;\r
\r
        foreach ($this->manager->modules as $module) {\r
            foreach ($module->info_tag_transform as $k => $v) {\r
                if ($v === false) {\r
                    unset($this->info_tag_transform[$k]);\r
                } else {\r
                    $this->info_tag_transform[$k] = $v;\r
                }\r
            }\r
            foreach ($module->info_attr_transform_pre as $k => $v) {\r
                if ($v === false) {\r
                    unset($this->info_attr_transform_pre[$k]);\r
                } else {\r
                    $this->info_attr_transform_pre[$k] = $v;\r
                }\r
            }\r
            foreach ($module->info_attr_transform_post as $k => $v) {\r
                if ($v === false) {\r
                    unset($this->info_attr_transform_post[$k]);\r
                } else {\r
                    $this->info_attr_transform_post[$k] = $v;\r
                }\r
            }\r
            foreach ($module->info_injector as $k => $v) {\r
                if ($v === false) {\r
                    unset($this->info_injector[$k]);\r
                } else {\r
                    $this->info_injector[$k] = $v;\r
                }\r
            }\r
        }\r
        $this->info = $this->manager->getElements();\r
        $this->info_content_sets = $this->manager->contentSets->lookup;\r
    }\r
\r
    /**\r
     * Sets up stuff based on config. We need a better way of doing this.\r
     * @param HTMLPurifier_Config $config\r
     */\r
    protected function setupConfigStuff($config)\r
    {\r
        $block_wrapper = $config->get('HTML.BlockWrapper');\r
        if (isset($this->info_content_sets['Block'][$block_wrapper])) {\r
            $this->info_block_wrapper = $block_wrapper;\r
        } else {\r
            trigger_error(\r
                'Cannot use non-block element as block wrapper',\r
                E_USER_ERROR\r
            );\r
        }\r
\r
        $parent = $config->get('HTML.Parent');\r
        $def = $this->manager->getElement($parent, true);\r
        if ($def) {\r
            $this->info_parent = $parent;\r
            $this->info_parent_def = $def;\r
        } else {\r
            trigger_error(\r
                'Cannot use unrecognized element as parent',\r
                E_USER_ERROR\r
            );\r
            $this->info_parent_def = $this->manager->getElement($this->info_parent, true);\r
        }\r
\r
        // support template text\r
        $support = "(for information on implementing this, see the support forums) ";\r
\r
        // setup allowed elements -----------------------------------------\r
\r
        $allowed_elements = $config->get('HTML.AllowedElements');\r
        $allowed_attributes = $config->get('HTML.AllowedAttributes'); // retrieve early\r
\r
        if (!is_array($allowed_elements) && !is_array($allowed_attributes)) {\r
            $allowed = $config->get('HTML.Allowed');\r
            if (is_string($allowed)) {\r
                list($allowed_elements, $allowed_attributes) = $this->parseTinyMCEAllowedList($allowed);\r
            }\r
        }\r
\r
        if (is_array($allowed_elements)) {\r
            foreach ($this->info as $name => $d) {\r
                if (!isset($allowed_elements[$name])) {\r
                    unset($this->info[$name]);\r
                }\r
                unset($allowed_elements[$name]);\r
            }\r
            // emit errors\r
            foreach ($allowed_elements as $element => $d) {\r
                $element = htmlspecialchars($element); // PHP doesn't escape errors, be careful!\r
                trigger_error("Element '$element' is not supported $support", E_USER_WARNING);\r
            }\r
        }\r
\r
        // setup allowed attributes ---------------------------------------\r
\r
        $allowed_attributes_mutable = $allowed_attributes; // by copy!\r
        if (is_array($allowed_attributes)) {\r
            // This actually doesn't do anything, since we went away from\r
            // global attributes. It's possible that userland code uses\r
            // it, but HTMLModuleManager doesn't!\r
            foreach ($this->info_global_attr as $attr => $x) {\r
                $keys = array($attr, "*@$attr", "*.$attr");\r
                $delete = true;\r
                foreach ($keys as $key) {\r
                    if ($delete && isset($allowed_attributes[$key])) {\r
                        $delete = false;\r
                    }\r
                    if (isset($allowed_attributes_mutable[$key])) {\r
                        unset($allowed_attributes_mutable[$key]);\r
                    }\r
                }\r
                if ($delete) {\r
                    unset($this->info_global_attr[$attr]);\r
                }\r
            }\r
\r
            foreach ($this->info as $tag => $info) {\r
                foreach ($info->attr as $attr => $x) {\r
                    $keys = array("$tag@$attr", $attr, "*@$attr", "$tag.$attr", "*.$attr");\r
                    $delete = true;\r
                    foreach ($keys as $key) {\r
                        if ($delete && isset($allowed_attributes[$key])) {\r
                            $delete = false;\r
                        }\r
                        if (isset($allowed_attributes_mutable[$key])) {\r
                            unset($allowed_attributes_mutable[$key]);\r
                        }\r
                    }\r
                    if ($delete) {\r
                        if ($this->info[$tag]->attr[$attr]->required) {\r
                            trigger_error(\r
                                "Required attribute '$attr' in element '$tag' " .\r
                                "was not allowed, which means '$tag' will not be allowed either",\r
                                E_USER_WARNING\r
                            );\r
                        }\r
                        unset($this->info[$tag]->attr[$attr]);\r
                    }\r
                }\r
            }\r
            // emit errors\r
            foreach ($allowed_attributes_mutable as $elattr => $d) {\r
                $bits = preg_split('/[.@]/', $elattr, 2);\r
                $c = count($bits);\r
                switch ($c) {\r
                    case 2:\r
                        if ($bits[0] !== '*') {\r
                            $element = htmlspecialchars($bits[0]);\r
                            $attribute = htmlspecialchars($bits[1]);\r
                            if (!isset($this->info[$element])) {\r
                                trigger_error(\r
                                    "Cannot allow attribute '$attribute' if element " .\r
                                    "'$element' is not allowed/supported $support"\r
                                );\r
                            } else {\r
                                trigger_error(\r
                                    "Attribute '$attribute' in element '$element' not supported $support",\r
                                    E_USER_WARNING\r
                                );\r
                            }\r
                            break;\r
                        }\r
                        // otherwise fall through\r
                    case 1:\r
                        $attribute = htmlspecialchars($bits[0]);\r
                        trigger_error(\r
                            "Global attribute '$attribute' is not ".\r
                            "supported in any elements $support",\r
                            E_USER_WARNING\r
                        );\r
                        break;\r
                }\r
            }\r
        }\r
\r
        // setup forbidden elements ---------------------------------------\r
\r
        $forbidden_elements   = $config->get('HTML.ForbiddenElements');\r
        $forbidden_attributes = $config->get('HTML.ForbiddenAttributes');\r
\r
        foreach ($this->info as $tag => $info) {\r
            if (isset($forbidden_elements[$tag])) {\r
                unset($this->info[$tag]);\r
                continue;\r
            }\r
            foreach ($info->attr as $attr => $x) {\r
                if (isset($forbidden_attributes["$tag@$attr"]) ||\r
                    isset($forbidden_attributes["*@$attr"]) ||\r
                    isset($forbidden_attributes[$attr])\r
                ) {\r
                    unset($this->info[$tag]->attr[$attr]);\r
                    continue;\r
                } elseif (isset($forbidden_attributes["$tag.$attr"])) { // this segment might get removed eventually\r
                    // $tag.$attr are not user supplied, so no worries!\r
                    trigger_error(\r
                        "Error with $tag.$attr: tag.attr syntax not supported for " .\r
                        "HTML.ForbiddenAttributes; use tag@attr instead",\r
                        E_USER_WARNING\r
                    );\r
                }\r
            }\r
        }\r
        foreach ($forbidden_attributes as $key => $v) {\r
            if (strlen($key) < 2) {\r
                continue;\r
            }\r
            if ($key[0] != '*') {\r
                continue;\r
            }\r
            if ($key[1] == '.') {\r
                trigger_error(\r
                    "Error with $key: *.attr syntax not supported for HTML.ForbiddenAttributes; use attr instead",\r
                    E_USER_WARNING\r
                );\r
            }\r
        }\r
\r
        // setup injectors -----------------------------------------------------\r
        foreach ($this->info_injector as $i => $injector) {\r
            if ($injector->checkNeeded($config) !== false) {\r
                // remove injector that does not have it's required\r
                // elements/attributes present, and is thus not needed.\r
                unset($this->info_injector[$i]);\r
            }\r
        }\r
    }\r
\r
    /**\r
     * Parses a TinyMCE-flavored Allowed Elements and Attributes list into\r
     * separate lists for processing. Format is element[attr1|attr2],element2...\r
     * @warning Although it's largely drawn from TinyMCE's implementation,\r
     *      it is different, and you'll probably have to modify your lists\r
     * @param array $list String list to parse\r
     * @return array\r
     * @todo Give this its own class, probably static interface\r
     */\r
    public function parseTinyMCEAllowedList($list)\r
    {\r
        $list = str_replace(array(' ', "\t"), '', $list);\r
\r
        $elements = array();\r
        $attributes = array();\r
\r
        $chunks = preg_split('/(,|[\n\r]+)/', $list);\r
        foreach ($chunks as $chunk) {\r
            if (empty($chunk)) {\r
                continue;\r
            }\r
            // remove TinyMCE element control characters\r
            if (!strpos($chunk, '[')) {\r
                $element = $chunk;\r
                $attr = false;\r
            } else {\r
                list($element, $attr) = explode('[', $chunk);\r
            }\r
            if ($element !== '*') {\r
                $elements[$element] = true;\r
            }\r
            if (!$attr) {\r
                continue;\r
            }\r
            $attr = substr($attr, 0, strlen($attr) - 1); // remove trailing ]\r
            $attr = explode('|', $attr);\r
            foreach ($attr as $key) {\r
                $attributes["$element.$key"] = true;\r
            }\r
        }\r
        return array($elements, $attributes);\r
    }\r
}\r
\r
// vim: et sw=4 sts=4\r