Wiktionary

Module:languages៖ ភាពខុសគ្នារវាងកំណែនានា

មើលប្រវត្តិបានរហ័ស
← កំណែប្រែមុននេះកំណែប្រែបន្ទាប់ →
ខ្លឹមសារដែលបានលុបចោល ខ្លឹមសារដែលបានសរសេរបន្ថែម
No edit summary
No edit summary
បន្ទាត់ទី២៖
 
local Language = {}
 
 
function Language:getCode()
return self._code
end
 
 
function Language:getCanonicalName()
return self._rawData.names[1]
end
 
 
function Language:getAllNames()
return self._rawData.names
end
 
 
function Language:getOtherNames()
if not self._otherNames then
self._otherNames = {}
for i, val in ipairs(self._rawData.names) do
if i > 1 then
table.insert(self._otherNames, val)
end
end
end
return self._otherNames
end
 
 
function Language:getType()
Line ១៩ ⟶ ៣៨:
end
 
 
function Language:getScripts()
function Language:getWikimediaLanguages()
local m_scripts = require("Module:scripts")
if not self._wikimediaLanguageObjects then
local ret = {}
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
for _, sc in ipairs(self._rawData.scripts) do
end
table.insert(ret, m_scripts.getScriptByCode(sc))
 
 
function Language:getScripts()
if not self._scriptObjects then
local m_scripts = require("Module:scripts")
self._scriptObjects = {}
for _, sc in ipairs(self._rawData.scripts) do
table.insert(self._scriptObjects, m_scripts.getByCode(sc))
end
end
return retself._scriptObjects
end
 
 
function Language:getFamily()
if not self._familyObject then
local m_families = require("Module:families")
return self._familyObject = m_familiesrequire("Module:families").getFamilyByCodegetByCode(self._rawData.family)
end
return self._familyObject
end
 
 
function Language:getAncestors()
if not self._ancestorObjects then
self._ancestorObjects = {}
for _, ancestor in ipairs(self._rawData.ancestors or {}) do
table.insert(self._ancestorObjects, export.getByCode(ancestor))
end
end
return self._ancestorObjects
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
return self._ancestorChain
end
 
 
function Language:getCategoryName()
Line ៤២ ⟶ ១១២:
return name
else
return "ភាសា"name .. name" language"
end
end
 
 
function Language:makeEntryName(text)
Line ៥៩ ⟶ ១៣០:
return text
end
 
 
function Language:makeSortKey(name)
Line ៨១ ⟶ ១៥៣:
end
 
 
function Language:transliterate(text, sc)
function Language:transliterate(text, sc, module_override)
if not self._rawData.translit_module or not text then
if not ((module_override or self._rawData.translit_module) and text) then
return nil
end
if module_override then
return require("Module:" .. self._rawData.translit_module).tr(text, self:getCode(), sc)
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:toJSON()
local entryNamePatterns = nil
if self._rawData.entry_name 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
local ret = {
ancestors = self._rawData.ancestors,
canonicalName = self:getCanonicalName(),
categoryName = self:getCategoryName(),
code = self._code,
entryNamePatterns = entryNamePatterns,
family = self._rawData.family,
otherNames = self:getOtherNames(),
scripts = self._rawData.scripts,
type = self:getType(),
wikimediaLanguages = self._rawData.wikimedia_codes,
}
return require("Module:JSON").toJSON(ret)
end
 
 
-- Do NOT use this method!
Line ៩៧ ⟶ ២០៤:
Language.__index = Language
 
 
local function getRawLanguageData(code)
local function getDataModuleName(code)
local stable = mw.loadData("Module:languages/stable")[code]
if stable then
return stable
end
local len = string.len(code)
if code:find("^[a-z][a-z]$") then
return mw.loadData("Module:languages/data2")[code]
elseif code:find("^[a-z][a-z][a-z]$") then
local preprefix = code:sub(1, 1)
return mw.loadData("Module:languages/data3/" .. pre)[code]prefix
elseif code:find("^[a-z-]+$") then
return mw.loadData("Module:languages/datax")[code]
else
return nil
Line ១១៨ ⟶ ២១៨:
end
 
-- The object cache implements memoisation, and is used to avoid duplication
-- of objects. If you request the same language code twice, you should also get
-- the same object twice, not two different objects with identical data.
-- It might also speed things up a bit.
local object_cache = {}
 
local function export.getLanguageByCodegetRawLanguageData(code)
local stable = mw.loadData("Module:languages/stable")[code]
if object_cache[code] then
return object_cache[code]
if stable then
return stable
end
local rawDatamodulename = getRawLanguageDatagetDataModuleName(code)
return modulename and mw.loadData("Module:" .. modulename)[code] or nil
if rawData then
local object = setmetatable({ _rawData = rawData, _code = code }, Language)
object_cache[code] = object
return object
else
return nil
end
end
 
 
-- Lua implementation of [[Template:langrev]]
function export.makeObject(code, data)
-- We could optimise this by prioritising stable and data2 modules,
return data and setmetatable({ _rawData = data, _code = code }, Language) or nil
-- as they are more frequently used and thus more likely to contain what the user
-- is looking for.
function export.getLanguageByCanonicalName(name)
mw.incrementExpensiveFunctionCount()
local m_data = mw.loadData("Module:languages/alldata")
for code, data in pairs(m_data) do
if data.names[1] == name then
return export.getLanguageByCode(code)
end
end
return nil
end
 
 
function export.findLanguagesByName(name, inexact)
function export.getByCode(code)
mw.incrementExpensiveFunctionCount()
return export.makeObject(code, getRawLanguageData(code))
local m_data = mw.loadData("Module:languages/alldata")
end
local found = {}
 
 
function export.getByCanonicalName(name)
local code = mw.loadData("Module:languages/by name")[name]
if not code then
for code, data in pairs(m_data) do
return nil
for _, n in ipairs(data.names) do
if inexact and n:find(name, nil, true) or n == name then
table.insert(found, export.getLanguageByCode(code))
break
end
end
end
return export.makeObject(code, getRawLanguageData(code))
return found
end
 
 
function export.getAllLanguages()
function export.iterateAll()
mw.incrementExpensiveFunctionCount()
local m_data = mw.loadData("Module:languages/alldata")
local func, t, var = pairs(m_data)
return function()
local ret = {}
local code, data = func(t, var)
for return export.makeObject(code, data in pairs(m_data) do
-- This isn't the most efficient way to do it, but it works for now.
table.insert(ret, export.getLanguageByCode(code))
end
return ret
end
 
បានពី "https://km.wiktionary.org/wiki/Module:languages"