Tavoraadmin: Importando predefinição/módulo da Wikipédia em português para manter layout

2026-07-05T04:52:40Z

Importando predefinição/módulo da Wikipédia em português para manter layout

Página nova

--------------------------------------------------------------------------------
-- Formatar ligação ("'Format link'")
--
-- Cria uma ligação wiki ('wikilink') a partir da ligação ('link') fornecida e
-- mostra os valores. As ligações ('links') são escapadas com dois pontos, se
-- necessário, e as ligações ('links') para as seções são detectados e mostradas
-- com " § " como separador em vez do "#" padrão no MediaWiki. Usado na
-- predefinição {{Format link}}.
--------------------------------------------------------------------------------
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local checkTypeForNamedArg = libraryUtil.checkTypeForNamedArg
local mArguments -- inicializa lentamente [[Módulo:Arguments]]
local mError -- inicializa lentamente [[Módulo:Erro]]
local yesno -- inicializa lentamente [[Módulo:Yesno]]

local p = {}

--------------------------------------------------------------------------------
-- Funções auxiliares
--------------------------------------------------------------------------------

local function getArgs(frame)
-- Busca os argumentos do quadro parental. Os espaços em branco são cortados
-- e os espaços em branco são removidos.
mArguments = require('Módulo:Arguments')
return mArguments.getArgs(frame, {parentOnly = true})
end

local function removeInitialColon(s)
-- Remove os dois pontos iniciais de uma sequência ('string'), se presentes.
return s:match('^:?(.*)')
end

local function maybeItalicize(s, shouldItalicize)
-- Coloca "s" em itálico se "s" for uma sequência ('string') e o parâmetro
-- "shouldItalicize" for verdadeiro ("true").
if s and shouldItalicize then
return '<i>' .. s .. '</i>'
else
return s
end
end

local function parseLink(link)
-- Analisa uma ligação ('link') e retorna uma tabela com os componentes da
-- ligação ('link'). Esses componentes são:
-- - link: a ligação ('link'), sem os dois pontos iniciais (sempre presente)
-- - page: o nome da página (sempre presente)
-- - section: o nome da página (pode ser nulo)
-- - display: o texto a ser mostrado, se inserido manualmente após uma
-- barra vertical ('pipe') (pode ser nulo)
link = removeInitialColon(link)

-- Localiza se um valor a ser mostrado falso foi adicionado com a
-- palavra mágica {{!}}.
local prePipe, display = link:match('^(.-)|(.*)$')
link = prePipe or link

-- Localiza a página, se ela existir.
-- Para ligações ('links') como [[#Algo]], a página será nula.
local preHash, postHash = link:match('^(.-)#(.*)$')
local page
if not preHash then
-- Temos uma ligação ('link') como [[Algo]].
page = link
elseif preHash ~= '' then
-- Temos uma ligação ('link') como [[Algo#Algo]].
page = preHash
end

-- Localiza a seção, se ela existir.
local section
if postHash and postHash ~= '' then
section = postHash
end

return {
link = link,
page = page,
section = section,
display = display,
}
end

local function formatDisplay(parsed, options)
-- Formata uma sequência ('string') a ser mostrada com base em uma tabela
-- de ligações ('links') analisadas (correspondendo à saída de "parseLink") e
-- uma tabela de opções (combinando com as opções de entrada para "_formatLink").
local page = maybeItalicize(parsed.page, options.italicizePage)
local section = maybeItalicize(parsed.section, options.italicizeSection)
if (not section) then
return page
elseif (not page) then
return mw.ustring.format('§ %s', section)
else
return mw.ustring.format('%s § %s', page, section)
end
end

local function missingArgError(target)
mError = require('Módulo:Erro')
return mError.error{message =
'Erro: Nenhuma ligação ou destino especificado! ([[' .. target .. '#Erros|ajuda]])'
}
end

--------------------------------------------------------------------------------
-- Funções principais
--------------------------------------------------------------------------------

function p.formatLink(frame)
-- A função de exportação "formatLink", para uso em predefinições.
yesno = require('Módulo:Yesno')
local args = getArgs(frame)
local link = args[1] or args.link
local target = args[3] or args.target
if not (link or target) then
return missingArgError('Predefinição:Format link')
end

return p._formatLink{
link = link,
display = args[2] or args.display,
target = target,
italicizePage = yesno(args.italicizepage),
italicizeSection = yesno(args.italicizesection),
categorizeMissing = args.categorizemissing
}
end

function p._formatLink(options)
-- A função de exportação "formatLink", para uso em módulos.
checkType('_formatLink', 1, options, 'table')
local function check(key, expectedType) -- para brevidade
checkTypeForNamedArg(
'_formatLink', key, options[key], expectedType or 'string', true
)
end
check('link')
check('display')
check('target')
check('italicizePage', 'boolean')
check('italicizeSection', 'boolean')
check('categorizeMissing')

-- Normaliza a ligação ('link') e o destino e verifica se pelo menos um está presente
if options.link == '' then options.link = nil end
if options.target == '' then options.target = nil end
if not (options.link or options.target) then
return missingArgError('Módulo:Format link')
end

local parsed = parseLink(options.link)
local display = options.display or parsed.display
local catMissing = options.categorizeMissing
local category = ''

-- Localiza o texto a ser mostrado
if not display then display = formatDisplay(parsed, options) end

-- Lida com a opção de destino, se presente
if options.target then
local parsedTarget = parseLink(options.target)
parsed.link = parsedTarget.link
parsed.page = parsedTarget.page
end

-- Testa se a página existe se uma categoria de diagnóstico for especificada
if catMissing and (mw.ustring.len(catMissing) > 0) then
local title = nil
if parsed.page then title = mw.title.new(parsed.page) end
if title and (not title.isExternal) then
local success, exists = pcall(function() return title.exists end)
if success and not exists then
category = mw.ustring.format('[[Categoria:%s]]', catMissing)
end
end
end

-- Formata o resultado como uma ligação ('link')
if parsed.link == display then
parsed.link = string.gsub(parsed.link, "[%[%]]*", "")
parsed.link = removeInitialColon(parsed.link)
return mw.ustring.format('[[:%s]]%s', parsed.link, category)
else
parsed.link = string.gsub(parsed.link, "[%[%]]*", "")
parsed.link = removeInitialColon(parsed.link)
display = string.gsub(display, "[%[%]]*", "")
display = removeInitialColon(display)
return mw.ustring.format('[[:%s|%s]]%s', parsed.link, display, category)
end
end

--------------------------------------------------------------------------------
-- Funções de conveniência derivadas
--------------------------------------------------------------------------------

function p.formatPages(options, pages)
-- Formata um arranjo de páginas usando "formatLink" e a tabela de opções
-- dada,e o retorna como um arranjo. Valores nulos não são permitidos.
local ret = {}
for i, page in ipairs(pages) do
ret[i] = p._formatLink{
link = page,
categorizeMissing = options.categorizeMissing,
italicizePage = options.italicizePage,
italicizeSection = options.italicizeSection
}
end
return ret
end

return p

Módulo:Format link - Histórico de revisão

Tavoraadmin: Importando predefinição/módulo da Wikipédia em português para manter layout