mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor
synced 2024-12-11 05:56:11 +00:00
0a7a845a42
Change-Id: I0b299c840ede1a1b8552cecfc70c5760ab036181
451 lines
13 KiB
JavaScript
451 lines
13 KiB
JavaScript
/*!
|
|
* VisualEditor DataModel MWLanguageVariantNode class.
|
|
*
|
|
* @copyright 2011-2018 VisualEditor Team and others; see AUTHORS.txt
|
|
* @license The MIT License (MIT); see LICENSE.txt
|
|
*/
|
|
|
|
/**
|
|
* DataModel MediaWiki language variant node, used to represent
|
|
* LanguageConverter markup.
|
|
*
|
|
* @class
|
|
* @abstract
|
|
* @extends ve.dm.LeafNode
|
|
* @mixins ve.dm.FocusableNode
|
|
*
|
|
* @constructor
|
|
*/
|
|
ve.dm.MWLanguageVariantNode = function VeDmMWLanguageVariantNode() {
|
|
// Parent constructor
|
|
ve.dm.MWLanguageVariantNode.super.apply( this, arguments );
|
|
|
|
// Mixin constructors
|
|
ve.dm.FocusableNode.call( this );
|
|
};
|
|
|
|
/* Inheritance */
|
|
|
|
OO.inheritClass( ve.dm.MWLanguageVariantNode, ve.dm.LeafNode );
|
|
|
|
OO.mixinClass( ve.dm.MWLanguageVariantNode, ve.dm.FocusableNode );
|
|
|
|
/* Static members */
|
|
|
|
ve.dm.MWLanguageVariantNode.static.name = 'mwLanguageVariant';
|
|
|
|
ve.dm.MWLanguageVariantNode.static.matchTagNames = null;
|
|
|
|
ve.dm.MWLanguageVariantNode.static.matchRdfaTypes = [ 'mw:LanguageVariant' ];
|
|
|
|
ve.dm.MWLanguageVariantNode.static.getHashObject = function ( dataElement ) {
|
|
return {
|
|
type: dataElement.type,
|
|
variantInfo: dataElement.attributes.variantInfo
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Node type to use when the contents are inline
|
|
*
|
|
* @static
|
|
* @property {string}
|
|
* @inheritable
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.inlineType = 'mwLanguageVariantInline';
|
|
|
|
/**
|
|
* Node type to use when the contents are a block
|
|
*
|
|
* @static
|
|
* @property {string}
|
|
* @inheritable
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.blockType = 'mwLanguageVariantBlock';
|
|
|
|
/**
|
|
* Node type to use when the contents are hidden
|
|
*
|
|
* @static
|
|
* @property {string}
|
|
* @inheritable
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.hiddenType = 'mwLanguageVariantHidden';
|
|
|
|
/**
|
|
* Migrate field names from old Parsoid spec to new field names.
|
|
* This method will go away after the next Parsoid flag day.
|
|
* @static
|
|
* @method
|
|
* @private
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.migrateFieldNames = function ( dataMwv ) {
|
|
// Field name migration: `bidir`=>`twoway`; `unidir`=>`oneway`
|
|
// This will go away eventually.
|
|
if ( dataMwv.bidir ) {
|
|
dataMwv.twoway = dataMwv.bidir;
|
|
delete dataMwv.bidir;
|
|
}
|
|
if ( dataMwv.unidir ) {
|
|
dataMwv.oneway = dataMwv.unidir;
|
|
delete dataMwv.unidir;
|
|
}
|
|
return dataMwv;
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.toDataElement = function ( domElements, converter ) {
|
|
var dataElement,
|
|
isInline,
|
|
firstElement = domElements[ 0 ],
|
|
dataMwvJSON = firstElement.getAttribute( 'data-mw-variant' ),
|
|
dataMwv = dataMwvJSON ? JSON.parse( dataMwvJSON ) : {};
|
|
|
|
this.migrateFieldNames( dataMwv );
|
|
|
|
dataElement = {
|
|
attributes: {
|
|
variantInfo: dataMwv,
|
|
originalVariantInfo: dataMwvJSON
|
|
}
|
|
};
|
|
|
|
if ( firstElement.tagName === 'META' ) {
|
|
dataElement.type = this.hiddenType;
|
|
return dataElement;
|
|
}
|
|
|
|
isInline = this.isHybridInline( domElements, converter );
|
|
dataElement.type = isInline ? this.inlineType : this.blockType;
|
|
return dataElement;
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.toDomElements = function ( dataElement, doc, converter ) {
|
|
var variantInfo = dataElement.attributes.variantInfo,
|
|
tagName = this.matchTagNames[ 0 ],
|
|
rdfaType = this.matchRdfaTypes[ 0 ],
|
|
domElement = doc.createElement( tagName ),
|
|
dataMwvJSON = JSON.stringify( variantInfo );
|
|
|
|
// Preserve exact equality of this attribute for selser.
|
|
if ( dataElement.attributes.originalVariantInfo ) {
|
|
if ( OO.compare(
|
|
this.migrateFieldNames(
|
|
JSON.parse( dataElement.attributes.originalVariantInfo )
|
|
),
|
|
variantInfo
|
|
) ) {
|
|
dataMwvJSON = dataElement.attributes.originalVariantInfo;
|
|
}
|
|
}
|
|
|
|
domElement.setAttribute( 'typeof', rdfaType );
|
|
domElement.setAttribute( 'data-mw-variant', dataMwvJSON );
|
|
if ( converter.isForClipboard() && tagName !== 'META' ) {
|
|
// Fill in contents of span for diff/cut-and-paste/etc.
|
|
this.insertPreviewElements( domElement, variantInfo );
|
|
}
|
|
return [ domElement ];
|
|
};
|
|
|
|
/**
|
|
* Add previews for language variant markup inside their <span> nodes.
|
|
* This ensures that template expansion, cut-and-paste, etc have reasonable
|
|
* renderings.
|
|
*
|
|
* @static
|
|
* @method
|
|
* @param {jQuery} $element Element to process
|
|
* @param {Object|null} opts Preview options
|
|
* @param {boolean} [opts.describeAll=false] Treat all rules as if the
|
|
* "describe" flag was set. This displays every language and its associated
|
|
* text, not just the one appropriate for the current user.
|
|
* @return {jQuery} $element
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.processVariants = function ( $element, opts ) {
|
|
var self = this,
|
|
selector = '[typeof="mw:LanguageVariant"]',
|
|
$variantElements = $element.find( selector ).addBack( selector );
|
|
|
|
$variantElements.each( function ( _, child ) {
|
|
var dataMwvJSON = child.getAttribute( 'data-mw-variant' );
|
|
if ( dataMwvJSON && child.tagName !== 'META' ) {
|
|
self.insertPreviewElements(
|
|
child, JSON.parse( dataMwvJSON ), opts
|
|
);
|
|
}
|
|
} );
|
|
return $element;
|
|
};
|
|
|
|
/**
|
|
* Insert language variant preview for specified element.
|
|
*
|
|
* @static
|
|
* @method
|
|
* @param {HTMLElement} element Element to insert preview inside of.
|
|
* @param {Object} variantInfo Language variant information object.
|
|
* @param {Object|null} opts Preview options
|
|
* @param {boolean} [opts.describeAll=false] Treat all rules as if the
|
|
* "describe" flag was set. This displays every language and its associated
|
|
* text, not just the one appropriate for the current user.
|
|
* @return {HTMLElement} el
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.insertPreviewElements = function ( element, variantInfo, opts ) {
|
|
// Note that `element` can't be a <meta> (or other void tag)
|
|
$( element ).html( this.getPreviewHtml( variantInfo, opts ) );
|
|
// This recurses into the children added by the `html` clause to ensure
|
|
// that nested variants are expanded.
|
|
this.processVariants( $( element ).children(), opts );
|
|
return element;
|
|
};
|
|
|
|
/**
|
|
* Helper method to return an appropriate HTML preview string for a
|
|
* language converter node, based on the language variant information
|
|
* object and the user's currently preferred variant.
|
|
*
|
|
* @static
|
|
* @method
|
|
* @private
|
|
* @param {Object} variantInfo Language variant information object.
|
|
* @param {Object|null} opts Preview options
|
|
* @param {boolean} [opts.describeAll=false] Treat all rules as if the
|
|
* "describe" flag was set. This displays every language and its associated
|
|
* text, not just the one appropriate for the current user.
|
|
* @return {string} HTML string
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.getPreviewHtml = function ( variantInfo, opts ) {
|
|
var languageIndex,
|
|
$holder;
|
|
if ( variantInfo.disabled ) {
|
|
return variantInfo.disabled.t;
|
|
} else if ( variantInfo.name ) {
|
|
return ve.init.platform.getLanguageName( variantInfo.name.t.toLowerCase() );
|
|
} else if ( variantInfo.filter ) {
|
|
return variantInfo.filter.t;
|
|
} else if ( variantInfo.describe || ( opts && opts.describeAll ) ) {
|
|
$holder = $( '<body>' );
|
|
if ( variantInfo.twoway && variantInfo.twoway.length ) {
|
|
variantInfo.twoway.forEach( function ( item ) {
|
|
$holder.append(
|
|
ve.init.platform.getLanguageName( item.l.toLowerCase() )
|
|
);
|
|
$holder.append( ':' );
|
|
$holder.append( $.parseHTML( item.t ) );
|
|
$holder.append( ';' );
|
|
} );
|
|
} else if ( variantInfo.oneway && variantInfo.oneway.length ) {
|
|
variantInfo.oneway.forEach( function ( item ) {
|
|
$holder.append( $.parseHTML( item.f ) );
|
|
$holder.append( '⇒' );
|
|
$holder.append(
|
|
ve.init.platform.getLanguageName( item.l.toLowerCase() )
|
|
);
|
|
$holder.append( ':' );
|
|
$holder.append( $.parseHTML( item.t ) );
|
|
$holder.append( ';' );
|
|
} );
|
|
}
|
|
return $holder.html();
|
|
} else {
|
|
if ( variantInfo.twoway && variantInfo.twoway.length ) {
|
|
languageIndex = this.matchLanguage( variantInfo.twoway );
|
|
return variantInfo.twoway[ languageIndex ].t;
|
|
} else if ( variantInfo.oneway && variantInfo.oneway.length ) {
|
|
languageIndex = this.matchLanguage( variantInfo.oneway );
|
|
return variantInfo.oneway[ languageIndex ].t;
|
|
}
|
|
}
|
|
return '';
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.describeChanges = function () {
|
|
// TODO: Provide a more detailed description of markup changes
|
|
return ve.msg( 'visualeditor-changedesc-mwlanguagevariant' );
|
|
};
|
|
|
|
/** */
|
|
ve.dm.MWLanguageVariantNode.static.cloneElement = function () {
|
|
// Parent method
|
|
var clone = ve.dm.MWLanguageVariantNode.super.static.cloneElement.apply( this, arguments );
|
|
delete clone.attributes.originalVariantInfo;
|
|
return clone;
|
|
};
|
|
|
|
/**
|
|
* Match the currently-selected language variant against the most appropriate
|
|
* among a provided list of language codes.
|
|
*
|
|
* @static
|
|
* @method
|
|
* @param {Object[]} [items] An array of objects, each of which have a field
|
|
* named `l` equal to a language code.
|
|
* @return {number} The index in `items` with the most appropriate language
|
|
* code.
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.matchLanguage = function ( items ) {
|
|
var userVariant = mw.config.get( 'wgUserVariant' ),
|
|
fallbacks = mw.config.get( 'wgVisualEditor' ).pageVariantFallbacks,
|
|
languageCodes =
|
|
( userVariant ? [ userVariant ] : [] ).concat( fallbacks || [] ),
|
|
code,
|
|
i,
|
|
j;
|
|
for ( j = 0; j < languageCodes.length; j++ ) {
|
|
code = languageCodes[ j ].toLowerCase();
|
|
for ( i = 0; i < items.length; i++ ) {
|
|
if (
|
|
items[ i ].l === '*' ||
|
|
items[ i ].l.toLowerCase() === code
|
|
) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
// Bail: just show the first item.
|
|
return 0;
|
|
};
|
|
|
|
/* Methods */
|
|
|
|
/*
|
|
* Helper function to get the description object for this markup node.
|
|
*
|
|
* @method
|
|
* @return {Object}
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.prototype.getVariantInfo = function () {
|
|
return this.element.attributes.variantInfo;
|
|
};
|
|
|
|
/**
|
|
* Helper function to discriminate between hidden and shown rules.
|
|
*
|
|
* @method
|
|
* @return {boolean} True if this node represents a conversion rule
|
|
* with no shown output
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.prototype.isHidden = function () {
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Helper function to discriminate between various types of language
|
|
* converter markup.
|
|
*
|
|
* @method
|
|
* @return {string}
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.prototype.getRuleType = function () {
|
|
return this.constructor.static.getRuleType( this.getVariantInfo() );
|
|
};
|
|
|
|
/**
|
|
* Helper function to discriminate between various types of language
|
|
* converter markup.
|
|
*
|
|
* @static
|
|
* @method
|
|
* @param {Object} variantInfo Language variant information object.
|
|
* @return {string}
|
|
*/
|
|
ve.dm.MWLanguageVariantNode.static.getRuleType = function ( variantInfo ) {
|
|
if ( variantInfo.disabled ) { return 'disabled'; }
|
|
if ( variantInfo.filter ) { return 'filter'; }
|
|
if ( variantInfo.name ) { return 'name'; }
|
|
if ( variantInfo.twoway ) { return 'twoway'; }
|
|
if ( variantInfo.oneway ) { return 'oneway'; }
|
|
return 'unknown'; // should never happen
|
|
};
|
|
|
|
/* Concrete subclasses */
|
|
|
|
/**
|
|
* DataModel MediaWiki language variant block node.
|
|
*
|
|
* @class
|
|
* @extends ve.dm.MWLanguageVariantNode
|
|
*
|
|
* @constructor
|
|
* @param {Object} [element] Reference to element in linear model
|
|
* @param {ve.dm.Node[]} [children]
|
|
*/
|
|
ve.dm.MWLanguageVariantBlockNode = function VeDmMWLanguageVariantBlockNode() {
|
|
// Parent constructor
|
|
ve.dm.MWLanguageVariantBlockNode.super.apply( this, arguments );
|
|
};
|
|
|
|
OO.inheritClass( ve.dm.MWLanguageVariantBlockNode, ve.dm.MWLanguageVariantNode );
|
|
|
|
ve.dm.MWLanguageVariantBlockNode.static.matchTagNames = [ 'div' ];
|
|
|
|
ve.dm.MWLanguageVariantBlockNode.static.name = 'mwLanguageVariantBlock';
|
|
|
|
/**
|
|
* DataModel MediaWiki language variant inline node.
|
|
*
|
|
* @class
|
|
* @extends ve.dm.MWLanguageVariantNode
|
|
*
|
|
* @constructor
|
|
* @param {Object} [element] Reference to element in linear model
|
|
* @param {ve.dm.Node[]} [children]
|
|
*/
|
|
ve.dm.MWLanguageVariantInlineNode = function VeDmMWLanguageVariantInlineNode() {
|
|
// Parent constructor
|
|
ve.dm.MWLanguageVariantInlineNode.super.apply( this, arguments );
|
|
};
|
|
|
|
OO.inheritClass( ve.dm.MWLanguageVariantInlineNode, ve.dm.MWLanguageVariantNode );
|
|
|
|
ve.dm.MWLanguageVariantInlineNode.static.matchTagNames = [ 'span' ];
|
|
|
|
ve.dm.MWLanguageVariantInlineNode.static.name = 'mwLanguageVariantInline';
|
|
|
|
ve.dm.MWLanguageVariantInlineNode.static.isContent = true;
|
|
|
|
/**
|
|
* DataModel MediaWiki language variant hidden node.
|
|
*
|
|
* @class
|
|
* @extends ve.dm.MWLanguageVariantNode
|
|
*
|
|
* @constructor
|
|
* @param {Object} [element] Reference to element in linear model
|
|
* @param {ve.dm.Node[]} [children]
|
|
*/
|
|
ve.dm.MWLanguageVariantHiddenNode = function VeDmMWLanguageVariantHiddenNode() {
|
|
// Parent constructor
|
|
ve.dm.MWLanguageVariantHiddenNode.super.apply( this, arguments );
|
|
};
|
|
|
|
OO.inheritClass( ve.dm.MWLanguageVariantHiddenNode, ve.dm.MWLanguageVariantNode );
|
|
|
|
ve.dm.MWLanguageVariantHiddenNode.static.matchTagNames = [ 'meta' ];
|
|
|
|
ve.dm.MWLanguageVariantHiddenNode.static.name = 'mwLanguageVariantHidden';
|
|
|
|
ve.dm.MWLanguageVariantHiddenNode.static.isContent = true;
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.dm.MWLanguageVariantHiddenNode.prototype.isHidden = function () {
|
|
return true;
|
|
};
|
|
|
|
/* Registration */
|
|
|
|
ve.dm.modelRegistry.register( ve.dm.MWLanguageVariantBlockNode );
|
|
ve.dm.modelRegistry.register( ve.dm.MWLanguageVariantInlineNode );
|
|
ve.dm.modelRegistry.register( ve.dm.MWLanguageVariantHiddenNode );
|