Localisation updates from https://translatewiki.net.

[mediawiki.git] / includes / tidy / RemexCompatMunger.php

<?php

namespace MediaWiki\Tidy;

use InvalidArgumentException;
use Wikimedia\RemexHtml\HTMLData;
use Wikimedia\RemexHtml\Serializer\Serializer;
use Wikimedia\RemexHtml\Serializer\SerializerNode;
use Wikimedia\RemexHtml\Tokenizer\Attributes;
use Wikimedia\RemexHtml\Tokenizer\PlainAttributes;
use Wikimedia\RemexHtml\TreeBuilder\Element;
use Wikimedia\RemexHtml\TreeBuilder\TreeBuilder;
use Wikimedia\RemexHtml\TreeBuilder\TreeHandler;

/**
 * @internal
 */
class RemexCompatMunger implements TreeHandler {
        private const ONLY_INLINE_ELEMENTS = [
                "a" => true,
                "abbr" => true,
                "acronym" => true,
                "applet" => true,
                "b" => true,
                "basefont" => true,
                "bdo" => true,
                "big" => true,
                "br" => true,
                "button" => true,
                "cite" => true,
                "code" => true,
                "del" => true,
                "dfn" => true,
                "em" => true,
                "font" => true,
                "i" => true,
                "iframe" => true,
                "img" => true,
                "input" => true,
                "ins" => true,
                "kbd" => true,
                "label" => true,
                "legend" => true,
                "map" => true,
                "object" => true,
                "param" => true,
                "q" => true,
                "rb" => true,
                "rbc" => true,
                "rp" => true,
                "rt" => true,
                "rtc" => true,
                "ruby" => true,
                "s" => true,
                "samp" => true,
                "select" => true,
                "small" => true,
                "span" => true,
                "strike" => true,
                "strong" => true,
                "sub" => true,
                "sup" => true,
                "textarea" => true,
                "tt" => true,
                "u" => true,
                "var" => true,
                // Those defined in tidy.conf
                "video" => true,
                "audio" => true,
                "bdi" => true,
                "data" => true,
                "time" => true,
                "mark" => true,
        ];

        /**
         * For the purposes of this class, "metadata" elements are those that
         * should neither trigger p-wrapping nor stop an outer p-wrapping,
         * typically those that are themselves invisible in a browser's rendering.
         * This isn't a complete list, it's just the tags that we're likely to
         * encounter in practice.
         */
        private const METADATA_ELEMENTS = [
                'style' => true,
                'script' => true,
                'link' => true,
                // Except for the TableOfContentsMarker (see ::isTableOfContentsMarker()
                // and Parser::TOC_PLACEHOLDER) which should break a paragraph.
                'meta' => true,
        ];

        private const FORMATTING_ELEMENTS = [
                'a' => true,
                'b' => true,
                'big' => true,
                'code' => true,
                'em' => true,
                'font' => true,
                'i' => true,
                'nobr' => true,
                's' => true,
                'small' => true,
                'strike' => true,
                'strong' => true,
                'tt' => true,
                'u' => true,
        ];

        /** @var Serializer */
        private $serializer;

        /** @var bool */
        private $trace;

        /**
         * @param Serializer $serializer
         * @param bool $trace
         */
        public function __construct( Serializer $serializer, $trace = false ) {
                $this->serializer = $serializer;
                $this->trace = $trace;
        }

        public function startDocument( $fragmentNamespace, $fragmentName ) {
                $this->serializer->startDocument( $fragmentNamespace, $fragmentName );
                $root = $this->serializer->getRootNode();
                $root->snData = new RemexMungerData;
                $root->snData->needsPWrapping = true;
        }

        public function endDocument( $pos ) {
                $this->serializer->endDocument( $pos );
        }

