mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor
synced 2024-12-05 03:08:37 +00:00
22098d6b16
Follow-up to a8e07e026dea4f54241d1dbb6b7bcdbd8c670db2 in core. Change-Id: I09333adb4876c6e584a4a6b6a1628227c4cd2616
204 lines
5.7 KiB
JavaScript
204 lines
5.7 KiB
JavaScript
/*!
|
|
* VisualEditor MediaWiki Initialization ApiResponseCache class.
|
|
*
|
|
* @copyright 2011-2019 VisualEditor Team and others; see AUTHORS.txt
|
|
* @license The MIT License (MIT); see LICENSE.txt
|
|
*/
|
|
|
|
/**
|
|
* MediaWiki API batch queue.
|
|
*
|
|
* Used to queue up lists of items centrally to get information about in batches
|
|
* of requests.
|
|
*
|
|
* @class
|
|
* @extends OO.EventEmitter
|
|
* @constructor
|
|
* @param {mw.Api} [api] API object to use. Defaults to new mw.Api()
|
|
*/
|
|
ve.init.mw.ApiResponseCache = function VeInitMwApiResponseCache( api ) {
|
|
// Mixin constructor
|
|
OO.EventEmitter.call( this );
|
|
|
|
this.api = api || new mw.Api();
|
|
|
|
// Keys are titles, values are deferreds
|
|
this.deferreds = {};
|
|
|
|
// Keys are page names, values are link data objects
|
|
// This is kept for synchronous retrieval of cached values via #getCached
|
|
this.cacheValues = {};
|
|
|
|
// Array of page titles queued to be looked up
|
|
this.queue = [];
|
|
|
|
this.schedule = ve.debounce( this.processQueue.bind( this ), 0 );
|
|
};
|
|
|
|
/* Inheritance */
|
|
|
|
OO.mixinClass( ve.init.mw.ApiResponseCache, OO.EventEmitter );
|
|
|
|
/* Static methods */
|
|
|
|
/**
|
|
* Process each page in the response of an API request
|
|
*
|
|
* @abstract
|
|
* @static
|
|
* @param {Object} page The page object
|
|
* @return {Object|undefined} Any relevant info that we want to cache and return.
|
|
*/
|
|
ve.init.mw.ApiResponseCache.static.processPage = null;
|
|
|
|
/**
|
|
* Normalize the title of the response
|
|
*
|
|
* @param {string} title Title
|
|
* @return {string} Normalized title
|
|
*/
|
|
ve.init.mw.ApiResponseCache.static.normalizeTitle = function ( title ) {
|
|
var titleObj = mw.Title.newFromText( title );
|
|
if ( !titleObj ) {
|
|
return title;
|
|
}
|
|
return titleObj.getPrefixedText();
|
|
};
|
|
|
|
/* Methods */
|
|
|
|
/**
|
|
* Look up data about a title. If the data about this title is already in the cache, this
|
|
* returns an already-resolved promise. Otherwise, it returns a pending promise and schedules
|
|
* an request to retrieve the data.
|
|
*
|
|
* @param {string} title Title
|
|
* @return {jQuery.Promise} Promise that will be resolved with the data once it's available
|
|
*/
|
|
ve.init.mw.ApiResponseCache.prototype.get = function ( title ) {
|
|
if ( typeof title !== 'string' ) {
|
|
// Don't bother letting things like undefined or null make it all the way through,
|
|
// just reject them here. Otherwise they'll cause problems or exceptions at random
|
|
// other points in this file.
|
|
return ve.createDeferred().reject().promise();
|
|
}
|
|
title = this.constructor.static.normalizeTitle( title );
|
|
if ( !Object.prototype.hasOwnProperty.call( this.deferreds, title ) ) {
|
|
this.deferreds[ title ] = ve.createDeferred();
|
|
this.queue.push( title );
|
|
this.schedule();
|
|
}
|
|
return this.deferreds[ title ].promise();
|
|
};
|
|
|
|
/**
|
|
* Look up data about a page in the cache. If the data about this page is already in the cache,
|
|
* this returns that data. Otherwise, it returns undefined.
|
|
*
|
|
* @param {string} name Normalized page title
|
|
* @return {Object|undefined} Cache data for this name.
|
|
*/
|
|
ve.init.mw.ApiResponseCache.prototype.getCached = function ( name ) {
|
|
if ( Object.prototype.hasOwnProperty.call( this.cacheValues, name ) ) {
|
|
return this.cacheValues[ name ];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Fired when a new entry is added to the cache.
|
|
*
|
|
* @event add
|
|
* @param {Object} entries Cache entries that were added. Object mapping names to data objects.
|
|
*/
|
|
|
|
/**
|
|
* Add entries to the cache. Does not overwrite already-set entries.
|
|
*
|
|
* @param {Object} entries Object keyed by page title, with the values being data objects
|
|
* @fires add
|
|
*/
|
|
ve.init.mw.ApiResponseCache.prototype.set = function ( entries ) {
|
|
var name;
|
|
for ( name in entries ) {
|
|
if ( !Object.prototype.hasOwnProperty.call( this.deferreds, name ) ) {
|
|
this.deferreds[ name ] = ve.createDeferred();
|
|
}
|
|
if ( this.deferreds[ name ].state() === 'pending' ) {
|
|
this.deferreds[ name ].resolve( entries[ name ] );
|
|
this.cacheValues[ name ] = entries[ name ];
|
|
}
|
|
}
|
|
this.emit( 'add', Object.keys( entries ) );
|
|
};
|
|
|
|
/**
|
|
* Get an API request promise to deal with a list of titles
|
|
*
|
|
* @abstract
|
|
* @param subqueue
|
|
* @return {jQuery.Promise}
|
|
*/
|
|
ve.init.mw.ApiResponseCache.prototype.getRequestPromise = null;
|
|
|
|
/**
|
|
* Perform any scheduled API requests.
|
|
*
|
|
* @private
|
|
* @fires add
|
|
*/
|
|
ve.init.mw.ApiResponseCache.prototype.processQueue = function () {
|
|
var subqueue, queue,
|
|
cache = this;
|
|
|
|
function rejectSubqueue( rejectQueue ) {
|
|
var i, len;
|
|
for ( i = 0, len = rejectQueue.length; i < len; i++ ) {
|
|
cache.deferreds[ rejectQueue[ i ] ].reject();
|
|
}
|
|
}
|
|
|
|
function processResult( data ) {
|
|
var i, pageid, page, processedPage, from, mappedTitles = [],
|
|
pages = ( data.query && data.query.pages ) || data.pages,
|
|
processed = {};
|
|
|
|
[ 'redirects', 'normalized', 'converted' ].forEach( function ( map ) {
|
|
mappedTitles = mappedTitles.concat( ( data.query && data.query[ map ] ) || [] );
|
|
} );
|
|
|
|
if ( pages ) {
|
|
for ( pageid in pages ) {
|
|
page = pages[ pageid ];
|
|
processedPage = cache.constructor.static.processPage( page );
|
|
if ( processedPage !== undefined ) {
|
|
processed[ page.title ] = processedPage;
|
|
}
|
|
}
|
|
for ( i = 0; i < mappedTitles.length; i++ ) {
|
|
// Locate the title in mapped titles, if any.
|
|
if ( mappedTitles[ i ].to === page.title ) {
|
|
from = mappedTitles[ i ].fromencoded === '' ?
|
|
decodeURIComponent( mappedTitles[ i ].from ) :
|
|
mappedTitles[ i ].from;
|
|
processed[ from ] = processedPage;
|
|
break;
|
|
}
|
|
}
|
|
cache.set( processed );
|
|
}
|
|
}
|
|
|
|
queue = this.queue;
|
|
this.queue = [];
|
|
while ( queue.length ) {
|
|
subqueue = queue.splice( 0, 50 ).map( this.constructor.static.normalizeTitle );
|
|
this.getRequestPromise( subqueue )
|
|
.then( processResult )
|
|
|
|
// Reject everything in subqueue; this will only reject the ones
|
|
// that weren't already resolved above, because .reject() on an
|
|
// already resolved Deferred is a no-op.
|
|
.then( rejectSubqueue.bind( null, subqueue ) );
|
|
}
|
|
};
|