Wikibooks

"Module:Languages/templates" හි සංශෝධන අතර වෙනස්කම්

Browse history interactively
Content deleted Content added
වික්ෂනරියෙන්!
 
වික්ෂනරියෙන්!
 
1 පේළිය:
local export = {}
 
function export.exists(frame)
--[=[ This function checks for things that could plausibly be a language code:
local args = frame.args
two or three lowercase letters, two or three groups of three lowercase
local lang = args[1] or error("Language code has not been specified. Please pass parameter 1 to the module invocation.")
letters with hyphens between them. If such a pattern is not found,
it is likely the editor simply forgot to enter a language code. ]=]
 
function export.err(langCode, param, text, template_tag, not_real_lang)
local ordinals = {
"first", "second", "third", "fourth", "fifth", "sixth",
"seventh", "eighth", "ninth", "tenth", "eleventh", "twelfth",
"thirteenth", "fourteenth", "fifteenth", "sixteenth", "seventeenth",
"eighteenth", "nineteenth", "twentieth"
}
lang = require("Module:languages").getByCode(lang)
text = text or "language code"
if not template_taglang then
template_tag =return "1"
else
return ""
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 not_real_lang or 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 .. ". The value \"" .. langCode .. "\" is not valid." .. template_tag, 2)
end
end
 
-- Used by the following JS:
local function do_entry_name_or_sort_key_replacements(text, replacements)
-- * [[WT:ACCEL]]
if replacements.from then
-- * [[WT:EDIT]]
for i, from in ipairs(replacements.from) do
-- * [[WT:NEC]]
local to = replacements.to[i] or ""
function export.getByCode(frame)
text = mw.ustring.gsub(text, from, to)
local args = frame.args
end
local langcode = args[1] or error("Language code has not been specified. Please pass parameter 1 to the module invocation.")
end
local itemname = args[2] or error("Type of information to look up has not been specified. Please pass parameter 2 to the module invocation.")
local lang = require("Module:languages").getByCode(langcode)
if replacements.remove_diacritics then
text = mw.ustring.toNFD(text)
text = mw.ustring.gsub(text,
'[' .. replacements.remove_diacritics .. ']',
'')
text = mw.ustring.toNFC(text)
end
if not lang then
return text
error("The language code '" .. langcode .. "' is not valid.")
end
 
local Language = {}
 
function Language:getCode()
return self._code
end
 
 
function Language:getCanonicalName()
return self._rawData[1] or self._rawData.canonicalName
end
 
 
function Language:getDisplayForm()
return self:getCanonicalName()
end
 
 
function Language:getOtherNames(onlyOtherNames)
return require("Module:language-like").getOtherNames(self, onlyOtherNames)
end
 
 
function Language:getAliases()
return self._rawData.aliases or {}
end
 
 
function Language:getVarieties(flatten)
return require("Module:language-like").getVarieties(self, flatten)
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
return self._wikimediaLanguageObjects
end
 
function Language:getWikipediaArticle()
if self._rawData.wikipedia_article then
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(), '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:getCanonicalName() .. "]]"
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
-- The item that the caller wanted to look up
return self._scriptObjects
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 itemname == "getOtherNames" then
return self._familyObject
local index = args[3]; if index == "" then index = nil end
end
index = tonumber(index) or error("Please specify the numeric index of the desired name.")
 
return lang:getOtherNames()[index] or ""
 
elseif itemname == "getFamily" then
function Language:getAncestors()
return lang:getFamily():getCode()
if not self._ancestorObjects then
elseif itemname == "getWikimediaLanguages" then
self._ancestorObjects = {}
local index = args[3]; if index == "" then index = nil end
index = tonumber(index) or error("Please specify the numeric index of the desired language.")
local langs = lang:getWikimediaLanguages()
if self._rawData.ancestorslangs[index] then
return langs[index]:getCode()
for _, ancestor in ipairs(self._rawData.ancestors) do
table.insert(self._ancestorObjects, export.getByCode(ancestor) or require("Module:etymology languages").getByCode(ancestor))
end
else
return ""
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
elseif itemname == "getScripts" then
end
local index = args[3]; if index == "" then index = nil end
index = tonumber(index) or error("Please specify the numeric index of the desired script.")
return self._ancestorObjects
local scripts = lang:getScriptCodes()
end
 
if scripts[index] then
local function iterateOverAncestorTree(node, func)
return scripts[index]
for _, ancestor in ipairs(node:getAncestors()) do
else
if ancestor then
return ""
local ret = func(ancestor) or iterateOverAncestorTree(ancestor, func)
if ret then
return ret
end
end
elseif itemname == "getAncestors" then
end
local index = args[3]; if index == "" then index = nil end
end
index = tonumber(index) or error("Please specify the numeric index of the desired ancestor.")
 
