All files / src/dm/nodes ve.dm.AlienNode.js

96.88% Statements 31/32
83.33% Branches 10/12
100% Functions 7/7
96.88% Lines 31/32

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106                                  1x   89x     89x         1x   1x       1x   1x   1x   1x   1x   75x 2x 2x 2x         73x 73x 73x     75x     1x 94x           1x 5x                 10x 4x         5x 5x   5x 5x   5x                 1x 2x              
/*!
 * VisualEditor DataModel AlienNode class.
 *
 * @copyright 2011-2020 VisualEditor Team and others; see http://ve.mit-license.org
 */
 
/**
 * DataModel alien node.
 *
 * @class
 * @abstract
 * @extends ve.dm.LeafNode
 * @mixins ve.dm.FocusableNode
 *
 * @constructor
 * @param {Object} [element] Reference to element in linear model
 */
ve.dm.AlienNode = function VeDmAlienNode() {
	// Parent constructor
	ve.dm.AlienNode.super.apply( this, arguments );
 
	// Mixin constructor
	ve.dm.FocusableNode.call( this );
};
 
/* Inheritance */
 
OO.inheritClass( ve.dm.AlienNode, ve.dm.LeafNode );
 
OO.mixinClass( ve.dm.AlienNode, ve.dm.FocusableNode );
 
/* Static members */
 
ve.dm.AlienNode.static.name = 'alien';
 
ve.dm.AlienNode.static.preserveHtmlAttributes = false;
 
ve.dm.AlienNode.static.enableAboutGrouping = true;
 
ve.dm.AlienNode.static.matchRdfaTypes = [ 've:Alien' ];
 
ve.dm.AlienNode.static.toDataElement = function ( domElements, converter ) {
	var element;
	if ( domElements.length === 1 && [ 'td', 'th' ].indexOf( domElements[ 0 ].nodeName.toLowerCase() ) !== -1 ) {
		var attributes = {};
		ve.dm.TableCellableNode.static.setAttributes( attributes, domElements );
		element = {
			type: 'alienTableCell',
			attributes: attributes
		};
	} else {
		var isInline = this.isHybridInline( domElements, converter );
		var type = isInline ? 'alienInline' : 'alienBlock';
		element = { type: type };
	}
 
	return element;
};
 
ve.dm.AlienNode.static.toDomElements = function ( dataElement, doc, converter ) {
	return ve.copyDomElements( converter.getStore().value( dataElement.originalDomElementsHash ) || [], doc );
};
 
/**
 * @inheritdoc
 */
ve.dm.AlienNode.static.isDiffComparable = function ( element, other, elementStore, otherStore ) {
	Iif ( element.type === other.type && element.originalDomElementsHash === other.originalDomElementsHash ) {
		return true;
	}
 
	// HACK: We can't strip 'about' attributes before converting, as we need them
	// for about grouping, but we should ignore them for diffing as they can be
	// non-persistent in historical diffs.
 
	function removeAboutAttributes( el ) {
		Array.prototype.forEach.call( el.querySelectorAll( '[about]' ), function ( e ) {
			e.removeAttribute( 'about' );
		} );
	}
 
	// Deep copy DOM nodes from store
	var elementOriginalDomElements = ve.copy( elementStore.value( element.originalDomElementsHash ) );
	var otherOriginalDomElements = ve.copy( otherStore.value( other.originalDomElementsHash ) );
	// Remove about attributes
	elementOriginalDomElements.forEach( removeAboutAttributes );
	otherOriginalDomElements.forEach( removeAboutAttributes );
	// Compare DOM trees
	return ve.compare(
		ve.copy( elementOriginalDomElements, ve.convertDomElements ),
		ve.copy( otherOriginalDomElements, ve.convertDomElements )
	);
};
 
/**
 * @inheritdoc
 */
ve.dm.AlienNode.static.getHashObject = function ( dataElement ) {
	return {
		type: dataElement.type,
		// Some comparison methods ignore the originalDomElementsHash
		// property. Rename it so it doesn't get ignored for alien nodes.
		alienDomElementsHash: dataElement.originalDomElementsHash
	};
};