Exibir código-fonte para Módulo:Japonês

require('strict');

--[[--------------------------< M E N S A G E N S _ D E _ E R R O >--------------------------------------------

mensagens de erro; as chaves dessa tabela são os nomes da base da predefinição:
	'japonês', 'nihongo3', 'nihongo krt', 'japonês nota' → 'japonês' etc.

]]

local err_msg = {
	['japonês'] = 'Texto em japonês ou romaji necessário',
	}

local err_cat = {
	['japonês'] = '[[Categoria:!Erros na predefinição japonês]]',
	}


--[[--------------------------< C O N F I G U R A Ç Ã O >------------------------------------------------------

definição de configuração para as várias predefinições. As chaves dessa tabela são os nomes das predefinições sem espaçamento

]]

local cfg = {
	['japonês'] = {
		tag = 'ja',
		system = 'hepburn',
		system_link = '[[Sistema Hepburn|Hepburn]]',
		err_msg = err_msg['japonês'],
		err_cat = err_cat['japonês'],
		},
	['nihongo3'] = {
		tag = 'ja',
		system = 'hepburn',
		err_msg = err_msg['japonês'],
		err_cat = err_cat['japonês'],
		},
	['nihongo krt'] = {
		tag = 'ja',
		system = 'hepburn',
		err_msg = err_msg['japonês'],
		err_cat = err_cat['japonês'],
		},
	['japonês nota'] = {
		tag = 'ja',
		system = 'hepburn',
		system_link = '[[Sistema Hepburn|Hepburn]]',
		err_msg = err_msg['japonês'],
		err_cat = err_cat['japonês'],
		},
	}


--[[--------------------------< M E N S A G E M _ D E _ E R R O >----------------------------------------------

Cria uma mensagem de erro para {{japonês}}, {{nihongo3}}, {{nihongo krt}} e {{japonês nota}} quando essas predefinições não têm entradas <japonês>
ou <romaji>; nomeia a predefinição incorreta, vincula à página da predefinição e adiciona o artigo à Categoria:Erros de predefinição do Nihongo

]]

local function error_message (template)
	local msg = {'<span class="error" style="font-size:100%">erro em {{'};
	table.insert (msg, template);
	table.insert (msg, '}}: ');
	table.insert (msg, cfg[template].err_msg);
	table.insert (msg, ' ([[Predefinição:');
	table.insert (msg, template);
	table.insert (msg, '|ajuda]])</span>');
	if 0 == mw.title.getCurrentTitle().namespace then
		table.insert (msg, cfg[template].err_cat);
	end

	return table.concat (msg);	
end


--[[--------------------------< R E N D E R E R >--------------------------------------------------------------

Função de suporte compartilhado para nihingo(), nihongo3() e nihongo_foot().  Calcula um índice em formatação{}
a partir de parâmetros definidos ou não:
	args[1] (texto traduzido) tem o valor de 8 (definido) o 0 (não definido)
	args[2] (texto nativo) tem o valor de 4
	args[3] (texto romanizado) tem o valor de 2
	args[4] (extra) tem o valor de 1
o índice, a soma desses valores, obtém a string de formatação apropriada da tabela formatting{} com valores associados
da tabela formatting[index][2]

]]

local function renderer (args, formatting, extra2)
	local output;
	local index = 0;															-- índice de formatting{}
	local param_weight = {8, 4, 2, 1};											-- parâmetro binário de pesos: [1] = translation (8), [2] = japanese (4), [3] = romaji (2), [4] = extra (1)

	for i=1, 5 do																-- roda por args[1] – args[4]
		index = index + (args[i] and param_weight[i] or 0);						-- calcula um índice para formatting{}
	end

	output = (0 ~= index) and string.format (formatting[index][1] and formatting[index][1], formatting[index][2][1], formatting[index][2][2], formatting[index][2][3], formatting[index][2][4]) or nil;

	if extra2 then																-- sempre apenas anexado ao final (se houver um final), portanto, não faz parte da formatação{}
		output = output and (output .. ' ' .. extra2) or '<5p4n>' .. extra2;	-- <5p4n> e </5p4n>: espaços reservados para o estilo de peso da fonte; semelhante a marcadores de faixa, a serem substituídos
	end																			-- (japonês e nihongo3) ou removido (japonês nota)

	return output and (output .. '</5p4n>') or '';								-- Onde houver saída, adicione a tag de fechamento
end


