remove autoload section in composer.json

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

<?php\r
\r
/**\r
 * Takes a well formed list of tokens and fixes their nesting.\r
 *\r
 * HTML elements dictate which elements are allowed to be their children,\r
 * for example, you can't have a p tag in a span tag.  Other elements have\r
 * much more rigorous definitions: tables, for instance, require a specific\r
 * order for their elements.  There are also constraints not expressible by\r
 * document type definitions, such as the chameleon nature of ins/del\r
 * tags and global child exclusions.\r
 *\r
 * The first major objective of this strategy is to iterate through all\r
 * the nodes and determine whether or not their children conform to the\r
 * element's definition.  If they do not, the child definition may\r
 * optionally supply an amended list of elements that is valid or\r
 * require that the entire node be deleted (and the previous node\r
 * rescanned).\r
 *\r
 * The second objective is to ensure that explicitly excluded elements of\r
 * an element do not appear in its children.  Code that accomplishes this\r
 * task is pervasive through the strategy, though the two are distinct tasks\r
 * and could, theoretically, be seperated (although it's not recommended).\r
 *\r
 * @note Whether or not unrecognized children are silently dropped or\r
 *       translated into text depends on the child definitions.\r
 *\r
 * @todo Enable nodes to be bubbled out of the structure.  This is\r
 *       easier with our new algorithm.\r
 */\r
\r
class HTMLPurifier_Strategy_FixNesting extends HTMLPurifier_Strategy\r
{\r
\r
    /**\r
     * @param HTMLPurifier_Token[] $tokens\r
     * @param HTMLPurifier_Config $config\r
     * @param HTMLPurifier_Context $context\r
     * @return array|HTMLPurifier_Token[]\r
     */\r
    public function execute($tokens, $config, $context)\r
    {\r
\r
        //####################################################################//\r
        // Pre-processing\r
\r
        // O(n) pass to convert to a tree, so that we can efficiently\r
        // refer to substrings\r
        $top_node = HTMLPurifier_Arborize::arborize($tokens, $config, $context);\r
\r
        // get a copy of the HTML definition\r
        $definition = $config->getHTMLDefinition();\r
\r
        $excludes_enabled = !$config->get('Core.DisableExcludes');\r
\r
        // setup the context variable 'IsInline', for chameleon processing\r
        // is 'false' when we are not inline, 'true' when it must always\r
        // be inline, and an integer when it is inline for a certain\r
        // branch of the document tree\r
        $is_inline = $definition->info_parent_def->descendants_are_inline;\r
        $context->register('IsInline', $is_inline);\r
\r
        // setup error collector\r
        $e =& $context->get('ErrorCollector', true);\r
\r
        //####################################################################//\r
        // Loop initialization\r
\r
        // stack that contains all elements that are excluded\r
        // it is organized by parent elements, similar to $stack,\r
        // but it is only populated when an element with exclusions is\r
        // processed, i.e. there won't be empty exclusions.\r
        $exclude_stack = array($definition->info_parent_def->excludes);\r
\r
        // variable that contains the start token while we are processing\r
        // nodes. This enables error reporting to do its job\r
        $node = $top_node;\r
        // dummy token\r
        list($token, $d) = $node->toTokenPair();\r
        $context->register('CurrentNode', $node);\r
        $context->register('CurrentToken', $token);\r
\r
        //####################################################################//\r
        // Loop\r
\r
        // We need to implement a post-order traversal iteratively, to\r
        // avoid running into stack space limits.  This is pretty tricky\r
        // to reason about, so we just manually stack-ify the recursive\r
        // variant:\r
        //\r
        //  function f($node) {\r
        //      foreach ($node->children as $child) {\r
        //          f($child);\r
        //      }\r
        //      validate($node);\r
        //  }\r
        //\r
        // Thus, we will represent a stack frame as array($node,\r
        // $is_inline, stack of children)\r
        // e.g. array_reverse($node->children) - already processed\r
        // children.\r
\r
        $parent_def = $definition->info_parent_def;\r
        $stack = array(\r
            array($top_node,\r
                  $parent_def->descendants_are_inline,\r
                  $parent_def->excludes, // exclusions\r
                  0)\r
            );\r
\r
        while (!empty($stack)) {\r
            list($node, $is_inline, $excludes, $ix) = array_pop($stack);\r
            // recursive call\r
            $go = false;\r
            $def = empty($stack) ? $definition->info_parent_def : $definition->info[$node->name];\r
            while (isset($node->children[$ix])) {\r
                $child = $node->children[$ix++];\r
                if ($child instanceof HTMLPurifier_Node_Element) {\r
                    $go = true;\r
                    $stack[] = array($node, $is_inline, $excludes, $ix);\r
                    $stack[] = array($child,\r
                        // ToDo: I don't think it matters if it's def or\r
                        // child_def, but double check this...\r
                        $is_inline || $def->descendants_are_inline,\r
                        empty($def->excludes) ? $excludes\r
                                              : array_merge($excludes, $def->excludes),\r
                        0);\r
                    break;\r
                }\r
            };\r
            if ($go) continue;\r
            list($token, $d) = $node->toTokenPair();\r
            // base case\r
            if ($excludes_enabled && isset($excludes[$node->name])) {\r
                $node->dead = true;\r
                if ($e) $e->send(E_ERROR, 'Strategy_FixNesting: Node excluded');\r
            } else {\r
                // XXX I suppose it would be slightly more efficient to\r
                // avoid the allocation here and have children\r
                // strategies handle it\r
                $children = array();\r
                foreach ($node->children as $child) {\r
                    if (!$child->dead) $children[] = $child;\r
                }\r
                $result = $def->child->validateChildren($children, $config, $context);\r
                if ($result === true) {\r
                    // nop\r
                    $node->children = $children;\r
                } elseif ($result === false) {\r
                    $node->dead = true;\r
                    if ($e) $e->send(E_ERROR, 'Strategy_FixNesting: Node removed');\r
                } else {\r
                    $node->children = $result;\r
                    if ($e) {\r
                        // XXX This will miss mutations of internal nodes. Perhaps defer to the child validators\r
                        if (empty($result) && !empty($children)) {\r
                            $e->send(E_ERROR, 'Strategy_FixNesting: Node contents removed');\r
                        } else if ($result != $children) {\r
                            $e->send(E_WARNING, 'Strategy_FixNesting: Node reorganized');\r
                        }\r
                    }\r
                }\r
            }\r
        }\r
\r
        //####################################################################//\r
        // Post-processing\r
\r
        // remove context variables\r
        $context->destroy('IsInline');\r
        $context->destroy('CurrentNode');\r
        $context->destroy('CurrentToken');\r
\r
        //####################################################################//\r
        // Return\r
\r
        return HTMLPurifier_Arborize::flatten($node, $config, $context);\r
    }\r
}\r
\r
// vim: et sw=4 sts=4\r