mediawiki-extensions-Visual.../modules/parser/mediawiki.DOMConverter.js

468 lines
12 KiB
JavaScript
Raw Normal View History

/**
* Conversions between HTML DOM and WikiDom
*
* @author Gabriel Wicke <gwicke@wikimedia.org>
*
* @class
* @constructor
*/
function DOMConverter () {
}
2011-12-15 10:55:30 +00:00
/**
* Convert HTML DOM to WikiDom
2011-12-15 10:55:30 +00:00
*
* @method
* @param {Object} root of HTML DOM (usually the body element)
* @returns {Object} WikiDom representation
*/
DOMConverter.prototype.HTMLtoWiki = function ( node ) {
return this._convertHTMLBranch( node, 'document' ).node;
};
2011-12-15 10:55:30 +00:00
/* Private stuff */
/**
* Map an HTML node name to (handler, wikiDomName [, attribs]). Only
* non-annotation html elements are handled here. The conversion should thus
* use this._getWikiDomAnnotationType first to check if the element is actually
* an annotation.
*
* @static
* @method
* @param {String} nodeName, the element's nodeName.
* @returns {Object} with keys 'handler' (one of the _convertHTMLLeaf and
* _convertHTMLBranch functions), 'type' (the name of this element in WikiDom)
* and optionally 'attribs', WikiDom-specific attributes implied by the element name.
*/
DOMConverter.prototype._getHTMLtoWikiDomHandlerInfo = function ( nodeName ) {
var wikiName = '';
switch ( nodeName.toLowerCase() ) {
// leaf nodes first, with fall-through to last leaf..
case 'p':
return {
handler: this._convertHTMLLeaf,
type: 'paragraph'
};
case 'h1':
case 'h2':
case 'h3':
case 'h4':
case 'h5':
case 'h6':
return {
handler: this._convertHTMLLeaf,
type: 'heading',
attribs: { level: nodeName.substr(1) }
};
case 'li':
case 'dt':
case 'dd':
return {
handler: this._convertHTMLBranch,
type: 'listItem'
};
case 'pre':
return {
handler: this._convertHTMLLeaf,
type: 'pre'
};
case 'table':
return {
handler: this._convertHTMLBranch,
type: 'table'
};
case 'tbody':
return {
handler: this._convertHTMLBranch,
type: 'tbody' // not in WikiDom!
};
case 'tr':
return {
handler: this._convertHTMLBranch,
type: 'tableRow'
};
case 'th':
return {
handler: this._convertHTMLBranch,
type: 'tableHeading'
};
case 'td':
return {
handler: this._convertHTMLBranch,
type: 'tableCell'
};
case 'caption':
return {
handler: this._convertHTMLBranch,
type: 'caption'
};
case 'hr':
return {
handler: this._convertHTMLLeaf,
type: 'horizontalRule' // XXX?
};
case 'ul':
case 'ol':
case 'dl':
return {
handler: this._convertHTMLBranch,
type: 'list'
};
case 'center':
//XXX: center is block-level in HTML, not sure what it should be
//in WikiDOM..
return {
handler: this._convertHTMLBranch,
type: 'center'
};
case 'blockquote':
//XXX: blockquote is block-level in HTML, not sure what it should be
//in WikiDOM..
return {
handler: this._convertHTMLBranch,
type: 'blockquote'
};
default:
console.log( 'HTML to Wiki DOM conversion warning: Unknown node name ' +
nodeName );
return {
handler: this._convertHTMLBranch,
type: nodeName.toLowerCase()
};
}
};
2011-12-15 10:55:30 +00:00
/**
* Map HTML element names to WikiDom annotation types or undefined.
*
* @param {String} nodeName, the HTML element name
* @param {Boolean} warn (optional), enable warnings for non-annotation
* element types
* @returns {String} WikiDom annotation type or undefined if element name does
* not map to an annotation.
*/
DOMConverter.prototype._getWikiDomAnnotationType = function ( node, warn ) {
var name = node.nodeName.toLowerCase();
switch ( name ) {
case 'i':
return 'textStyle/italic';
case 'b':
return 'textStyle/bold';
case 'span':
return 'textStyle/span';
case 'a':
var atype = node.getAttribute( 'data-type' );
if ( atype ) {
return 'link/' + atype;
} else {
return 'link/unknown';
}
break; // make JSHint happy
case 'template':
return 'object/template';
case 'ref':
return 'object/hook';
case 'includeonly':
return 'object/includeonly'; // XXX
default:
if ( warn ) {
2011-12-28 01:36:54 +00:00
console.log( 'HTML to Wiki DOM conversion warning: Unsupported html annotation ' + name );
}
return undefined;
}
};
/**
* Private HTML branch node handler
*
* @param {Object} HTML DOM element
* @param {Int} WikiDom offset within a block
* @returns {Object} WikiDom object
*/
DOMConverter.prototype._convertHTMLBranch = function ( node, type ) {
var children = node.childNodes,
wnode = {
type: type,
attributes: this._HTMLPropertiesToWikiAttributes( node ),
children: []
},
parNode = null,
offset = 0,
res;
function newPara () {
offset = 0;
parNode = {
type: 'paragraph',
content: {
text: '',
annotations: []
}
};
wnode.children.push( parNode );
}
for ( var i = 0, l = children.length; i < l; i++ ) {
var cnode = children[i];
switch ( cnode.nodeType ) {
case Node.ELEMENT_NODE:
// Check if element type is an annotation
var annotationtype = this._getWikiDomAnnotationType( cnode );
if ( annotationtype ) {
if ( !parNode ) {
newPara();
}
res = this._convertHTMLAnnotation( cnode, offset, annotationtype );
//console.log( 'res leaf: ' + JSON.stringify(res, null, 2));
offset += res.text.length;
parNode.content.text += res.text;
//console.log( 'res annotations: ' + JSON.stringify(res, null, 2));
parNode.content.annotations = parNode.content.annotations
.concat( res.annotations );
} else {
// Close last paragraph, if still open.
parNode = null;
// Call a handler for the particular node type
2011-12-15 10:55:30 +00:00
var hi = this._getHTMLtoWikiDomHandlerInfo( cnode.nodeName );
res = hi.handler.call(this, cnode, hi.type );
if ( hi.attribs ) {
$.extend( res.node.attributes, hi.attribs );
}
wnode.children.push( res.node );
offset = res.offset;
}
break;
case Node.TEXT_NODE:
if ( !parNode ) {
newPara();
}
parNode.content.text += cnode.data;
offset += cnode.data.length;
break;
case Node.COMMENT_NODE:
// add a comment node.
break;
default:
console.log( "HTML to Wiki DOM conversion error. Unhandled node " +
cnode.innerHTML );
break;
}
}
return {
offset: offset,
node: wnode
};
};
/**
* Private HTML leaf node handler
*
* @param {Object} HTML DOM element
* @param {Int} WikiDom offset within a block
* @returns {Object} WikiDom object
*/
DOMConverter.prototype._convertHTMLLeaf = function ( node, type ) {
var offset = 0;
var children = node.childNodes,
wnode = {
type: type,
attributes: this._HTMLPropertiesToWikiAttributes( node ),
content: {
text: '',
annotations: []
}
};
//console.log( 'res wnode: ' + JSON.stringify(wnode, null, 2));
for ( var i = 0, l = children.length; i < l; i++ ) {
var cnode = children[i];
switch ( cnode.nodeType ) {
case Node.ELEMENT_NODE:
// Call a handler for the particular annotation node type
var annotationtype = this._getWikiDomAnnotationType( cnode, true );
if ( annotationtype ) {
var res = this._convertHTMLAnnotation( cnode, offset, annotationtype );
//console.log( 'res leaf: ' + JSON.stringify(res, null, 2));
offset += res.text.length;
wnode.content.text += res.text;
//console.log( 'res annotations: ' + JSON.stringify(res, null, 2));
wnode.content.annotations = wnode.content.annotations
.concat( res.annotations );
}
break;
case Node.TEXT_NODE:
// Add text as content, and increment offset
wnode.content.text += cnode.data;
offset += cnode.data.length;
break;
case Node.COMMENT_NODE:
// add a comment annotation?
break;
default:
console.log( "HTML to Wiki DOM conversion error. Unhandled node " +
cnode.innerHTML );
break;
}
}
return {
offset: offset,
node: wnode
};
};
2011-12-15 10:55:30 +00:00
/**
* Private: Convert an HTML element to an annotation
*
* @param {Object} HTML element node
* @offset {Int} plain-text offset within leaf node
* @type {String} type of annotation returned by _getWikiDomAnnotationType
* @return {Object} {text: extracted plain text, annotations: {Array} of
* annotation nodes}
*/
DOMConverter.prototype._convertHTMLAnnotation = function ( node, offset, type ) {
var children = node.childNodes,
text = '',
annotations = [
{
type: type,
data: this._HTMLPropertiesToWikiData( node ),
range: {
start: offset,
end: offset
}
}
];
for ( var i = 0, l = children.length; i < l; i++ ) {
var cnode = children[i];
switch ( cnode.nodeType ) {
case Node.ELEMENT_NODE:
// Call a handler for the particular annotation node type
var annotationtype = this._getWikiDomAnnotationType(cnode, true);
if ( annotationtype ) {
var res = this._convertHTMLAnnotation( cnode, offset, annotationtype );
//console.log( 'res annotations 2: ' + JSON.stringify(res, null, 2));
text += res.text;
offset += res.text.length;
annotations = annotations.concat( res.annotations );
}
break;
case Node.TEXT_NODE:
// Add text as content, and increment offset
text += cnode.data;
offset += cnode.data.length;
break;
case Node.COMMENT_NODE:
// add a comment annotation?
break;
default:
console.log( "HTML to Wiki DOM conversion error. Unhandled node " +
cnode.innerHTML );
break;
}
}
// Insert one char if no text was returned to satisfy WikiDom's
// 1-char-minimum width for annotations. Feels a bit icky, but likely
// simplifies editor internals.
if ( text === '' ) {
text = ' ';
offset++;
}
annotations[0].range.end = offset;
return {
text: text,
annotations: annotations
};
};
DOMConverter.prototype._HTMLPropertiesToWikiAttributes = function ( elem ) {
var attribs = elem.attributes,
out = {};
for ( var i = 0, l = attribs.length; i < l; i++ ) {
var attrib = attribs.item(i),
key = attrib.name;
if ( key.match( /^data-json-/ ) ) {
// strip data- prefix and decode
out[key.replace( /^data-json-/, '' )] = JSON.parse(attrib.value);
} else if ( key.match( /^data-/ ) ) {
// strip data- prefix
out[key.replace( /^data-/, '' )] = attrib.value;
} else {
// prefix html properties with html/
out['html/' + key] = attrib.value;
}
}
return out;
};
/**
* Convert HTML element attributes into WikiDom annotation data attributes.
*
* @param {Object} DOM node
* @return {Object} data object
*/
DOMConverter.prototype._HTMLPropertiesToWikiData = function ( elem ) {
var attribs = elem.attributes,
name = elem.tagName.toLowerCase();
out = {};
for ( var i = 0, l = attribs.length; i < l; i++ ) {
var attrib = attribs.item(i),
key = attrib.name;
if ( this._HTMLPropertiesToWikiAttributesMap[name] &&
this._HTMLPropertiesToWikiAttributesMap[name][key] ) {
out[this._HTMLPropertiesToWikiAttributesMap[name][key]] = attrib.value;
} else if ( key.match( /^data-json-/ ) ) {
// strip data-json- prefix and decode
out[key.replace( /^data-json-/, '' )] = JSON.parse(attrib.value);
} else if ( key.match( /^data-/ ) ) {
// strip data- prefix
out[key.replace( /^data-/, '' )] = attrib.value;
} else {
// pass through a few whitelisted keys
// XXX: This subsets html DOM
if ( ['title'].indexOf(key) != -1 ) {
out[key] = attrib.value;
} else {
// prefix key with 'html/'
out['html/' + key] = attrib.value;
}
}
}
return out;
};
// Map HTML (tagName, attributeName) pairs to WikiDom names for the same
// element
DOMConverter.prototype._HTMLPropertiesToWikiAttributesMap = {
a: {
href: 'title'
}
};
// Quick HACK: define Node constants locally
2011-12-15 10:55:30 +00:00
// https://developer.mozilla.org/en/nodeType
var Node = {
ELEMENT_NODE: 1,
ATTRIBUTE_NODE: 2,
TEXT_NODE: 3,
CDATA_SECTION_NODE: 4,
ENTITY_REFERENCE_NODE: 5,
ENTITY_NODE: 6,
PROCESSING_INSTRUCTION_NODE: 7,
COMMENT_NODE: 8,
DOCUMENT_NODE: 9,
DOCUMENT_TYPE_NODE: 10,
DOCUMENT_FRAGMENT_NODE: 11,
NOTATION_NODE: 12
};
if (typeof module == "object") {
module.exports.DOMConverter = DOMConverter;
}