From a24487ca4df531b80e15eda7dfb7b91b80e49d48 Mon Sep 17 00:00:00 2001 From: Neil Kandalgaonkar Date: Tue, 13 Dec 2011 03:03:05 +0000 Subject: [PATCH] moved language library to core mediawiki.jqueryMsg --- resources/mediawiki/mediawiki.jqueryMsg.js | 648 ++++++++++++++++++ resources/mediawiki/mediawiki.jqueryMsg.peg | 76 ++ .../spec/mediawiki.jqueryMsg.spec.data.js | 488 +++++++++++++ .../jasmine/spec/mediawiki.jqueryMsg.spec.js | 350 ++++++++++ .../jasmine/spec_makers/makeJqueryMsgSpec.php | 114 +++ 5 files changed, 1676 insertions(+) create mode 100644 resources/mediawiki/mediawiki.jqueryMsg.js create mode 100644 resources/mediawiki/mediawiki.jqueryMsg.peg create mode 100644 tests/jasmine/spec/mediawiki.jqueryMsg.spec.data.js create mode 100644 tests/jasmine/spec/mediawiki.jqueryMsg.spec.js create mode 100644 tests/jasmine/spec_makers/makeJqueryMsgSpec.php diff --git a/resources/mediawiki/mediawiki.jqueryMsg.js b/resources/mediawiki/mediawiki.jqueryMsg.js new file mode 100644 index 0000000000..459d000e27 --- /dev/null +++ b/resources/mediawiki/mediawiki.jqueryMsg.js @@ -0,0 +1,648 @@ +/** + * Experimental advanced wikitext parser-emitter. + * See: http://www.mediawiki.org/wiki/Extension:UploadWizard/MessageParser for docs + * + * @author neilk@wikimedia.org + */ + +( function( mw, $, undefined ) { + + mw.jqueryMsg = {}; + + /** + * Given parser options, return a function that parses a key and replacements, returning jQuery object + * @param {Object} parser options + * @return {Function} accepting ( String message key, String replacement1, String replacement2 ... ) and returning {jQuery} + */ + function getFailableParserFn( options ) { + var parser = new mw.jqueryMsg.parser( options ); + /** + * Try to parse a key and optional replacements, returning a jQuery object that may be a tree of jQuery nodes. + * If there was an error parsing, return the key and the error message (wrapped in jQuery). This should put the error right into + * the interface, without causing the page to halt script execution, and it hopefully should be clearer how to fix it. + * + * @param {Array} first element is the key, replacements may be in array in 2nd element, or remaining elements. + * @return {jQuery} + */ + return function( args ) { + var key = args[0]; + var replacements = $.isArray( args[1] ) ? args[1] : $.makeArray( args ).slice( 1 ); + try { + return parser.parse( key, replacements ); + } catch ( e ) { + return $( '' ).append( key + ': ' + e.message ); + } + }; + } + + /** + * Class method. + * Returns a function suitable for use as a global, to construct strings from the message key (and optional replacements). + * e.g. + * window.gM = mediaWiki.parser.getMessageFunction( options ); + * $( 'p#headline' ).html( gM( 'hello-user', username ) ); + * + * Like the old gM() function this returns only strings, so it destroys any bindings. If you want to preserve bindings use the + * jQuery plugin version instead. This is only included for backwards compatibility with gM(). + * + * @param {Array} parser options + * @return {Function} function suitable for assigning to window.gM + */ + mw.jqueryMsg.getMessageFunction = function( options ) { + var failableParserFn = getFailableParserFn( options ); + /** + * N.B. replacements are variadic arguments or an array in second parameter. In other words: + * somefunction(a, b, c, d) + * is equivalent to + * somefunction(a, [b, c, d]) + * + * @param {String} message key + * @param {Array} optional replacements (can also specify variadically) + * @return {String} rendered HTML as string + */ + return function( /* key, replacements */ ) { + return failableParserFn( arguments ).html(); + }; + }; + + /** + * Class method. + * Returns a jQuery plugin which parses the message in the message key, doing replacements optionally, and appends the nodes to + * the current selector. Bindings to passed-in jquery elements are preserved. Functions become click handlers for [$1 linktext] links. + * e.g. + * $.fn.msg = mediaWiki.parser.getJqueryPlugin( options ); + * var userlink = $( '' ).click( function() { alert( "hello!!") } ); + * $( 'p#headline' ).msg( 'hello-user', userlink ); + * + * @param {Array} parser options + * @return {Function} function suitable for assigning to jQuery plugin, such as $.fn.msg + */ + mw.jqueryMsg.getPlugin = function( options ) { + var failableParserFn = getFailableParserFn( options ); + /** + * N.B. replacements are variadic arguments or an array in second parameter. In other words: + * somefunction(a, b, c, d) + * is equivalent to + * somefunction(a, [b, c, d]) + * + * We append to 'this', which in a jQuery plugin context will be the selected elements. + * @param {String} message key + * @param {Array} optional replacements (can also specify variadically) + * @return {jQuery} this + */ + return function( /* key, replacements */ ) { + var $target = this.empty(); + $.each( failableParserFn( arguments ).contents(), function( i, node ) { + $target.append( node ); + } ); + return $target; + }; + }; + + var parserDefaults = { + 'magic' : {}, + 'messages' : mw.messages, + 'language' : mw.language + }; + + /** + * The parser itself. + * Describes an object, whose primary duty is to .parse() message keys. + * @param {Array} options + */ + mw.jqueryMsg.parser = function( options ) { + this.settings = $.extend( {}, parserDefaults, options ); + this.emitter = new mw.jqueryMsg.htmlEmitter( this.settings.language, this.settings.magic ); + }; + + mw.jqueryMsg.parser.prototype = { + + // cache, map of mediaWiki message key to the AST of the message. In most cases, the message is a string so this is identical. + // (This is why we would like to move this functionality server-side). + astCache: {}, + + /** + * Where the magic happens. + * Parses a message from the key, and swaps in replacements as necessary, wraps in jQuery + * If an error is thrown, returns original key, and logs the error + * @param {String} message key + * @param {Array} replacements for $1, $2... $n + * @return {jQuery} + */ + parse: function( key, replacements ) { + return this.emitter.emit( this.getAst( key ), replacements ); + }, + + /** + * Fetch the message string associated with a key, return parsed structure. Memoized. + * Note that we pass '[' + key + ']' back for a missing message here. + * @param {String} key + * @return {String|Array} string of '[key]' if message missing, simple string if possible, array of arrays if needs parsing + */ + getAst: function( key ) { + if ( this.astCache[ key ] === undefined ) { + var wikiText = this.settings.messages.get( key ); + if ( typeof wikiText !== 'string' ) { + wikiText = "\\[" + key + "\\]"; + } + this.astCache[ key ] = this.wikiTextToAst( wikiText ); + } + return this.astCache[ key ]; + }, + + /* + * Parses the input wikiText into an abstract syntax tree, essentially an s-expression. + * + * CAVEAT: This does not parse all wikitext. It could be more efficient, but it's pretty good already. + * n.b. We want to move this functionality to the server. Nothing here is required to be on the client. + * + * @param {String} message string wikitext + * @throws Error + * @return {Mixed} abstract syntax tree + */ + wikiTextToAst: function( input ) { + + // Indicates current position in input as we parse through it. + // Shared among all parsing functions below. + var pos = 0; + + // ========================================================= + // parsing combinators - could be a library on its own + // ========================================================= + + + // Try parsers until one works, if none work return null + function choice( ps ) { + return function() { + for ( var i = 0; i < ps.length; i++ ) { + var result = ps[i](); + if ( result !== null ) { + return result; + } + } + return null; + }; + } + + // try several ps in a row, all must succeed or return null + // this is the only eager one + function sequence( ps ) { + var originalPos = pos; + var result = []; + for ( var i = 0; i < ps.length; i++ ) { + var res = ps[i](); + if ( res === null ) { + pos = originalPos; + return null; + } + result.push( res ); + } + return result; + } + + // run the same parser over and over until it fails. + // must succeed a minimum of n times or return null + function nOrMore( n, p ) { + return function() { + var originalPos = pos; + var result = []; + var parsed = p(); + while ( parsed !== null ) { + result.push( parsed ); + parsed = p(); + } + if ( result.length < n ) { + pos = originalPos; + return null; + } + return result; + }; + } + + // There is a general pattern -- parse a thing, if that worked, apply transform, otherwise return null. + // But using this as a combinator seems to cause problems when combined with nOrMore(). + // May be some scoping issue + function transform( p, fn ) { + return function() { + var result = p(); + return result === null ? null : fn( result ); + }; + } + + // Helpers -- just make ps out of simpler JS builtin types + + function makeStringParser( s ) { + var len = s.length; + return function() { + var result = null; + if ( input.substr( pos, len ) === s ) { + result = s; + pos += len; + } + return result; + }; + } + + function makeRegexParser( regex ) { + return function() { + var matches = input.substr( pos ).match( regex ); + if ( matches === null ) { + return null; + } + pos += matches[0].length; + return matches[0]; + }; + } + + + /** + * =================================================================== + * General patterns above this line -- wikitext specific parsers below + * =================================================================== + */ + + // Parsing functions follow. All parsing functions work like this: + // They don't accept any arguments. + // Instead, they just operate non destructively on the string 'input' + // As they can consume parts of the string, they advance the shared variable pos, + // and return tokens (or whatever else they want to return). + + // some things are defined as closures and other things as ordinary functions + // converting everything to a closure makes it a lot harder to debug... errors pop up + // but some debuggers can't tell you exactly where they come from. Also the mutually + // recursive functions seem not to work in all browsers then. (Tested IE6-7, Opera, Safari, FF) + // This may be because, to save code, memoization was removed + + + var regularLiteral = makeRegexParser( /^[^{}[\]$\\]/ ); + var regularLiteralWithoutBar = makeRegexParser(/^[^{}[\]$\\|]/); + var regularLiteralWithoutSpace = makeRegexParser(/^[^{}[\]$\s]/); + + var backslash = makeStringParser( "\\" ); + var anyCharacter = makeRegexParser( /^./ ); + + function escapedLiteral() { + var result = sequence( [ + backslash, + anyCharacter + ] ); + return result === null ? null : result[1]; + } + + var escapedOrLiteralWithoutSpace = choice( [ + escapedLiteral, + regularLiteralWithoutSpace + ] ); + + var escapedOrLiteralWithoutBar = choice( [ + escapedLiteral, + regularLiteralWithoutBar + ] ); + + var escapedOrRegularLiteral = choice( [ + escapedLiteral, + regularLiteral + ] ); + + // Used to define "literals" without spaces, in space-delimited situations + function literalWithoutSpace() { + var result = nOrMore( 1, escapedOrLiteralWithoutSpace )(); + return result === null ? null : result.join(''); + } + + // Used to define "literals" within template parameters. The pipe character is the parameter delimeter, so by default + // it is not a literal in the parameter + function literalWithoutBar() { + var result = nOrMore( 1, escapedOrLiteralWithoutBar )(); + return result === null ? null : result.join(''); + } + + function literal() { + var result = nOrMore( 1, escapedOrRegularLiteral )(); + return result === null ? null : result.join(''); + } + + var whitespace = makeRegexParser( /^\s+/ ); + var dollar = makeStringParser( '$' ); + var digits = makeRegexParser( /^\d+/ ); + + function replacement() { + var result = sequence( [ + dollar, + digits + ] ); + if ( result === null ) { + return null; + } + return [ 'REPLACE', parseInt( result[1], 10 ) - 1 ]; + } + + + var openExtlink = makeStringParser( '[' ); + var closeExtlink = makeStringParser( ']' ); + + // this extlink MUST have inner text, e.g. [foo] not allowed; [foo bar] is allowed + function extlink() { + var result = null; + var parsedResult = sequence( [ + openExtlink, + nonWhitespaceExpression, + whitespace, + expression, + closeExtlink + ] ); + if ( parsedResult !== null ) { + result = [ 'LINK', parsedResult[1], parsedResult[3] ]; + } + return result; + } + + var openLink = makeStringParser( '[[' ); + var closeLink = makeStringParser( ']]' ); + + function link() { + var result = null; + var parsedResult = sequence( [ + openLink, + expression, + closeLink + ] ); + if ( parsedResult !== null ) { + result = [ 'WLINK', parsedResult[1] ]; + } + return result; + } + + var templateName = transform( + // see $wgLegalTitleChars + // not allowing : due to the need to catch "PLURAL:$1" + makeRegexParser( /^[ !"$&'()*,.\/0-9;=?@A-Z\^_`a-z~\x80-\xFF+-]+/ ), + function( result ) { return result.toString(); } + ); + + function templateParam() { + var result = sequence( [ + pipe, + nOrMore( 0, paramExpression ) + ] ); + if ( result === null ) { + return null; + } + var expr = result[1]; + // use a "CONCAT" operator if there are multiple nodes, otherwise return the first node, raw. + return expr.length > 1 ? [ "CONCAT" ].concat( expr ) : expr[0]; + } + + var pipe = makeStringParser( '|' ); + + function templateWithReplacement() { + var result = sequence( [ + templateName, + colon, + replacement + ] ); + return result === null ? null : [ result[0], result[2] ]; + } + + var colon = makeStringParser(':'); + + var templateContents = choice( [ + function() { + var res = sequence( [ + templateWithReplacement, + nOrMore( 0, templateParam ) + ] ); + return res === null ? null : res[0].concat( res[1] ); + }, + function() { + var res = sequence( [ + templateName, + nOrMore( 0, templateParam ) + ] ); + if ( res === null ) { + return null; + } + return [ res[0] ].concat( res[1] ); + } + ] ); + + var openTemplate = makeStringParser('{{'); + var closeTemplate = makeStringParser('}}'); + + function template() { + var result = sequence( [ + openTemplate, + templateContents, + closeTemplate + ] ); + return result === null ? null : result[1]; + } + + var nonWhitespaceExpression = choice( [ + template, + link, + extlink, + replacement, + literalWithoutSpace + ] ); + + var paramExpression = choice( [ + template, + link, + extlink, + replacement, + literalWithoutBar + ] ); + + var expression = choice( [ + template, + link, + extlink, + replacement, + literal + ] ); + + function start() { + var result = nOrMore( 0, expression )(); + if ( result === null ) { + return null; + } + return [ "CONCAT" ].concat( result ); + } + + // everything above this point is supposed to be stateless/static, but + // I am deferring the work of turning it into prototypes & objects. It's quite fast enough + + // finally let's do some actual work... + + var result = start(); + + /* + * For success, the p must have gotten to the end of the input + * and returned a non-null. + * n.b. This is part of language infrastructure, so we do not throw an internationalizable message. + */ + if (result === null || pos !== input.length) { + throw new Error( "Parse error at position " + pos.toString() + " in input: " + input ); + } + return result; + } + + }; + + /** + * htmlEmitter - object which primarily exists to emit HTML from parser ASTs + */ + mw.jqueryMsg.htmlEmitter = function( language, magic ) { + this.language = language; + var _this = this; + + $.each( magic, function( key, val ) { + _this[ key.toLowerCase() ] = function() { return val; }; + } ); + + /** + * (We put this method definition here, and not in prototype, to make sure it's not overwritten by any magic.) + * Walk entire node structure, applying replacements and template functions when appropriate + * @param {Mixed} abstract syntax tree (top node or subnode) + * @param {Array} replacements for $1, $2, ... $n + * @return {Mixed} single-string node or array of nodes suitable for jQuery appending + */ + this.emit = function( node, replacements ) { + var ret = null; + var _this = this; + switch( typeof node ) { + case 'string': + case 'number': + ret = node; + break; + case 'object': // node is an array of nodes + var subnodes = $.map( node.slice( 1 ), function( n ) { + return _this.emit( n, replacements ); + } ); + var operation = node[0].toLowerCase(); + if ( typeof _this[operation] === 'function' ) { + ret = _this[ operation ]( subnodes, replacements ); + } else { + throw new Error( 'unknown operation "' + operation + '"' ); + } + break; + case 'undefined': + // Parsing the empty string (as an entire expression, or as a paramExpression in a template) results in undefined + // Perhaps a more clever parser can detect this, and return the empty string? Or is that useful information? + // The logical thing is probably to return the empty string here when we encounter undefined. + ret = ''; + break; + default: + throw new Error( 'unexpected type in AST: ' + typeof node ); + } + return ret; + }; + + }; + + // For everything in input that follows double-open-curly braces, there should be an equivalent parser + // function. For instance {{PLURAL ... }} will be processed by 'plural'. + // If you have 'magic words' then configure the parser to have them upon creation. + // + // An emitter method takes the parent node, the array of subnodes and the array of replacements (the values that $1, $2... should translate to). + // Note: all such functions must be pure, with the exception of referring to other pure functions via this.language (convertPlural and so on) + mw.jqueryMsg.htmlEmitter.prototype = { + + /** + * Parsing has been applied depth-first we can assume that all nodes here are single nodes + * Must return a single node to parents -- a jQuery with synthetic span + * However, unwrap any other synthetic spans in our children and pass them upwards + * @param {Array} nodes - mixed, some single nodes, some arrays of nodes + * @return {jQuery} + */ + concat: function( nodes ) { + var span = $( '' ).addClass( 'mediaWiki_htmlEmitter' ); + $.each( nodes, function( i, node ) { + if ( node instanceof jQuery && node.hasClass( 'mediaWiki_htmlEmitter' ) ) { + $.each( node.contents(), function( j, childNode ) { + span.append( childNode ); + } ); + } else { + // strings, integers, anything else + span.append( node ); + } + } ); + return span; + }, + + /** + * Return replacement of correct index, or string if unavailable. + * Note that we expect the parsed parameter to be zero-based. i.e. $1 should have become [ 0 ]. + * if the specified parameter is not found return the same string + * (e.g. "$99" -> parameter 98 -> not found -> return "$99" ) + * TODO throw error if nodes.length > 1 ? + * @param {Array} of one element, integer, n >= 0 + * @return {String} replacement + */ + replace: function( nodes, replacements ) { + var index = parseInt( nodes[0], 10 ); + return index < replacements.length ? replacements[index] : '$' + ( index + 1 ); + }, + + /** + * Transform wiki-link + * TODO unimplemented + */ + wlink: function( nodes ) { + return "unimplemented"; + }, + + /** + * Transform parsed structure into external link + * If the href is a jQuery object, treat it as "enclosing" the link text. + * ... function, treat it as the click handler + * ... string, treat it as a URI + * TODO: throw an error if nodes.length > 2 ? + * @param {Array} of two elements, {jQuery|Function|String} and {String} + * @return {jQuery} + */ + link: function( nodes ) { + var arg = nodes[0]; + var contents = nodes[1]; + var $el; + if ( arg instanceof jQuery ) { + $el = arg; + } else { + $el = $( '' ); + if ( typeof arg === 'function' ) { + $el.click( arg ).attr( 'href', '#' ); + } else { + $el.attr( 'href', arg.toString() ); + } + } + $el.append( contents ); + return $el; + }, + + /** + * Transform parsed structure into pluralization + * n.b. The first node may be a non-integer (for instance, a string representing an Arabic number). + * So convert it back with the current language's convertNumber. + * @param {Array} of nodes, [ {String|Number}, {String}, {String} ... ] + * @return {String} selected pluralized form according to current language + */ + plural: function( nodes ) { + var count = parseInt( this.language.convertNumber( nodes[0], true ), 10 ); + var forms = nodes.slice(1); + return forms.length ? this.language.convertPlural( count, forms ) : ''; + } + + }; + + // TODO figure out a way to make magic work with common globals like wgSiteName, without requiring init from library users... + // var options = { magic: { 'SITENAME' : mw.config.get( 'wgSiteName' ) } }; + + // deprecated! don't rely on gM existing. + // the window.gM ought not to be required - or if required, not required here. But moving it to extensions breaks it (?!) + // Need to fix plugin so it could do attributes as well, then will be okay to remove this. + window.gM = mw.jqueryMsg.getMessageFunction(); + + $.fn.msg = mw.jqueryMsg.getPlugin(); + +} )( mediaWiki, jQuery ); diff --git a/resources/mediawiki/mediawiki.jqueryMsg.peg b/resources/mediawiki/mediawiki.jqueryMsg.peg new file mode 100644 index 0000000000..74c57e4b2a --- /dev/null +++ b/resources/mediawiki/mediawiki.jqueryMsg.peg @@ -0,0 +1,76 @@ +/* PEG grammar for a subset of wikitext, useful in the MediaWiki frontend */ + +start + = e:expression* { return e.length > 1 ? [ "CONCAT" ].concat(e) : e[0]; } + +expression + = template + / link + / extlink + / replacement + / literal + +paramExpression + = template + / link + / extlink + / replacement + / literalWithoutBar + +template + = "{{" t:templateContents "}}" { return t; } + +templateContents + = twr:templateWithReplacement p:templateParam* { return twr.concat(p) } + / t:templateName p:templateParam* { return p.length ? [ t, p ] : [ t ] } + +templateWithReplacement + = t:templateName ":" r:replacement { return [ t, r ] } + +templateParam + = "|" e:paramExpression* { return e.length > 1 ? [ "CONCAT" ].concat(e) : e[0]; } + +templateName + = tn:[A-Za-z_]+ { return tn.join('').toUpperCase() } + +link + = "[[" w:expression "]]" { return [ 'WLINK', w ]; } + +extlink + = "[" url:url whitespace text:expression "]" { return [ 'LINK', url, text ] } + +url + = url:[^ ]+ { return url.join(''); } + +whitespace + = [ ]+ + +replacement + = '$' digits:digits { return [ 'REPLACE', parseInt( digits, 10 ) - 1 ] } + +digits + = [0-9]+ + +literal + = lit:escapedOrRegularLiteral+ { return lit.join(''); } + +literalWithoutBar + = lit:escapedOrLiteralWithoutBar+ { return lit.join(''); } + +escapedOrRegularLiteral + = escapedLiteral + / regularLiteral + +escapedOrLiteralWithoutBar + = escapedLiteral + / regularLiteralWithoutBar + +escapedLiteral + = "\\" escaped:. { return escaped; } + +regularLiteral + = [^{}\[\]$\\] + +regularLiteralWithoutBar + = [^{}\[\]$\\|] + diff --git a/tests/jasmine/spec/mediawiki.jqueryMsg.spec.data.js b/tests/jasmine/spec/mediawiki.jqueryMsg.spec.data.js new file mode 100644 index 0000000000..a867f72cfb --- /dev/null +++ b/tests/jasmine/spec/mediawiki.jqueryMsg.spec.data.js @@ -0,0 +1,488 @@ +// This file stores the results from the PHP parser for certain messages and arguments, +// so we can test the equivalent Javascript libraries. +// Last generated with makeLanguageSpec.php at 2011-01-28T02:04:09+00:00 + +mediaWiki.messages.set( { + "en_undelete_short": "Undelete {{PLURAL:$1|one edit|$1 edits}}", + "en_category-subcat-count": "{{PLURAL:$2|This category has only the following subcategory.|This category has the following {{PLURAL:$1|subcategory|$1 subcategories}}, out of $2 total.}}", + "fr_undelete_short": "Restaurer $1 modification{{PLURAL:$1||s}}", + "fr_category-subcat-count": "Cette cat\u00e9gorie comprend {{PLURAL:$2|la sous-cat\u00e9gorie|$2 sous-cat\u00e9gories, dont {{PLURAL:$1|celle|les $1}}}} ci-dessous.", + "ar_undelete_short": "\u0627\u0633\u062a\u0631\u062c\u0627\u0639 {{PLURAL:$1|\u062a\u0639\u062f\u064a\u0644 \u0648\u0627\u062d\u062f|\u062a\u0639\u062f\u064a\u0644\u064a\u0646|$1 \u062a\u0639\u062f\u064a\u0644\u0627\u062a|$1 \u062a\u0639\u062f\u064a\u0644|$1 \u062a\u0639\u062f\u064a\u0644\u0627}}", + "ar_category-subcat-count": "{{PLURAL:$2|\u0644\u0627 \u062a\u0635\u0627\u0646\u064a\u0641 \u0641\u0631\u0639\u064a\u0629 \u0641\u064a \u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641|\u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0641\u064a\u0647 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0627\u0644\u0641\u0631\u0639\u064a \u0627\u0644\u062a\u0627\u0644\u064a \u0641\u0642\u0637.|\u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0641\u064a\u0647 {{PLURAL:$1||\u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0627\u0644\u0641\u0631\u0639\u064a|\u0647\u0630\u064a\u0646 \u0627\u0644\u062a\u0635\u0646\u064a\u0641\u064a\u0646 \u0627\u0644\u0641\u0631\u0639\u064a\u064a\u0646|\u0647\u0630\u0647 \u0627\u0644$1 \u062a\u0635\u0627\u0646\u064a\u0641 \u0627\u0644\u0641\u0631\u0639\u064a\u0629|\u0647\u0630\u0647 \u0627\u0644$1 \u062a\u0635\u0646\u064a\u0641\u0627 \u0641\u0631\u0639\u064a\u0627|\u0647\u0630\u0647 \u0627\u0644$1 \u062a\u0635\u0646\u064a\u0641 \u0641\u0631\u0639\u064a}}\u060c \u0645\u0646 \u0625\u062c\u0645\u0627\u0644\u064a $2.}}", + "jp_undelete_short": "Undelete {{PLURAL:$1|one edit|$1 edits}}", + "jp_category-subcat-count": "{{PLURAL:$2|This category has only the following subcategory.|This category has the following {{PLURAL:$1|subcategory|$1 subcategories}}, out of $2 total.}}", + "zh_undelete_short": "\u6062\u590d\u88ab\u5220\u9664\u7684$1\u9879\u4fee\u8ba2", + "zh_category-subcat-count": "{{PLURAL:$2|\u672c\u5206\u7c7b\u53ea\u6709\u4e0b\u5217\u4e00\u4e2a\u5b50\u5206\u7c7b\u3002|\u672c\u5206\u7c7b\u5305\u542b\u4e0b\u5217$1\u4e2a\u5b50\u5206\u7c7b\uff0c\u5171\u6709$2\u4e2a\u5b50\u5206\u7c7b\u3002}}" +} ); +var jasmineMsgSpec = [ + { + "name": "en undelete_short 0", + "key": "en_undelete_short", + "args": [ + 0 + ], + "result": "Undelete 0 edits", + "lang": "en" + }, + { + "name": "en undelete_short 1", + "key": "en_undelete_short", + "args": [ + 1 + ], + "result": "Undelete one edit", + "lang": "en" + }, + { + "name": "en undelete_short 2", + "key": "en_undelete_short", + "args": [ + 2 + ], + "result": "Undelete 2 edits", + "lang": "en" + }, + { + "name": "en undelete_short 5", + "key": "en_undelete_short", + "args": [ + 5 + ], + "result": "Undelete 5 edits", + "lang": "en" + }, + { + "name": "en undelete_short 21", + "key": "en_undelete_short", + "args": [ + 21 + ], + "result": "Undelete 21 edits", + "lang": "en" + }, + { + "name": "en undelete_short 101", + "key": "en_undelete_short", + "args": [ + 101 + ], + "result": "Undelete 101 edits", + "lang": "en" + }, + { + "name": "en category-subcat-count 0,10", + "key": "en_category-subcat-count", + "args": [ + 0, + 10 + ], + "result": "This category has the following 0 subcategories, out of 10 total.", + "lang": "en" + }, + { + "name": "en category-subcat-count 1,1", + "key": "en_category-subcat-count", + "args": [ + 1, + 1 + ], + "result": "This category has only the following subcategory.", + "lang": "en" + }, + { + "name": "en category-subcat-count 1,2", + "key": "en_category-subcat-count", + "args": [ + 1, + 2 + ], + "result": "This category has the following subcategory, out of 2 total.", + "lang": "en" + }, + { + "name": "en category-subcat-count 3,30", + "key": "en_category-subcat-count", + "args": [ + 3, + 30 + ], + "result": "This category has the following 3 subcategories, out of 30 total.", + "lang": "en" + }, + { + "name": "fr undelete_short 0", + "key": "fr_undelete_short", + "args": [ + 0 + ], + "result": "Restaurer 0 modification", + "lang": "fr" + }, + { + "name": "fr undelete_short 1", + "key": "fr_undelete_short", + "args": [ + 1 + ], + "result": "Restaurer 1 modification", + "lang": "fr" + }, + { + "name": "fr undelete_short 2", + "key": "fr_undelete_short", + "args": [ + 2 + ], + "result": "Restaurer 2 modifications", + "lang": "fr" + }, + { + "name": "fr undelete_short 5", + "key": "fr_undelete_short", + "args": [ + 5 + ], + "result": "Restaurer 5 modifications", + "lang": "fr" + }, + { + "name": "fr undelete_short 21", + "key": "fr_undelete_short", + "args": [ + 21 + ], + "result": "Restaurer 21 modifications", + "lang": "fr" + }, + { + "name": "fr undelete_short 101", + "key": "fr_undelete_short", + "args": [ + 101 + ], + "result": "Restaurer 101 modifications", + "lang": "fr" + }, + { + "name": "fr category-subcat-count 0,10", + "key": "fr_category-subcat-count", + "args": [ + 0, + 10 + ], + "result": "Cette cat\u00e9gorie comprend 10 sous-cat\u00e9gories, dont celle ci-dessous.", + "lang": "fr" + }, + { + "name": "fr category-subcat-count 1,1", + "key": "fr_category-subcat-count", + "args": [ + 1, + 1 + ], + "result": "Cette cat\u00e9gorie comprend la sous-cat\u00e9gorie ci-dessous.", + "lang": "fr" + }, + { + "name": "fr category-subcat-count 1,2", + "key": "fr_category-subcat-count", + "args": [ + 1, + 2 + ], + "result": "Cette cat\u00e9gorie comprend 2 sous-cat\u00e9gories, dont celle ci-dessous.", + "lang": "fr" + }, + { + "name": "fr category-subcat-count 3,30", + "key": "fr_category-subcat-count", + "args": [ + 3, + 30 + ], + "result": "Cette cat\u00e9gorie comprend 30 sous-cat\u00e9gories, dont les 3 ci-dessous.", + "lang": "fr" + }, + { + "name": "ar undelete_short 0", + "key": "ar_undelete_short", + "args": [ + 0 + ], + "result": "\u0627\u0633\u062a\u0631\u062c\u0627\u0639 \u062a\u0639\u062f\u064a\u0644 \u0648\u0627\u062d\u062f", + "lang": "ar" + }, + { + "name": "ar undelete_short 1", + "key": "ar_undelete_short", + "args": [ + 1 + ], + "result": "\u0627\u0633\u062a\u0631\u062c\u0627\u0639 \u062a\u0639\u062f\u064a\u0644\u064a\u0646", + "lang": "ar" + }, + { + "name": "ar undelete_short 2", + "key": "ar_undelete_short", + "args": [ + 2 + ], + "result": "\u0627\u0633\u062a\u0631\u062c\u0627\u0639 2 \u062a\u0639\u062f\u064a\u0644\u0627\u062a", + "lang": "ar" + }, + { + "name": "ar undelete_short 5", + "key": "ar_undelete_short", + "args": [ + 5 + ], + "result": "\u0627\u0633\u062a\u0631\u062c\u0627\u0639 5 \u062a\u0639\u062f\u064a\u0644", + "lang": "ar" + }, + { + "name": "ar undelete_short 21", + "key": "ar_undelete_short", + "args": [ + 21 + ], + "result": "\u0627\u0633\u062a\u0631\u062c\u0627\u0639 21 \u062a\u0639\u062f\u064a\u0644\u0627", + "lang": "ar" + }, + { + "name": "ar undelete_short 101", + "key": "ar_undelete_short", + "args": [ + 101 + ], + "result": "\u0627\u0633\u062a\u0631\u062c\u0627\u0639 101 \u062a\u0639\u062f\u064a\u0644\u0627", + "lang": "ar" + }, + { + "name": "ar category-subcat-count 0,10", + "key": "ar_category-subcat-count", + "args": [ + 0, + 10 + ], + "result": "\u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0641\u064a\u0647 \u060c \u0645\u0646 \u0625\u062c\u0645\u0627\u0644\u064a 10.", + "lang": "ar" + }, + { + "name": "ar category-subcat-count 1,1", + "key": "ar_category-subcat-count", + "args": [ + 1, + 1 + ], + "result": "\u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0641\u064a\u0647 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0627\u0644\u0641\u0631\u0639\u064a \u0627\u0644\u062a\u0627\u0644\u064a \u0641\u0642\u0637.", + "lang": "ar" + }, + { + "name": "ar category-subcat-count 1,2", + "key": "ar_category-subcat-count", + "args": [ + 1, + 2 + ], + "result": "\u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0641\u064a\u0647 \u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0627\u0644\u0641\u0631\u0639\u064a\u060c \u0645\u0646 \u0625\u062c\u0645\u0627\u0644\u064a 2.", + "lang": "ar" + }, + { + "name": "ar category-subcat-count 3,30", + "key": "ar_category-subcat-count", + "args": [ + 3, + 30 + ], + "result": "\u0647\u0630\u0627 \u0627\u0644\u062a\u0635\u0646\u064a\u0641 \u0641\u064a\u0647 \u0647\u0630\u0647 \u0627\u06443 \u062a\u0635\u0627\u0646\u064a\u0641 \u0627\u0644\u0641\u0631\u0639\u064a\u0629\u060c \u0645\u0646 \u0625\u062c\u0645\u0627\u0644\u064a 30.", + "lang": "ar" + }, + { + "name": "jp undelete_short 0", + "key": "jp_undelete_short", + "args": [ + 0 + ], + "result": "Undelete 0 edits", + "lang": "jp" + }, + { + "name": "jp undelete_short 1", + "key": "jp_undelete_short", + "args": [ + 1 + ], + "result": "Undelete one edit", + "lang": "jp" + }, + { + "name": "jp undelete_short 2", + "key": "jp_undelete_short", + "args": [ + 2 + ], + "result": "Undelete 2 edits", + "lang": "jp" + }, + { + "name": "jp undelete_short 5", + "key": "jp_undelete_short", + "args": [ + 5 + ], + "result": "Undelete 5 edits", + "lang": "jp" + }, + { + "name": "jp undelete_short 21", + "key": "jp_undelete_short", + "args": [ + 21 + ], + "result": "Undelete 21 edits", + "lang": "jp" + }, + { + "name": "jp undelete_short 101", + "key": "jp_undelete_short", + "args": [ + 101 + ], + "result": "Undelete 101 edits", + "lang": "jp" + }, + { + "name": "jp category-subcat-count 0,10", + "key": "jp_category-subcat-count", + "args": [ + 0, + 10 + ], + "result": "This category has the following 0 subcategories, out of 10 total.", + "lang": "jp" + }, + { + "name": "jp category-subcat-count 1,1", + "key": "jp_category-subcat-count", + "args": [ + 1, + 1 + ], + "result": "This category has only the following subcategory.", + "lang": "jp" + }, + { + "name": "jp category-subcat-count 1,2", + "key": "jp_category-subcat-count", + "args": [ + 1, + 2 + ], + "result": "This category has the following subcategory, out of 2 total.", + "lang": "jp" + }, + { + "name": "jp category-subcat-count 3,30", + "key": "jp_category-subcat-count", + "args": [ + 3, + 30 + ], + "result": "This category has the following 3 subcategories, out of 30 total.", + "lang": "jp" + }, + { + "name": "zh undelete_short 0", + "key": "zh_undelete_short", + "args": [ + 0 + ], + "result": "\u6062\u590d\u88ab\u5220\u9664\u76840\u9879\u4fee\u8ba2", + "lang": "zh" + }, + { + "name": "zh undelete_short 1", + "key": "zh_undelete_short", + "args": [ + 1 + ], + "result": "\u6062\u590d\u88ab\u5220\u9664\u76841\u9879\u4fee\u8ba2", + "lang": "zh" + }, + { + "name": "zh undelete_short 2", + "key": "zh_undelete_short", + "args": [ + 2 + ], + "result": "\u6062\u590d\u88ab\u5220\u9664\u76842\u9879\u4fee\u8ba2", + "lang": "zh" + }, + { + "name": "zh undelete_short 5", + "key": "zh_undelete_short", + "args": [ + 5 + ], + "result": "\u6062\u590d\u88ab\u5220\u9664\u76845\u9879\u4fee\u8ba2", + "lang": "zh" + }, + { + "name": "zh undelete_short 21", + "key": "zh_undelete_short", + "args": [ + 21 + ], + "result": "\u6062\u590d\u88ab\u5220\u9664\u768421\u9879\u4fee\u8ba2", + "lang": "zh" + }, + { + "name": "zh undelete_short 101", + "key": "zh_undelete_short", + "args": [ + 101 + ], + "result": "\u6062\u590d\u88ab\u5220\u9664\u7684101\u9879\u4fee\u8ba2", + "lang": "zh" + }, + { + "name": "zh category-subcat-count 0,10", + "key": "zh_category-subcat-count", + "args": [ + 0, + 10 + ], + "result": "\u672c\u5206\u7c7b\u5305\u542b\u4e0b\u52170\u4e2a\u5b50\u5206\u7c7b\uff0c\u5171\u670910\u4e2a\u5b50\u5206\u7c7b\u3002", + "lang": "zh" + }, + { + "name": "zh category-subcat-count 1,1", + "key": "zh_category-subcat-count", + "args": [ + 1, + 1 + ], + "result": "\u672c\u5206\u7c7b\u53ea\u6709\u4e0b\u5217\u4e00\u4e2a\u5b50\u5206\u7c7b\u3002", + "lang": "zh" + }, + { + "name": "zh category-subcat-count 1,2", + "key": "zh_category-subcat-count", + "args": [ + 1, + 2 + ], + "result": "\u672c\u5206\u7c7b\u5305\u542b\u4e0b\u52171\u4e2a\u5b50\u5206\u7c7b\uff0c\u5171\u67092\u4e2a\u5b50\u5206\u7c7b\u3002", + "lang": "zh" + }, + { + "name": "zh category-subcat-count 3,30", + "key": "zh_category-subcat-count", + "args": [ + 3, + 30 + ], + "result": "\u672c\u5206\u7c7b\u5305\u542b\u4e0b\u52173\u4e2a\u5b50\u5206\u7c7b\uff0c\u5171\u670930\u4e2a\u5b50\u5206\u7c7b\u3002", + "lang": "zh" + } +]; diff --git a/tests/jasmine/spec/mediawiki.jqueryMsg.spec.js b/tests/jasmine/spec/mediawiki.jqueryMsg.spec.js new file mode 100644 index 0000000000..1d10ca7263 --- /dev/null +++ b/tests/jasmine/spec/mediawiki.jqueryMsg.spec.js @@ -0,0 +1,350 @@ +/* spec for language & message behaviour in MediaWiki */ + +mw.messages.set( { + "en_empty": "", + "en_simple": "Simple message", + "en_replace": "Simple $1 replacement", + "en_replace2": "Simple $1 $2 replacements", + "en_link": "Simple [http://example.com link to example].", + "en_link_replace": "Complex [$1 $2] behaviour.", + "en_simple_magic": "Simple {{ALOHOMORA}} message", + "en_undelete_short": "Undelete {{PLURAL:$1|one edit|$1 edits}}", + "en_undelete_empty_param": "Undelete{{PLURAL:$1|| multiple edits}}", + "en_category-subcat-count": "{{PLURAL:$2|This category has only the following subcategory.|This category has the following {{PLURAL:$1|subcategory|$1 subcategories}}, out of $2 total.}}", + "en_escape0": "Escape \\to fantasy island", + "en_escape1": "I had \\$2.50 in my pocket", + "en_escape2": "I had {{PLURAL:$1|the absolute \\|$1\\| which came out to \\$3.00 in my C:\\\\drive| some stuff}}", + "en_fail": "This should fail to {{parse", + "en_fail_magic": "There is no such magic word as {{SIETNAME}}" +} ); + +/** + * Tests + */ +( function( mw, $, undefined ) { + + describe( "mediaWiki.jqueryMsg", function() { + + describe( "basic message functionality", function() { + + it( "should return identity for empty string", function() { + var parser = new mw.jqueryMsg.parser(); + expect( parser.parse( 'en_empty' ).html() ).toEqual( '' ); + } ); + + + it( "should return identity for simple string", function() { + var parser = new mw.jqueryMsg.parser(); + expect( parser.parse( 'en_simple' ).html() ).toEqual( 'Simple message' ); + } ); + + } ); + + describe( "escaping", function() { + + it ( "should handle simple escaping", function() { + var parser = new mw.jqueryMsg.parser(); + expect( parser.parse( 'en_escape0' ).html() ).toEqual( 'Escape to fantasy island' ); + } ); + + it ( "should escape dollar signs found in ordinary text when backslashed", function() { + var parser = new mw.jqueryMsg.parser(); + expect( parser.parse( 'en_escape1' ).html() ).toEqual( 'I had $2.50 in my pocket' ); + } ); + + it ( "should handle a complicated escaping case, including escaped pipe chars in template args", function() { + var parser = new mw.jqueryMsg.parser(); + expect( parser.parse( 'en_escape2', [ 1 ] ).html() ).toEqual( 'I had the absolute |1| which came out to $3.00 in my C:\\drive' ); + } ); + + } ); + + describe( "replacing", function() { + + it ( "should handle simple replacing", function() { + var parser = new mw.jqueryMsg.parser(); + expect( parser.parse( 'en_replace', [ 'foo' ] ).html() ).toEqual( 'Simple foo replacement' ); + } ); + + it ( "should return $n if replacement not there", function() { + var parser = new mw.jqueryMsg.parser(); + expect( parser.parse( 'en_replace', [] ).html() ).toEqual( 'Simple $1 replacement' ); + expect( parser.parse( 'en_replace2', [ 'bar' ] ).html() ).toEqual( 'Simple bar $2 replacements' ); + } ); + + } ); + + describe( "linking", function() { + + it ( "should handle a simple link", function() { + var parser = new mw.jqueryMsg.parser(); + var parsed = parser.parse( 'en_link' ); + var contents = parsed.contents(); + expect( contents.length ).toEqual( 3 ); + expect( contents[0].nodeName ).toEqual( '#text' ); + expect( contents[0].nodeValue ).toEqual( 'Simple ' ); + expect( contents[1].nodeName ).toEqual( 'A' ); + expect( contents[1].getAttribute( 'href' ) ).toEqual( 'http://example.com' ); + expect( contents[1].childNodes[0].nodeValue ).toEqual( 'link to example' ); + expect( contents[2].nodeName ).toEqual( '#text' ); + expect( contents[2].nodeValue ).toEqual( '.' ); + } ); + + it ( "should replace a URL into a link", function() { + var parser = new mw.jqueryMsg.parser(); + var parsed = parser.parse( 'en_link_replace', [ 'http://example.com/foo', 'linking' ] ); + var contents = parsed.contents(); + expect( contents.length ).toEqual( 3 ); + expect( contents[0].nodeName ).toEqual( '#text' ); + expect( contents[0].nodeValue ).toEqual( 'Complex ' ); + expect( contents[1].nodeName ).toEqual( 'A' ); + expect( contents[1].getAttribute( 'href' ) ).toEqual( 'http://example.com/foo' ); + expect( contents[1].childNodes[0].nodeValue ).toEqual( 'linking' ); + expect( contents[2].nodeName ).toEqual( '#text' ); + expect( contents[2].nodeValue ).toEqual( ' behaviour.' ); + } ); + + it ( "should bind a click handler into a link", function() { + var parser = new mw.jqueryMsg.parser(); + var clicked = false; + var click = function() { clicked = true; }; + var parsed = parser.parse( 'en_link_replace', [ click, 'linking' ] ); + var contents = parsed.contents(); + expect( contents.length ).toEqual( 3 ); + expect( contents[0].nodeName ).toEqual( '#text' ); + expect( contents[0].nodeValue ).toEqual( 'Complex ' ); + expect( contents[1].nodeName ).toEqual( 'A' ); + expect( contents[1].getAttribute( 'href' ) ).toEqual( '#' ); + expect( contents[1].childNodes[0].nodeValue ).toEqual( 'linking' ); + expect( contents[2].nodeName ).toEqual( '#text' ); + expect( contents[2].nodeValue ).toEqual( ' behaviour.' ); + // determining bindings is hard in IE + var anchor = parsed.find( 'a' ); + if ( ( $.browser.mozilla || $.browser.webkit ) && anchor.click ) { + expect( clicked ).toEqual( false ); + anchor.click(); + expect( clicked ).toEqual( true ); + } + } ); + + it ( "should wrap a jquery arg around link contents -- even another element", function() { + var parser = new mw.jqueryMsg.parser(); + var clicked = false; + var click = function() { clicked = true; }; + var button = $( ' behaviour.' ).html(); + var createdHtml = $div.find( '.foo' ).html(); + // it is hard to test for clicks with IE; also it inserts or removes spaces around nodes when creating HTML tags, depending on their type. + // so need to check the strings stripped of spaces. + if ( ( $.browser.mozilla || $.browser.webkit ) && $button.click ) { + expect( createdHtml ).toEqual( expectedHtml ); + $div.find( 'button ').click(); + expect( clicked ).toEqual( true ); + } else if ( $.browser.ie ) { + expect( createdHtml.replace( /\s/, '' ) ).toEqual( expectedHtml.replace( /\s/, '' ) ); + } + delete $.fn.msg; + } ); + + } ); + + // The parser functions can throw errors, but let's not actually blow up for the user -- instead dump the error into the interface so we have + // a chance at fixing this + describe( "easy message interface functions with graceful failures", function() { + it( "should allow a global that returns strings, with graceful failure", function() { + var gM = mw.jqueryMsg.getMessageFunction(); + // passing this through jQuery and back to string, because browsers may have subtle differences, like the case of tag names. + // a surrounding is needed for html() to work right + var expectedHtml = $( 'en_fail: Parse error at position 20 in input: This should fail to {{parse' ).html(); + var result = gM( 'en_fail' ); + expect( typeof result ).toEqual( 'string' ); + expect( result ).toEqual( expectedHtml ); + } ); + + it( "should allow a global that returns strings, with graceful failure on missing magic words", function() { + var gM = mw.jqueryMsg.getMessageFunction(); + // passing this through jQuery and back to string, because browsers may have subtle differences, like the case of tag names. + // a surrounding is needed for html() to work right + var expectedHtml = $( 'en_fail_magic: unknown operation "sietname"' ).html(); + var result = gM( 'en_fail_magic' ); + expect( typeof result ).toEqual( 'string' ); + expect( result ).toEqual( expectedHtml ); + } ); + + + it( "should allow a jQuery plugin, with graceful failure", function() { + $.fn.msg = mw.jqueryMsg.getPlugin(); + var $div = $( '
' ).append( $( '

' ).addClass( 'foo' ) ); + $div.find( '.foo' ).msg( 'en_fail' ); + // passing this through jQuery and back to string, because browsers may have subtle differences, like the case of tag names. + // a surrounding is needed for html() to work right + var expectedHtml = $( 'en_fail: Parse error at position 20 in input: This should fail to {{parse' ).html(); + var createdHtml = $div.find( '.foo' ).html(); + expect( createdHtml ).toEqual( expectedHtml ); + delete $.fn.msg; + } ); + + } ); + + + + + describe( "test plurals and other language-specific functions", function() { + /* copying some language definitions in here -- it's hard to make this test fast and reliable + otherwise, and we don't want to have to know the mediawiki URL from this kind of test either. + We also can't preload the langs for the test since they clobber the same namespace. + In principle Roan said it was okay to change how languages worked so that didn't happen... maybe + someday. We'd have to the same kind of importing of the default rules for most rules, or maybe + come up with some kind of subclassing scheme for languages */ + var languageClasses = { + ar: { + /** + * Arabic (العربية) language functions + */ + + convertPlural: function( count, forms ) { + forms = mw.language.preConvertPlural( forms, 6 ); + if ( count === 0 ) { + return forms[0]; + } + if ( count == 1 ) { + return forms[1]; + } + if ( count == 2 ) { + return forms[2]; + } + if ( count % 100 >= 3 && count % 100 <= 10 ) { + return forms[3]; + } + if ( count % 100 >= 11 && count % 100 <= 99 ) { + return forms[4]; + } + return forms[5]; + }, + + digitTransformTable: { + '0': 'Ù ', // ٠ + '1': 'Ù¡', // ١ + '2': 'Ù¢', // ٢ + '3': 'Ù£', // ٣ + '4': 'Ù¤', // ٤ + '5': 'Ù¥', // ٥ + '6': 'Ù¦', // ٦ + '7': 'Ù§', // ٧ + '8': 'Ù¨', // ٨ + '9': 'Ù©', // ٩ + '.': 'Ù«', // ٫ wrong table ? + ',': 'Ù¬' // ٬ + } + + }, + en: { }, + fr: { + convertPlural: function( count, forms ) { + forms = mw.language.preConvertPlural( forms, 2 ); + return ( count <= 1 ) ? forms[0] : forms[1]; + } + }, + jp: { }, + zh: { } + }; + + /* simulate how the language classes override, or don't, the standard functions in mw.language */ + $.each( languageClasses, function( langCode, rules ) { + $.each( [ 'convertPlural', 'convertNumber' ], function( i, propertyName ) { + if ( typeof rules[ propertyName ] === 'undefined' ) { + rules[ propertyName ] = mw.language[ propertyName ]; + } + } ); + } ); + + $.each( jasmineMsgSpec, function( i, test ) { + it( "should parse " + test.name, function() { + // using language override so we don't have to muck with global namespace + var parser = new mw.jqueryMsg.parser( { language: languageClasses[ test.lang ] } ); + var parsedHtml = parser.parse( test.key, test.args ).html(); + expect( parsedHtml ).toEqual( test.result ); + } ); + } ); + + } ); + + } ); +} )( window.mediaWiki, jQuery ); diff --git a/tests/jasmine/spec_makers/makeJqueryMsgSpec.php b/tests/jasmine/spec_makers/makeJqueryMsgSpec.php new file mode 100644 index 0000000000..1ac8dcba56 --- /dev/null +++ b/tests/jasmine/spec_makers/makeJqueryMsgSpec.php @@ -0,0 +1,114 @@ + array( + array( 0 ), + array( 1 ), + array( 2 ), + array( 5 ), + array( 21 ), + array( 101 ) + ), + 'category-subcat-count' => array( + array( 0, 10 ), + array( 1, 1 ), + array( 1, 2 ), + array( 3, 30 ) + ) + ); + + public function __construct() { + parent::__construct(); + $this->mDescription = "Create a JasmineBDD-compatible specification for message parsing"; + // add any other options here + } + + public function execute() { + list( $messages, $tests ) = $this->getMessagesAndTests(); + $this->writeJavascriptFile( $messages, $tests, "spec/mediawiki.language.parser.spec.data.js" ); + } + + private function getMessagesAndTests() { + $messages = array(); + $tests = array(); + $wfMsgExtOptions = array( 'parsemag' ); + foreach ( array( 'en', 'fr', 'ar', 'jp', 'zh' ) as $languageCode ) { + $wfMsgExtOptions['language'] = $languageCode; + foreach ( self::$keyToTestArgs as $key => $testArgs ) { + foreach ($testArgs as $args) { + // get the raw template, without any transformations + $template = wfMsgGetKey( $key, /* useDb */ true, $languageCode, /* transform */ false ); + + // get the magic-parsed version with args + $wfMsgExtArgs = array_merge( array( $key, $wfMsgExtOptions ), $args ); + $result = call_user_func_array( 'wfMsgExt', $wfMsgExtArgs ); + + // record the template, args, language, and expected result + // fake multiple languages by flattening them together + $langKey = $languageCode . '_' . $key; + $messages[ $langKey ] = $template; + $tests[] = array( + 'name' => $languageCode . " " . $key . " " . join( ",", $args ), + 'key' => $langKey, + 'args' => $args, + 'result' => $result, + 'lang' => $languageCode + ); + } + } + } + return array( $messages, $tests ); + } + + private function writeJavascriptFile( $messages, $tests, $dataSpecFile ) { + global $argv; + $arguments = count($argv) ? $argv : $_SERVER[ 'argv' ]; + + $json = new Services_JSON; + $json->pretty = true; + $javascriptPrologue = "// This file stores the results from the PHP parser for certain messages and arguments,\n" + . "// so we can test the equivalent Javascript libraries.\n" + . '// Last generated with ' . join(' ', $arguments) . ' at ' . gmdate('c') . "\n\n"; + $javascriptMessages = "mediaWiki.messages.set( " . $json->encode( $messages, true ) . " );\n"; + $javascriptTests = 'var jasmineMsgSpec = ' . $json->encode( $tests, true ) . ";\n"; + + $fp = fopen( $dataSpecFile, 'w' ); + if ( !$fp ) { + die( "couldn't open $dataSpecFile for writing" ); + } + $success = fwrite( $fp, $javascriptPrologue . $javascriptMessages . $javascriptTests ); + if ( !$success ) { + die( "couldn't write to $dataSpecFile" ); + } + $success = fclose( $fp ); + if ( !$success ) { + die( "couldn't close $dataSpecFile" ); + } + } +} + +$maintClass = "MakeLanguageSpec"; +require_once( "$maintenanceDir/doMaintenance.php" ); + + + -- 2.20.1