Support message parameters in JavaScript messages with uselang=qqx
authorBartosz Dziewoński <matma.rex@gmail.com>
Sat, 27 Oct 2018 20:01:39 +0000 (22:01 +0200)
committerBartosz Dziewoński <matma.rex@gmail.com>
Tue, 11 Dec 2018 22:22:42 +0000 (23:22 +0100)
Change-Id: I2266ec0770f08e826892a28f52f3201dfd10191d

resources/src/mediawiki.base/mediawiki.base.js
resources/src/mediawiki.jqueryMsg/mediawiki.jqueryMsg.js
tests/qunit/suites/resources/mediawiki/mediawiki.jqueryMsg.test.js
tests/qunit/suites/resources/mediawiki/mediawiki.test.js

index 8a44dcc..04ed5d6 100644 (file)
                 * @return {string} Parsed message
                 */
                parser: function () {
-                       return mw.format.apply( null, [ this.map.get( this.key ) ].concat( this.parameters ) );
+                       var text;
+                       if ( mw.config.get( 'wgUserLanguage' ) === 'qqx' ) {
+                               text = '(' + this.key + '$*)';
+                       } else {
+                               text = this.map.get( this.key );
+                       }
+                       return mw.format.apply( null, [ text ].concat( this.parameters ) );
                },
 
                /**
                 * @return {boolean}
                 */
                exists: function () {
+                       if ( mw.config.get( 'wgUserLanguage' ) === 'qqx' ) {
+                               return true;
+                       }
                        return this.map.exists( this.key );
                }
        };
                } );
        };
 
+       /**
+        * Replace $* with a list of parameters for &uselang=qqx.
+        *
+        * @since 1.33
+        * @param {string} formatString Format string
+        * @param {Array} parameters Values for $N replacements
+        * @return {string} Transformed format string
+        */
+       mw.transformFormatForQqx = function ( formatString, parameters ) {
+               var parametersString;
+               if ( formatString.indexOf( '$*' ) !== -1 ) {
+                       parametersString = '';
+                       if ( parameters.length ) {
+                               parametersString = ': ' + parameters.map( function ( _, i ) {
+                                       return '$' + ( i + 1 );
+                               } ).join( ', ' );
+                       }
+                       return formatString.replace( '$*', parametersString );
+               }
+               return formatString;
+       };
+
        /**
         * Format a string. Replace $1, $2 ... $N with positional arguments.
         *
         */
        mw.format = function ( formatString ) {
                var parameters = slice.call( arguments, 1 );
+               formatString = mw.transformFormatForQqx( formatString, parameters );
                return formatString.replace( /\$(\d+)/g, function ( str, match ) {
                        var index = parseInt( match, 10 ) - 1;
                        return parameters[ index ] !== undefined ? parameters[ index ] : '$' + match;
index ebb469f..3dc09b7 100644 (file)
                 * @return {jQuery}
                 */
                parse: function ( key, replacements ) {
-                       var ast = this.getAst( key );
+                       var ast = this.getAst( key, replacements );
                        return this.emitter.emit( ast, replacements );
                },
 
                 * Note that we pass '⧼' + key + '⧽' back for a missing message here.
                 *
                 * @param {string} key
+                * @param {Array} replacements Variable replacements for $1, $2... $n
                 * @return {string|Array} string of '⧼key⧽' if message missing, simple string if possible, array of arrays if needs parsing
                 */
-               getAst: function ( key ) {
+               getAst: function ( key, replacements ) {
                        var wikiText;
 
                        if ( !Object.prototype.hasOwnProperty.call( this.astCache, key ) ) {
-                               wikiText = this.settings.messages.get( key );
-                               if ( typeof wikiText !== 'string' ) {
-                                       wikiText = '⧼' + key + '⧽';
+                               if ( mw.config.get( 'wgUserLanguage' ) === 'qqx' ) {
+                                       wikiText = '(' + key + '$*)';
+                               } else {
+                                       wikiText = this.settings.messages.get( key );
+                                       if ( typeof wikiText !== 'string' ) {
+                                               wikiText = '⧼' + key + '⧽';
+                                       }
                                }
+                               wikiText = mw.transformFormatForQqx( wikiText, replacements );
                                this.astCache[ key ] = this.wikiTextToAst( wikiText );
                        }
                        return this.astCache[ key ];
index 913022d..1c7d8ee 100644 (file)
        } );
 
        QUnit.test( 'Integration', function ( assert ) {
-               var expected, msg;
+               var expected, msg, $bar;
 
                expected = '<b><a title="Bold" href="/wiki/Bold">Bold</a>!</b>';
                mw.messages.set( 'integration-test', '<b>[[Bold]]!</b>' );
                        '<a href="http://example.com/">Link</a>',
                        'Calling .parse() multiple times does not duplicate link contents'
                );
+
+               mw.config.set( 'wgUserLanguage', 'qqx' );
+               $bar = $( '<b>' ).text( 'bar' );
+               assert.strictEqual( mw.message( 'foo', $bar, 'baz' ).parse(), '(foo: <b>bar</b>, baz)', 'qqx message with parameters' );
        } );
 
        QUnit.test( 'setParserDefaults', function ( assert ) {
index 0353694..425e18e 100644 (file)
                        'Script escaped when using parse format'
                );
 
+               mw.config.set( 'wgUserLanguage', 'qqx' );
+               assert.strictEqual( mw.message( 'foo' ).plain(), '(foo)', 'qqx message' );
+               assert.strictEqual( mw.message( 'foo', 'bar', 'baz' ).plain(), '(foo: bar, baz)', 'qqx message with parameters' );
        } );
 
        QUnit.test( 'mw.msg', function ( assert ) {