Jump to content

Module:Wikt-lang/sandbox: Difference between revisions

Add links
From Wikipedia, the free encyclopedia
Browse history interactively
← Previous editNext edit →
Content deleted Content added
No edit summary
Tag: Reverted
Undid revision 1262068387 by Gonnym (talk)
Line 9: Line 9:
internal = {
internal = {
["get_clean_Wiktionary_page_name"] = "The function get_clean_Wiktionary_page_name requires a page_name.",
["get_clean_Wiktionary_page_name"] = "The function get_clean_Wiktionary_page_name requires a page_name.",
["language_code_missing"] = "Name for the language code %q could not be retrieved. Add it to [[Module:Lang/data]].",
["language_code_missing"] = "Name for the language code %q could not be retrieved. Add it to [[Module:Wikt-lang/data]].",
["make_Wiktionary_link"] = "The function make_Wiktionary_link needs a Wiktionary page name, display text and language code.",
["make_Wiktionary_link"] = "The function make_Wiktionary_link needs a Wiktionary page name, display text and language code.",
},
},

Revision as of 12:29, 9 December 2024

require('strict')

local m_data = mw.loadData("Module:Wikt-lang/data/sandbox")
local lang_data = m_data.languages or m_data

local p = {}

local error_msgs = {
	internal = {
		["get_clean_Wiktionary_page_name"] = "The function get_clean_Wiktionary_page_name requires a page_name.",
		["language_code_missing"] = "Name for the language code %q could not be retrieved. Add it to [[Module:Wikt-lang/data]].",
		["make_Wiktionary_link"] = "The function make_Wiktionary_link needs a Wiktionary page name, display text and language code.",
	},
	["no_text"] = "A Wiktionary entry is required.",
	["invalid_parameters"] = 'Invalid parameter: |%s=',
}

local cfg = {
	template = "Wikt-lang",
	valid_parameters = {
		[1] = true,
		[2] = true,
		[3] = true,
		["italic"] = true,
	},
	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

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

Returns the page_name 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 add_namespace_to_link(data, language_name, page_name)
	if page_name:sub(1, 1) == "*" then
		return string.format(cfg.namespace.reconstruction.name, language_name, page_name: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, page_name)
		elseif data.type == cfg.namespace.appendix.data_type then
			return string.format(cfg.namespace.appendix.name, language_name, page_name)
		end
	end
	
	-- If for any reason this reaches here, return the unaltered page_name.
	return page_name
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_Wiktionary_language_name(data, language_name)
	if data and data.Wiktionary_name then
		return data.Wiktionary_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 page_name, 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(page_name, display_text, language_code, language_name)
	if not page_name and not display_text and not language_code then
		return nil, make_error(error_msgs.internal.make_Wiktionary_link)
	end

	local data = lang_data[language_code]
	language_name = get_Wiktionary_language_name(data, language_name)
	if not language_name then
		return make_error(error_msgs.language_code_missing)
	end

	page_name = add_namespace_to_link(data, language_name, page_name)

	local link = "[[wikt:%s#%s|%s]]"
	return string.format(link, page_name, language_name, display_text)
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, text)
	local replacements = data and data["replacements"]
	if replacements == nil then
		-- No replacements needed; use text as is.
		return 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
		text = mw.ustring.toNFD(text)
		for i, from in ipairs(replacements.from) do
			text = mw.ustring.gsub(text, from, replacements.to and replacements.to[i] or "")
		end
		return text
	end

	for regex, replacement in pairs(replacements) do
		text = mw.ustring.gsub(text, regex, replacement)
	end
	return 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(text)
	if not text then
		return text
	end
	text = text:gsub("\'\'\'", "")
	text = text:gsub("\'\'", "")
	return 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(page_name, language_code)
	page_name = tostring(page_name)
	if page_name == nil or page_name == "" then
		return nil, make_error(error_msgs.internal.get_clean_Wiktionary_page_name)
	end

	page_name = remove_bold_italic(page_name)

	local data = lang_data[language_code]
	if data == nil then
		-- No language specific data in module; use text as is.
		return page_name
	end

	return replace_characters(data, page_name)
end

--[[--------------------------< C H E C K _ F O R _ U N K N O W N _ P A R A M E T E R S >--------------------------------------------------

Checks that all user-used parameters are valid.

]]
local function check_for_unknown_parameters(args)
	for param, _ in pairs(args) do
		if not cfg.valid_parameters[param] then
			return make_error(string.format(error_msgs.invalid_parameters, param))
		end
	end
end

--[[--------------------------< M A I N >--------------------------------------------------------------------

Entry point for {{Wikt-lang}}.

Parameters are received from the template's frame (parent frame).

* |1= – language code
* |2= – Wiktionary page name
* |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 page name is required.
		return make_error(error_msgs.no_text)
	end

	local error_msg = check_for_unknown_parameters(args)
	if error_msg then
		return error_msg
	end

	-- For the display text, use args[3] if supplied, if not, use the Wiktionary page name (args[2])
	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.
	--TODO: replace /sandbox when live.
	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: Do we need the result to return with a <span title=""> tag?

	local page_name, error_msg = get_clean_Wiktionary_page_name(args[2], result.code)
	if error_msg then
		return error_msg
	end

	local link, error_msg = make_Wiktionary_link(page_name, result.html, result.code, result.name)
	if error_msg then
		return error_msg
	end

	return link .. result.language_categories .. result.maintenance  
end

return p
Retrieved from "https://en.wikipedia.org/w/index.php?title=Module:Wikt-lang/sandbox&oldid=1262068417"