Multilingual Templates and Modules

Introduction

What is it? This project makes it possible for modules and templates to be used on multiple wikis, without any modifications. All translations are stored in one place, accessible from everywhere.

Why is this needed? Because we do not have a single Wikipedia, we have 300 separate Wikipedias plus many other projects, and every time someone creates a good new template or a Lua module, it has to be copied 300+ times. More importantly, each template has to be translated 300 times, which is often very difficult, in part because one has to thoroughly understand MediaWiki markup, and also because often authors assume templates will be used for just one language. Plus templates depend on other templates. Plus once copied, templates are often improved, and each copy has to be updated. The pure human expense of copying templates and modules is such, that most templates are either never copied or never updated, especially for the smaller wikis.

Is this the best approach? No, but it is the best approach with the current technology. A very significant MediaWiki rewrite is required to make this possible on the system level. This functionality has been requested from the start 18 years ago, but not much was done simply because this is a very hard problem to solve. With this approach it is possible to create multilingual content now, and once MediaWiki supports it, we can easily migrate this content to the new system without much work.

Method

• DiBabel bot will copy templates and modules from mediawiki.org to all other sites/languages listed in Wikidata for that page, automatically changing the template and module names.
• It will be copied ONLY if Wikidata item has "instance of" set to Wikimedia multi-site page (Q63090714).
• It will be copied ONLY if the current content of the page exists in the history of mediawiki.org's (origin) version. E.g. if a user modifies English version of the page, it will not be overwritten unless that exact text ever existed in the history of the page on mediawiki.org. To resume automatic synchronization, a user must copy the latest version of the page from mediawiki.org. Note that simply reverting a page to an older version will not be enough to prevent a bot from copying it again. A page has to be different from any of origin's revisions (e.g. add a note why the page was modified).
• Any template names will be automatically localized inside the wiki markup, e.g. {{MW name|...}} text will become {{Localized name|...}}, as long as Template:MW name exists on mediawiki.org, and it has a corresponding template on the destination wiki. Shared templates should not use non-shared templates, as that may cause unexpected results.
• Just like templates, modules text require('Module:MW name') will be converted to require('Module:Localized name').

How can you help?

• translate bot summary messages (they will show up in the page history when bot makes a change)
• translate warning messages (shown at the top of all auto-copied templates and modules), and corresponding template data params.
• translate TNT error messages (shown when TNT module finds an error in a template).
• organize a bot account for DiBabelYurikBot user on all wikis that already use TNT module, or a global bot account if that is possible.
• For template and module authors -- create a new localized template or module on mediawiki.org. It might be easiest to start with a simple template, like an info or a warning box, or internationalize a popular existing module. Shared templates and modules should not use any templates or modules that are not already shared, except for the few listed as non-shareable below, like {{Documentation}}.

Module Example

Module:No globals was migrated to the new system with very few changes. These were the steps taken:

1. Ensure proper testing. There could be millions of pages that rely on any given module, so we need to make sure the module is adequately tested before making any changes. For this example, I had to create Module:No_globals/testcases that verified that the module would raise expected errors when global variables were accessed without declaration, and do nothing otherwise. The testcases/doc (detailed) and the main doc (summary) pages were updated to show the results of the test runs.
   • Note that the testcases can work with both the main module and the sandbox module, so that we can compare the results.
   • Note that the testcases/doc and the main doc pages shows the results of both the sandbox and main modules. The summary test results must always be visible in order to catch errors as early as possible.
