Jump to content

Module:Wikt-lang and Module:Wikt-lang/sandbox: Difference between pages

(Difference between pages)
Page 1
Page 2
Content deleted Content added
more unused code
 
m Asukite moved page Module:Module:Wikt-lang/sandbox to Module:Wikt-lang/sandbox without leaving a redirect: promise I'm not going to try and manually tackle one of these again
 
Line 1: Line 1:
require('strict')
require('strict')

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


local p = {}
local p = {}


local function ifNotEmpty(value)
local error_msgs = {
internal = {
if value == "" then
["get_clean_Wiktionary_page_name"] = "The function get_clean_Wiktionary_page_name requires a page_name.",
return nil
["language_code_missing"] = "Name for the language code %q could not be retrieved. Add it to [[Module:Wikt-lang/data]].",
else
["make_Wiktionary_link"] = "The function make_Wiktionary_link needs a Wiktionary page name, display text and language code.",
return value
end
},
["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
end


--[[--------------------------< A D D _ N A M E S P A C E _ T O _ L I N K >--------------------------------------------------
local function makeEntryName(word, languageCode)

local data = langData[languageCode]
Returns the page_name with a prefix of a Wiktionary namespace, if relevant.
local ugsub = mw.ustring.gsub
Current namespaces that can be returned: "Appendix:" and "Reconstruction:".
word = tostring(word)
If not one of the above namespaces, returns the unalerted link_text.
if word == nil then

error("The function makeEntryName requires a string argument")
]]
elseif word == "" then
local function add_namespace_to_link(data, language_name, page_name)
return ""
if page_name:sub(1, 1) == "*" then
else
return string.format(cfg.namespace.reconstruction.name, language_name, page_name:sub(2))
-- Remove bold and italics, so that words that contain bolding or emphasis can be linked without piping.
end
word = word:gsub("\'\'\'", "")

word = word:gsub("\'\'", "")
if data == nil then
if data and data.type then
if data.type == cfg.namespace.reconstruction.data_type then
return word
return string.format(cfg.namespace.reconstruction.name, language_name, page_name)
else
elseif data.type == cfg.namespace.appendix.data_type then
local replacements = data and data["replacements"]
return string.format(cfg.namespace.appendix.name, language_name, page_name)
if replacements == nil then
return word
else
-- 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
word = mw.ustring.toNFD(word)
for i, from in ipairs(replacements.from) do
word = ugsub(
word,
from,
replacements.to and replacements.to[i] or "")
end
else
for regex, replacement in pairs(replacements) do
word = ugsub(word, regex, replacement)
end
end
return word
end
end
end
end
end
-- If for any reason this reaches here, return the unaltered page_name.
return page_name
end
end


--[[--------------------------< G E T _ L A N G U A G E _ N A M E >--------------------------------------------------
local function fixScriptCode(firstLetter, threeLetters)

return string.upper(firstLetter) .. string.lower(threeLetters)
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
end


--[[--------------------------< M A K E _ W I K T I O N A R Y _ L I N K >--------------------------------------------------
local function getCodes(codes, text)
local languageCode, scriptCode, invalidCode
local errorText
if codes == nil or codes == "" then
errorText = 'no language or script code provided'
elseif codes:find("^%a%a%a?$") or codes:find("^%a%a%a?%-%a%a%a%a$") then
-- A three- or two-letter lowercase sequence at beginning of first parameter
languageCode =
codes:find("^%a%a%a?") and (
codes:match("^(%l%l%l?)")
or codes:match("^(%a%a%a?)")
:gsub("(%a%a%a?)", string.lower, 1)
)
-- One uppercase and three lowercase letters at the end of the first parameter
scriptCode =
codes:find("%a%a%a%a$") and (
codes:match("(%u%l%l%l)$")
or gsub(
codes:match("(%a%a%a%a)$"),
"(%a)(%a%a%a)",
fixScriptCode,
1
)
)
elseif codes:find("^%a%a%a?%-%a%a%a?$")
or codes:find("^%a%a%a%-%a%a%a%-%a%a%a$") then
languageCode = codes
Creates a Wiktionary link.
-- Private-use subtag: x followed by one or more sequences of 1-8 lowercase
A page_name, display_text and language_code are always needed. Error if they are missing.
-- letters separated by hyphens. This only allows for one sequence, as it is

-- needed for proto-languages such as ine-x-proto (Proto-Indo-European).
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.
elseif codes:find("^%a%a%a?%-x%-%a%a?%a?%a?%a?%a?%a?%a?$") then
If a language name cannot be retrieved, an erorr is returned.
languageCode, scriptCode =

codes:match("^(%a%a%a%-x%-%a%a?%a?%a?%a?%a?%a?%a?)%-?(.*)$")
]]
if not languageCode then
local function make_Wiktionary_link(page_name, display_text, language_code, language_name)
errorText = '<code>'..codes..'</code> is not a valid language or script code.'
if not page_name and not display_text and not language_code then
elseif scriptCode ~= "" and not scriptCode:find("%a%a%a%a") then
return nil, make_error(error_msgs.internal.make_Wiktionary_link)
errorText = '<code>'..scriptCode..'</code> is not a valid script code.'
end
else

scriptCode = scriptCode:gsub(
local data = lang_data[language_code]
"(%a)(%a%a%a)",
language_name = get_Wiktionary_language_name(data, language_name)
fixScriptCode,
if not language_name then
1
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
end
return text
elseif codes:find("^%a%a%a?") then
languageCode, invalidCode = codes:match("^(%a%a%a?)%-?(.*)")
languageCode = string.lower(languageCode)
errorText = '<code>'..invalidCode..'</code> is not a valid script code.'
elseif codes:find("%-?%a%a%a%a$") then
invalidCode, scriptCode = codes:match("(.*)%-?(%a%a%a%a)$")
scriptCode = gsub(
scriptCode,
"(%a)(%a%a%a)",
fixScriptCode
)
errorText = '<code>'..invalidCode..'</code> is not a valid language code.'
else
errorText = '<code>'..codes..'</code> is not a valid language or script code.'
end
end

if not scriptCode or scriptCode == "" then
for regex, replacement in pairs(replacements) do
scriptCode = require("Module:Unicode data").is_Latin(text) and "Latn" or "unknown"
text = mw.ustring.gsub(text, regex, replacement)
end
end
return text
if errorText then

errorText = ' <span style="font-size: smaller">[' .. errorText .. ']</span>'
end
else

errorText = ""
--[[--------------------------< 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
end
text = text:gsub("\'\'\'", "")
languageCode = m_data.redirects[languageCode] or languageCode
text = text:gsub("\'\'", "")
return languageCode, scriptCode, errorText
return text
end
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 >--------------------------------------------------
local function tag(text, languageCode, script, italics)

local data = langData[languageCode]
Returns a clean a Wiktionary page name by removing bold and italics, and by replacing specific characters as defined in Module:Wikt-lang/data.
-- Use Wikipedia code if it has been given: for instance,

-- Proto-Indo-European has the Wiktionary code "ine-pro" but the Wikipedia
]]
-- code "ine-x-proto".
local function get_clean_Wiktionary_page_name(page_name, language_code)
languageCode = data and data.Wikipedia_code or languageCode
page_name = tostring(page_name)
local italicize = script == "Latn" and italics
if page_name == nil or page_name == "" then
return nil, make_error(error_msgs.internal.get_clean_Wiktionary_page_name)
if not text then text = "[text?]" end
local textDirectionMarkers = { "", "", "" }
if data and data["direction"] == "rtl" then
textDirectionMarkers = { ' dir="rtl"', '&rlm;', '&lrm;' }
end
end

page_name = remove_bold_italic(page_name)
local out = { textDirectionMarkers[2] }

if italicize then
local data = lang_data[language_code]
table.insert(out, "<i lang=\"" .. languageCode .. "\"" .. textDirectionMarkers[1] .. ">" .. text .. "</i>")
if data == nil then
else
-- No language specific data in module; use text as is.
table.insert(out, "<span lang=\"" .. languageCode .. "\"" .. textDirectionMarkers[1] .. ">" .. text .. "</span>")
return page_name
end
end

table.insert(out, textDirectionMarkers[3])
return replace_characters(data, page_name)
return table.concat(out)
end
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 >--------------------------------------------------
local function linkToWiktionary(entry, linkText, languageCode)

local data = langData[languageCode]
Checks that all user-used parameters are valid.
local name

if languageCode then
]]
if data and data.name then
local function check_for_unknown_parameters(args)
name = data.name
for param, _ in pairs(args) do
else
if not cfg.valid_parameters[param] then
-- On other languages' wikis, use mw.getContentLanguage():getCode(),
return make_error(string.format(error_msgs.invalid_parameters, param))
-- or replace 'en' with that wiki's language code.
name = mw.language.fetchLanguageName(languageCode, 'en')
if name == "" then
error("Name for the language code " .. ("%q"):format(languageCode or nil)
.. " could not be retrieved with mw.language.fetchLanguageName, "
.. "so it should be added to [[Module:Wikt-lang/data]]")
end
end
end
if entry:sub(1, 1) == "*" then
if name ~= "" then
entry = "Reconstruction:" .. name .. "/" .. entry:sub(2)
else
error("Language name is empty")
end
elseif data and data.type == "reconstructed" then
mw.log("Reconstructed language without asterisk:", languageCode, name, entry)
local frame = mw.getCurrentFrame()
-- Track reconstructed entries with no asterisk by transcluding
-- a nonexistent template. This technique is used in Wiktionary:
-- see [[wikt:Module:debug]].
-- [[Special:WhatLinksHere/tracking/wikt-lang/reconstructed with no asterisk]]
pcall(frame.expandTemplate, frame,
{ title = 'tracking/wikt-lang/reconstructed with no asterisk' })
if name ~= "" then
entry = "Reconstruction:" .. name .. "/" .. entry
else
error("Language name is empty")
end
elseif data and data.type == "appendix" then
if name ~= "" then
entry = "Appendix:" .. name .. "/" .. entry
else
error("Language name is empty")
end
end
if entry and linkText then
return "[[wikt:" .. entry .. "#" .. name .. "|" .. linkText .. "]]"
else
error("linkToWiktionary needs a Wiktionary entry or link text, or both")
end
else
return "[[wikt:" .. entry .. "|" .. linkText .. "]]"
end
end
end
end


--[[--------------------------< M A I N >--------------------------------------------------------------------
function p.wiktlang(frame)

local parent = frame:getParent()
Entry point for {{Wikt-lang}}.
local args = parent.args[1] and parent.args or frame.args

Parameters are received from the template's frame (parent frame).
local codes = args[1] and mw.text.trim(args[1])

local word1 = ifNotEmpty(args[2])
* |1= – language code
local word2 = ifNotEmpty(args[3])
* |2= – Wiktionary page name
* |3= – display text
if not args[2] or '' == args[2] then
* |italic= – "no" to disable
return '<span style="color:#d33">[text?] Parameter 2 is required</span>';

]]
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
end

local error_msg = check_for_unknown_parameters(args)
local languageCode, scriptCode, errorText = getCodes(codes, word2 or word1)
if error_msg then
return error_msg
local italics = args.italics or args.i or args.italic
italics = not (italics == "n" or italics == "-" or italics == "no")
local entry, linkText
if word2 and word1 then
entry = makeEntryName(word1, languageCode)
linkText = word2
elseif word1 then
entry = makeEntryName(word1, languageCode)
linkText = word1
end
end

-- For the display text, use args[3] if supplied, if not, use the Wiktionary page name (args[2])
local out
args[2] = args[3] or args[2]
if languageCode and entry and linkText then

out = tag(linkToWiktionary(entry, linkText, languageCode), languageCode, scriptCode, italics)
-- To allow the errors to be associated with this template.
elseif entry and linkText then
args.template = cfg.template
out = linkToWiktionary(entry, linkText)
args.error_category = cfg.category
else

out = '<span style="font-size: smaller;">[text?]</span>'
-- Handle the display text html tag.
local lang = require("Module:Lang/sandbox")
local result = lang._wikt_lang(args)

-- An error returned, stop here.
if type(result) == "string" and string.find(result, "Error") then
return result
end
end

--TODO: Do we need the result to return with a <span title=""> tag?
if out and errorText then

return out .. errorText
local page_name, error_msg = get_clean_Wiktionary_page_name(args[2], result.code)
else
if error_msg then
return errorText or error("The function wiktlang generated nothing")
return error_msg
end
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
end


Retrieved from "https://en.wikipedia.org/wiki/Special:ComparePages"