local ancestors = lang:getAncestors()
function Language:getAncestorChain()
if not self._ancestorChain then
self._ancestorChain = {}
local step = #self:getAncestors() == 1 and self:getAncestors()[1] or nil
if ancestors[index] then
while step do
return ancestors[index]:getCode()
table.insert(self._ancestorChain, 1, step)
else
step = #step:getAncestors() == 1 and step:getAncestors()[1] or nil
return ""
end
elseif itemname == "transliterate" then
end
local text = args[3]; if text == "" then text = nil end
local sc = args[4]; if sc == "" then sc = nil end
return self._ancestorChain
local module_override = args[5]; if module_override == "" then module_override = nil end
end
sc = (sc and (require("Module:scripts").getByCode(sc) or error("The script code \"" .. sc .. "\" is not valid.")) or nil)
 
return lang:transliterate(text, sc, module_override) or ""
 
elseif itemname == "makeEntryName" then
function Language:hasAncestor(otherlang)
local text = args[3]; if text == "" then text = nil end
local function compare(ancestor)
return ancestorlang:getCodemakeEntryName(text) ==or otherlang:getCode()""
elseif itemname == "makeSortKey" then
end
local text = args[3]; if text == "" then text = nil end
return iterateOverAncestorTreelang:makeSortKey(self, comparetext) or false""
elseif lang[itemname] then
end
local ret = lang[itemname](lang)
 
 
function Language:getCategoryName()
local name = self:getCanonicalName()
-- If the name already has "language" in it, don't add it.
if name:find("[Ll]anguage$") then
return name
else
return name .. " language"
end
end
 
 
function Language:makeCategoryLink()
return "[[:Category:" .. 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)
if type(ret) == "string" then
if text == waSla or mw.ustring.find(text, "^" .. taTwiil .. "?[" .. Arabic_diacritics .. "]" .. "$") then
return textret
else
error("The function \"" .. itemname .. "\" did not return a string value.")
end
else
error("Requested invalid item name \"" .. itemname .. "\".")
end
if type(self._rawData.entry_name) == "table" then
text = do_entry_name_or_sort_key_replacements(text, self._rawData.entry_name)
end
return text
end
 
function export.getByCanonicalName(frame)
 
local args = frame.args
-- Add to data tables?
local langname = args[1] or error("Language name has not been specified. Please pass parameter 1 to the module invocation.")
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
local lang = require("Module:languages").getByCanonicalName(langname)
name = mw.ustring.lower(name)
if lang then
-- Remove initial hyphens and *
return lang:getCode()
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 export.getByName(frame)
 
local args = frame.args
function Language:transliterate(text, sc, module_override)
local langname = args[1] or error("Language name has not been specified. Please pass parameter 1 to the module invocation.")
if not ((module_override or self._rawData.translit_module) and text) then
return nil
end
local lang = require("Module:languages").getByName(langname)
if module_override then
require("Module:debug").track("module_override")
end
if lang then
return require("Module:" .. (module_override or self._rawData.translit_module)).tr(text, self:getCode(), sc and sc:getCode() or nil)
return lang:getCode()
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(true),
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/data2"
elseif code:find("^%l%l%l$") then
local prefix = code:sub(1, 1)
return "languages/data3/" .. prefix
elseif code:find("^[%l-]+$") then
return "languages/datax"
else
return nil""
end
end
 
function export.makeEntryName(frame)
 
local args = frame.args
local function getRawLanguageData(code)
local langname = args[1] or error("Language name has not been specified. Please pass parameter 1 to the module invocation.")
local modulename = export.getDataModuleName(code)
return modulename and mw.loadData("Module:" .. 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
local lang = require("Module:languages").getByCode(langname)
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
if lang then
local retval = export.makeObject(code, getRawLanguageData(code))
return lang:makeEntryName(args[2])
if not retval and allowEtymLang then
else
retval = require("Module:etymology languages").getByCode(code)
return ""
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
error("The " .. codetext .. " \"" .. code .. "\" is not valid.")
else
export.err(code, paramForError, codetext)
end
end
return retval
end
 
function export.getCanonicalName(frame)
 
local langCode
function export.getByName(name, errorIfInvalid)
if require("Module:yesno")(frame.args.parent) then
local byName = mw.loadData("Module:languages/by name")
langCode = frame:getParent().args[1]
local code = byName.all and byName.all[name] or byName[name]
else
langCode = frame.args[1]
if not code then
if errorIfInvalid then
error("The language name \"" .. name .. "\" is not valid.")
else
return nil
end
end
if not langCode or langCode == "" then
return export.makeObject(code, getRawLanguageData(code))
error("Supply a language code in parameter 1.")
end
 
function export.getByCanonicalName(name, errorIfInvalid, allowEtymLang, allowFamily)
local byName = mw.loadData("Module:languages/canonical names")
local code = byName and byName[name]
 
local retval = code and export.makeObject(code, getRawLanguageData(code)) or nil
if not retval and allowEtymLang then
retval = require("Module:etymology languages").getByCanonicalName(name)
end
if not retval and allowFamily then
local famname = name:match("^(.*) languages$")
famname = famname or name
retval = require("Module:families").getByCanonicalName(famname)
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/alldata")
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 mw.loadData("Module:languages/code to canonical_name")[langCode] or ""
return lang
end
 
"https://si.wikibooks.org/wiki/Module:Languages/templates" වෙතින් සම්ප්‍රවේශනය කෙරිණි