        private function getParentForInsert( $preposition, $refElement ) {
                if ( $preposition === TreeBuilder::ROOT ) {
                        return [ $this->serializer->getRootNode(), null ];
                } elseif ( $preposition === TreeBuilder::BEFORE ) {
                        $refNode = $refElement->userData;
                        return [ $this->serializer->getParentNode( $refNode ), $refNode ];
                } else {
                        $refNode = $refElement->userData;
                        $refData = $refNode->snData;
                        if ( $refData->currentCloneElement ) {
                                // Follow a chain of clone links if necessary
                                $origRefData = $refData;
                                while ( $refData->currentCloneElement ) {
                                        $refElement = $refData->currentCloneElement;
                                        $refNode = $refElement->userData;
                                        $refData = $refNode->snData;
                                }
                                // Cache the end of the chain in the requested element
                                $origRefData->currentCloneElement = $refElement;
                        } elseif ( $refData->childPElement ) {
                                $refElement = $refData->childPElement;
                                $refNode = $refElement->userData;
                        }
                        return [ $refNode, $refNode ];
                }
        }

        /**
         * Insert a p-wrapper
         *
         * @param SerializerNode $parent
         * @param int $sourceStart
         * @return SerializerNode
         */
        private function insertPWrapper( SerializerNode $parent, $sourceStart ) {
                $pWrap = new Element( HTMLData::NS_HTML, 'mw:p-wrap', new PlainAttributes );
                $this->serializer->insertElement( TreeBuilder::UNDER, $parent, $pWrap, false,
                        $sourceStart, 0 );
                $data = new RemexMungerData;
                $data->isPWrapper = true;
                $data->wrapBaseNode = $parent;
                $pWrap->userData->snData = $data;
                $parent->snData->childPElement = $pWrap;
                return $pWrap->userData;
        }

        public function characters( $preposition, $refElement, $text, $start, $length,
                $sourceStart, $sourceLength
        ) {
                $isBlank = strspn( $text, "\t\n\f\r ", $start, $length ) === $length;

                [ $parent, $refNode ] = $this->getParentForInsert( $preposition, $refElement );
                $parentData = $parent->snData;

                if ( $preposition === TreeBuilder::UNDER ) {
                        if ( $parentData->needsPWrapping && !$isBlank ) {
                                // Add a p-wrapper for bare text under body/blockquote
                                $refNode = $this->insertPWrapper( $refNode, $sourceStart );
                                $parent = $refNode;
                                $parentData = $parent->snData;
                        } elseif ( $parentData->isSplittable && !$parentData->ancestorPNode ) {
                                // The parent is splittable and in block mode, so split the tag stack
                                $refNode = $this->splitTagStack( $refNode, true, $sourceStart );
                                $parent = $refNode;
                                $parentData = $parent->snData;
                        }
                }

                if ( !$isBlank ) {
                        // Non-whitespace characters detected
                        $parentData->nonblankNodeCount++;
                }
                $this->serializer->characters( $preposition, $refNode, $text, $start,
                        $length, $sourceStart, $sourceLength );
        }

        private function trace( $msg ) {
                if ( $this->trace ) {
                        wfDebug( "[RCM] $msg" );
                }
        }

