mediawiki-extensions-Visual.../modules/ve/dm/ve.dm.NodeFactory.js
Timo Tijhof 44623c9b2a ve.copy: Remove obsolete copyArray and copyObject
These have been pointing to the same method for a while now,
we can safely remove these obsolete aliases and just use it
as generic copy.

* Each file touched by my editor had its new line at EOF fixed
  where absent
* Don't copy an otherwise unused empty object
  (ve.dm.Converter)
* Use common ve#copy syntax instead to create a link
  (ve.dm.Document, ve.dm.example)
* Remove redundant conditionals for isArray/copyArray/copyObject
  (ve.dm.example)

Change-Id: If560e658dc1fb59bf01f702c97e3e82a50a8a255
2013-07-30 01:44:22 +02:00

237 lines
6.5 KiB
JavaScript

/*!
* VisualEditor DataModel NodeFactory class.
*
* @copyright 2011-2013 VisualEditor Team and others; see AUTHORS.txt
* @license The MIT License (MIT); see LICENSE.txt
*/
/**
* DataModel node factory.
*
* @class
* @extends ve.NamedClassFactory
* @constructor
*/
ve.dm.NodeFactory = function VeDmNodeFactory() {
// Parent constructor
ve.NamedClassFactory.call( this );
};
/* Inheritance */
ve.inheritClass( ve.dm.NodeFactory, ve.NamedClassFactory );
/* Methods */
/**
* Get a document data element.
*
* @method
* @param {string} type Node type
* @param {Object} attributes Node attributes, defaults will be used where needed
* @returns {Object} Data element
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.getDataElement = function ( type, attributes ) {
var element = { 'type': type };
if ( type in this.registry ) {
attributes = ve.extendObject( {}, this.registry[type].static.defaultAttributes, attributes );
if ( !ve.isEmptyObject( attributes ) ) {
element.attributes = ve.copy( attributes );
}
return element;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Get allowed child node types for a node.
*
* @method
* @param {string} type Node type
* @returns {string[]|null} List of node types allowed as children or null if any type is allowed
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.getChildNodeTypes = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.childNodeTypes;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Get allowed parent node types for a node.
*
* @method
* @param {string} type Node type
* @returns {string[]|null} List of node types allowed as parents or null if any type is allowed
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.getParentNodeTypes = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.parentNodeTypes;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Get suggested parent node types for a node.
*
* @method
* @param {string} type Node type
* @returns {string[]|null} List of node types suggested as parents or null if any type is suggested
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.getSuggestedParentNodeTypes = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.suggestedParentNodeTypes;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if a node can have children.
*
* @method
* @param {string} type Node type
* @returns {boolean} The node can have children
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.canNodeHaveChildren = function ( type ) {
if ( type in this.registry ) {
// If childNodeTypes is null any child is allowed, if it's an array of at least one element
// than at least one kind of node is allowed
var types = this.registry[type].static.childNodeTypes;
return types === null || ( ve.isArray( types ) && types.length > 0 );
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if a node can have children but not content nor be content.
*
* @method
* @param {string} type Node type
* @returns {boolean} The node can have children but not content nor be content
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.canNodeHaveChildrenNotContent = function ( type ) {
if ( type in this.registry ) {
return this.canNodeHaveChildren( type ) &&
!this.registry[type].static.canContainContent &&
!this.registry[type].static.isContent;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if a node has a wrapped element in the document data.
*
* @method
* @param {string} type Node type
* @returns {boolean} Whether the node has a wrapping element
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.isNodeWrapped = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.isWrapped;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if a node can contain content.
*
* @method
* @param {string} type Node type
* @returns {boolean} The node contains content
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.canNodeContainContent = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.canContainContent;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if a node is content.
*
* @method
* @param {string} type Node type
* @returns {boolean} The node is content
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.isNodeContent = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.isContent;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if the node has significant whitespace.
*
* Can only be true if canContainContent is also true.
*
* @method
* @param {string} type Node type
* @returns {boolean} The node has significant whitespace
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.doesNodeHaveSignificantWhitespace = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.hasSignificantWhitespace;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if the node handles its own children.
*
* @method
* @param {string} type Node type
* @returns {boolean} Whether the node handles its own children
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.doesNodeHandleOwnChildren = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.handlesOwnChildren;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if the node is internal.
*
* @method
* @param {string} type Node type
* @returns {boolean} Whether the node is internal
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.isNodeInternal = function ( type ) {
if ( type in this.registry ) {
return this.registry[type].static.isInternal;
}
throw new Error( 'Unknown node type: ' + type );
};
/**
* Check if the node is focusable.
*
* @method
* @param {string} type Node type
* @returns {boolean} Whether the node is focusable
* @throws {Error} Unknown node type
*/
ve.dm.NodeFactory.prototype.isNodeFocusable = function ( type ) {
if ( ve.dm.nodeFactory.lookup( type ) ) {
return ve.isMixedIn( ve.ce.nodeFactory.registry[type], ve.ce.FocusableNode );
}
throw new Error( 'Unknown node type: ' + type );
};
/* Initialization */
ve.dm.nodeFactory = new ve.dm.NodeFactory();