--[[--------------------------< R O M A N I Z E D _ K E R N >--------------------------------------------------

Adiciona kerning quando o primeiro ou o último caractere do texto romanizado entrar em contato com parênteses adjacentes de abertura ou fechamento

Neste exemplo, sem kerning, os caracteres romanizados 'j' e 'V' estão em itálico e, portanto, entrarão em contato com os parênteses
	(<i lang=\"ja-Latn\" title=\"Hepburn transliteration\">jV</i>)

<ret_string> é a saída formatada da predefinição (exceto pelo fato de que a string mágica '<5p4n>' ainda não foi substituída)
<romanized> é o retorno de lang_module._transl(), portanto, não está entre parênteses

]]

local function romanized_kern (ret_string, romanized)
	if not romanized or ('' == romanized) then									-- se romanized não estiver definido
		return ret_string;														-- então não há nada a ser feito
	end

	local romanized_text = romanized:gsub ('%b<>', ''):gsub ('\'\'+', ''):gsub ('%[%[', ''):gsub ('%]%]', '');	-- remove tags html

	romanized = romanized:gsub ('([%(%)%.%%%+%-%*%?%[%^%$%]])', '%%%1');		-- caracteres de padrão de escape lua

	local romanized_has_leading_paren = ret_string:match ('%(' .. romanized);	-- tem valor se (<romanized>; senão nil
	local romanized_has_trailing_paren = ret_string:match (romanized .. '%)');	-- tem valor se <romanized>); senão nil

	local kern_lead_pattern = '^[jpy]';											-- lista de caracteres que, quando em itálico, entram em contato com parênteses da esquerda
	local kern_tail_pattern = '[dfijkltCEFHIJKMNPR-Z\'"%?!%]]$';				-- lista de caracteres que, quando em itálico, entram em contato com parênteses da direita

	local kern_right = '<span style="margin-right:.09em">(</span>%1';			-- %1 é a captura de <romanized>
	local kern_left = '%1<span style="margin-left:.09em">)</span>';				-- %1 é a captura de <romanized>

	if romanized_has_leading_paren and romanized_text:match (kern_lead_pattern) then
		ret_string = ret_string:gsub ('%((' .. romanized .. ')', kern_right);		-- Substitua '(' simples por '(' com kerning; <romanized> incluído aqui para garantir que seja adicionado kerning ao '(' correto
	end
	if romanized_has_trailing_paren and romanized_text:match (kern_tail_pattern) then
		ret_string = ret_string:gsub ('(' .. romanized .. ')%)', kern_left);		-- Substitua ')' simples por ')' com kerning; <romanized> incluído aqui para garantir que seja adicionado kerning ao ')' correto
	end

	return ret_string;															-- done
end


--[[--------------------------< C O M M O N >------------------------------------------------------------------

Suporte comum para {{nihongo}}

ordem de renderização: is translated, native, romanized

<template> é usado para selecionara a tabela cfg apropriada

]]

local function common (frame, template)
	local lang_module = require ('Módulo:Lang');
	local args = require ('Módulo:Arguments').getArgs (frame);
	
	local translation, native, romanized, extra, extra2 = args[1], args[2], args[3], args.extra or args[4], args.extra2 or args[5];	-- nomes significativos
	args[4] = extra or args[4];													-- garantir que extra seja "posicional" para uso por renderer()

	local lead = require ('Módulo:yesno')(args.lead or args.prefixo);

	if not (native or romanized) then											-- se não presente, retorna uma mensagem de erro
		return error_message (template);
	end
	if native and native ~= '' then
		native = ((lead and '[[Língua japonesa|japonês]]: ') or '') .. lang_module._lang ({cfg[template].tag, native, ['template']=template});	-- adiciona script ja com/sem prefixo língua
	end
	if romanized then
		romanized = (lead and translation and (cfg[template].system_link .. ': ') or '') .. lang_module._transl ({'ja', cfg[template].system, romanized, ['template']=template}) or nil;
	end

	local formatting = {														-- <5p4n> e </5p4n>: espaços reservados para intervalos de estilo de peso de fonte; semelhante a marcadores de faixa, substituídos antes do retorno da função
		{'<5p4n>(%s)', {extra}}, 												-- 1 - (extra)
		{'%s<5p4n>', {romanized}},												-- 2 - romanized
		{'%s<5p4n> (%s)', {romanized, extra}},									-- 3 - romanized (extra)
		{'<5p4n>(%s)', {native}},												-- 4 - native
		{'<5p4n>(%s; %s)', {native, extra}},									-- 5 - (native; extra)
		{'%s<5p4n> (%s)', {romanized, native}},									-- 6 - romanized (native)
		{'%s<5p4n> (%s; %s)', {romanized, native, extra}},						-- 7 - romanized (native; extra)
		{'%s<5p4n>', {translation}},											-- 8 - translation
		{'%s<5p4n> (%s)', {translation, extra}},								-- 9 - translation (extra)
		{'%s<5p4n> (%s)', {translation, romanized}},							-- 10 - translation (romanized)
		{'%s<5p4n> (%s; %s)', {translation, romanized, extra}},					-- 11 - translation (romanized; extra)
		{'%s<5p4n> (%s)', {translation, native}},								-- 12 - translation (native)
		{'%s<5p4n> (%s; %s)', {translation, native, extra}},					-- 13 - translation (native; extra)
		{'%s<5p4n> (%s, %s)', {translation, native, romanized}},				-- 14 - translation (native, romanized)
		{'%s<5p4n> (%s, %s; %s)', {translation, native, romanized, extra}},		-- 15 - translation (native, romanized; extra)
		}

	local ret_string = renderer (args, formatting, extra2)
	ret_string = romanized_kern (ret_string, romanized);						-- aplica o kern no texto romanizado quando apropriado
	ret_string = ret_string:gsub ('<5p4n>', '<span style="font-weight: normal">'):gsub ('</5p4n>', '</span>');	-- substitui para as tags adequadas

	return ret_string;															-- porque o gsub retorna o número de substituições feitas como segundo valor de retorno
end


--[[--------------------------< C O M M O N _ R O M A N I Z E D _ N A T I V E _ T R A N S L A T E D >----------

Suporte comum para {{nihongo3}}

ordem de renderização: is romanized, native, translated

<template> é usado para selecionara a tabela cfg apropriada

]]

local function common_romanized_native_translated (frame, template)
	local lang_module = require ('Módulo:Lang');
	local args = require ('Módulo:Arguments').getArgs (frame);
	
	local translation, native, romanized, extra, extra2 = args[1], args[2], args[3], args.extra or args[4], args.extra2 or args[5];	-- nomes significativos
	args[4] = extra or args[4];													-- garantir que extra seja "posicional" para uso por renderer()

	if not (native or romanized) then											-- se não presente, retorna uma mensagem de erro
		return error_message (template);
	end
	native = native and lang_module._lang ({cfg[template].tag, native, ['template']=template}) or nil;
	romanized = romanized and lang_module._transl ({cfg[template].tag, cfg[template].system, romanized, ['template']=template}) or nil;
	
	local formatting = {														-- <5p4n> e </5p4n>: espaços reservados para intervalos de estilo de peso de fonte; semelhante a marcadores de faixa, substituídos antes do retorno da função
		{'<5p4n>(%s)', {extra}}, 												-- 1 - (extra)
		{'%s<5p4n>', {romanized}},												-- 2 - romanized
		{'%s<5p4n> (%s)', {romanized, extra}},									-- 3 - romanized (extra)
		{'<5p4n>(%s)', {native}},												-- 4 - native
		{'<5p4n>(%s, %s)', {native, extra}},									-- 5 - (native, extra)
		{'%s<5p4n> (%s)', {romanized, native}},									-- 6 - romanized (native)
		{'%s<5p4n> (%s, %s)', {romanized, native, extra}},						-- 7 - romanized (native, extra)
		{'%s<5p4n>', {translation}},											-- 8 - translation
		{'%s<5p4n> (%s)', {translation, extra}},								-- 9 - translation (extra)
		{'%s<5p4n> (%s)', {romanized, translation}},							-- 10 - romanized (translation)
		{'%s<5p4n> (%s, %s)', {romanized, translation, extra}},					-- 11 - romanized (translation, extra)
		{'%s<5p4n> (%s)', {translation, native}},								-- 12 - translation (native)
		{'%s<5p4n> (%s, %s)', {translation, native, extra}},					-- 13 - translation (native, extra)
		{'%s<5p4n> (%s, %s)', {romanized, native, translation}},				-- 14 - romanized (native, translation)
		{'%s<5p4n> (%s, %s, %s)', {romanized, native, translation, extra}},		-- 15 - romanized (native, translation, extra)
		}

	local ret_string = renderer (args, formatting, extra2)
	ret_string = ret_string:gsub ('<5p4n>', '<span style="font-weight: normal">'):gsub ('</5p4n>', '</span>');	-- substitui para as tags adequadas
	return ret_string;															-- porque o gsub retorna o número de substituições feitas como segundo valor de retorno
end

--[[--------------------------< C O M M O N _ N A T I V E _ R O M A N I Z E D _ T R A N S L A T E D >----------

Suporte comum para {{nihongo krt}}

ordem de renderização: is native, romanized, translated

<template> é usado para selecionara a tabela cfg apropriada

]]

local function common_native_romanized_translated (frame, template)
	local lang_module = require ('Módulo:Lang');
	local args = require ('Módulo:Arguments').getArgs (frame);
	
	local translation, native, romanized, extra, extra2 = args[1], args[2], args[3], args.extra or args[4], args.extra2 or args[5];	-- nomes significativos
	args[4] = extra or args[4];													-- garantir que extra seja "posicional" para uso por renderer()

	if not (native or romanized) then											-- se não presente, retorna uma mensagem de erro
		return error_message (template);
	end
	native = native and lang_module._lang ({cfg[template].tag, native, ['template']=template}) or nil;
	romanized = romanized and lang_module._transl ({cfg[template].tag, cfg[template].system, romanized, ['template']=template}) or nil;
	
	local formatting = {														-- <5p4n> e </5p4n>: espaços reservados para intervalos de estilo de peso de fonte; semelhante a marcadores de faixa, substituídos antes do retorno da função
		{'<5p4n>(%s)', {extra}}, 												-- 1 - (extra)
		{'%s<5p4n>', {romanized}},												-- 2 - romanized
		{'%s<5p4n> (%s)', {romanized, extra}},									-- 3 - romanized (extra)
		{'<5p4n>%s', {native}},													-- 4 - native
		{'<5p4n>%s (%s)', {native, extra}},										-- 5 - native (extra)
		{'<5p4n>%s (%s)', {native, romanized}},									-- 6 - native (romanized)
		{'<5p4n>%s (%s, %s)', {native, romanized, extra}},						-- 7 - native (romanized, extra)
		{'%s<5p4n>', {translation}},											-- 8 - translation
		{'%s<5p4n> (%s)', {translation, extra}},								-- 9 - translation (extra)
		{'%s<5p4n> (%s)', {romanized, translation}},							-- 10 - romanized (translation)
		{'%s<5p4n> (%s, %s)', {romanized, translation, extra}},					-- 11 - romanized (translation, extra)
		{'<5p4n>%s (%s)', {native, translation}},								-- 12 - native (translation)
		{'<5p4n>%s (%s, %s)', {native, translation, extra}},					-- 13 - native (translation, extra)
		{'<5p4n>%s (%s, %s)', {native, romanized, translation}},				-- 14 - native (romanized, translation)
		{'<5p4n>%s (%s, %s, %s)', {native, romanized, translation, extra}},		-- 15 - native (romanized, translation, extra)
		}

	local ret_string = renderer (args, formatting, extra2)
	ret_string = romanized_kern (ret_string, romanized);						-- aplica o kern no texto romanizado quando apropriado
	ret_string = ret_string:gsub ('<5p4n>', '<span style="font-weight: normal">'):gsub ('</5p4n>', '</span>');	-- substitui para as tags adequadas
	return ret_string;															-- porque o gsub retorna o número de substituições feitas como segundo valor de retorno
end


--[[--------------------------< C O M M O N _ F O O T >--------------------------------------------------------

Suporte comum para {{nihongo foot}}

ordem de renderização: is translated<ref>native, romanized</ref>

<template> é usado para selecionara a tabela cfg apropriada

]]

local function common_foot (frame, template)
	local lang_module = require ('Módulo:Lang');
	local args = require ('Módulo:Arguments').getArgs (frame);
	
	local translation, native, romanized, extra, extra2 = args[1], args[2], args[3], args.extra or args[4], args.extra2 or args[5];	-- nomes significativos
	args[4] = extra or args[4];													-- garantir que extra seja "posicional" para uso por renderer()
	local post = args[6] or args['pós'];
	local group = args.group or args.grupo or 'lower-alpha';
	local ref_name = args.ref_name or args.ref_nome;
	local lead = require ('Módulo:yesno')(args.lead or args.prefixo);

	if not (native or romanized) then											-- se não presente, retorna uma mensagem de erro
		return error_message (template);
	end
	if native and native ~= '' then
		native = ((lead and '[[Língua japonesa|japonês]]: ') or '') .. lang_module._lang ({cfg[template].tag, native, ['template']=template});	-- adiciona script ja com/sem prefixo língua
	end
	if romanized then
		romanized = (lead and (cfg[template].system_link .. ': ') or '') .. lang_module._transl ({'ja', cfg[template].system, romanized, ['template']=template}) or nil;
	end
	
	local formatting = {
		{'%s', {extra}}, 														-- 1 - extra
		{'%s', {romanized}},													-- 2 - romanized
		{'%s, %s', {romanized, extra}},											-- 3 - romanized, extra
		{'%s', {native}},														-- 4 - native
		{'%s, %s', {native, extra}},											-- 5 - native, extra
		{'%s, %s', {native, romanized}},										-- 6 - native romanized
		{'%s, %s, %s', {native, romanized, extra}},								-- 7 - native romanized, extra
																				-- a partir daqui, translation é usado no mapeamento, mas não é renderizado pelo renderizador, portanto não é incluído na tabela
		{'', {''}},																-- 8 - translation
		{'%s', {extra}},														-- 9 - extra
		{'%s', {romanized}},													-- 10 - romanized
		{'%s, %s', {romanized, extra}},											-- 11 - romanized, extra
		{'%s', {native}},														-- 12 - native
		{'%s, %s', {native, extra}},											-- 13 - native, extra
		{'%s, %s', {native, romanized}},										-- 14 - native romanized
		{'%s, %s, %s', {native, romanized, extra}},								-- 15 - native romanized, extra
		}

	if translation and post then												-- reescreve translation para incluir |pós=
		translation = translation .. post;										-- se translation possui valor, concatena com post, senão apenas post
	elseif post then
		translation = post;														-- translation não definido, use post
	elseif not translation then													-- nenhum é definido
		translation = '';														-- faça translation ser uma string vazia para concatenação
	end

	if native or romanized or extra or extra2 then								-- nenhuma tag de referência quando nenhuma delas estiver definida (ela estaria vazia)
		local content = renderer (args, formatting, extra2);
		content = content:gsub ('<5p4n>', ''):gsub ('</5p4n>$', '', 1);			-- Retirar as tags <5p4n> e </5p4n> adicionadas por renderer(); spans não usados por essa predefinição

		if translation:match ('\'\'+$') then									-- se <translation> é itálico, negrito, ou ambos
			local text = translation:gsub ('%b<>', ''):gsub ('\'\'+', ''):gsub ('%[%[', ''):gsub ('%]%]', '');	-- remove a marcação
			if text:match ('[dfijkltCEFHIJKMNPR-Z\'"%?!%]]$') then				-- quando <translation> termina com um desses caracteres
				translation =  '<span style="margin-right:.09em">' .. translation .. '</span>';	-- adiciona kerning
			end
		end

		return translation .. frame:extensionTag ({name='ref', args={group=group, name=ref_name}, content=content});	-- translation com a tag de referência
	else
		return translation;															-- nada para estar dentro da tag ref, então só retorna translation
	end
end


--[=[-------------------------< N I H O N G O >----------------------------------------------------------------

Implementa {{japonês}} usando Módulo:Lang para marcação de linguagem e transliteração

]=]

local function nihongo (frame)
	return common (frame, 'japonês')
end


--[=[-------------------------< N I H O N G O 3 >--------------------------------------------------------------

Implementa {{nihongo}} usando Módulo:Lang para marcação de linguagem e transliteração

Similar a {{japonês}}, mas altera a ordem de renderização e não suporta |prefixo=

]=]

local function nihongo3 (frame)
	return common_romanized_native_translated (frame, 'nihongo3')
end


--[=[-------------------------< N I H O N G O _ K R T >--------------------------------------------------------

Implementa {{nihongo krt}} usando Módulo:Lang para marcação de linguagem e transliteração

Similar a {{japonês}}, mas altera a ordem de renderização e não suporta |prefixo=

]=]

local function nihongo_krt (frame)
	return common_native_romanized_translated (frame, 'nihongo krt')
end


--[=[-------------------------< N I H O N G O _ F O O T >------------------------------------------------------

Implementa {{japonês nota}} usando Módulo:Lang para marcação de linguagem e transliteração

]=]

local function nihongo_foot (frame)
	return common_foot (frame, 'japonês nota')
end


--[[--------------------------< F U N Ç Õ E S _ E X P O R T A D A S >------------------------------------------
]]

return {
	nihongo = nihongo,
	nihongo3 = nihongo3,
	nihongo_krt = nihongo_krt,
	nihongo_foot = nihongo_foot,
	}