mirror of
https://github.com/apache/cordova-android.git
synced 2026-04-23 00:00:09 +08:00
CB-14145 remove old node_modules before patch fix
This commit is contained in:
Christopher J. Brody
-20
@@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2011 Rackspace
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
var DEFAULT_PARSER = 'sax';
|
||||
|
||||
exports.DEFAULT_PARSER = DEFAULT_PARSER;
|
||||
-343
@@ -1,343 +0,0 @@
|
||||
/**
|
||||
* Copyright 2011 Rackspace
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
var sprintf = require('./sprintf').sprintf;
|
||||
|
||||
var utils = require('./utils');
|
||||
var SyntaxError = require('./errors').SyntaxError;
|
||||
|
||||
var _cache = {};
|
||||
|
||||
var RE = new RegExp(
|
||||
"(" +
|
||||
"'[^']*'|\"[^\"]*\"|" +
|
||||
"::|" +
|
||||
"//?|" +
|
||||
"\\.\\.|" +
|
||||
"\\(\\)|" +
|
||||
"[/.*:\\[\\]\\(\\)@=])|" +
|
||||
"((?:\\{[^}]+\\})?[^/\\[\\]\\(\\)@=\\s]+)|" +
|
||||
"\\s+", 'g'
|
||||
);
|
||||
|
||||
var xpath_tokenizer = utils.findall.bind(null, RE);
|
||||
|
||||
function prepare_tag(next, token) {
|
||||
var tag = token[0];
|
||||
|
||||
function select(context, result) {
|
||||
var i, len, elem, rv = [];
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
elem._children.forEach(function(e) {
|
||||
if (e.tag === tag) {
|
||||
rv.push(e);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
return select;
|
||||
}
|
||||
|
||||
function prepare_star(next, token) {
|
||||
function select(context, result) {
|
||||
var i, len, elem, rv = [];
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
elem._children.forEach(function(e) {
|
||||
rv.push(e);
|
||||
});
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
return select;
|
||||
}
|
||||
|
||||
function prepare_dot(next, token) {
|
||||
function select(context, result) {
|
||||
var i, len, elem, rv = [];
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
rv.push(elem);
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
return select;
|
||||
}
|
||||
|
||||
function prepare_iter(next, token) {
|
||||
var tag;
|
||||
token = next();
|
||||
|
||||
if (token[1] === '*') {
|
||||
tag = '*';
|
||||
}
|
||||
else if (!token[1]) {
|
||||
tag = token[0] || '';
|
||||
}
|
||||
else {
|
||||
throw new SyntaxError(token);
|
||||
}
|
||||
|
||||
function select(context, result) {
|
||||
var i, len, elem, rv = [];
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
elem.iter(tag, function(e) {
|
||||
if (e !== elem) {
|
||||
rv.push(e);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
return select;
|
||||
}
|
||||
|
||||
function prepare_dot_dot(next, token) {
|
||||
function select(context, result) {
|
||||
var i, len, elem, rv = [], parent_map = context.parent_map;
|
||||
|
||||
if (!parent_map) {
|
||||
context.parent_map = parent_map = {};
|
||||
|
||||
context.root.iter(null, function(p) {
|
||||
p._children.forEach(function(e) {
|
||||
parent_map[e] = p;
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
|
||||
if (parent_map.hasOwnProperty(elem)) {
|
||||
rv.push(parent_map[elem]);
|
||||
}
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
return select;
|
||||
}
|
||||
|
||||
|
||||
function prepare_predicate(next, token) {
|
||||
var tag, key, value, select;
|
||||
token = next();
|
||||
|
||||
if (token[1] === '@') {
|
||||
// attribute
|
||||
token = next();
|
||||
|
||||
if (token[1]) {
|
||||
throw new SyntaxError(token, 'Invalid attribute predicate');
|
||||
}
|
||||
|
||||
key = token[0];
|
||||
token = next();
|
||||
|
||||
if (token[1] === ']') {
|
||||
select = function(context, result) {
|
||||
var i, len, elem, rv = [];
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
|
||||
if (elem.get(key)) {
|
||||
rv.push(elem);
|
||||
}
|
||||
}
|
||||
|
||||
return rv;
|
||||
};
|
||||
}
|
||||
else if (token[1] === '=') {
|
||||
value = next()[1];
|
||||
|
||||
if (value[0] === '"' || value[value.length - 1] === '\'') {
|
||||
value = value.slice(1, value.length - 1);
|
||||
}
|
||||
else {
|
||||
throw new SyntaxError(token, 'Ivalid comparison target');
|
||||
}
|
||||
|
||||
token = next();
|
||||
select = function(context, result) {
|
||||
var i, len, elem, rv = [];
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
|
||||
if (elem.get(key) === value) {
|
||||
rv.push(elem);
|
||||
}
|
||||
}
|
||||
|
||||
return rv;
|
||||
};
|
||||
}
|
||||
|
||||
if (token[1] !== ']') {
|
||||
throw new SyntaxError(token, 'Invalid attribute predicate');
|
||||
}
|
||||
}
|
||||
else if (!token[1]) {
|
||||
tag = token[0] || '';
|
||||
token = next();
|
||||
|
||||
if (token[1] !== ']') {
|
||||
throw new SyntaxError(token, 'Invalid node predicate');
|
||||
}
|
||||
|
||||
select = function(context, result) {
|
||||
var i, len, elem, rv = [];
|
||||
|
||||
for (i = 0, len = result.length; i < len; i++) {
|
||||
elem = result[i];
|
||||
|
||||
if (elem.find(tag)) {
|
||||
rv.push(elem);
|
||||
}
|
||||
}
|
||||
|
||||
return rv;
|
||||
};
|
||||
}
|
||||
else {
|
||||
throw new SyntaxError(null, 'Invalid predicate');
|
||||
}
|
||||
|
||||
return select;
|
||||
}
|
||||
|
||||
|
||||
|
||||
var ops = {
|
||||
"": prepare_tag,
|
||||
"*": prepare_star,
|
||||
".": prepare_dot,
|
||||
"..": prepare_dot_dot,
|
||||
"//": prepare_iter,
|
||||
"[": prepare_predicate,
|
||||
};
|
||||
|
||||
function _SelectorContext(root) {
|
||||
this.parent_map = null;
|
||||
this.root = root;
|
||||
}
|
||||
|
||||
function findall(elem, path) {
|
||||
var selector, result, i, len, token, value, select, context;
|
||||
|
||||
if (_cache.hasOwnProperty(path)) {
|
||||
selector = _cache[path];
|
||||
}
|
||||
else {
|
||||
// TODO: Use smarter cache purging approach
|
||||
if (Object.keys(_cache).length > 100) {
|
||||
_cache = {};
|
||||
}
|
||||
|
||||
if (path.charAt(0) === '/') {
|
||||
throw new SyntaxError(null, 'Cannot use absolute path on element');
|
||||
}
|
||||
|
||||
result = xpath_tokenizer(path);
|
||||
selector = [];
|
||||
|
||||
function getToken() {
|
||||
return result.shift();
|
||||
}
|
||||
|
||||
token = getToken();
|
||||
while (true) {
|
||||
var c = token[1] || '';
|
||||
value = ops[c](getToken, token);
|
||||
|
||||
if (!value) {
|
||||
throw new SyntaxError(null, sprintf('Invalid path: %s', path));
|
||||
}
|
||||
|
||||
selector.push(value);
|
||||
token = getToken();
|
||||
|
||||
if (!token) {
|
||||
break;
|
||||
}
|
||||
else if (token[1] === '/') {
|
||||
token = getToken();
|
||||
}
|
||||
|
||||
if (!token) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
_cache[path] = selector;
|
||||
}
|
||||
|
||||
// Execute slector pattern
|
||||
result = [elem];
|
||||
context = new _SelectorContext(elem);
|
||||
|
||||
for (i = 0, len = selector.length; i < len; i++) {
|
||||
select = selector[i];
|
||||
result = select(context, result);
|
||||
}
|
||||
|
||||
return result || [];
|
||||
}
|
||||
|
||||
function find(element, path) {
|
||||
var resultElements = findall(element, path);
|
||||
|
||||
if (resultElements && resultElements.length > 0) {
|
||||
return resultElements[0];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
function findtext(element, path, defvalue) {
|
||||
var resultElements = findall(element, path);
|
||||
|
||||
if (resultElements && resultElements.length > 0) {
|
||||
return resultElements[0].text;
|
||||
}
|
||||
|
||||
return defvalue;
|
||||
}
|
||||
|
||||
|
||||
exports.find = find;
|
||||
exports.findall = findall;
|
||||
exports.findtext = findtext;
|
||||
-611
@@ -1,611 +0,0 @@
|
||||
/**
|
||||
* Copyright 2011 Rackspace
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
var sprintf = require('./sprintf').sprintf;
|
||||
|
||||
var utils = require('./utils');
|
||||
var ElementPath = require('./elementpath');
|
||||
var TreeBuilder = require('./treebuilder').TreeBuilder;
|
||||
var get_parser = require('./parser').get_parser;
|
||||
var constants = require('./constants');
|
||||
|
||||
var element_ids = 0;
|
||||
|
||||
function Element(tag, attrib)
|
||||
{
|
||||
this._id = element_ids++;
|
||||
this.tag = tag;
|
||||
this.attrib = {};
|
||||
this.text = null;
|
||||
this.tail = null;
|
||||
this._children = [];
|
||||
|
||||
if (attrib) {
|
||||
this.attrib = utils.merge(this.attrib, attrib);
|
||||
}
|
||||
}
|
||||
|
||||
Element.prototype.toString = function()
|
||||
{
|
||||
return sprintf("<Element %s at %s>", this.tag, this._id);
|
||||
};
|
||||
|
||||
Element.prototype.makeelement = function(tag, attrib)
|
||||
{
|
||||
return new Element(tag, attrib);
|
||||
};
|
||||
|
||||
Element.prototype.len = function()
|
||||
{
|
||||
return this._children.length;
|
||||
};
|
||||
|
||||
Element.prototype.getItem = function(index)
|
||||
{
|
||||
return this._children[index];
|
||||
};
|
||||
|
||||
Element.prototype.setItem = function(index, element)
|
||||
{
|
||||
this._children[index] = element;
|
||||
};
|
||||
|
||||
Element.prototype.delItem = function(index)
|
||||
{
|
||||
this._children.splice(index, 1);
|
||||
};
|
||||
|
||||
Element.prototype.getSlice = function(start, stop)
|
||||
{
|
||||
return this._children.slice(start, stop);
|
||||
};
|
||||
|
||||
Element.prototype.setSlice = function(start, stop, elements)
|
||||
{
|
||||
var i;
|
||||
var k = 0;
|
||||
for (i = start; i < stop; i++, k++) {
|
||||
this._children[i] = elements[k];
|
||||
}
|
||||
};
|
||||
|
||||
Element.prototype.delSlice = function(start, stop)
|
||||
{
|
||||
this._children.splice(start, stop - start);
|
||||
};
|
||||
|
||||
Element.prototype.append = function(element)
|
||||
{
|
||||
this._children.push(element);
|
||||
};
|
||||
|
||||
Element.prototype.extend = function(elements)
|
||||
{
|
||||
this._children.concat(elements);
|
||||
};
|
||||
|
||||
Element.prototype.insert = function(index, element)
|
||||
{
|
||||
this._children[index] = element;
|
||||
};
|
||||
|
||||
Element.prototype.remove = function(element)
|
||||
{
|
||||
this._children = this._children.filter(function(e) {
|
||||
/* TODO: is this the right way to do this? */
|
||||
if (e._id === element._id) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
};
|
||||
|
||||
Element.prototype.getchildren = function() {
|
||||
return this._children;
|
||||
};
|
||||
|
||||
Element.prototype.find = function(path)
|
||||
{
|
||||
return ElementPath.find(this, path);
|
||||
};
|
||||
|
||||
Element.prototype.findtext = function(path, defvalue)
|
||||
{
|
||||
return ElementPath.findtext(this, path, defvalue);
|
||||
};
|
||||
|
||||
Element.prototype.findall = function(path, defvalue)
|
||||
{
|
||||
return ElementPath.findall(this, path, defvalue);
|
||||
};
|
||||
|
||||
Element.prototype.clear = function()
|
||||
{
|
||||
this.attrib = {};
|
||||
this._children = [];
|
||||
this.text = null;
|
||||
this.tail = null;
|
||||
};
|
||||
|
||||
Element.prototype.get = function(key, defvalue)
|
||||
{
|
||||
if (this.attrib[key] !== undefined) {
|
||||
return this.attrib[key];
|
||||
}
|
||||
else {
|
||||
return defvalue;
|
||||
}
|
||||
};
|
||||
|
||||
Element.prototype.set = function(key, value)
|
||||
{
|
||||
this.attrib[key] = value;
|
||||
};
|
||||
|
||||
Element.prototype.keys = function()
|
||||
{
|
||||
return Object.keys(this.attrib);
|
||||
};
|
||||
|
||||
Element.prototype.items = function()
|
||||
{
|
||||
return utils.items(this.attrib);
|
||||
};
|
||||
|
||||
/*
|
||||
* In python this uses a generator, but in v8 we don't have em,
|
||||
* so we use a callback instead.
|
||||
**/
|
||||
Element.prototype.iter = function(tag, callback)
|
||||
{
|
||||
var self = this;
|
||||
var i, child;
|
||||
|
||||
if (tag === "*") {
|
||||
tag = null;
|
||||
}
|
||||
|
||||
if (tag === null || this.tag === tag) {
|
||||
callback(self);
|
||||
}
|
||||
|
||||
for (i = 0; i < this._children.length; i++) {
|
||||
child = this._children[i];
|
||||
child.iter(tag, function(e) {
|
||||
callback(e);
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
Element.prototype.itertext = function(callback)
|
||||
{
|
||||
this.iter(null, function(e) {
|
||||
if (e.text) {
|
||||
callback(e.text);
|
||||
}
|
||||
|
||||
if (e.tail) {
|
||||
callback(e.tail);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
function SubElement(parent, tag, attrib) {
|
||||
var element = parent.makeelement(tag, attrib);
|
||||
parent.append(element);
|
||||
return element;
|
||||
}
|
||||
|
||||
function Comment(text) {
|
||||
var element = new Element(Comment);
|
||||
if (text) {
|
||||
element.text = text;
|
||||
}
|
||||
return element;
|
||||
}
|
||||
|
||||
function CData(text) {
|
||||
var element = new Element(CData);
|
||||
if (text) {
|
||||
element.text = text;
|
||||
}
|
||||
return element;
|
||||
}
|
||||
|
||||
function ProcessingInstruction(target, text)
|
||||
{
|
||||
var element = new Element(ProcessingInstruction);
|
||||
element.text = target;
|
||||
if (text) {
|
||||
element.text = element.text + " " + text;
|
||||
}
|
||||
return element;
|
||||
}
|
||||
|
||||
function QName(text_or_uri, tag)
|
||||
{
|
||||
if (tag) {
|
||||
text_or_uri = sprintf("{%s}%s", text_or_uri, tag);
|
||||
}
|
||||
this.text = text_or_uri;
|
||||
}
|
||||
|
||||
QName.prototype.toString = function() {
|
||||
return this.text;
|
||||
};
|
||||
|
||||
function ElementTree(element)
|
||||
{
|
||||
this._root = element;
|
||||
}
|
||||
|
||||
ElementTree.prototype.getroot = function() {
|
||||
return this._root;
|
||||
};
|
||||
|
||||
ElementTree.prototype._setroot = function(element) {
|
||||
this._root = element;
|
||||
};
|
||||
|
||||
ElementTree.prototype.parse = function(source, parser) {
|
||||
if (!parser) {
|
||||
parser = get_parser(constants.DEFAULT_PARSER);
|
||||
parser = new parser.XMLParser(new TreeBuilder());
|
||||
}
|
||||
|
||||
parser.feed(source);
|
||||
this._root = parser.close();
|
||||
return this._root;
|
||||
};
|
||||
|
||||
ElementTree.prototype.iter = function(tag, callback) {
|
||||
this._root.iter(tag, callback);
|
||||
};
|
||||
|
||||
ElementTree.prototype.find = function(path) {
|
||||
return this._root.find(path);
|
||||
};
|
||||
|
||||
ElementTree.prototype.findtext = function(path, defvalue) {
|
||||
return this._root.findtext(path, defvalue);
|
||||
};
|
||||
|
||||
ElementTree.prototype.findall = function(path) {
|
||||
return this._root.findall(path);
|
||||
};
|
||||
|
||||
/**
|
||||
* Unlike ElementTree, we don't write to a file, we return you a string.
|
||||
*/
|
||||
ElementTree.prototype.write = function(options) {
|
||||
var sb = [];
|
||||
options = utils.merge({
|
||||
encoding: 'utf-8',
|
||||
xml_declaration: null,
|
||||
default_namespace: null,
|
||||
method: 'xml'}, options);
|
||||
|
||||
if (options.xml_declaration !== false) {
|
||||
sb.push("<?xml version='1.0' encoding='"+options.encoding +"'?>\n");
|
||||
}
|
||||
|
||||
if (options.method === "text") {
|
||||
_serialize_text(sb, self._root, encoding);
|
||||
}
|
||||
else {
|
||||
var qnames, namespaces, indent, indent_string;
|
||||
var x = _namespaces(this._root, options.encoding, options.default_namespace);
|
||||
qnames = x[0];
|
||||
namespaces = x[1];
|
||||
|
||||
if (options.hasOwnProperty('indent')) {
|
||||
indent = 0;
|
||||
indent_string = new Array(options.indent + 1).join(' ');
|
||||
}
|
||||
else {
|
||||
indent = false;
|
||||
}
|
||||
|
||||
if (options.method === "xml") {
|
||||
_serialize_xml(function(data) {
|
||||
sb.push(data);
|
||||
}, this._root, options.encoding, qnames, namespaces, indent, indent_string);
|
||||
}
|
||||
else {
|
||||
/* TODO: html */
|
||||
throw new Error("unknown serialization method "+ options.method);
|
||||
}
|
||||
}
|
||||
|
||||
return sb.join("");
|
||||
};
|
||||
|
||||
var _namespace_map = {
|
||||
/* "well-known" namespace prefixes */
|
||||
"http://www.w3.org/XML/1998/namespace": "xml",
|
||||
"http://www.w3.org/1999/xhtml": "html",
|
||||
"http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
|
||||
"http://schemas.xmlsoap.org/wsdl/": "wsdl",
|
||||
/* xml schema */
|
||||
"http://www.w3.org/2001/XMLSchema": "xs",
|
||||
"http://www.w3.org/2001/XMLSchema-instance": "xsi",
|
||||
/* dublic core */
|
||||
"http://purl.org/dc/elements/1.1/": "dc",
|
||||
};
|
||||
|
||||
function register_namespace(prefix, uri) {
|
||||
if (/ns\d+$/.test(prefix)) {
|
||||
throw new Error('Prefix format reserved for internal use');
|
||||
}
|
||||
|
||||
if (_namespace_map.hasOwnProperty(uri) && _namespace_map[uri] === prefix) {
|
||||
delete _namespace_map[uri];
|
||||
}
|
||||
|
||||
_namespace_map[uri] = prefix;
|
||||
}
|
||||
|
||||
|
||||
function _escape(text, encoding, isAttribute, isText) {
|
||||
if (text) {
|
||||
text = text.toString();
|
||||
text = text.replace(/&/g, '&');
|
||||
text = text.replace(/</g, '<');
|
||||
text = text.replace(/>/g, '>');
|
||||
if (!isText) {
|
||||
text = text.replace(/\n/g, '
');
|
||||
text = text.replace(/\r/g, '
');
|
||||
}
|
||||
if (isAttribute) {
|
||||
text = text.replace(/"/g, '"');
|
||||
}
|
||||
}
|
||||
return text;
|
||||
}
|
||||
|
||||
/* TODO: benchmark single regex */
|
||||
function _escape_attrib(text, encoding) {
|
||||
return _escape(text, encoding, true);
|
||||
}
|
||||
|
||||
function _escape_cdata(text, encoding) {
|
||||
return _escape(text, encoding, false);
|
||||
}
|
||||
|
||||
function _escape_text(text, encoding) {
|
||||
return _escape(text, encoding, false, true);
|
||||
}
|
||||
|
||||
function _namespaces(elem, encoding, default_namespace) {
|
||||
var qnames = {};
|
||||
var namespaces = {};
|
||||
|
||||
if (default_namespace) {
|
||||
namespaces[default_namespace] = "";
|
||||
}
|
||||
|
||||
function encode(text) {
|
||||
return text;
|
||||
}
|
||||
|
||||
function add_qname(qname) {
|
||||
if (qname[0] === "{") {
|
||||
var tmp = qname.substring(1).split("}", 2);
|
||||
var uri = tmp[0];
|
||||
var tag = tmp[1];
|
||||
var prefix = namespaces[uri];
|
||||
|
||||
if (prefix === undefined) {
|
||||
prefix = _namespace_map[uri];
|
||||
if (prefix === undefined) {
|
||||
prefix = "ns" + Object.keys(namespaces).length;
|
||||
}
|
||||
if (prefix !== "xml") {
|
||||
namespaces[uri] = prefix;
|
||||
}
|
||||
}
|
||||
|
||||
if (prefix) {
|
||||
qnames[qname] = sprintf("%s:%s", prefix, tag);
|
||||
}
|
||||
else {
|
||||
qnames[qname] = tag;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (default_namespace) {
|
||||
throw new Error('cannot use non-qualified names with default_namespace option');
|
||||
}
|
||||
|
||||
qnames[qname] = qname;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
elem.iter(null, function(e) {
|
||||
var i;
|
||||
var tag = e.tag;
|
||||
var text = e.text;
|
||||
var items = e.items();
|
||||
|
||||
if (tag instanceof QName && qnames[tag.text] === undefined) {
|
||||
add_qname(tag.text);
|
||||
}
|
||||
else if (typeof(tag) === "string") {
|
||||
add_qname(tag);
|
||||
}
|
||||
else if (tag !== null && tag !== Comment && tag !== CData && tag !== ProcessingInstruction) {
|
||||
throw new Error('Invalid tag type for serialization: '+ tag);
|
||||
}
|
||||
|
||||
if (text instanceof QName && qnames[text.text] === undefined) {
|
||||
add_qname(text.text);
|
||||
}
|
||||
|
||||
items.forEach(function(item) {
|
||||
var key = item[0],
|
||||
value = item[1];
|
||||
if (key instanceof QName) {
|
||||
key = key.text;
|
||||
}
|
||||
|
||||
if (qnames[key] === undefined) {
|
||||
add_qname(key);
|
||||
}
|
||||
|
||||
if (value instanceof QName && qnames[value.text] === undefined) {
|
||||
add_qname(value.text);
|
||||
}
|
||||
});
|
||||
});
|
||||
return [qnames, namespaces];
|
||||
}
|
||||
|
||||
function _serialize_xml(write, elem, encoding, qnames, namespaces, indent, indent_string) {
|
||||
var tag = elem.tag;
|
||||
var text = elem.text;
|
||||
var items;
|
||||
var i;
|
||||
|
||||
var newlines = indent || (indent === 0);
|
||||
write(Array(indent + 1).join(indent_string));
|
||||
|
||||
if (tag === Comment) {
|
||||
write(sprintf("<!--%s-->", _escape_cdata(text, encoding)));
|
||||
}
|
||||
else if (tag === ProcessingInstruction) {
|
||||
write(sprintf("<?%s?>", _escape_cdata(text, encoding)));
|
||||
}
|
||||
else if (tag === CData) {
|
||||
text = text || '';
|
||||
write(sprintf("<![CDATA[%s]]>", text));
|
||||
}
|
||||
else {
|
||||
tag = qnames[tag];
|
||||
if (tag === undefined) {
|
||||
if (text) {
|
||||
write(_escape_text(text, encoding));
|
||||
}
|
||||
elem.iter(function(e) {
|
||||
_serialize_xml(write, e, encoding, qnames, null, newlines ? indent + 1 : false, indent_string);
|
||||
});
|
||||
}
|
||||
else {
|
||||
write("<" + tag);
|
||||
items = elem.items();
|
||||
|
||||
if (items || namespaces) {
|
||||
items.sort(); // lexical order
|
||||
|
||||
items.forEach(function(item) {
|
||||
var k = item[0],
|
||||
v = item[1];
|
||||
|
||||
if (k instanceof QName) {
|
||||
k = k.text;
|
||||
}
|
||||
|
||||
if (v instanceof QName) {
|
||||
v = qnames[v.text];
|
||||
}
|
||||
else {
|
||||
v = _escape_attrib(v, encoding);
|
||||
}
|
||||
write(sprintf(" %s=\"%s\"", qnames[k], v));
|
||||
});
|
||||
|
||||
if (namespaces) {
|
||||
items = utils.items(namespaces);
|
||||
items.sort(function(a, b) { return a[1] < b[1]; });
|
||||
|
||||
items.forEach(function(item) {
|
||||
var k = item[1],
|
||||
v = item[0];
|
||||
|
||||
if (k) {
|
||||
k = ':' + k;
|
||||
}
|
||||
|
||||
write(sprintf(" xmlns%s=\"%s\"", k, _escape_attrib(v, encoding)));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (text || elem.len()) {
|
||||
if (text && text.toString().match(/^\s*$/)) {
|
||||
text = null;
|
||||
}
|
||||
|
||||
write(">");
|
||||
if (!text && newlines) {
|
||||
write("\n");
|
||||
}
|
||||
|
||||
if (text) {
|
||||
write(_escape_text(text, encoding));
|
||||
}
|
||||
elem._children.forEach(function(e) {
|
||||
_serialize_xml(write, e, encoding, qnames, null, newlines ? indent + 1 : false, indent_string);
|
||||
});
|
||||
|
||||
if (!text && indent) {
|
||||
write(Array(indent + 1).join(indent_string));
|
||||
}
|
||||
write("</" + tag + ">");
|
||||
}
|
||||
else {
|
||||
write(" />");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (newlines) {
|
||||
write("\n");
|
||||
}
|
||||
}
|
||||
|
||||
function parse(source, parser) {
|
||||
var tree = new ElementTree();
|
||||
tree.parse(source, parser);
|
||||
return tree;
|
||||
}
|
||||
|
||||
function tostring(element, options) {
|
||||
return new ElementTree(element).write(options);
|
||||
}
|
||||
|
||||
exports.PI = ProcessingInstruction;
|
||||
exports.Comment = Comment;
|
||||
exports.CData = CData;
|
||||
exports.ProcessingInstruction = ProcessingInstruction;
|
||||
exports.SubElement = SubElement;
|
||||
exports.QName = QName;
|
||||
exports.ElementTree = ElementTree;
|
||||
exports.ElementPath = ElementPath;
|
||||
exports.Element = function(tag, attrib) {
|
||||
return new Element(tag, attrib);
|
||||
};
|
||||
|
||||
exports.XML = function(data) {
|
||||
var et = new ElementTree();
|
||||
return et.parse(data);
|
||||
};
|
||||
|
||||
exports.parse = parse;
|
||||
exports.register_namespace = register_namespace;
|
||||
exports.tostring = tostring;
|
||||
-31
@@ -1,31 +0,0 @@
|
||||
/**
|
||||
* Copyright 2011 Rackspace
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
var util = require('util');
|
||||
|
||||
var sprintf = require('./sprintf').sprintf;
|
||||
|
||||
function SyntaxError(token, msg) {
|
||||
msg = msg || sprintf('Syntax Error at token %s', token.toString());
|
||||
this.token = token;
|
||||
this.message = msg;
|
||||
Error.call(this, msg);
|
||||
}
|
||||
|
||||
util.inherits(SyntaxError, Error);
|
||||
|
||||
exports.SyntaxError = SyntaxError;
|
||||
-33
@@ -1,33 +0,0 @@
|
||||
/*
|
||||
* Copyright 2011 Rackspace
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/* TODO: support node-expat C++ module optionally */
|
||||
|
||||
var util = require('util');
|
||||
var parsers = require('./parsers/index');
|
||||
|
||||
function get_parser(name) {
|
||||
if (name === 'sax') {
|
||||
return parsers.sax;
|
||||
}
|
||||
else {
|
||||
throw new Error('Invalid parser: ' + name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
exports.get_parser = get_parser;
|
||||
-1
@@ -1 +0,0 @@
|
||||
exports.sax = require('./sax');
|
||||
-56
@@ -1,56 +0,0 @@
|
||||
var util = require('util');
|
||||
|
||||
var sax = require('sax');
|
||||
|
||||
var TreeBuilder = require('./../treebuilder').TreeBuilder;
|
||||
|
||||
function XMLParser(target) {
|
||||
this.parser = sax.parser(true);
|
||||
|
||||
this.target = (target) ? target : new TreeBuilder();
|
||||
|
||||
this.parser.onopentag = this._handleOpenTag.bind(this);
|
||||
this.parser.ontext = this._handleText.bind(this);
|
||||
this.parser.oncdata = this._handleCdata.bind(this);
|
||||
this.parser.ondoctype = this._handleDoctype.bind(this);
|
||||
this.parser.oncomment = this._handleComment.bind(this);
|
||||
this.parser.onclosetag = this._handleCloseTag.bind(this);
|
||||
this.parser.onerror = this._handleError.bind(this);
|
||||
}
|
||||
|
||||
XMLParser.prototype._handleOpenTag = function(tag) {
|
||||
this.target.start(tag.name, tag.attributes);
|
||||
};
|
||||
|
||||
XMLParser.prototype._handleText = function(text) {
|
||||
this.target.data(text);
|
||||
};
|
||||
|
||||
XMLParser.prototype._handleCdata = function(text) {
|
||||
this.target.data(text);
|
||||
};
|
||||
|
||||
XMLParser.prototype._handleDoctype = function(text) {
|
||||
};
|
||||
|
||||
XMLParser.prototype._handleComment = function(comment) {
|
||||
};
|
||||
|
||||
XMLParser.prototype._handleCloseTag = function(tag) {
|
||||
this.target.end(tag);
|
||||
};
|
||||
|
||||
XMLParser.prototype._handleError = function(err) {
|
||||
throw err;
|
||||
};
|
||||
|
||||
XMLParser.prototype.feed = function(chunk) {
|
||||
this.parser.write(chunk);
|
||||
};
|
||||
|
||||
XMLParser.prototype.close = function() {
|
||||
this.parser.close();
|
||||
return this.target.close();
|
||||
};
|
||||
|
||||
exports.XMLParser = XMLParser;
|
||||
-86
@@ -1,86 +0,0 @@
|
||||
/*
|
||||
* Copyright 2011 Rackspace
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
var cache = {};
|
||||
|
||||
|
||||
// Do any others need escaping?
|
||||
var TO_ESCAPE = {
|
||||
'\'': '\\\'',
|
||||
'\n': '\\n'
|
||||
};
|
||||
|
||||
|
||||
function populate(formatter) {
|
||||
var i, type,
|
||||
key = formatter,
|
||||
prev = 0,
|
||||
arg = 1,
|
||||
builder = 'return \'';
|
||||
|
||||
for (i = 0; i < formatter.length; i++) {
|
||||
if (formatter[i] === '%') {
|
||||
type = formatter[i + 1];
|
||||
|
||||
switch (type) {
|
||||
case 's':
|
||||
builder += formatter.slice(prev, i) + '\' + arguments[' + arg + '] + \'';
|
||||
prev = i + 2;
|
||||
arg++;
|
||||
break;
|
||||
case 'j':
|
||||
builder += formatter.slice(prev, i) + '\' + JSON.stringify(arguments[' + arg + ']) + \'';
|
||||
prev = i + 2;
|
||||
arg++;
|
||||
break;
|
||||
case '%':
|
||||
builder += formatter.slice(prev, i + 1);
|
||||
prev = i + 2;
|
||||
i++;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
} else if (TO_ESCAPE[formatter[i]]) {
|
||||
builder += formatter.slice(prev, i) + TO_ESCAPE[formatter[i]];
|
||||
prev = i + 1;
|
||||
}
|
||||
}
|
||||
|
||||
builder += formatter.slice(prev) + '\';';
|
||||
cache[key] = new Function(builder);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A fast version of sprintf(), which currently only supports the %s and %j.
|
||||
* This caches a formatting function for each format string that is used, so
|
||||
* you should only use this sprintf() will be called many times with a single
|
||||
* format string and a limited number of format strings will ever be used (in
|
||||
* general this means that format strings should be string literals).
|
||||
*
|
||||
* @param {String} formatter A format string.
|
||||
* @param {...String} var_args Values that will be formatted by %s and %j.
|
||||
* @return {String} The formatted output.
|
||||
*/
|
||||
exports.sprintf = function(formatter, var_args) {
|
||||
if (!cache[formatter]) {
|
||||
populate(formatter);
|
||||
}
|
||||
|
||||
return cache[formatter].apply(null, arguments);
|
||||
};
|
||||
-60
@@ -1,60 +0,0 @@
|
||||
function TreeBuilder(element_factory) {
|
||||
this._data = [];
|
||||
this._elem = [];
|
||||
this._last = null;
|
||||
this._tail = null;
|
||||
if (!element_factory) {
|
||||
/* evil circular dep */
|
||||
element_factory = require('./elementtree').Element;
|
||||
}
|
||||
this._factory = element_factory;
|
||||
}
|
||||
|
||||
TreeBuilder.prototype.close = function() {
|
||||
return this._last;
|
||||
};
|
||||
|
||||
TreeBuilder.prototype._flush = function() {
|
||||
if (this._data) {
|
||||
if (this._last !== null) {
|
||||
var text = this._data.join("");
|
||||
if (this._tail) {
|
||||
this._last.tail = text;
|
||||
}
|
||||
else {
|
||||
this._last.text = text;
|
||||
}
|
||||
}
|
||||
this._data = [];
|
||||
}
|
||||
};
|
||||
|
||||
TreeBuilder.prototype.data = function(data) {
|
||||
this._data.push(data);
|
||||
};
|
||||
|
||||
TreeBuilder.prototype.start = function(tag, attrs) {
|
||||
this._flush();
|
||||
var elem = this._factory(tag, attrs);
|
||||
this._last = elem;
|
||||
|
||||
if (this._elem.length) {
|
||||
this._elem[this._elem.length - 1].append(elem);
|
||||
}
|
||||
|
||||
this._elem.push(elem);
|
||||
|
||||
this._tail = null;
|
||||
};
|
||||
|
||||
TreeBuilder.prototype.end = function(tag) {
|
||||
this._flush();
|
||||
this._last = this._elem.pop();
|
||||
if (this._last.tag !== tag) {
|
||||
throw new Error("end tag mismatch");
|
||||
}
|
||||
this._tail = 1;
|
||||
return this._last;
|
||||
};
|
||||
|
||||
exports.TreeBuilder = TreeBuilder;
|
||||
-72
@@ -1,72 +0,0 @@
|
||||
/**
|
||||
* Copyright 2011 Rackspace
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param {Object} hash.
|
||||
* @param {Array} ignored.
|
||||
*/
|
||||
function items(hash, ignored) {
|
||||
ignored = ignored || null;
|
||||
var k, rv = [];
|
||||
|
||||
function is_ignored(key) {
|
||||
if (!ignored || ignored.length === 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return ignored.indexOf(key);
|
||||
}
|
||||
|
||||
for (k in hash) {
|
||||
if (hash.hasOwnProperty(k) && !(is_ignored(ignored))) {
|
||||
rv.push([k, hash[k]]);
|
||||
}
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
||||
function findall(re, str) {
|
||||
var match, matches = [];
|
||||
|
||||
while ((match = re.exec(str))) {
|
||||
matches.push(match);
|
||||
}
|
||||
|
||||
return matches;
|
||||
}
|
||||
|
||||
function merge(a, b) {
|
||||
var c = {}, attrname;
|
||||
|
||||
for (attrname in a) {
|
||||
if (a.hasOwnProperty(attrname)) {
|
||||
c[attrname] = a[attrname];
|
||||
}
|
||||
}
|
||||
for (attrname in b) {
|
||||
if (b.hasOwnProperty(attrname)) {
|
||||
c[attrname] = b[attrname];
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
exports.items = items;
|
||||
exports.findall = findall;
|
||||
exports.merge = merge;
|
||||
Reference in New Issue
Block a user