        /**
         * Insert or reparent an element. Create p-wrappers or split the tag stack
         * as necessary.
         *
         * Consider the following insertion locations. The parent may be:
         *
         *   - A: A body or blockquote (!!needsPWrapping)
         *   - B: A p-wrapper (!!isPWrapper)
         *   - C: A descendant of a p-wrapper (!!ancestorPNode)
         *     - CS: With splittable formatting elements in the stack region up to
         *       the p-wrapper
         *     - CU: With one or more unsplittable elements in the stack region up
         *       to the p-wrapper
         *   - D: Not a descendant of a p-wrapper (!ancestorNode)
         *     - DS: With splittable formatting elements in the stack region up to
         *       the body or blockquote
         *     - DU: With one or more unsplittable elements in the stack region up
         *       to the body or blockquote
         *
         * And consider that we may insert two types of element:
         *   - b: block
         *   - i: inline
         *
         * We handle the insertion as follows:
         *
         *   - A/i: Create a p-wrapper, insert under it
         *   - A/b: Insert as normal
         *   - B/i: Insert as normal
         *   - B/b: Close the p-wrapper, insert under the body/blockquote (wrap
         *     base) instead)
         *   - C/i: Insert as normal
         *   - CS/b: Split the tag stack, insert the block under cloned formatting
         *     elements which have the wrap base (the parent of the p-wrap) as
         *     their ultimate parent.
         *   - CU/b: Disable the p-wrap, by reparenting the currently open child
         *     of the p-wrap under the p-wrap's parent. Then insert the block as
         *     normal.
         *   - D/b: Insert as normal
         *   - DS/i: Split the tag stack, creating a new p-wrapper as the ultimate
         *     parent of the formatting elements thus cloned. The parent of the
         *     p-wrapper is the body or blockquote.
         *   - DU/i: Insert as normal
         *
         * FIXME: fostering ($preposition == BEFORE) is mostly done by inserting as
         * normal, the full algorithm is not followed.
         *
         * @param int $preposition
         * @param Element|SerializerNode|null $refElement
         * @param Element $element
         * @param bool $void
         * @param int $sourceStart
         * @param int $sourceLength
         */
        public function insertElement( $preposition, $refElement, Element $element, $void,
                $sourceStart, $sourceLength
        ) {
                [ $parent, $newRef ] = $this->getParentForInsert( $preposition, $refElement );
                $parentData = $parent->snData;
                $elementName = $element->htmlName;

                $inline = isset( self::ONLY_INLINE_ELEMENTS[$elementName] );
                $under = $preposition === TreeBuilder::UNDER;

                if ( isset( self::METADATA_ELEMENTS[$elementName] )
                        && !self::isTableOfContentsMarker( $element )
                ) {
                        // The element is a metadata element, that we allow to appear in
                        // both inline and block contexts.
                        $this->trace( 'insert metadata' );
                } elseif ( $under && $parentData->isPWrapper && !$inline ) {
                        // [B/b] The element is non-inline and the parent is a p-wrapper,
                        // close the parent and insert into its parent instead
                        $this->trace( 'insert B/b' );
                        $newParent = $this->serializer->getParentNode( $parent );
                        $parent = $newParent;
                        $parentData = $parent->snData;
                        $parentData->childPElement = null;
                        $newRef = $refElement->userData;
                } elseif ( $under && $parentData->isSplittable
                        && (bool)$parentData->ancestorPNode !== $inline
                ) {
                        // [CS/b, DS/i] The parent is splittable and the current element is
                        // inline in block context, or if the current element is a block
                        // under a p-wrapper, split the tag stack.
                        $this->trace( $inline ? 'insert DS/i' : 'insert CS/b' );
                        $newRef = $this->splitTagStack( $newRef, $inline, $sourceStart );
                        $parent = $newRef;
                        $parentData = $parent->snData;
                } elseif ( $under && $parentData->needsPWrapping && $inline ) {
                        // [A/i] If the element is inline and we are in body/blockquote,
                        // we need to create a p-wrapper
                        $this->trace( 'insert A/i' );
                        $newRef = $this->insertPWrapper( $newRef, $sourceStart );
                        $parent = $newRef;
                        $parentData = $parent->snData;
                } elseif ( $parentData->ancestorPNode && !$inline ) {
                        // [CU/b] If the element is non-inline and (despite attempting to
                        // split above) there is still an ancestor p-wrap, disable that
                        // p-wrap
                        $this->trace( 'insert CU/b' );
                        $this->disablePWrapper( $parent, $sourceStart );
                } else {
                        // [A/b, B/i, C/i, D/b, DU/i] insert as normal
                        $this->trace( 'insert normal' );
                }

                // An element with element children is a non-blank element
                $parentData->nonblankNodeCount++;

                // Insert the element downstream and so initialise its userData
                $this->serializer->insertElement( $preposition, $newRef,
                        $element, $void, $sourceStart, $sourceLength );

                // Initialise snData
                if ( !$element->userData->snData ) {
                        $elementData = $element->userData->snData = new RemexMungerData;
                } else {
                        $elementData = $element->userData->snData;
                }
                if ( ( $parentData->isPWrapper || $parentData->isSplittable )
                        && isset( self::FORMATTING_ELEMENTS[$elementName] )
                ) {
                        $elementData->isSplittable = true;
                }
                if ( $parentData->isPWrapper ) {
                        $elementData->ancestorPNode = $parent;
                } elseif ( $parentData->ancestorPNode ) {
                        $elementData->ancestorPNode = $parentData->ancestorPNode;
                }
                if ( $parentData->wrapBaseNode ) {
                        $elementData->wrapBaseNode = $parentData->wrapBaseNode;
                } elseif ( $parentData->needsPWrapping ) {
                        $elementData->wrapBaseNode = $parent;
                }
                if ( $elementName === 'body'
                        || $elementName === 'blockquote'
                        || $elementName === 'html'
                ) {
                        $elementData->needsPWrapping = true;
                }
        }

