|
local export = {}
function export.head_t(frame)
--[=[ This function checks for things that could plausibly be a language code:
local function track(page)
two or three lowercase letters, two or three groups of three lowercase
require("Module:debug/track")("headword/templates/" .. page)
letters with hyphens between them. If such a pattern is not found,
return true
it is likely the editor simply forgot to enter a language code. ]=]
function export.err(langCode, param, text, template_tag)
local ordinals = {
"first", "second", "third", "fourth", "fifth", "sixth",
"seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth",
"thirteenth", "fourteenth", "fifteenth", "sixteenth", "seventeenth",
"eighteenth", "nineteenth", "twentieth"
}
text = text or "language code"
if not template_tag then
template_tag = ""
else
if type(template_tag) ~= "string" then
template_tag = template_tag()
end
template_tag = " (Original template: " .. template_tag .. ")"
end
local paramType = type(param)
if paramType == "number" then
ordinal = ordinals[param]
param = ordinal .. ' parameter'
elseif paramType == "string" then
param = 'parameter "' .. param .. '"'
else
error("The parameter name is "
.. (paramType == "table" and "a table" or tostring(param))
.. ", but it should be a number or a string." .. template_tag, 2)
end
-- Can use string.find because language codes only contain ASCII.
if not langCode or langCode == "" then
error("The " .. param .. " (" .. text .. ") is missing." .. template_tag, 2)
elseif langCode:find("^%l%l%l?$")
or langCode:find("^%l%l%l%-%l%l%l$")
or langCode:find("^%l%l%l%-%l%l%l%-%l%l%l$") then
error("The " .. text .. " \"" .. langCode .. "\" is not valid." .. template_tag, 2)
else
error("Please enter a " .. text .. " in the " .. param .. "." .. template_tag, 2)
end
end
local args = require("Module:parameters").process(frame:getParent().args, mw.loadData("Module:parameters/data")["headword/templates"].head_t, nil, "headword/templates", "head_t")
local function do_entry_name_or_sort_key_replacements(text, replacements)
if replacements.from then
for i, from in ipairs(replacements.from) do
local to = replacements.to[i] or ""
text = mw.ustring.gsub(text, from, to)
end
end
-- Get language and script information
if replacements.remove_diacritics then
local data = {}
text = mw.ustring.toNFD(text)
data.lang = require("Module:languages").getByCode(args[1]) or require("Module:languages").err(args[1], 1)
text = mw.ustring.gsub(text,
data.sort_key = args["sort"]
'[' .. replacements.remove_diacritics .. ']',
data.heads = args["head"]
'')
data.id = args["id"]
text = mw.ustring.toNFC(text)
data.translits = args["tr"]
end
data.transcriptions = args["ts"]
data.genders = args["g"]
return text
-- This shouldn't really happen.
end
for i=1,args["head"].maxindex do
if not args["head"][i] then
local Language = {}
track("head-with-holes")
function Language:getCode()
return self._code
end
function Language:getCanonicalName()
return self._rawData[1] or self._rawData.canonicalName
end
function Language:getOtherNames(onlyOtherNames)
if onlyOtherNames then
return self._rawData.otherNames or {}
end
-- Combine otherNames, aliases and varieties. First try to optimize and not create any
-- new memory. This is possible if exactly one of the three exist, and if it's `varieties`,
-- there are no nested lists in `varieties`.
if self._rawData.otherNames and not self._rawData.aliases and not self._rawData.varieties then
return self._rawData.otherNames
elseif self._rawData.aliases and not self._rawData.otherNames and not self._rawData.varieties then
return self._rawData.aliases
elseif self._rawData.varieties and not self._rawData.otherNames and not self._rawData.aliases then
local saw_table = false
for _, name in ipairs(self._rawData.varieties) do
if type(name) == "table" then
saw_table = true
break
end
end
if not saw_table then
return self._rawData.varieties
end
end
-- Have to do it the "hard way".
local ret = {}
if self._rawData.otherNames then
for _, name in ipairs(self._rawData.otherNames) do
table.insert(ret, name)
end
end
if self._rawData.aliases then
for _, name in ipairs(self._rawData.aliases) do
table.insert(ret, name)
end
end
for k, v in pairs(args["gqual"]) do
if self._rawData.varieties then
if k ~= "maxindex" then
for _, name in ipairs(self._rawData.varieties) do
if type(name) == "table"data.genders[k] then
data.genders[k] = {spec = data.genders[k], qualifiers = {v}}
for _, n in ipairs(name) do
table.insert(ret, n)
end
else
k = k == 1 and "" or tostring(k)
table.insert(ret, name)
error(("g%squal= specified without g%s="):format(k, k))
end
end
end
return ret
end
-- Script
data.sc = args["sc"] and require("Module:scripts").getByCode(args["sc"], "sc") or nil
data.sccat = args["sccat"]
-- Part-of-speech category
function Language:getAliases()
data.pos_category = args[2]
return self._rawData.aliases or {}
data.noposcat = args["noposcat"]
end
local headword_data = mw.loadData("Module:headword/data")
-- Check for headword aliases and then pluralize if the POS term does not have an invariable plural.
function Language:getVarieties(flatten)
data.pos_category = headword_data.pos_aliases[data.pos_category] or data.pos_category
if self._rawData.varieties then
if not data.pos_category:find("s$") and not headword_data.invariable[data.pos_category] then
-- If flattening not requested, just return them.
-- Make the plural form of the part of speech
if not flatten then
data.pos_category = data.pos_category:gsub("x$", "%0e") .. "s"
return self._rawData.varieties
end
-- Check if no nested table; if so, just return the result.
local saw_table = false
for _, name in ipairs(self._rawData.varieties) do
if type(name) == "table" then
saw_table = true
break
end
end
if not saw_table then
return self._rawData.varieties
end
-- At this point, we need to flatten the varieties.
local ret = {}
for _, name in ipairs(self._rawData.varieties) do
if type(name) == "table" then
for _, n in ipairs(name) do
table.insert(ret, n)
end
else
table.insert(ret, name)
end
end
return ret
else
return {}
end
end
function Language:getType()
return self._rawData.type or "regular"
end
function Language:getWikimediaLanguages()
if not self._wikimediaLanguageObjects then
local m_wikimedia_languages = require("Module:wikimedia languages")
self._wikimediaLanguageObjects = {}
local wikimedia_codes = self._rawData.wikimedia_codes or { self._code }
for _, wlangcode in ipairs(wikimedia_codes) do
table.insert(self._wikimediaLanguageObjects, m_wikimedia_languages.getByCode(wlangcode))
end
end
-- Additional categories.
return self._wikimediaLanguageObjects
data.categories = {}
end
data.whole_page_categories = {}
data.nomultiwordcat = args["nomultiwordcat"]
function Language:getWikipediaArticle()
data.nogendercat = args["nogendercat"]
if self._rawData.wikipedia_article then
data.nopalindromecat = args["nopalindromecat"]
return self._rawData.wikipedia_article
elseif self._wikipedia_article then
return self._wikipedia_article
elseif self:getWikidataItem() and mw.wikibase then
self._wikipedia_article = mw.wikibase.sitelink(self:getWikidataItem(), "mnwwiki") or mw.wikibase.sitelink(self:getWikidataItem(), "enwiki")
end
if not self._wikipedia_article then
self._wikipedia_article = mw.ustring.gsub(self:getCategoryName(), "Creole language", "Creole")
end
return self._wikipedia_article
end
function Language:makeWikipediaLink()
return "[[w:" .. self:getWikipediaArticle() .. "|" .. self:getCategoryName() .. "]]"
end
function Language:getWikidataItem()
return self._rawData[2] or self._rawData.wikidata_item
end
function Language:getScripts()
if not self._scriptObjects then
local m_scripts = require("Module:scripts")
self._scriptObjects = {}
for _, sc in ipairs(self._rawData.scripts or { "None" }) do
table.insert(self._scriptObjects, m_scripts.getByCode(sc))
end
end
if args["cat2"] then
return self._scriptObjects
table.insert(data.categories, data.lang:getCanonicalName() .. " " .. args["cat2"])
end
function Language:getScriptCodes()
return self._rawData.scripts or { "None" }
end
function Language:getFamily()
if self._familyObject then
return self._familyObject
end
local family = self._rawData[3] or self._rawData.family
if family then
self._familyObject = require("Module:families").getByCode(family)
end
if args["cat3"] then
return self._familyObject
table.insert(data.categories, data.lang:getCanonicalName() .. " " .. args["cat3"])
end
function Language:getAncestors()
if not self._ancestorObjects then
self._ancestorObjects = {}
if self._rawData.ancestors then
for _, ancestor in ipairs(self._rawData.ancestors) do
table.insert(self._ancestorObjects, export.getByCode(ancestor) or require("Module:etymology languages").getByCode(ancestor))
end
else
local fam = self:getFamily()
local protoLang = fam and fam:getProtoLanguage() or nil
-- For the case where the current language is the proto-language
-- of its family, we need to step up a level higher right from the start.
if protoLang and protoLang:getCode() == self:getCode() then
fam = fam:getFamily()
protoLang = fam and fam:getProtoLanguage() or nil
end
while not protoLang and not (not fam or fam:getCode() == "qfa-not") do
fam = fam:getFamily()
protoLang = fam and fam:getProtoLanguage() or nil
end
table.insert(self._ancestorObjects, protoLang)
end
end
if args["cat4"] then
return self._ancestorObjects
table.insert(data.categories, data.lang:getCanonicalName() .. " " .. args["cat4"])
end
local function iterateOverAncestorTree(node, func)
for _, ancestor in ipairs(node:getAncestors()) do
if ancestor then
local ret = func(ancestor) or iterateOverAncestorTree(ancestor, func)
if ret then
return ret
end
end
end
end
function Language:getAncestorChain()
if not self._ancestorChain then
self._ancestorChain = {}
local step = #self:getAncestors() == 1 and self:getAncestors()[1] or nil
while step do
table.insert(self._ancestorChain, 1, step)
step = #step:getAncestors() == 1 and step:getAncestors()[1] or nil
end
end
-- Inflected forms
return self._ancestorChain
data.inflections = {enable_auto_translit = args["autotrinfl"]}
end
function Language:hasAncestor(otherlang)
local function compare(ancestor)
return ancestor:getCode() == otherlang:getCode()
end
for i = 1, math.ceil(args[3].maxindex / 2) do
return iterateOverAncestorTree(self, compare) or false
local infl_part = {
end
label = args[3][i * 2 - 1],
accel = args["faccel-form"][i] and {
form = args["faccel-form"][i],
function Language:getCategoryName()
translit = args["faccel-translit"][i],
local name = self:getCanonicalName()
lemma = args["faccel-lemma"][i],
lemma_translit = args["faccel-lemma-translit"][i],
-- နွံဝေါဟာအရေဝ် " " လ္ပဒးဆက်ချူ, ဟွံသေင်မ္ဂး " " ကဵုတုဲအာ
gender = args["faccel-gender"][i],
if name:find("^ ") or name == " " then
nostore = args["faccel-nostore"][i],
return name
} or nil,
else
request = args["frequest"][i],
return " " .. name
enable_auto_translit = args["fautotr"][i],
end
}
end
function Language:makeCategoryLink()
return "[[:ကဏ္ဍ:" .. self:getCategoryName() .. "|" .. self:getCanonicalName() .. "]]"
end
function Language:getStandardCharacters()
return self._rawData.standardChars
end
function Language:makeEntryName(text)
text = mw.ustring.match(text, "^[¿¡]?(.-[^%s%p].-)%s*[؟?!;՛՜ ՞ ՟？！︖︕।॥။၊་།]?$") or text
if self:getCode() == "ar" then
local U = mw.ustring.char
local taTwiil = U(0x640)
local waSla = U(0x671)
-- diacritics ordinarily removed by entry_name replacements
local Arabic_diacritics = U(0x64B, 0x64C, 0x64D, 0x64E, 0x64F, 0x650, 0x651, 0x652, 0x670)
local form = {
if text == waSla or mw.ustring.find(text, "^" .. taTwiil .. "?[" .. Arabic_diacritics .. "]" .. "$") then
term = args[3][i * 2],
return text
alt = args["falt"][i],
end
genders = args["fg"][i] and mw.text.split(args["fg"][i], ",") or {},
end
id = args["fid"][i],
lang = args["flang"][i],
if type(self._rawData.entry_name) == "table" then
nolink = args["fnolink"][i],
text = do_entry_name_or_sort_key_replacements(text, self._rawData.entry_name)
q = {args["fqual"][i]},
end
sc = args["fsc"][i],
translit = args["ftr"][i],
return text
transcription = args["fts"][i],
end
-- Add to data tables?
local has_dotted_undotted_i = {
["az"] = true,
["crh"] = true,
["gag"] = true,
["kaa"] = true,
["tt"] = true,
["tr"] = true,
["zza"] = true,
}
function Language:makeSortKey(name, sc)
if has_dotted_undotted_i[self:getCode()] then
name = name:gsub("I", "ı")
end
name = mw.ustring.lower(name)
-- Remove initial hyphens and *
local hyphens_regex = "^[-־ـ*]+(.)"
name = mw.ustring.gsub(name, hyphens_regex, "%1")
-- If there are language-specific rules to generate the key, use those
if type(self._rawData.sort_key) == "table" then
name = do_entry_name_or_sort_key_replacements(name, self._rawData.sort_key)
elseif type(self._rawData.sort_key) == "string" then
name = require("Module:" .. self._rawData.sort_key).makeSortKey(name, self:getCode(), sc and sc:getCode())
end
-- Remove parentheses, as long as they are either preceded or followed by something
name = mw.ustring.gsub(name, "(.)[()]+", "%1")
name = mw.ustring.gsub(name, "[()]+(.)", "%1")
if has_dotted_undotted_i[self:getCode()] then
name = name:gsub("i", "İ")
end
return mw.ustring.upper(name)
end
function Language:overrideManualTranslit()
if self._rawData.override_translit then
return true
else
return false
end
end
function Language:transliterate(text, sc, module_override)
if not ((module_override or self._rawData.translit_module) and text) then
return nil
end
if module_override then
require("Module:debug").track("module_override")
end
return require("Module:" .. (module_override or self._rawData.translit_module)).tr(text, self:getCode(), sc and sc:getCode() or nil)
end
function Language:hasTranslit()
return self._rawData.translit_module and true or false
end
function Language:link_tr()
return self._rawData.link_tr and true or false
end
function Language:toJSON()
local entryNamePatterns = nil
local entryNameRemoveDiacritics = nil
if self._rawData.entry_name then
entryNameRemoveDiacritics = self._rawData.entry_name.remove_diacritics
if self._rawData.entry_name.from then
entryNamePatterns = {}
for i, from in ipairs(self._rawData.entry_name.from) do
local to = self._rawData.entry_name.to[i] or ""
table.insert(entryNamePatterns, { from = from, to = to })
end
end
end
local ret = {
ancestors = self._rawData.ancestors,
canonicalName = self:getCanonicalName(),
categoryName = self:getCategoryName(),
code = self._code,
entryNamePatterns = entryNamePatterns,
entryNameRemoveDiacritics = entryNameRemoveDiacritics,
family = self._rawData[3] or self._rawData.family,
otherNames = self:getOtherNames(),
aliases = self:getAliases(),
varieties = self:getVarieties(),
scripts = self._rawData.scripts,
type = self:getType(),
wikimediaLanguages = self._rawData.wikimedia_codes,
wikidataItem = self:getWikidataItem(),
}
return require("Module:JSON").toJSON(ret)
end
-- Do NOT use this method!
-- All uses should be pre-approved on the talk page!
function Language:getRawData()
return self._rawData
end
Language.__index = Language
function export.getDataModuleName(code)
if code:find("^%l%l$") then
return "languages/data/2"
elseif code:find("^%l%l%l$") then
local prefix = code:sub(1, 1)
return "languages/data/3/" .. prefix
elseif code:find("^[%l-]+$") then
return "languages/data/exceptional"
else
return nil
end
end
local function getRawLanguageData(code)
local modulename = export.getDataModuleName(code)
return modulename and mw.loadData("မဝ်ဂျူ:" .. modulename)[code] or nil
end
function export.makeObject(code, data)
if data and data.deprecated then
require("Module:debug").track {
"languages/deprecated",
"languages/deprecated/" .. code
}
end
if form.lang then
form.lang = require("Module:languages").getByCode(form.lang) or require("Module:languages").err(form.lang, "f" .. i .. "lang")
return data and setmetatable({ _rawData = data, _code = code }, Language) or nil
end
function export.getByCode(code, paramForError, allowEtymLang, allowFamily)
if type(code) ~= "string" then
error("The function getByCode expects a string as its first argument, but received " .. (code == nil and "nil" or "a " .. type(code)) .. ".")
end
local retval = export.makeObject(code, getRawLanguageData(code))
if not retval and allowEtymLang then
retval = require("Module:etymology languages").getByCode(code)
end
if not retval and allowFamily then
retval = require("Module:families").getByCode(code)
end
if not retval and paramForError then
local codetext = nil
if allowEtymLang and allowFamily then
codetext = "language, etymology language or family code"
elseif allowEtymLang then
codetext = "language or etymology language code"
elseif allowFamily then
codetext = "language or family code"
else
codetext = "language code"
end
if paramForError == true then
if form.sc then
error("The " .. codetext .. " \"" .. code .. "\" is not valid.")
form.sc = require("Module:scripts").getByCode(form.sc) or error("The script code \"" .. form.sc .. "\" is not valid.")
else
export.err(code, paramForError, codetext)
end
end
-- If no term or alt is given, then the label is shown alone.
return retval
if form.term or form.alt then
end
table.insert(infl_part, form)
function export.getByName(name, errorIfInvalid)
local byName = mw.loadData("Module:languages/by name")
local code = byName.all and byName.all[name] or byName[name]
if not code then
if errorIfInvalid then
error("The language name \"" .. name .. "\" is not valid.")
else
return nil
end
end
if infl_part.label == "or" then
-- Append to the previous inflection part, if one exists
return export.makeObject(code, getRawLanguageData(code))
if #infl_part > 0 and data.inflections[1] then
end
table.insert(data.inflections[#data.inflections], form)
end
function export.getByCanonicalName(name, errorIfInvalid, allowEtymLang, allowFamily)
elseif infl_part.label then
local byName = mw.loadData("Module:languages/canonical names")
-- Add a new inflection part
local code = byName and byName[name]
table.insert(data.inflections, infl_part)
local retval = code and export.makeObject(code, getRawLanguageData(code)) or nil
if not retval and allowEtymLang then
retval = require("Module:etymology languages").getByCanonicalName(code)
end
if not retval and allowFamily then
retval = require("Module:families").getByCanonicalName(code)
end
if not retval and errorIfInvalid then
local text
if allowEtymLang and allowFamily then
text = "language, etymology language or family name"
elseif allowEtymLang then
text = "language or etymology language name"
elseif allowFamily then
text = "language or family name"
else
text = "language name"
end
error("The " .. text .. " \"" .. name .. "\" is not valid.")
end
return retval
end
function export.iterateAll()
mw.incrementExpensiveFunctionCount()
local m_data = mw.loadData("Module:languages/data/all")
local func, t, var = pairs(m_data)
return function()
local code, data = func(t, var)
return export.makeObject(code, data)
end
end
--[[ If language is an etymology language, iterates through parent languages
until it finds a non-etymology language. ]]
function export.getNonEtymological(lang)
while lang:getType() == "etymology language" do
local parentCode = lang:getParentCode()
lang = export.getByCode(parentCode)
or require("Module:etymology languages").getByCode(parentCode)
or require("Module:families").getByCode(parentCode)
end
return require("Module:headword").full_headword(data)
return lang
end
| 