2. Create translation table from strings. The No globals module contained two English strings: Tried to read nil global ... and Tried to write global ..., and both strings were followed by a parameter tostring(k). We created a new translation table Data:I18n/No_globals.tab on Commons with the two strings, giving each a unique ID: err-read and err-write. The parameter placeholder for both strings had to be included into the string itself as a $1. It is very important to store parameters as parts of the string because in many languages the parameter would have to be placed at a different position in the string according to the norms of the language.
3. Replace strings with calls to TNT module. Now we can use Module:TNT format function to convert err-read from the translation table into a localized string. Place local TNT = require('Module:TNT') at the top of your module, and call TNT.format('I18n/No globals', 'err-read', tostring(k)) to get the localized text. For this specific example, we do not need to load TNT module unless there is an error, so we can do both calls on the same line to optimize performance. These were the two replacements made:

   ...
   old: error('Tried to read nil global ' .. tostring(k), 2)
   new: error(require('Module:TNT').format('I18n/No globals', 'err-read', tostring(k)), 2)
   ...
   old: error('Tried to write global ' .. tostring(k), 2)
   new: error(require('Module:TNT').format('I18n/No globals', 'err-write', tostring(k)), 2)
   ...
   

   Note that we first modified the Module:No globals/sandbox page to make sure our changes did not break any of the tests (see point #1).
4. Lastly we need to indicate that this is a shared module by adding a {{Shared Template Warning|Module:No globals|No globals}} to the top of the doc page. The first parameter is the name of our template on mediawiki.org, and the second parameter indicates that this module has a translation table called Data:I18n/No_globals.tab on Commons. We also need to add Q63090714 as an additional instance-of for the Module:No globals wikidata entry (Q16748603).

Requirements for the Shared Modules

• Sandbox: Each module must have a .../sandbox sub-page with a copy of the module code (the code might have a few changes compared to the main module page)
• Testcases: Each module must have a .../testcases page with good unit tests to ensure highly quality and stability of the shared module.
  • Testcases must use Module:ScribuntoUnit
  • Testcases must be able to run with both the module and module/sandbox versions (see TNT or TableTools examples)
  • Testcases should have require('Module:no globals') to avoid accidentally using non-declared variables
• Documentation: Each module must have a good quality documentation in the /doc page:
  • The /doc page must start with {{Shared Template Warning|Module:__module_name_on_mw__}}.
  • If module has a translation table, add it as a second parameter in the warning, e.g. Module:TNT would link to Data:I18n/Module:TNT.tab on Commons.
  • Add a quality control section at the top, listing the summary of the testcase runs for both the primary and the sandbox versions of the module. See Module:TNT for an example.
  • Document all public functions of the module.
• Translations: module must not have any user-visible strings in any language. Instead, it should use TNT module to convert a message ID with optional parameters to a string for the current language. See below for an example.

Requirements for the Shared Templates

• Translations: template must not have any user-visible strings in any language. Instead, it should use TNT module to convert a message ID with optional parameters to a string for the current language. See below for an example.
• Documentation: Each template must have a good quality documentation in the /doc page:
  • The /doc page must start with {{Shared Template Warning|Template:__template_name_on_mw__}}.
  • If template has a translation table, add it as a second parameter in the warning, e.g. Template:XX would link to Data:I18n/Template:XX.tab on Commons.
  • Template one-line description and parameters must be stored in a template parameter table, see Translating Template Parameters below.
  • Insert {{#invoke:TNT|doc|Template_Name}} at the end of the /doc page, where Template_Name would mean Data:Templatedata/Template_Name.tab on Commons.
• If possible, create a /testcases subpage to run unit tests.

Translating Content

There is very little value in having non-translated content copied as is. The Module:TNT was created specifically to solve that. Instead of storing English text in a module or a template, TNT allows them to be designed language-neutral, and store multilingual text in the tabular data pages on Commons. This way your module or template will use those translated strings (messages), or if the message has not yet been translated, will fallback to English. When someone updates the translation table, your page will automatically update (might take some time, or you can purge it), but no change in the template or module is needed on any of the wikis. This process is very similar to MediaWiki's localisation, and supports all standard localization conventions such as {{PLURAL|...}} and other parameters.

For a simple example, see Data:I18n/Template:Graphs.tab - a table with two messages, each message having a single parameter. By convention, all translation pages should have '''Data:I18n/...''' prefix to separate them from other types of data.

Global Templates

Description	Wiki Markup
In a template, this command translates source_table message using Commons' Data:I18n/Template:Graphs.tab translation table.	{{#invoke:TNT | msg | I18n/Template:Graphs.tab | source_table }}
If your message contains parameters, you can specify them after the message ID.	{{#invoke:TNT | msg | I18n/Template:My Template.tab | message-with-two-params | param1 | param2 }}

Global Modules

Just like templates, modules should also use TNT module for localization:

local TNT = require('Module:TNT')
local text = TNT.format('I18n/My_module_messages', 'messageId', 'param1', 'param2', ...)

-- or in a specific language:
local text = TNT.formatInLanguage('fr', 'I18n/My_module_messages', 'messageId', 'param1', 'param2', ...)

Translating Template Parameters

Template parameters are usually stored as a JSON templatedata block inside the template's /doc subpage. This makes it convenient to translate, but when a new parameter is added to a global template, all /doc pages need to be updated in every language. TNT helps with this by automatically generating the templatedata block from a table stored on Commons. Placing this line into every /doc sub-page will use Data:Templatedata/Graph:Lines.tab table to generate all the needed templatedata information in every language. Even if the local community has not translated the full template documentation, they will be able to see all template parameters, centrally updated.

{{#invoke:TNT | doc | Graph:Lines }}

Progress

Currently the bot is being run by Yurik manually. This section will list down the plan to automate the process.

Volunteers

• Capankajsmilyo (talk) 18:24, 17 May 2019 (UTC)

See also

• Wishlist proposal 2019 (40 votes)
• T122086 - RFC: Sharing templates and modules between wikis - poor man's version (original idea for this bot)
• T121470 - Central Global Repository for Templates, Lua modules, and Gadgets ticket (main ticket for everything cross-site shareable)
• Bot approval status
• Extension:Scribunto/Central modules

Candidate modules to use this approach

Done

• Module:No globals (translations) -- implemented , needs to be moved to communities
• Module:TableTools

Pages OK to use without synchronization

These templates and modules exist on most wikis, but contain too much language-specific customizations to benefit from this system. A shared module/template can rely on these in addition to any other shared module/templates. Any new wiki should copy and modify these templates by hand.

• Template:Documentation -- most templates on most wikis use this template to show a documentation header on the template pages.
• Module:Yesno -- what each language accepts as "yes" and "no" for template parameters

Proposed

• Module:Arguments
  • Support - while we can adapt it as is, we may also enhance it to allow parameter name translation table to come from Commons (many templates localize their parameters). --Yurik (talk) 19:06, 7 May 2019 (UTC)
• Module:Navbar
• Module:Infobox
  • Neutral - eventually yes, but I suspect infobox has some dependencies we need to solve first. --Yurik (talk) 19:06, 7 May 2019 (UTC)
  • Neutral - hard CSS dependencies. Missing navbar module can be handled with code. --Zache (talk) 02:01, 8 May 2019 (UTC)
• Module:Location map
• Module:String
  • Support - the _error() function should be changed to accept (message_id, ...) (id + optional params). If not ignoring errors, use TNT to translate messages. --Yurik (talk)
• d:Module:Databox