Aller au contenu

Module:TNT

Modifier les liens
Une page de Wikipédia, l'encyclopédie libre.

 Documentation[voir] [modifier] [historique] [purger]

Présentation

[modifier le code]

Ce module permet une traduction simple du texte des modèles et modules entre les différentes versions linguistiques de Wikipédia dans le cadre du projet de modèles et modules multilingues. Le module TNT (abréviation de Template Namespace Translation, litt. « Traduction de l'espace de nom Modèle ») permet aux modules d'être conçus indépendamment de la langue et de stocker du texte pour chaque langue dans les pages de données tabulaires sur Commons. Lorsqu'un texte n'a pas encore été traduit, l'anglais est utilisé par défaut. Lorsque la table de traduction est mise à jour, les modèles et modules utilisant ces textes sont automatiquement mis à jour (une purge du cache peut être nécessaire) et aucune modification du modèle ou du module n'est nécessaire sur aucun des wikis. Ce processus est très similaire à l'internationalisation de MediaWiki et prend en charge toutes les conventions d'internationalisation standard telles que {{plural:...}}.

Ce module peut être invoqué à partir de modèles en utilisant #invoke et être importé à partir d'autres modules. Pour un exemple simple, voir Data:I18n/Template:Graphs.tab - une table avec deux messages, chaque message ayant un seul paramètre. Par convention, toutes les tables de traduction doivent avoir le préfixe Data:I18n/... pour les séparer des autres types de données.

Utilisation dans un modèle

[modifier le code]
Code Utilisation 
{{#invoke:TNT | msg
| I18n/Template:Graphs.tab
| table_source
}}
Dans un modèle, ce code appelle la fonction msg du module TNT pour obtenir la traduction du texte table_source depuis la table de traductions Data:I18n/Template:Graphs.tab. 
{{#invoke:TNT | msg
| I18n/Template:My Template.tab
| id-message
| param1
| param2
}}
Les éventuels paramètres sont spécifiés après l'id du message.

Traduction des templatedata des modèles

[modifier le code]

Les paramètres d'un modèle sont généralement stockés sous la forme d'un bloc templatedata JSON à l'intérieur de la sous-page de documentation du modèle. Cela facilite la traduction, mais lorsqu'un nouveau paramètre est ajouté à un modèle global, les pages de documentation doivent être mises à jour dans chaque langue. TNT facilite la traduction en générant automatiquement le bloc templatedata à partir d'une table stockée sur Commons. Placer le code ci-dessous ligne dans une sous-page de documentation utilisera le tableau Data:Templatedata/Graph:Lines.tab pour générer les templatedata dans chaque langue. Même si la communauté locale n'a pas traduit la documentation complète du modèle, elle pourra voir tous les paramètres du modèle, mis à jour de manière centralisée. 

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

Utilisation dans un Module

[modifier le code]

De même que les modèles, les modules peuvent utiliser le module TNT pour la traduction dans la langue locale (c'est-à-dire en français) des textes affichés : 

local TNT = require('Module:TNT')

-- format <idMessage> chaîne de caractères avec deux paramètres utilisant une table de traduction
local texte = TNT.format('I18n/Messages_de_mon_module', 'idMessage', 'param1', 'param2', ...)

-- Même chose, mais en précisant la langue pour la traduction
local texte = TNT.formatInLanguage('en', 'I18n/Messages_de_mon_module', 'idMessage', 'param1', 'param2', ...)

Fonctions exportables

[modifier le code]
  • doc(frame) – Prend en argument un frame contenant pour unique paramètre non nommé dataset (au même format que pour msg(frame)) et renvoie le wikitexte des TemplateData associées à ce dataset.
  • getTemplateData(dataset) – Prend en argument une chaîne de caractères dataset et renvoie le JSON (encodé comme chaîne de caractères) des TemplateData associées à ce dataset.

Modules externes et autres éléments dont ce module a besoin pour fonctionner

[modifier le code]
  • libraryUtil – Bibliothèque de fonctions pour retourner une erreur lorsque le type d'un objet n'est pas celui attendu.

La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (créer).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.

--
-- INTRO:   (!!! DO NOT RENAME THIS PAGE !!!)
--    This module allows any template or module to be copy/pasted between
--    wikis without any translation changes. All translation text is stored
--    in the global  Data:*.tab  pages on Commons, and used everywhere.
--
-- SEE:   https://www.mediawiki.org/wiki/Multilingual_Templates_and_Modules
--
-- ATTENTION:
--    Please do NOT rename this module - it has to be identical on all wikis.
--    This code is maintained at https://www.mediawiki.org/wiki/Module:TNT
--    Please do not modify it anywhere else, as it may get copied and override your changes.
--    Suggestions can be made at https://www.mediawiki.org/wiki/Module_talk:TNT
--
-- DESCRIPTION:
--    The "msg" function uses a Commons dataset to translate a message
--    with a given key (e.g. source-table), plus optional arguments
--    to the wiki markup in the current content language.
--    Use lang=xx to set language.  Example:
--
--    {{#invoke:TNT | msg
--     | I18n/Template:Graphs.tab  <!-- https://commons.wikimedia.org/wiki/Data:I18n/Template:Graphs.tab -->
--     | source-table              <!-- uses a translation message with id = "source-table" -->
--     | param1 }}                 <!-- optional parameter -->
--
--
--    The "doc" function will generate the <templatedata> parameter documentation for templates.
--    This way all template parameters can be stored and localized in a single Commons dataset.
--    NOTE: "doc" assumes that all documentation is located in Data:Templatedata/* on Commons.
--
--    {{#invoke:TNT | doc | Graph:Lines }}
--        uses https://commons.wikimedia.org/wiki/Data:Templatedata/Graph:Lines.tab
--        if the current page is Template:Graph:Lines/doc
--

local p = {}
local i18nDataset = 'I18n/Module:TNT.tab'

-- Forward declaration of the local functions
local sanitizeDataset, loadData, link, formatMessage

function p.msg(frame)
	local dataset, id
	local params = {}
	local lang = nil
	for k, v in pairs(frame.args) do
		if k == 1 then
			dataset = mw.text.trim(v)
		elseif k == 2 then
			id = mw.text.trim(v)
		elseif type(k) == 'number' then
			params[k - 2] = mw.text.trim(v)
		elseif k == 'lang' and v ~= '_' then
			lang = mw.text.trim(v)
		end
	end
	return formatMessage(dataset, id, params, lang)
end

-- Identical to p.msg() above, but used from other lua modules
-- Parameters:  name of dataset, message key, optional arguments
-- Example with 2 params:  format('I18n/Module:TNT', 'error_bad_msgkey', 'my-key', 'my-dataset')
function p.format(dataset, key, ...)
	local checkType = require('libraryUtil').checkType
	checkType('format', 1, dataset, 'string')
	checkType('format', 2, key, 'string')
	return formatMessage(dataset, key, {...})
end


-- Identical to p.msg() above, but used from other lua modules with the language param
-- Parameters:  language code, name of dataset, message key, optional arguments
-- Example with 2 params:  formatInLanguage('es', I18n/Module:TNT', 'error_bad_msgkey', 'my-key', 'my-dataset')
function p.formatInLanguage(lang, dataset, key, ...)
	local checkType = require('libraryUtil').checkType
	checkType('formatInLanguage', 1, lang, 'string')
	checkType('formatInLanguage', 2, dataset, 'string')
	checkType('formatInLanguage', 3, key, 'string')
	return formatMessage(dataset, key, {...}, lang)
end

-- Obsolete function that adds a 'c:' prefix to the first param.
-- "Sandbox/Sample.tab" -> 'c:Data:Sandbox/Sample.tab'
function p.link(frame)
	return link(frame.args[1])
end

function p.doc(frame)
	local dataset = 'Templatedata/' .. sanitizeDataset(frame.args[1])
	return frame:extensionTag('templatedata', p.getTemplateData(dataset)) ..
		   formatMessage(i18nDataset, 'edit_doc', {link(dataset)})
end

function p.getTemplateData(dataset)
	-- TODO: add '_' parameter once lua starts reindexing properly for "all" languages
	local data = loadData(dataset)
	local names = {}
	for _, field in ipairs(data.schema.fields) do
		table.insert(names, field.name)
	end

	local numOnly = true
	local params = {}
	local paramOrder = {}
	for _, row in ipairs(data.data) do
		local newVal = {}
		local name = nil
		for pos, columnName in ipairs(names) do
			if columnName == 'name' then
				name = row[pos]
			else
				newVal[columnName] = row[pos]
			end
		end
		if name then
			if (
				(type(name) ~= "number")
				and (
					(type(name) ~= "string")
					or not string.match(name, "^%d+$")
				)
			) then
				numOnly = false
			end
			params[name] = newVal
			table.insert(paramOrder, name)
		end
	end

	-- Work around json encoding treating {"1":{...}} as an [{...}]
	if numOnly then
		params['zzz123']=''
	end

	local json = mw.text.jsonEncode({
		params=params,
		paramOrder=paramOrder,
		description=data.description,
	})

	if numOnly then
		json = string.gsub(json,'"zzz123":"",?', "")
	end

	return json
end

-- Local functions

sanitizeDataset = function(dataset)
	if not dataset then
		return nil
	end
	dataset = mw.text.trim(dataset)
	if dataset == '' then
		return nil
	elseif string.sub(dataset,-4) ~= '.tab' then
		return dataset .. '.tab'
	else
		return dataset
	end
end

loadData = function(dataset, lang)
	dataset = sanitizeDataset(dataset)
	if not dataset then
		error(formatMessage(i18nDataset, 'error_no_dataset', {}))
	end

	-- Give helpful error to thirdparties who try and copy this module.
	if not mw.ext or not mw.ext.data or not mw.ext.data.get then
		error(string.format([['''Missing JsonConfig extension, or not properly configured;
Cannot load https://commons.wikimedia.org/wiki/Data:%s.
See https://www.mediawiki.org/wiki/Extension:JsonConfig#Supporting_Wikimedia_templates''']], dataset))
	end

	local data = mw.ext.data.get(dataset, lang)

	if data == false then
		if dataset == i18nDataset then
			-- Prevent cyclical calls
			error('Missing Commons dataset ' .. i18nDataset)
		else
			error(formatMessage(i18nDataset, 'error_bad_dataset', {link(dataset)}))
		end
	end
	return data
end

-- Given a dataset name, convert it to a title with the 'commons:data:' prefix
link = function(dataset)
	return 'c:Data:' .. mw.text.trim(dataset or '')
end

formatMessage = function(dataset, key, params, lang)
	for _, row in pairs(loadData(dataset, lang).data) do
		local id, msg = unpack(row)
		if id == key then
			local result = mw.message.newRawMessage(msg, unpack(params or {}))
			return result:plain()
		end
	end
	if dataset == i18nDataset then
		-- Prevent cyclical calls
		error('Invalid message key "' .. key .. '"')
	else
		error(formatMessage(i18nDataset, 'error_bad_msgkey', {key, link(dataset)}))
	end
end

return p
Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Module:TNT&oldid=212983181 ».