require('strict')
local m_data = mw.loadData("Module:Wikt-lang/data/sandbox")
local langData = m_data.languages or m_data
local p = {}
local error_msgs = {
internal = {
["language_code_missing"] = "Name for the language code %q could not be retrieved. Add it to [[Module:Wikt-lang/data]].",
["get_clean_Wiktionary_page_name"] = "The function get_clean_Wiktionary_page_name requires a link string.",
["make_Wiktionary_link"] = "The function make_Wiktionary_link needs a Wiktionary link, display text and language code.",
},
["no_text"] = "A Wiktionary entry is required.",
}
local cfg = {
template = "Wikt-lang",
error_msg = '<span style="color: #d33;">Error: {{%s}}: %s</span>[[Category:%s]]',
category = "Wikt-lang template errors",
namespace = {
appendix = {
name = "Appendix:%s/%s",
data_type = "appendix",
},
reconstruction = {
name = "Reconstruction:%s/%s",
data_type = "reconstructed",
},
},
}
--[[--------------------------< M A K E _ E R R O R >--------------------------------------------------
Creates an error span with the supplied error message and attaches the error category.
]]
local function make_error(msg)
return string.format(cfg.error_msg, cfg.template, msg, cfg.category)
end
--[[--------------------------< R E P L A C E _ C H A R A C T E R S >--------------------------------------------------
Replaces specific characters as defined in Module:Wikt-lang/data in a language's "replacement" value.
]]
local function replace_characters(data, link_text)
local replacements = data and data["replacements"]
if replacements == nil then
-- No replacements needed; use text as is.
return link_text
end
-- Decompose so that the diacritics of characters such
-- as á can be removed in one go.
-- No need to compose at the end, because the MediaWiki software
-- will handle that.
if replacements.decompose then
link_text = mw.ustring.toNFD(link_text)
for i, from in ipairs(replacements.from) do
link_text = mw.ustring.gsub(
link_text,
from,
replacements.to and replacements.to[i] or "")
end
return link_text
end
for regex, replacement in pairs(replacements) do
link_text = mw.ustring.gsub(link_text, regex, replacement)
end
return link_text
end
--[[--------------------------< R E M O V E _ B O L D _ I T A L I C >--------------------------------------------------
Removes bold and italics, so that words that contain bolding or emphasis can be linked without piping.
]]
local function remove_bold_italic(link_text)
if not link_text then
return link_text
end
link_text = link_text:gsub("\'\'\'", "")
link_text = link_text:gsub("\'\'", "")
return link_text
end
--[[--------------------------< G E T _ C L E A N _ W I K T I O N A R Y _ P A G E _ N A M E >--------------------------------------------------
Returns a clean a Wiktionary page name by removing bold and italics, and by replacing specific characters as defined in Module:Wikt-lang/data.
]]
local function get_clean_Wiktionary_page_name(link_text, language_code)
link_text = tostring(link_text)
if link_text == nil or link_text == "" then
return nil, make_error(error_msgs.internal.get_clean_Wiktionary_page_name)
end
link_text = remove_bold_italic(link_text)
local data = langData[language_code]
if data == nil then
-- No language specific data in module; use text as is.
return link_text
end
return replace_characters(data, link_text)
end
--[[--------------------------< G E T _ N A M E S P A C E >--------------------------------------------------
Returns the link_text with a prefix of a Wiktionary namespace, if relevant.
Current namespaces that can be returned: "Appendix:" and "Reconstruction:".
If not one of the above namespaces, returns the unalerted link_text.
]]
local function get_namespace(data, language_name, link_text)
if link_text:sub(1, 1) == "*" then
return string.format(cfg.namespace.reconstruction.name, language_name, link_text:sub(2))
end
if data and data.type then
if data.type == cfg.namespace.reconstruction.data_type then
return string.format(cfg.namespace.reconstruction.name, language_name, link_text)
elseif data_type == cfg.namespace.appendix.data_type then
return string.format(cfg.namespace.appendix.name, language_name, link_text)
end
end
-- If for any reason this reaches here, return the unaltered link_text.
return link_text
end
--[[--------------------------< G E T _ L A N G U A G E _ N A M E >--------------------------------------------------
Retrieves the language name.
A langauge is first searched in Module:Wikt-lang/data and if found and has a language name set, returns it.
That database is used to override the language names produced by Module:Lang/data.
If no language is found or the language does not have a language name set, returns the language name from Module:Lang/data.
]]
local function get_language_name(data, language_name)
if data and data.name then
return data.name
end
return language_name
end
--[[--------------------------< M A K E _ W I K T I O N A R Y _ L I N K >--------------------------------------------------
Creates a Wiktionary link.
A link_text, display_text and language_code are always needed. Error if they are missing.
A language name can sometimes be nil if the private code is only listed at Module:Wikt-lang/data and not on Module:Lang/data.
If a language name cannot be retrieved, an erorr is returned.
]]
local function make_Wiktionary_link(link_text, display_text, language_code, language_name)
if not link_text and not display_text and not language_code then
return nil, make_error(error_msgs.internal.make_Wiktionary_link)
end
local data = langData[language_code]
language_name = get_language_name(data, language_name)
if not language_name then
return make_error(error_msgs.language_code_missing)
end
link_text = get_namespace(data, language_name, link_text)
local link = "[[wikt:%s#%s|%s]]"
return string.format(link, link_text, language_name, display_text)
end
--[[--------------------------< M A I N >--------------------------------------------------------------------
Entry point for {{Wikt-lang}}.
Parameters are received from the template's frame (parent frame).
* |1= – language code
* |2= – link text
* |3= – display text
* |italic= – "no" to disable
]]
function p.main(frame)
local getArgs = require('Module:Arguments').getArgs
local args = getArgs(frame)
if not args[2] then
-- A Wiktionary entry is required.
return make_error(error_msgs.no_text)
end
-- The display text should be the text wrapped in the language tag.
args[2] = args[3] or args[2]
-- To allow the errors to be associated with this template.
args.template = cfg.template
args.error_category = cfg.category
-- Handle the display text html tag.
local lang = require("Module:Lang/sandbox2")
local result = lang._lang(args)
-- An error returned, stop here.
if type(result) == "string" and string.find(result, "Error") then
return result
end
--TODO: we need the result to return without a <span title=""> tag which probably should be removed.
local entry, error_msg = get_clean_Wiktionary_page_name(args[2], result.code)
if error_msg then
return error_msg
end
local link
link, error_msg = make_Wiktionary_link(entry, result.html, result.code, result.name)
if error_msg then
return error_msg
end
return link .. result.language_categories .. result.maintenance
end
return p
