ဝိၵ်ႇသျိၼ်ႇၼရီႇ

မေႃႇၵျူး:languages: လွင်ႈပႅၵ်ႇပိူင်ႈ ၼႂ်းၵႄႈ လွင်ႈၶူၼ်ႉၶႆႈ

Browse history interactively
ၵၢၼ်မႄးထတ်း ဢၼ်ၵဝ်ႇၵၢၼ်မႄးထတ်း ဢၼ်မႂ်ႇမႂ်ႇ
Content deleted Content added
Saimawnkham (ဢုပ်ႇဢူဝ်း) ၵေႃႉ ၶိုၼ်ၶိုၼ်း လွင်ႈၶူၼ်ႉၶႆႈ 92501
Tags: Undo Reverted
No edit summary
Tag: Reverted
ထႅဝ် 1:
local export = {}
 
--[=[ This function checks for things that could plausibly be a language code:
two or three lowercase letters, two or three groups of three lowercase
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)
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 function do_entry_name_or_sort_key_replacements(text, replacements)
Line 10 ⟶ 57:
if replacements.remove_diacritics then
if replacements.remove_exceptions then -- converts any exceptions into PUA characters, to avoid having characters stripped
for _,exception in ipairs(replacements.remove_exceptions) do
local substitute = {mw.ustring.codepoint(exception,1,mw.ustring.len(exception))}
for _,codepoint in ipairs(substitute) do codepoint = codepoint+0xF000 end
text = mw.ustring.gsub(text, exception, table.concat(substitute))
end
end
text = mw.ustring.toNFD(text)
text = mw.ustring.gsub(text,
Line 22 ⟶ 62:
'')
text = mw.ustring.toNFC(text)
if replacements.remove_exceptions then -- converts the exceptions back
for _,exception in ipairs(replacements.remove_exceptions) do
local substitute = {mw.ustring.codepoint(exception,1,mw.ustring.len(exception))}
for _,codepoint in ipairs(substitute) do codepoint = codepoint+0xF000 end
text = mw.ustring.gsub(text, table.concat(substitute), exception)
end
end
end
Line 43 ⟶ 76:
function Language:getCanonicalName()
return self._rawData[1] or self._rawData.canonicalName
end
 
 
function Language:getDisplayForm()
return self:getCanonicalName()
end
 
 
function Language:getOtherNames(onlyOtherNames)
if onlyOtherNames then
self:loadInExtraData()
return self._rawData.otherNames or {}
return require("Module:language-like").getOtherNames(self, onlyOtherNames)
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
if self._rawData.varieties then
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
end
return ret
end
 
 
function Language:getAliases()
return self._rawData.aliases or {}
self:loadInExtraData()
return self._extraData.aliases or {}
end
 
 
function Language:getVarieties(flatten)
if self._rawData.varieties then
self:loadInExtraData()
-- If flattening not requested, just return them.
return require("Module:language-like").getVarieties(self, flatten)
if not flatten then
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
 
Line 94 ⟶ 195:
return self._wikipedia_article
elseif self:getWikidataItem() and mw.wikibase then
self._wikipedia_article = mw.wikibase.sitelink(self:getWikidataItem(), '"shnwiki") or mw.wikibase.sitelink(self:getWikidataItem(), "enwiki'")
end
if not self._wikipedia_article then
Line 103 ⟶ 204:
 
function Language:makeWikipediaLink()
return "[[w:" .. self:getWikipediaArticle() .. "|" .. self:getCanonicalNamegetCategoryName() .. "]]"
end
 
function Language:getWikidataItem()
local item =return self._rawData[2] or self._rawData.wikidata_item
if type(item) == "number" then
return "Q" .. item
else
return item
end
end
 
Line 121 ⟶ 216:
self._scriptObjects = {}
for _, sc in ipairs(self:getScriptCodes()._rawData.scripts or { "None" }) do
table.insert(self._scriptObjects, m_scripts.getByCode(sc))
end
Line 130 ⟶ 225:
 
function Language:getScriptCodes()
return self._rawData.scripts or self._rawData[4] or { "None" }
end
 
Line 237 ⟶ 332:
 
 
function Language:makeEntryName(text, sc)
text = mw.ustring.match(text, "^[¿¡]?(.-[^%s%p].-)%s*[؟?!;՛՜ ՞ ՟？！︖︕।॥။၊་།]?$") or text
if self:getCode() == "ar" then
local entry_name_data = self._rawData.entry_name
local U = mw.ustring.char
if type(entry_name_data) == "table" then
local taTwiil = U(0x640)
text = do_entry_name_or_sort_key_replacements(text, entry_name_data)
local waSla = U(0x671)
elseif type(entry_name_data) == "string" then
-- diacritics ordinarily removed by entry_name replacements
text = require("Module:" .. entry_name_data).makeEntryName(text, self:getCode(), sc and sc:getCode())
local Arabic_diacritics = U(0x64B, 0x64C, 0x64D, 0x64E, 0x64F, 0x650, 0x651, 0x652, 0x670)
if text == waSla or mw.ustring.find(text, "^" .. taTwiil .. "?[" .. Arabic_diacritics .. "]" .. "$") then
return text
end
end
if type(self._rawData.entry_name) == "table" then
text = do_entry_name_or_sort_key_replacements(text, self._rawData.entry_name)
end
Line 251 ⟶ 355:
 
 
-- Add to data tables?
-- Return true if the language has display processing enabled, i.e. lang:makeDisplayText()
local has_dotted_undotted_i = {
-- does non-trivial processing.
["az"] = true,
function Language:hasDisplayProcessing()
["crh"] = true,
return not not self._rawData.display
["gag"] = true,
end
["kaa"] = true,
["tt"] = true,
["tr"] = true,
["zza"] = true,
}
 
function Language:makeSortKey(name, sc)
 
if has_dotted_undotted_i[self:getCode()] then
-- Apply display-text replacements to `text`, if any.
name = name:gsub("I", "ı")
function Language:makeDisplayText(text)
if type(self._rawData.display) == "table" then
text = do_entry_name_or_sort_key_replacements(text, self._rawData.display)
end
name = mw.ustring.lower(name)
return text
end
 
function Language:makeSortKey(name, sc)
-- Remove initial hyphens and *
local hyphens_regex = "^[-־ـ*]+(.)"
name = mw.ustring.gsub(name, hyphens_regex, "%1")
-- If there is aare language-specific sortkeyrules to generate the modulekey, use thatthose
if type(self._rawData.sort_key) == "stringtable" 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())
else
if self.dotted_dotless_i then
name = name:gsub("I", "ı")
end
name = mw.ustring.lower(name)
-- 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)
end
if self.dotted_dotless_i then
name = name:gsub("i", "İ")
end
name = mw.ustring.upper(name)
end
Line 298 ⟶ 388:
name = mw.ustring.gsub(name, "[()]+(.)", "%1")
if has_dotted_undotted_i[self:getCode()] then
return name
name = name:gsub("i", "İ")
end
return mw.ustring.upper(name)
end
 
