parse5 0.6.1 → 1.0.0

package/lib/{default_tree_adapter.js → tree_adapters/default.js}

@@ -1,3 +1,4 @@
+//Node construction
 exports.createDocument = function () {
     return {
         nodeName: '#document',
@@ -41,6 +42,8 @@ var createTextNode = function (value) {
     }
 };
 
+
+//Tree mutation
 exports.setDocumentType = function (document, name, publicId, systemId) {
     var doctypeNode = null;
 
@@ -130,10 +133,16 @@ exports.adoptAttributes = function (recipientNode, attrs) {
     }
 };
 
+
+//Tree traversing
 exports.getFirstChild = function (node) {
     return node.childNodes[0];
 };
 
+exports.getChildNodes = function (node) {
+    return node.childNodes;
+};
+
 exports.getParentNode = function (node) {
     return node.parentNode;
 };
@@ -142,10 +151,48 @@ exports.getAttrList = function (node) {
     return node.attrs;
 };
 
+//Node data
 exports.getTagName = function (element) {
     return element.tagName;
 };
 
 exports.getNamespaceURI = function (element) {
     return element.namespaceURI;
+};
+
+exports.getTextNodeContent = function (textNode) {
+    return textNode.value;
+};
+
+exports.getCommentNodeContent = function (commentNode) {
+    return commentNode.data;
+};
+
+exports.getDocumentTypeNodeName = function (doctypeNode) {
+    return doctypeNode.name;
+};
+
+exports.getDocumentTypeNodePublicId = function (doctypeNode) {
+    return doctypeNode.publicId;
+};
+
+exports.getDocumentTypeNodeSystemId = function (doctypeNode) {
+    return doctypeNode.systemId;
+};
+
+//Node types
+exports.isTextNode = function (node) {
+    return node.nodeName === '#text';
+};
+
+exports.isCommentNode = function (node) {
+    return node.nodeName === '#comment';
+};
+
+exports.isDocumentTypeNode = function (node) {
+    return node.nodeName === '#documentType';
+};
+
+exports.isElementNode = function (node) {
+    return !!node.tagName;
 };

package/lib/tree_adapters/htmlparser2.js

@@ -0,0 +1,267 @@
+//Node construction
+exports.createDocument =
+exports.createDocumentFragment = function () {
+    return {
+        type: 'root',
+        name: 'root',
+        parent: null,
+        prev: null,
+        next: null,
+        children: []
+    };
+};
+
+exports.createElement = function (tagName, namespaceURI, attrs) {
+    var attribs = {},
+        attribsNamespace = {},
+        attribsPrefix = {};
+
+    for (var i = 0; i < attrs.length; i++) {
+        var attrName = attrs[i].name;
+
+        attribs[attrName] = attrs[i].value;
+        attribsNamespace[attrName] = attrs[i].namespace;
+        attribsPrefix[attrName] = attrs[i].prefix;
+    }
+
+    return {
+        type: tagName === 'script' || tagName === 'style' ? tagName : 'tag',
+        name: tagName,
+        namespace: namespaceURI,
+        attribs: attribs,
+        'x-attribsNamespace': attribsNamespace,
+        'x-attribsPrefix': attribsPrefix,
+        children: [],
+        parent: null,
+        prev: null,
+        next: null
+    };
+};
+
+exports.createCommentNode = function (data) {
+    return {
+        type: 'comment',
+        data: data,
+        parent: null,
+        prev: null,
+        next: null
+    };
+};
+
+var createTextNode = function (value) {
+    return {
+        type: 'text',
+        data: value,
+        parent: null,
+        prev: null,
+        next: null
+    }
+};
+
+
+//Tree mutation
+exports.setDocumentType = function (document, name, publicId, systemId) {
+    var data = '!DOCTYPE';
+
+    if (name)
+        data += ' ' + name;
+
+    if (publicId)
+        data += ' PUBLIC "' + publicId + '"';
+
+    if (systemId)
+        data += ' "' + systemId + '"';
+
+    var doctypeNode = null;
+
+    for (var i = 0; i < document.children.length; i++) {
+        if (document.children[i].type === 'directive' && document.children[i].name === '!doctype') {
+            doctypeNode = document.children[i];
+            break;
+        }
+    }
+
+    if (doctypeNode) {
+        doctypeNode.data = data;
+        doctypeNode['x-name'] = name;
+        doctypeNode['x-publicId'] = publicId;
+        doctypeNode['x-systemId'] = systemId;
+    }
+
+    else {
+        appendChild(document, {
+            type: 'directive',
+            name: '!doctype',
+            data: data,
+            'x-name': name,
+            'x-publicId': publicId,
+            'x-systemId': systemId
+        });
+    }
+
+};
+
+exports.setQuirksMode = function (document) {
+    document.quirksMode = true;
+};
+
+exports.isQuirksMode = function (document) {
+    return document.quirksMode;
+};
+
+var appendChild = exports.appendChild = function (parentNode, newNode) {
+    var prev = parentNode.children[parentNode.children.length - 1];
+
+    if (prev) {
+        prev.next = newNode;
+        newNode.prev = prev;
+    }
+
+    parentNode.children.push(newNode);
+    newNode.parent = parentNode;
+};
+
+var insertBefore = exports.insertBefore = function (parentNode, newNode, referenceNode) {
+    var insertionIdx = parentNode.children.indexOf(referenceNode),
+        prev = referenceNode.prev;
+
+    if (prev) {
+        prev.next = newNode;
+        newNode.prev = prev;
+    }
+
+    referenceNode.prev = newNode;
+    newNode.next = referenceNode;
+
+    parentNode.children.splice(insertionIdx, 0, newNode);
+    newNode.parent = parentNode;
+};
+
+exports.detachNode = function (node) {
+    if (node.parent) {
+        var idx = node.parent.children.indexOf(node),
+            prev = node.prev,
+            next = node.next;
+
+        node.prev = null;
+        node.next = null;
+
+        if (prev)
+            prev.next = next;
+
+        if (next)
+            next.prev = prev;
+
+        node.parent.children.splice(idx, 1);
+        node.parent = null;
+    }
+};
+
+exports.insertText = function (parentNode, text) {
+    var lastChild = parentNode.children[parentNode.children.length - 1];
+
+    if (lastChild && lastChild.type === 'text')
+        lastChild.data += text;
+    else
+        appendChild(parentNode, createTextNode(text));
+};
+
+exports.insertTextBefore = function (parentNode, text, referenceNode) {
+    var prevNode = parentNode.children[parentNode.children.indexOf(referenceNode) - 1];
+
+    if (prevNode && prevNode.type === 'text')
+        prevNode.data += text;
+    else
+        insertBefore(parentNode, createTextNode(text), referenceNode);
+};
+
+exports.adoptAttributes = function (recipientNode, attrs) {
+    for (var i = 0; i < attrs.length; i++) {
+        var attrName = attrs[i].name;
+
+        if (typeof recipientNode.attribs[attrName] === 'undefined') {
+            recipientNode.attribs[attrName] = attrs[i].value;
+            recipientNode['x-attribsNamespace'][attrName] = attrs[i].namespace;
+            recipientNode['x-attribsPrefix'][attrName] = attrs[i].prefix;
+        }
+    }
+};
+
+
+//Tree traversing
+exports.getFirstChild = function (node) {
+    return node.children[0];
+};
+
+exports.getChildNodes = function (node) {
+    return node.children;
+};
+
+exports.getParentNode = function (node) {
+    return node.parent;
+};
+
+exports.getAttrList = function (node) {
+    var attrList = [];
+
+    for (var name in node.attribs) {
+        if (node.attribs.hasOwnProperty(name)) {
+            attrList.push({
+                name: name,
+                value: node.attribs[name],
+                namespace: node['x-attribsNamespace'][name],
+                prefix: node['x-attribsPrefix'][name]
+            });
+        }
+    }
+
+    return attrList;
+};
+
+
+//Node data
+exports.getTagName = function (element) {
+    return element.name;
+};
+
+exports.getNamespaceURI = function (element) {
+    return element.namespace;
+};
+
+exports.getTextNodeContent = function (textNode) {
+    return textNode.data;
+};
+
+exports.getCommentNodeContent = function (commentNode) {
+    return commentNode.data;
+};
+
+exports.getDocumentTypeNodeName = function (doctypeNode) {
+    return doctypeNode['x-name'];
+};
+
+exports.getDocumentTypeNodePublicId = function (doctypeNode) {
+    return doctypeNode['x-publicId'];
+};
+
+exports.getDocumentTypeNodeSystemId = function (doctypeNode) {
+    return doctypeNode['x-systemId'];
+};
+
+
+//Node types
+exports.isTextNode = function (node) {
+    return node.type === 'text';
+};
+
+exports.isCommentNode = function (node) {
+    return node.type === 'comment';
+};
+
+exports.isDocumentTypeNode = function (node) {
+    return node.type === 'directive' && node.name === '!doctype';
+};
+
+exports.isElementNode = function (node) {
+    return !!node.attribs;
+};

package/lib/{formatting_element_list.js → tree_construction_stage/formatting_element_list.js}

@@ -2,7 +2,7 @@
 var NOAH_ARK_CAPACITY = 3;
 
 //List of formatting elements
-var FormattingElementList = exports.FormattingElementList = function (treeAdapter) {
+var FormattingElementList = module.exports = function (treeAdapter) {
     this.length = 0;
     this.entries = [];
     this.treeAdapter = treeAdapter;

package/lib/{open_element_stack.js → tree_construction_stage/open_element_stack.js}

@@ -1,4 +1,4 @@
-var HTML = require('./html');
+var HTML = require('../const/html');
 
 //Aliases
 var $ = HTML.TAG_NAMES,
@@ -75,7 +75,7 @@ function isScopingElement(tn, ns) {
 }
 
 //Stack of open elements
-var OpenElementStack = exports.OpenElementStack = function (document, treeAdapter) {
+var OpenElementStack = module.exports = function (document, treeAdapter) {
     this.stackTop = -1;
     this.items = [];
     this.current = document;

package/lib/{parser.js → tree_construction_stage/parser.js}

@@ -1,9 +1,9 @@
-var Tokenizer = require('./tokenizer').Tokenizer,
-    OpenElementStack = require('./open_element_stack').OpenElementStack,
-    FormattingElementList = require('./formatting_element_list').FormattingElementList,
-    defaultTreeAdapter = require('./default_tree_adapter'),
-    unicode = require('./unicode'),
-    HTML = require('./html');
+var Tokenizer = require('../tokenization_stage/tokenizer'),
+    OpenElementStack = require('./open_element_stack'),
+    FormattingElementList = require('./formatting_element_list'),
+    defaultTreeAdapter = require('../tree_adapters/default'),
+    UNICODE = require('../const/unicode'),
+    HTML = require('../const/html');
 
 //Aliases
 var $ = HTML.TAG_NAMES,
@@ -757,7 +757,7 @@ function getSearchableIndexInputAttrs(isindexStartTagToken) {
 }
 
 //Parser
-var Parser = exports.Parser = function (treeAdapter) {
+var Parser = module.exports = function (treeAdapter) {
     this.treeAdapter = treeAdapter || defaultTreeAdapter;
 };
 
@@ -2971,7 +2971,7 @@ function startTagAfterAfterFrameset(p, token) {
 //12.2.5.5 The rules for parsing tokens in foreign content
 //------------------------------------------------------------------
 function nullCharacterInForeignContent(p, token) {
-    token.chars = unicode.REPLACEMENT_CHARACTER;
+    token.chars = UNICODE.REPLACEMENT_CHARACTER;
     p._insertCharacters(token);
 }
 

package/lib/tree_construction_stage/tree_serializer.js

@@ -0,0 +1,165 @@
+var defaultTreeAdapter = require('../tree_adapters/default'),
+    HTML = require('../const/html');
+
+//Aliases
+var $ = HTML.TAG_NAMES,
+    NS = HTML.NAMESPACES;
+
+
+//Escaping regexes
+var AMP_REGEX = /&/g,
+    NBSP_REGEX = /\u00a0/g,
+    DOUBLE_QUOTE_REGEX = /"/g,
+    LT_REGEX = /</g,
+    GT_REGEX = />/g;
+
+
+//Escape string
+function escapeString(str, attrMode) {
+    str = str
+        .replace(AMP_REGEX, '&amp;')
+        .replace(NBSP_REGEX, '&nbsp;');
+
+    if (attrMode)
+        str = str.replace(DOUBLE_QUOTE_REGEX, '&quot;');
+
+    else {
+        str = str
+            .replace(LT_REGEX, '&lt;')
+            .replace(GT_REGEX, '&gt;');
+    }
+
+    return str;
+}
+
+
+//TreeSerializer
+var TreeSerializer = module.exports = function (treeAdapter) {
+    this.treeAdapter = treeAdapter || defaultTreeAdapter;
+};
+
+
+//API
+TreeSerializer.prototype.serialize = function (node) {
+    this.html = '';
+    this._serializeChildNodes(node);
+
+    return this.html;
+};
+
+
+//Internals
+TreeSerializer.prototype._serializeChildNodes = function (parentNode) {
+    var childNodes = this.treeAdapter.getChildNodes(parentNode);
+
+    if (childNodes) {
+        for (var i = 0, cnLength = childNodes.length; i < cnLength; i++) {
+            var currentNode = childNodes[i];
+
+            if (this.treeAdapter.isElementNode(currentNode))
+                this._serializeElement(currentNode);
+
+            else if (this.treeAdapter.isTextNode(currentNode))
+                this._serializeTextNode(currentNode);
+
+            else if (this.treeAdapter.isCommentNode(currentNode))
+                this._serializeCommentNode(currentNode);
+
+            else if (this.treeAdapter.isDocumentTypeNode(currentNode))
+                this._serializeDocumentTypeNode(currentNode);
+        }
+    }
+};
+
+TreeSerializer.prototype._serializeElement = function (node) {
+    var tn = this.treeAdapter.getTagName(node),
+        ns = this.treeAdapter.getNamespaceURI(node),
+        qualifiedTn = (ns === NS.HTML || ns === NS.SVG || ns === NS.MATHML) ? tn : (ns + ':' + tn);
+
+    this.html += '<' + qualifiedTn;
+    this._serializeAttributes(node);
+    this.html += '>';
+
+    if (tn !== $.AREA && tn !== $.BASE && tn !== $.BASEFONT && tn !== $.BGSOUND && tn !== $.BR && tn !== $.BR &&
+        tn !== $.COL && tn !== $.EMBED && tn !== $.FRAME && tn !== $.HR && tn !== $.IMG && tn !== $.INPUT &&
+        tn !== $.KEYGEN && tn !== $.LINK && tn !== $.MENUITEM && tn !== $.META && tn !== $.PARAM && tn !== $.SOURCE &&
+        tn !== $.TRACK && tn !== $.WBR) {
+
+        if (tn === $.PRE || tn === $.TEXTAREA || tn === $.LISTING) {
+            var firstChild = this.treeAdapter.getFirstChild(node);
+
+            if (firstChild && this.treeAdapter.isTextNode(firstChild))
+                this.html += '\n';
+        }
+
+        this._serializeChildNodes(node);
+        this.html += '</' + qualifiedTn + '>';
+    }
+};
+
+TreeSerializer.prototype._serializeAttributes = function (node) {
+    var attrs = this.treeAdapter.getAttrList(node);
+
+    for (var i = 0, attrsLength = attrs.length; i < attrsLength; i++) {
+        var attr = attrs[i];
+
+        this.html += ' ';
+
+        if (!attr.namespace)
+            this.html += attr.name;
+
+        else if (attr.namespace === NS.XML)
+            this.html += 'xml:' + attr.name;
+
+        else if (attr.namespace === NS.XMLNS) {
+            if (attr.name !== 'xmlns')
+                this.html += 'xmlns:';
+
+            this.html += attr.name;
+        }
+
+        else if (attr.namespace === NS.XLINK)
+            this.html += 'xlink:' + attr.name;
+
+        else
+            this.html += attr.namespace + ':' + attr.name;
+
+        this.html += '="' + escapeString(attr.value, true) + '"';
+    }
+};
+
+TreeSerializer.prototype._serializeTextNode = function (node) {
+    var parent = this.treeAdapter.getParentNode(node),
+        parentTn = parent && this.treeAdapter.getTagName(parent),
+        content = this.treeAdapter.getTextNodeContent(node);
+
+    if (parentTn === $.STYLE || parentTn === $.SCRIPT || parentTn === $.XMP || parentTn === $.IFRAME ||
+        parentTn === $.NOEMBED || parentTn === $.NOFRAMES || parentTn === $.PLAINTEXT || parentTn === $.NOSCRIPT) {
+        this.html += content;
+    }
+
+    else
+        this.html += escapeString(content, false);
+};
+
+TreeSerializer.prototype._serializeCommentNode = function (node) {
+    this.html += '<!--' + this.treeAdapter.getCommentNodeContent(node) + '-->';
+};
+
+TreeSerializer.prototype._serializeDocumentTypeNode = function (node) {
+    var name = this.treeAdapter.getDocumentTypeNodeName(node),
+        publicId = this.treeAdapter.getDocumentTypeNodePublicId(node),
+        systemId = this.treeAdapter.getDocumentTypeNodeSystemId(node);
+
+    this.html += '<!DOCTYPE ' + name;
+
+    if (publicId !== null)
+        this.html += ' PUBLIC "' + publicId + '"';
+
+
+    if (systemId !== null)
+        this.html += ' "' + systemId + '"';
+
+    this.html += '>';
+};
+

package/package.json

@@ -1,28 +1,35 @@
 {
-  "name": "parse5",
-  "description": "Fast full-featured HTML parser for Node. Based on WHATWG HTML5 specification.",
-  "version": "0.6.1",
-  "author": "Ivan Nikulin (ifaaan@gmail.com, https://github.com/inikulin)",
-  "keywords": [
-    "html",
-    "parser",
-    "html5",
-    "WHATWG",
-    "specification",
-    "fast"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/inikulin/parse5.git"
-  },
-  "main": "./lib/parser.js",
-  "devDependencies": {
-    "nodeunit": "0.8.0"
-  },
-  "licenses": [
-    {
-      "type": "MIT",
-      "url": "https://raw.github.com/inikulin/parse5/master/LICENSE"
-    }
-  ]
+    "name": "parse5",
+    "description": "Fast full-featured HTML parser for Node. Based on WHATWG HTML5 specification.",
+    "version": "1.0.0",
+    "author": "Ivan Nikulin (ifaaan@gmail.com, https://github.com/inikulin)",
+    "keywords": [
+        "html",
+        "parser",
+        "html5",
+        "WHATWG",
+        "specification",
+        "fast",
+        "html parser",
+        "html5 parser",
+        "htmlparser",
+        "parse5",
+        "serializer",
+        "html serializer",
+        "htmlserializer"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/inikulin/parse5.git"
+    },
+    "main": "./index.js",
+    "devDependencies": {
+        "nodeunit": "0.8.0"
+    },
+    "licenses": [
+        {
+            "type": "MIT",
+            "url": "https://raw.github.com/inikulin/parse5/master/LICENSE"
+        }
+    ]
 }