        /**
         * Clone nodes in a stack range and return the new parent
         *
         * @param SerializerNode $parentNode
         * @param bool $inline
         * @param int $pos The source position
         * @return SerializerNode
         */
        private function splitTagStack( SerializerNode $parentNode, $inline, $pos ) {
                $parentData = $parentNode->snData;
                $wrapBase = $parentData->wrapBaseNode;
                $pWrap = $parentData->ancestorPNode;
                if ( !$pWrap ) {
                        $cloneEnd = $wrapBase;
                } else {
                        $cloneEnd = $parentData->ancestorPNode;
                }

                $serializer = $this->serializer;
                $node = $parentNode;
                $root = $serializer->getRootNode();
                $nodes = [];
                $removableNodes = [];
                while ( $node !== $cloneEnd ) {
                        $nextParent = $serializer->getParentNode( $node );
                        if ( $nextParent === $root ) {
                                throw new InvalidArgumentException( 'Did not find end of clone range' );
                        }
                        $nodes[] = $node;
                        if ( $node->snData->nonblankNodeCount === 0 ) {
                                $removableNodes[] = $node;
                                $nextParent->snData->nonblankNodeCount--;
                        }
                        $node = $nextParent;
                }

                if ( $inline ) {
                        $pWrap = $this->insertPWrapper( $wrapBase, $pos );
                        $node = $pWrap;
                } else {
                        if ( $pWrap ) {
                                // End the p-wrap which was open, cancel the diversion
                                $wrapBase->snData->childPElement = null;
                        }
                        $pWrap = null;
                        $node = $wrapBase;
                }

                for ( $i = count( $nodes ) - 1; $i >= 0; $i-- ) {
                        $oldNode = $nodes[$i];
                        $oldData = $oldNode->snData;
                        $nodeParent = $node;
                        $element = new Element( $oldNode->namespace, $oldNode->name, $oldNode->attrs );
                        $this->serializer->insertElement( TreeBuilder::UNDER, $nodeParent,
                                $element, false, $pos, 0 );
                        $oldData->currentCloneElement = $element;

                        $newNode = $element->userData;
                        $newData = $newNode->snData = new RemexMungerData;
                        if ( $pWrap ) {
                                $newData->ancestorPNode = $pWrap;
                        }
                        $newData->isSplittable = true;
                        $newData->wrapBaseNode = $wrapBase;
                        $newData->isPWrapper = $oldData->isPWrapper;

                        $nodeParent->snData->nonblankNodeCount++;

                        $node = $newNode;
                }
                foreach ( $removableNodes as $rNode ) {
                        $fakeElement = new Element( $rNode->namespace, $rNode->name, $rNode->attrs );
                        $fakeElement->userData = $rNode;
                        $this->serializer->removeNode( $fakeElement, $pos );
                }
                // @phan-suppress-next-line PhanTypeMismatchReturnNullable False positive
                return $node;
        }