Line 350 ⟶ 444:
ancestors = self._rawData.ancestors,
canonicalName = self:getCanonicalName(),
categoryName = self:getCategoryName("nocap"),
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 or self._rawData[4],
type = self:getType(),
wikimediaLanguages = self._rawData.wikimedia_codes,
Line 368 ⟶ 462:
 
 
-- Do NOT use thesethis methodsmethod!
-- All uses should be pre-approved on the talk page!
function Language:getRawData()
return self._rawData
end
 
function Language:getRawExtraData()
self:loadInExtraData()
return self._extraData
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
 
 
Line 412 ⟶ 487:
local function getRawLanguageData(code)
local modulename = export.getDataModuleName(code)
return modulename and mw.loadData("Moduleမေႃႇၵျူး:" .. modulename)[code] or nil
end
 
 
local function getRawExtraLanguageData(code)
local modulename = export.getExtraDataModuleName(code)
return modulename and mw.loadData("Module:" .. modulename)[code] or nil
end
 
 
function Language:loadInExtraData()
if not self._extraData then
-- load extra data from module and assign to meta table
-- use empty table as a fallback if extra data is nil
local meta = getmetatable(self)
meta._extraData = getRawExtraLanguageData(self._code) or {}
setmetatable(self, meta)
end
end
 
Line 458 ⟶ 516:
end
if not retval and paramForError then
local codetext = nil
require("Module:languages/errorGetBy").code(code, paramForError, allowEtymLang, allowFamily)
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
Line 470 ⟶ 542:
if not code then
if errorIfInvalid then
error("The language name \"" .. name .. "\" is not valid. See [[Wiktionary:List of languages]].")
else
return nil
Line 485 ⟶ 557:
local retval = code and export.makeObject(code, getRawLanguageData(code)) or nil
if not retval and allowEtymLang then
retval = require("Module:etymology languages").getByCanonicalName(namecode)
end
if not retval and allowFamily then
retval = require("Module:families").getByCanonicalName(code)
local famname = name:match("^(.*) languages$")
famname = famname or name
retval = require("Module:families").getByCanonicalName(famname)
end
if not retval and errorIfInvalid then
local text
require("Module:languages/errorGetBy").canonicalName(name, allowEtymLang, allowFamily)
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
 
Line 509 ⟶ 600:
return lang
end
 
-- for backwards compatibility only; modules should require the /error themselves
function export.err(lang_code, param, code_desc, template_tag, not_real_lang)
return require("Module:languages/error")(lang_code, param, code_desc, template_tag, not_real_lang)
end
 
ဢဝ်ၶိုၼ်းမႃးတီႈ "https://shn.wiktionary.org/wiki/မေႃႇၵျူး:languages"