| 'use strict'; |
| |
| var OpenElementStack = require('./open_element_stack'), |
| Tokenizer = require('../tokenization/tokenizer'), |
| HTML = require('../common/html'); |
| |
| |
| //Aliases |
| var $ = HTML.TAG_NAMES; |
| |
| |
| function setEndLocation(element, closingToken, treeAdapter) { |
| var loc = element.__location; |
| |
| if (!loc) |
| return; |
| |
| if (!loc.startTag) { |
| loc.startTag = { |
| start: loc.start, |
| end: loc.end |
| }; |
| } |
| |
| if (closingToken.location) { |
| var tn = treeAdapter.getTagName(element), |
| // NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing tag and |
| // for cases like <td> <p> </td> - 'p' closes without a closing tag |
| isClosingEndTag = closingToken.type === Tokenizer.END_TAG_TOKEN && |
| tn === closingToken.tagName; |
| |
| if (isClosingEndTag) { |
| loc.endTag = { |
| start: closingToken.location.start, |
| end: closingToken.location.end |
| }; |
| } |
| |
| loc.end = closingToken.location.end; |
| } |
| } |
| |
| //NOTE: patch open elements stack, so we can assign end location for the elements |
| function patchOpenElementsStack(stack, parser) { |
| var treeAdapter = parser.treeAdapter; |
| |
| stack.pop = function () { |
| setEndLocation(this.current, parser.currentToken, treeAdapter); |
| OpenElementStack.prototype.pop.call(this); |
| }; |
| |
| stack.popAllUpToHtmlElement = function () { |
| for (var i = this.stackTop; i > 0; i--) |
| setEndLocation(this.items[i], parser.currentToken, treeAdapter); |
| |
| OpenElementStack.prototype.popAllUpToHtmlElement.call(this); |
| }; |
| |
| stack.remove = function (element) { |
| setEndLocation(element, parser.currentToken, treeAdapter); |
| OpenElementStack.prototype.remove.call(this, element); |
| }; |
| } |
| |
| exports.assign = function (parser) { |
| //NOTE: obtain Parser proto this way to avoid module circular references |
| var parserProto = Object.getPrototypeOf(parser), |
| treeAdapter = parser.treeAdapter; |
| |
| |
| //NOTE: patch _reset method |
| parser._reset = function (html, document, fragmentContext) { |
| parserProto._reset.call(this, html, document, fragmentContext); |
| |
| this.attachableElementLocation = null; |
| this.lastFosterParentingLocation = null; |
| this.currentToken = null; |
| |
| patchOpenElementsStack(this.openElements, parser); |
| }; |
| |
| parser._processTokenInForeignContent = function (token) { |
| this.currentToken = token; |
| parserProto._processTokenInForeignContent.call(this, token); |
| }; |
| |
| parser._processToken = function (token) { |
| this.currentToken = token; |
| parserProto._processToken.call(this, token); |
| |
| //NOTE: <body> and <html> are never popped from the stack, so we need to updated |
| //their end location explicitly. |
| if (token.type === Tokenizer.END_TAG_TOKEN && |
| (token.tagName === $.HTML || |
| (token.tagName === $.BODY && this.openElements.hasInScope($.BODY)))) { |
| for (var i = this.openElements.stackTop; i >= 0; i--) { |
| var element = this.openElements.items[i]; |
| |
| if (this.treeAdapter.getTagName(element) === token.tagName) { |
| setEndLocation(element, token, treeAdapter); |
| break; |
| } |
| } |
| } |
| }; |
| |
| //Doctype |
| parser._setDocumentType = function (token) { |
| parserProto._setDocumentType.call(this, token); |
| |
| var documentChildren = this.treeAdapter.getChildNodes(this.document), |
| cnLength = documentChildren.length; |
| |
| for (var i = 0; i < cnLength; i++) { |
| var node = documentChildren[i]; |
| |
| if (this.treeAdapter.isDocumentTypeNode(node)) { |
| node.__location = token.location; |
| break; |
| } |
| } |
| }; |
| |
| //Elements |
| parser._attachElementToTree = function (element) { |
| //NOTE: _attachElementToTree is called from _appendElement, _insertElement and _insertTemplate methods. |
| //So we will use token location stored in this methods for the element. |
| element.__location = this.attachableElementLocation || null; |
| this.attachableElementLocation = null; |
| parserProto._attachElementToTree.call(this, element); |
| }; |
| |
| parser._appendElement = function (token, namespaceURI) { |
| this.attachableElementLocation = token.location; |
| parserProto._appendElement.call(this, token, namespaceURI); |
| }; |
| |
| parser._insertElement = function (token, namespaceURI) { |
| this.attachableElementLocation = token.location; |
| parserProto._insertElement.call(this, token, namespaceURI); |
| }; |
| |
| parser._insertTemplate = function (token) { |
| this.attachableElementLocation = token.location; |
| parserProto._insertTemplate.call(this, token); |
| |
| var tmplContent = this.treeAdapter.getChildNodes(this.openElements.current)[0]; |
| |
| tmplContent.__location = null; |
| }; |
| |
| parser._insertFakeRootElement = function () { |
| parserProto._insertFakeRootElement.call(this); |
| this.openElements.current.__location = null; |
| }; |
| |
| //Comments |
| parser._appendCommentNode = function (token, parent) { |
| parserProto._appendCommentNode.call(this, token, parent); |
| |
| var children = this.treeAdapter.getChildNodes(parent), |
| commentNode = children[children.length - 1]; |
| |
| commentNode.__location = token.location; |
| }; |
| |
| //Text |
| parser._findFosterParentingLocation = function () { |
| //NOTE: store last foster parenting location, so we will be able to find inserted text |
| //in case of foster parenting |
| this.lastFosterParentingLocation = parserProto._findFosterParentingLocation.call(this); |
| return this.lastFosterParentingLocation; |
| }; |
| |
| parser._insertCharacters = function (token) { |
| parserProto._insertCharacters.call(this, token); |
| |
| var hasFosterParent = this._shouldFosterParentOnInsertion(), |
| parentingLocation = this.lastFosterParentingLocation, |
| parent = (hasFosterParent && parentingLocation.parent) || |
| this.openElements.currentTmplContent || |
| this.openElements.current, |
| siblings = this.treeAdapter.getChildNodes(parent), |
| textNodeIdx = hasFosterParent && parentingLocation.beforeElement ? |
| siblings.indexOf(parentingLocation.beforeElement) - 1 : |
| siblings.length - 1, |
| textNode = siblings[textNodeIdx]; |
| |
| //NOTE: if we have location assigned by another token, then just update end position |
| if (textNode.__location) |
| textNode.__location.end = token.location.end; |
| |
| else |
| textNode.__location = token.location; |
| }; |
| }; |
| |