        /**
         * Find the ancestor of $node which is a child of a p-wrapper, and
         * reparent that node so that it is placed after the end of the p-wrapper
         * @param SerializerNode $node
         * @param int $sourceStart
         */
        private function disablePWrapper( SerializerNode $node, $sourceStart ) {
                $nodeData = $node->snData;
                $pWrapNode = $nodeData->ancestorPNode;
                $newParent = $this->serializer->getParentNode( $pWrapNode );
                if ( $pWrapNode !== $this->serializer->getLastChild( $newParent ) ) {
                        // Fostering or something? Abort!
                        return;
                }

                $nextParent = $node;
                do {
                        $victim = $nextParent;
                        $victim->snData->ancestorPNode = null;
                        $nextParent = $this->serializer->getParentNode( $victim );
                } while ( $nextParent !== $pWrapNode );

                // Make a fake Element to use in a reparenting operation
                $victimElement = new Element( $victim->namespace, $victim->name, $victim->attrs );
                $victimElement->userData = $victim;

                // Reparent
                $this->serializer->insertElement( TreeBuilder::UNDER, $newParent, $victimElement,
                        false, $sourceStart, 0 );

                // Decrement nonblank node count
                $pWrapNode->snData->nonblankNodeCount--;

                // Cancel the diversion so that no more elements are inserted under this p-wrap
                $newParent->snData->childPElement = null;
        }

        public function endTag( Element $element, $sourceStart, $sourceLength ) {
                $data = $element->userData->snData;
                if ( $data->childPElement ) {
                        $this->endTag( $data->childPElement, $sourceStart, 0 );
                }
                $this->serializer->endTag( $element, $sourceStart, $sourceLength );
                $element->userData->snData = null;
                $element->userData = null;
        }

        public function doctype( $name, $public, $system, $quirks, $sourceStart, $sourceLength ) {
                $this->serializer->doctype( $name, $public, $system, $quirks,
                        $sourceStart, $sourceLength );
        }

        public function comment( $preposition, $refElement, $text, $sourceStart, $sourceLength ) {
                [ , $refNode ] = $this->getParentForInsert( $preposition, $refElement );
                $this->serializer->comment( $preposition, $refNode, $text, $sourceStart, $sourceLength );
        }

        public function error( $text, $pos ) {
                $this->serializer->error( $text, $pos );
        }

        public function mergeAttributes( Element $element, Attributes $attrs, $sourceStart ) {
                $this->serializer->mergeAttributes( $element, $attrs, $sourceStart );
        }

        public function removeNode( Element $element, $sourceStart ) {
                $this->serializer->removeNode( $element, $sourceStart );
        }

        public function reparentChildren( Element $element, Element $newParent, $sourceStart ) {
                $self = $element->userData;
                if ( $self->snData->childPElement ) {
                        // Reparent under the p-wrapper instead, so that e.g.
                        //   <blockquote><mw:p-wrap>...</mw:p-wrap></blockquote>
                        // becomes
                        //   <blockquote><mw:p-wrap><i>...</i></mw:p-wrap></blockquote>

                        // The formatting element should not be the parent of the p-wrap.
                        // Without this special case, the insertElement() of the <i> below
                        // would be diverted into the p-wrapper, causing infinite recursion
                        // (T178632)
                        $this->reparentChildren( $self->snData->childPElement, $newParent, $sourceStart );
                        return;
                }

                $children = $self->children;
                $self->children = [];
                $this->insertElement( TreeBuilder::UNDER, $element, $newParent, false, $sourceStart, 0 );
                $newParentNode = $newParent->userData;
                $newParentId = $newParentNode->id;
                foreach ( $children as $child ) {
                        if ( is_object( $child ) ) {
                                $this->trace( "reparent <{$child->name}>" );
                                $child->parentId = $newParentId;
                        }
                }
                $newParentNode->children = $children;
        }

        /**
         * Helper function to match the Parser::TOC_PLACEHOLDER.
         * Note that Parsoid's version of this placeholder might
         * include additional attributes.
         * @param Element $element
         * @return bool If the given element is a Parser::TOC_PLACEHOLDER
         */
        private function isTableOfContentsMarker( Element $element ): bool {
                // Keep this in sync with Parser::TOC_PLACEHOLDER
                return (
                        $element->htmlName === 'meta' &&
                        isset( $element->attrs['property'] ) &&
                        $element->attrs['property'] === 'mw:PageProp/toc'
                );
        }
}