Ir al contenido

Módulo:Lang/documentor tool

De Wikipedia, la enciclopedia libre
Esta plantilla utiliza los módulos Argumentos, No globals y Lang. Antes de modificarla, deberías familiarizarte con las funciones de la extensión Scribunto y el lenguaje de programación Lua.

Module:Lang/documentor tool implementa las siguientes plantillas:

También se utiliza para generar los siguientes casos de prueba: 


require('Módulo:No globals')
local p = {}


--[[ -------------------------- < L A N G - X X _ S E T T I N G S > --------------------------

{{#invoke:Lang/documentor tool|lang_xx_settings|template={{ROOTPAGENAME}}}}

Lee el contenido de la plantilla y extrae los parámetros de {{#invoke:Lang|...}} para ser mostrados en la página de documentación de la plantilla.

]]

local function lang_xx_settings(frame)
	local page = mw.title.makeTitle('Plantilla', frame.args['template'] or frame.args[1])	-- get a page object for this page in 'Plantilla:' namespace
	if not page then
		return ''																-- TODO: error message?
	end

	local content = page:getContent()											-- get unparsed content
	if not page then
		return ''																-- TODO: error message?
	end

	local out = {}

	local params
	local style

	if content:match('{{%s*#invoke:%s*[Ll]ang%s*|[^|]+|[^}]+}}') or content:match('{{%s*#invoke:%s*[Ll]ang/zona de pruebas%s*|[^|]+|[^}]+}}') then			-- if this template uses [[Módulo:Lang]]
		params = content:match('{{%s*#invoke:%s*[Ll]ang%s*|[^|]+(|[^}]+)}}') or content:match('{{%s*#invoke:%s*[Ll]ang/zona de pruebas%s*|[^|]+(|[^}]+)}}')	-- extract the #invoke:'s parameters
		if not params then 
			return ''															-- there should be at least one or the template/module won't work TODO: error message?
		end
		table.insert(out, '{| class="wikitable" style="text-align: right; float: right;"\n|+configuración')	-- start a wikitable
		for k, v in params:gmatch('%s*|%s*([^%s=]+)%s*=%s*([^%s|]+)') do		-- get the parameter names (k) and values (v)
			if 'label' == k then												-- special case for labels because spaces and pipes
				v = params:match('label%s*=%s*(%[%[[^%]]+%]%])') or params:match('label%s*=%s*([^|\n]+)') or 'missing label'
			end
			table.insert(out, table.concat({k, '\n|', v}))						-- make rudimentary wikitable entries
		end

		style = content:match('lang_xx_([^|]+)')
		return table.concat({table.concat(out,'\n|-\n! scope="row" | '), '\n|-\n|colspan="2"|estilo: ', style:gsub('italic', 'cursiva'), '\n|-\n|}'})	-- add inter-row markup and close the wikitable and done
	else
		return ''																-- does not use [[Módulo:Lang]] so abandon quietly
	end
end


--[[ -------------------------- < U S E S _ M O D U L E > --------------------------

{{#invoke:Lang/documentor tool|uses_module|template={{ROOTPAGENAME}}}}

Lee el contenido de la plantilla para determinar si esta plantilla {{lang-xx}} utiliza Módulo:odule:Lang.
Retorna el índice del substring '{{#invoke|lang|' dentro del contenido de la plantilla si es true y si no un string vacío.

Utilizado en las funciones {#if:}} de la documentación de las plantillas.

]]

local function uses_module(frame)
	local page = mw.title.makeTitle('Plantilla', frame.args['template'] or frame.args[1])	-- get a page object for this page in 'Plantilla:' namespace
	if not page then
		return ''																-- TODO: error message?
	end

	local content = page:getContent()											-- get unparsed content
	if not page then
		return ''																-- TODO: error message?
	end

	return content:find('{{%s*#invoke:[Ll]ang%s*|') or ''						-- return index or empty string
end


--[[ -------------------------- < S H A R E D _ C O D E > --------------------------

- Tables:
-- language_categories
-- error_messages
-- strings

- Functions:
-- make_error(message, layout, parent_category, nocat)
-- get_language_link(language_name, language_code)
-- get_see_also_section(page_title, language_name, language_code)
-- get_hidden_category_template(frame)
-- get_top_section(frame)
-- get_bottom_section(frame, language_name, see_also_section, parent_category)

]]

local language_categories = {
	--["LANGUAGES_SOURCES"] = "Articles with %s-language sources (%s)",                    --ESTOS TRES NO ESTÁN EN eswiki
	--["LANGUAGES_COLLECTIVE_SOURCES"] = "Articles with %s-collective sources (%s)",
	--["CS1"] = "CS1 %s-language sources (%s)",
	["LANGUAGE_TEXT"] = "Wikipedia:Artículos con texto en %s",
	["LANGUAGES_COLLECTIVE_TEXT"] = "Wikipedia:Artículos con texto en %s",
	["SPANISH"] = "Wikipedia:Artículos con texto citado explícitamente en %s",
}

local error_assistance = " Por favor, ve a [[Plantilla discusión:Lang]] para encontrar asistencia."

local error_messages = {
	["ASSISTANCE"] = "Por favor, ve a [[Plantilla discusión:Lang]] para encontrar asistencia.",
	["INCORRECT_CATEGORY_TITLE"] = "[[:%s]] no es la categoría poblada por la plantilla {{tlx|%s}}. La categoría correcta se encuentra en: [[:%s]].",
	["NO_CATEGORY_TITLE_FOUND"] = "No se ha encontrado una categoría de idioma para '''%s.'''" .. error_assistance,
	["NOT_VALID_CATEGORY_FORMAT"] = "'''%s''' no es un título válido de categoría." .. error_assistance,
	["NOT_VALID_LANGUAGE_CODE"] = "[[%s]] no es un nombre de idioma válido entre los códigos ISO 639 o IETF." .. error_assistance,
}

local strings = {
	["ERROR_CATEGORY"] = "[[Categoría:Wikipedia:Errores de Lang y lang-xx]]",
	["ERROR_SPAN"] = '<span style="font-size: 100%%; font-style: normal;" class="error">Error: %s </span>',
	["PURGE_DIV"] = '<div style="font-size: x-small;">%s</div>',
	["SEE_ALSO"] = "\n==Véase también==",
	["SEE_ALSO_ITEM"] = "* [[:%s]]",
}


--[[ -------------------------- < M A K E _ E R R O R > --------------------------

Crea un mensaje de error.
No categoriza la página se se utiliza args.nocat.
No categoriza en la categoría padre si se utiliza en otro espacio de nombres (normalmente para /tests).

]]

local function make_error(message, layout, parent_category, nocat)
	table.insert(layout, string.format(strings["ERROR_SPAN"], message))

	if not nocat then
		table.insert(layout, strings["ERROR_CATEGORY"])
	end

	if mw.title.getCurrentTitle().nsText == "Categoría" then
		table.insert(layout, parent_category)
	end

	return table.concat(layout)
end


--[[ -------------------------- < G E T _ L A N G U A G E _ L I N K > --------------------------

Genera el enlace de idioma en el estilo correcto.

Las lenguas colectivas utilizan el valor de name_from_tag,
mientras que otras utilizan la fórmula "idioma x".

]]

local function get_language_link(language_name, language_code)
	local lang_module = require('Módulo:Lang')
	-- Es una lengua colectiva?
	if language_name:find('lenguas') or language_name:find('languages') then
		return lang_module.name_from_tag({language_code, link = "yes"})
	else
		return lang_module.name_from_tag({language_code, link = "yes", label = ("idioma " .. lang_module.name_from_tag({language_code}))})
	end
end


--[[ -------------------------- < G E T _ S E E _ A L S O _ S E C T I O N > --------------------------

Genera una sección "Véase también" con el estilo consistente para
{{Category articles containing non-English-language text}} and {{Non-English-language source category}}.

If {{CS1 language sources}} is converted, it should also use it.

]]

local function get_see_also_section(page_title, language_name, language_code)
	local see_also_section = {}

	for _, category_name in pairs(language_categories) do
		local category = mw.title.new(string.format(category_name, language_name, language_code), 14)
 		if category and page_title ~= category.text and category.exists then
			table.insert(see_also_section, string.format(strings["SEE_ALSO_ITEM"], category.prefixedText))
		end
	end

	table.sort(see_also_section)
	table.insert(see_also_section, 1, strings["SEE_ALSO"])

	if table.getn(see_also_section) == 1 then
		return ""
	else
		return table.concat(see_also_section, "\n")
	end
end


--[[ -------------------------- < G E T _ H I D D E N _ C A T E G O R Y _ T E M P L A T E > --------------------------

Genera la plantilla {{Categoría oculta}}.

Esta función está separada de get_top_section()
porque debe usarse tanto en categorías erróneas como válidas.

]]

local function get_hidden_category_template(frame)
	return frame:expandTemplate{title = 'Categoría oculta'}
end

--[[ -------------------------- < G E T _ T O P _ S E C T I O N > --------------------------

Genera una plantilla de mantenimiento consistente para la sección superior que consiste en:
-- Plantilla:Categoría vacía
-- Plantilla:Purgar

]]

local function get_top_section(frame)
	local top_section = {}
	table.insert(top_section, frame:expandTemplate{title = 'Aviso', args = {encabezado = "Esta es una categoría automática que se gestiona desde [[Módulo:Lang]].", texto = "Cualquier cambio de nombre se debe consensuar en [[Módulo discusión:Lang|la página de discusión correspondiente]]."}})
	table.insert(top_section, frame:expandTemplate{title = 'Categoría vacía'})
	table.insert(top_section, "<div style=\"font-size:x-small;\">" .. frame:expandTemplate{title = 'Purgar', args = {"Purgar la caché de la página"}} .. "</div>")

	return table.concat(top_section, "\n\n")
end


--[[ -------------------------- < G E T _ B O T T O M _ S E C T I O N > --------------------------

Genera una sección no textual consistente que consiste en:
-- Plantilla:Índice automático
-- Una sección de "Véase también"
-- {{DEFAULTSORT}}
-- Categorización en la categoría superior

]]

local function get_bottom_section(frame, language_name, see_also_section, parent_category)
	local bottom_section = {}
	table.insert(bottom_section, frame:expandTemplate{title = 'Índice automático'}) 
	table.insert(bottom_section, see_also_section)

	if mw.title.getCurrentTitle().nsText == "Categoría" then
		table.insert(bottom_section, frame:preprocess{text = "{{DEFAULTSORT:" .. language_name .. "}}"})
		table.insert(bottom_section, parent_category)
	end

	return table.concat(bottom_section, "\n\n\n")
end


--[[ -------------------------- < N O N _ S P A N I S H _ L A N G U A G E _ T E X T _ C A T E G O R Y > --------------------------

{{#invoke:Lang/documentor tool|non_spanish_language_text_category}}

Esta función implementa {{Non-English-language text category}}.

]]

local non_spanish_language_text_strings = {
	["LINE1"] = "Esta categoría contiene artículos con texto en %s%s. El principal propósito de estas categorías es facilitar la comprobación manual o automatizada de textos en otros idiomas.",
	["LINE2"] = "Esta categoría sólo debería ser añadida con la familia de plantillas %s, nunca de forma explícita.",
	["LINE3"] = 'Por ejemplo %s, que rodea el texto con <code>&lt;span lang="%s"&gt;</code>.%s',
	["LINE3_EXTRA"] = " También está disponible %s que se muestra como %s.",
	["IN_SCRIPT"] = " (en %s)",
	["EXAMPLE_DEFAULT_TEXT"] = "texto en idioma %s aquí",
	["PARENT_CATEGORY"] = "[[Categoría:Wikipedia:Artículos que contienen texto en otros idiomas]]",
	["TEMPLATE"] = "Lang",
}


local function non_spanish_language_text_category(frame)
	local page = mw.title.getCurrentTitle()
	local args = require('Módulo:Argumentos').obtenerArgumentos(frame)
	-- args.test se utiliza para /tests
	if args.test then
		page = mw.title.new(args.test)
	end

	-- Naming style: Articles with text from the Berber languages collective
	local page_title_modified = page.text
	local split_title = "([^,]+)%%s([^,]*)"
	local part1 = ""
	local part2 = ""

	if page_title_modified:find('lenguas') or page_title_modified:find('languages') then
		-- Nomeclatura: Categoría:Artículos con texto en lenguas bereberes
		part1, part2 = language_categories["LANGUAGES_COLLECTIVE_TEXT"]:match(split_title)    --"Artículos con texto en %s"
	elseif page_title_modified:find('citado explícitamente') then
		part1, part2 = language_categories["SPANISH"]:match(split_title)   --"Artículos con citas explícitas en %s"
	else
		-- Nomeclatura: Categoría:Artículos con texto en idioma francés
		part1, part2 = language_categories["LANGUAGE_TEXT"]:match(split_title)   --"Artículos con texto en %s"
	end

	page_title_modified = page_title_modified:gsub(part1, "")
	--page_title_modified = page_title_modified:gsub(part2, "")
	local language_name = page_title_modified

	local layout = {}
	table.insert(layout, get_hidden_category_template(frame))
	table.insert(layout, get_top_section(frame))
	local parent_category = non_spanish_language_text_strings["PARENT_CATEGORY"]

	if language_name == page.text then
		-- Error: Formato del título de la categoría no soportado.
		return make_error(string.format(error_messages["NOT_VALID_CATEGORY_FORMAT"], page.text), layout, parent_category, args.nocat)
	end

	local lang_module = require('Módulo:Lang')
	local language_code = lang_module._tag_from_name({language_name})	

	if language_code:find('error') then
		-- Error: Código de idioma no encontrado en la base de datos.
		return make_error(string.format(error_messages["NOT_VALID_LANGUAGE_CODE"], language_name), layout, parent_category, args.nocat)
	end

	local correct_language_category_title = lang_module._category_from_tag({language_code})
	if correct_language_category_title:find('error') then
		-- Error: No se ha encontrado el título de categoría para el código de idioma.
		return make_error(string.format(error_messages["NO_CATEGORY_TITLE_FOUND"], language_code), layout, parent_category, args.nocat)
	end

	local current_category_title = page.prefixedText
	if current_category_title ~= correct_language_category_title then
		-- Error: El título actual de la categoría no está en el formato soportado. TODO: can this still be reached?
		return make_error(
			string.format(error_messages["INCORRECT_CATEGORY_TITLE"], current_category_title, non_spanish_language_text_strings["TEMPLATE"], correct_language_category_title),
			layout, parent_category, args.nocat)
	end

		local script_text = ""
	if args.script then
		script_text = string.format(non_spanish_language_text_strings["IN_SCRIPT"], args.script)
	end

	local language_link = get_language_link(language_name, language_code)
	table.insert(layout, string.format(non_spanish_language_text_strings["LINE1"], language_link, script_text))

	local lang_template = frame:expandTemplate{title = 'ep', args = {non_spanish_language_text_strings["TEMPLATE"]}}
	table.insert(layout, string.format(non_spanish_language_text_strings["LINE2"], lang_template))

	local language_code_link = lang_module._name_from_tag({language_code, link="yes", label=language_code})
	local example_default_text = string.format(non_spanish_language_text_strings["EXAMPLE_DEFAULT_TEXT"], language_name)
	local example_text = args.example or example_default_text
	local lang_template_example = frame:expandTemplate{title = 'ep', args = {non_spanish_language_text_strings["TEMPLATE"], language_code_link, example_text}}
	local lang_x = mw.title.makeTitle(10, "Lang-" .. language_code)

	local line3_extra = ""
	if lang_x.exists then
		local lang_x_template_example = frame:expandTemplate{title = 'ep', args = {lang_x.text, example_text}}
		local lang_x_template = frame:expandTemplate{title = lang_x.text, args = {example_text}}
		line3_extra = string.format(non_spanish_language_text_strings["LINE3_EXTRA"], lang_x_template_example, lang_x_template)
	end

	table.insert(layout, string.format(non_spanish_language_text_strings["LINE3"], lang_template_example, language_code, line3_extra))
	local see_also_section = get_see_also_section(page.text, language_name, language_code)

	local bottom = get_bottom_section(frame, language_name, see_also_section, non_spanish_language_text_strings["PARENT_CATEGORY"])
	return table.concat(layout, "\n\n") .. bottom
end


--[[ -------------------------- < N O N _ E N G L I S H _ L A N G U A G E _ S O U R C E S _ C A T E G O R Y > --------------------------

NO IMPLEMENTADO PARA eswiki

{{#invoke:Lang/documentor tool|non_english_language_sources_category}}

This function implements {{Non-English-language sources category}}.

]]

local non_english_language_sources_strings = {
	["LINE1"] = "This is a tracking category for articles that use %s to identify %s sources.",
	["PARENT_CATEGORY"] = "[[Category:Articles with non-English-language sources]]",
	["TEMPLATE"] = "In lang",
}

local function non_english_language_sources_category(frame)
	local page = mw.title.getCurrentTitle()
	local args = require('Módulo:Argumentos').obtenerArgumentos(frame)
	-- args.test is used for /testcases
	if args.test then
		page = mw.title.new(args.test)
	end

	local page_title = page.text
	local language_code = page_title:match('%(([%a%-]+)%)')
	local language_name = require('Módulo:Lang')._name_from_tag({language_code})

	local layout = {}
	table.insert(layout, get_hidden_category_template(frame))
	local parent_category = non_english_language_sources_strings["PARENT_CATEGORY"]

	local correct_language_category_title = require('Módulo:In lang')._in_lang({language_code, ["list-cats"]="yes"})
	if correct_language_category_title == "" then
		-- Error: No category title found for language code.
		return make_error(string.format(error_messages["NO_CATEGORY_TITLE_FOUND"], language_code), layout, parent_category, args.nocat)
	end

	local current_category_title = page.prefixedText
	if correct_language_category_title ~= current_category_title then
		-- Error: The current title used is not in the supported format.
		return make_error(
			string.format(error_messages["INCORRECT_CATEGORY_TITLE"], current_category_title, non_english_language_sources_strings["TEMPLATE"], correct_language_category_title),
			layout, parent_category, args.nocat)
	end

	local language_link = get_language_link(language_name, language_code)
	local text = string.format(non_english_language_sources_strings["LINE1"], frame:expandTemplate{title = 'Tlx', args = {non_english_language_sources_strings["TEMPLATE"], language_code}}, language_link)

	table.insert(layout, get_top_section(frame))	
	table.insert(layout, text)
	local see_also_section = get_see_also_section(page_title, language_name, language_code)

	local bottom = get_bottom_section(frame, language_name, see_also_section, parent_category)
	return table.concat(layout, "\n\n") .. bottom
end


--[[ -------------------------- < N O N _ E N G L I S H _ L A N G U A G E _ C S 1 _ S O U R C E S _ C A T E G O R Y > --------------------------

NO IMPLEMENTADO PARA eswiki

{{#invoke:Lang/documentor tool|non_english_language_cs1_sources_category}}

This function implements {{Non-English-language CS1 sources category}}.

]]

local non_english_language_cs1_text_strings = {
	["LINE1"] = "This is a tracking category for [[WP:CS1|CS1 citations]] that use the parameter %s to identify a source in [[%s language|%s]]. Pages in this category should only be added by CS1 templates and [[Módulo:Citation/CS1]].",
	["PARENT_CATEGORY"] = "[[Category:CS1 foreign language sources]]", -- #TODO change to "Articles with non-english CS1 language sources" or "CS1 non-English language sources"
}

	--"This is a tracking category for [[WP:CS1|CS1 citations]] that use the parameter %s to hold a citation title that uses %s characters and contains the language prefix <code>%s:</code>. Pages in this category should only be added by CS1 templates and [[Módulo:Citation/CS1]].",
	--"[[Category:CS1 uses foreign language script]]",

	-- "This is a tracking category for [[WP:CS1|CS1 citations]] that use the parameter %s. Pages in this category should only be added by CS1 templates and [[Módulo:Citation/CS1]].",
	-- "to identify a source in [[%s language|%s]].",
	-- "to hold a citation title that uses %s characters and contains the language prefix <code>%s:</code>.",

local function non_english_language_cs1_sources_category(frame)
	local page_title_object = mw.title.getCurrentTitle()
	local page_title = page_title_object.text
	local language_code = page_title:match('%(([%a%-]+)%)')
	local language_name = require('Módulo:Lang')._name_from_tag({language_code})
	local layout = {}
	table.insert(layout, get_hidden_category_template(frame))
	local see_also_section = ""
	local parameter_doc = frame:expandTemplate{title = 'para', args = {"language", language_code}}
	table.insert(layout, get_top_section(frame))
	table.insert(layout, string.format(non_english_language_cs1_text_strings["LINE1"], parameter_doc, language_name, language_name))
	local see_also_section = get_see_also_section(page_title, language_name, language_code)
	local bottom = get_bottom_section(frame, language_name, see_also_section, non_english_language_cs1_text_strings["PARENT_CATEGORY"])
	return table.concat(layout, "\n\n") .. bottom
end


--[[ -------------------------- < T E S T _ C A S E S _ S H A R E D _ C O D E > -------------------------- 

]]

local function compare_by_keys2(a, b)											-- local function used by table.sort()
	return a[2] < b[2]															-- ascending sort by code
end


local function compare_by_keys(a, b)											-- local function used by table.sort()
	return a[1] < b[1]															-- ascending sort by code
end


-- Used by testcases_iso_code_to_name()
local function get_language_code_table_from_code(args)
	local entry = {}
	--if args.override_table[args.language_code] then
	--	table.insert(entry, args.override_table[args.language_code][1]) -- :gsub(' %b()$', '') fails here
	--else
		table.insert(entry, args.language_code)
--	end
	return entry
end


-- Used by testcases_name_from_tag()
local function get_language_code_and_name_table_from_code(args)
	local entry = {}
	if args.override_table[args.language_code] then
		table.insert(entry, args.language_code)
		local language_code, _ = args.override_table[args.language_code][1]:gsub(' %b()$', '')
		table.insert(entry, language_code)
	else
		table.insert(entry, args.language_code)
		table.insert(entry, args.language_table[args.language_code])
	end
	return entry
end


-- Used by testcases_category_from_tag()
local function get_language_code_and_category_table_from_code(args)
	local entry = {}
	table.insert(entry, args.language_code)
	table.insert(entry, args.test_function({args.language_code}))
	return entry
end


-- Used by testcases_iso_name_to_code() and testcases_tag_from_name()
local function get_language_name_and_code_table_from_code(args)
	local entry = {}
	if args.override_table[args.language_code] then
		table.insert(entry, args.override_table[args.language_code][1])			-- only the first name when there are multiples
		table.insert(entry, args.language_code)
	else
		table.insert(entry, args.language_names[1])								-- only the first name when there are multiples
		table.insert(entry, args.language_code)
	end
	return entry
end


local function get_table(table_function, language_table, length, range, iso_number, test_function)
	local table_of_language_name_and_code_tables = {}

	local override_table_name = "override"
	if iso_number then
		override_table_name = "override_" .. iso_number
	end
	-- Se queda vacía, depende de un módulo inexistente <FUTURO>
	local override_table = {}; --require("Módulo:Language/data/ISO_639_override/sandbox")[override_table_name]


	-- For most ISO 639s.
	if range then
		for language_code, language_names in pairs(language_table) do
			if language_code:find(range) then
				table.insert(table_of_language_name_and_code_tables, table_function({
					override_table = override_table,
					language_code = language_code,
					language_names = language_names,
					test_function = test_function,
					language_table = language_table
				}))
			end
		end
	-- For ISO 639-1.
	elseif length then
		for language_code, language_names in pairs(language_table) do
			if language_code:len() == 2 then
				table.insert(table_of_language_name_and_code_tables, table_function({
					override_table = override_table,
					language_code = language_code,
					language_names = language_names,
					test_function = test_function,
					language_table = language_table
				}))
			end
		end
	-- For general /testcases.
	else
		for language_code, language_names in pairs(language_table) do
				table.insert(table_of_language_name_and_code_tables, table_function({
					override_table = override_table,
					language_code = language_code,
					language_names = language_names,
					test_function = test_function,
					language_table = language_table
				}))
		end
	end
	return table_of_language_name_and_code_tables
end


local function get_undabbed_table(language_list, length, range)
	local undabbed_language_table = {}											-- for this test, ISO 639-3 language name disambiguators must be removed; un-dabbed names go here
	for language_code, language_names in pairs(language_list) do
		-- For most ISO 639s.
		if range then
			if language_code:find(range) then
				undabbed_language_table[language_code] = language_names[1]:gsub(' %b()$', '')	-- undab and save only the first name; ignore all other names assigned to a code
			end
		-- For ISO 639-1.
		elseif length then
			if language_code:len() == 2 then
				undabbed_language_table[language_code] = language_names[1]:gsub(' %b()$', '')	-- undab and save only the first name; ignore all other names assigned to a code
			end
		-- For general /testcases.
		else
			undabbed_language_table[language_code] = language_names[1]:gsub(' %b()$', '')
		end
	end
	return undabbed_language_table
end


local function merge_tables(table_1, table_2)  --table 1 takes precedence
	merged_table = {}
	for code, names in pairs(table_1) do
		if table_2[code] then
			merged_table[code] = table_2[code]
		else
			merged_table[code] = names
		end
	end
	return merged_table
end

--[[ -------------------------- < T E S T C A S E S _ C A T E G O R Y _ F R O M _ T A G > --------------------------

Entry point for the various category_from_tag testcases.

Build a table of test patterns where each entry in the table is a table with two members:
	{"<language_code>", "<category name according to Módulo:Lang>"}

- "Expected" column value is the category name according to Módulo:Lang.
- "Actual" column value is the result of {{#invoke:Lang/zona de pruebas|category_from_tag|<language_code>}}.

TODO: Currently not working.

]]

local function testcases_category_from_tag(self, args)
	local cat_from_tag_function = require('Módulo:Lang')._category_from_tag	
	local language_tables = get_table(get_language_code_and_category_table_from_code, args.language_list, args.length, args.range, args.iso_number, cat_from_tag_function)
	table.sort(language_tables, compare_by_keys)

	self:preprocess_equals_preprocess_many(
		'{{#invoke:Lang/zona de pruebas|category_from_tag|', '}}', '', '',
		language_tables, 
		{nowiki=false}
	)
end


--[[ -------------------------- < T E S T C A S E S _ N A M E _ F R O M _ T A G > --------------------------

Entry point for the various name_from_tag testcases.

Build a table of test patterns where each entry in the table is a table with two members:
	{"<language_code>", "<language_name>"}

- "Expected" column value is the <language_name>.
- "Actual" column value is the result of sandbox version {{#invoke:Lang/zona de pruebas|name_from_tag|<language_code>}}.

]]

local function testcases_name_from_tag(self, args)
	--local merged = merge_tables(args.language_list, args.language_list_translated)
	local undabbed_language_table = get_undabbed_table(args.language_list, args.length, args.range, nil)
	local language_tables = get_table(get_language_code_and_name_table_from_code, undabbed_language_table, args.length, args.range)
	table.sort(language_tables, compare_by_keys)

	self:preprocess_equals_preprocess_many(
		'{{#invoke:Lang/zona de pruebas|name_from_tag|', '}}', '', '',
		language_tables, 
		{nowiki=false}
	)
end


--[[ -------------------------- < T E S T C A S E S _ T A G _ F R O M _ N A M E > --------------------------

Entry point for the various tag_from_name testcases.

Build a table of test patterns where each entry in the table is a table with two members:
	{"<language_name>", "<language_code>"}

- "Expected" column value is the <language_code>.
- "Actual" column value is the result of sandbox version {{#invoke:Lang/zona de pruebas|tag_from_name|<language_name>}}.

TODO: Currently not working.

]]

local function testcases_tag_from_name(self, args)
	local language_tables = get_table(get_language_name_and_code_table_from_code, args.language_list, args.length, args.range, args.iso_number, nil)
	table.sort(language_tables, compare_by_keys2)

	local ordered_table = {}
	table.sort(unordered_table)
	for _, key in ipairs(unordered_table) do
		table.insert(ordered_table, {key, reverse_table[key]})
	end

	self:preprocess_equals_preprocess_many(
		'{{#invoke:Lang/zona de pruebas|tag_from_name|', '}}', '', '',
		language_tables, 
		{nowiki=false}
	)
end


--[[ -------------------------- < T E S T C A S E S _ I S O _ C O D E _ T O _ N A M E > --------------------------

Entry point for the various iso_code_to_name testcases.

Build a table of test patterns where each entry in the table is a table with one member:
	{"<language_code>"}

- "Expected" column value is the result of the live version of {{#invoke:ISO 639 name|iso_639_name_to_code|<language_code>}}.
- "Actual" column value is the result of sandbox version {{#invoke:ISO 639 name/sandbox|iso_639_name_to_code|<language_code>}}.

]]

local function testcases_iso_code_to_name(self, args)
	local language_tables = get_table(get_language_code_table_from_code, args.language_list, args.length, args.range, args.iso_number, nil)
	table.sort(language_tables, compare_by_keys)

	self:preprocess_equals_preprocess_many(
		'{{#invoke:ISO 639 name/sandbox|iso_639_code_to_name|link=yes|', '}}', '{{#invoke:ISO 639 name|iso_639_code_to_name|link=yes|', '}}',
		language_tables, 
		{nowiki=false}
	)
end


--[[ -------------------------- < T E S T C A S E S _ I S O _ N A M E _ T O _ C O D E > --------------------------

Entry point for the various iso_name_to_code testcases.

Build a table of test patterns where each entry in the table is a table with two members:
	{"<language_name>", "<language_code>"}

- "Expected" column value is the <language_code>.
- "Actual" column is value the result of {{#invoke:ISO 639 name/sandbox|iso_639_name_to_code|<language_name>}}.

]]

local function testcases_iso_name_to_code(self, args)
	local language_tables = get_table(get_language_name_and_code_table_from_code, args.language_list, args.length, args.range, args.iso_number, nil)
	table.sort(language_tables, compare_by_keys2)
	self:preprocess_equals_preprocess_many(
		'{{#invoke:ISO 639 name/sandbox|iso_639_name_to_code|2=' .. args.iso_number .. "|", '}}', '', '',
		language_tables, 
		{nowiki=false}
	)
end


--[[ -------------------------- < E X P O R T E D _ F U N C T I O N S > --------------------------

]]

return {
	lang_xx_settings = lang_xx_settings,
	uses_module = uses_module,
	non_spanish_language_text_category = non_spanish_language_text_category,
	non_english_language_sources_category = non_english_language_sources_category,
	non_english_language_cs1_sources_category = non_english_language_cs1_sources_category,

	-- Módulo:Lang (casos de prueba)
	testcases_category_from_tag = testcases_category_from_tag,
	testcases_name_from_tag = testcases_name_from_tag,
	testcases_tag_from_name = testcases_tag_from_name,

	--  Módulo:ISO 639 (casos de prueba)   NO EXISTENTE EN eswiki
	testcases_iso_code_to_name = testcases_iso_code_to_name,
	testcases_iso_name_to_code = testcases_iso_name_to_code,
}
Obtenido de «https://es.wikipedia.org/w/index.php?title=Módulo:Lang/documentor_tool&oldid=138418839»