Linguifex

Module:etymology languages: Difference between revisions

Module Discussion

Module:etymology languages (view source)

Revision as of 17:31, 19 October 2025

25 bytes removed ,  19 October
no edit summary
(Created page with "local export = {} local EtymologyLanguage = {} function EtymologyLanguage:getCode() return self._code end function EtymologyLanguage:getCanonicalName() return self._raw...")
 
No edit summary
 
Line 1: Line 1:
local export = {}
local export = {}


local EtymologyLanguage = {}
function export.makeObject(code)
local data = mw.loadData("Module:etymology languages/data")[code]
code = data and data.main_code or code


 
if not data then
function EtymologyLanguage:getCode()
return nil
return self._code
end
 
 
function EtymologyLanguage:getCanonicalName()
return self._rawData.canonicalName
end
 
 
function EtymologyLanguage:getDisplayForm()
return self:getCanonicalName()
end
 
 
function EtymologyLanguage:getOtherNames(onlyOtherNames)
return require("Module:language-like").getOtherNames(self, onlyOtherNames)
end
 
 
function EtymologyLanguage:getAliases()
return self._rawData.aliases or {}
end
 
 
function EtymologyLanguage:getVarieties(flatten)
return require("Module:language-like").getVarieties(self, flatten)
end
 
 
--function EtymologyLanguage:getAllNames()
-- return self._rawData.names
--end
 
 
function EtymologyLanguage:getCategoryName(nocap)
local name = self:getCanonicalName()
if not nocap then
name = mw.getContentLanguage():ucfirst(name)
end
end
return name
end
function EtymologyLanguage:makeCategoryLink()
return "[[:Category:" .. self:getCategoryName() .. "|" .. self:getDisplayForm() .. "]]"
end
function EtymologyLanguage:getType()
return "etymology language"
end


local EtymologyLanguage = require("Module:languages").getByCode(data.parent, nil, true, true)


function EtymologyLanguage:getParentCode()
local familyCode
return self._rawData.parent
if EtymologyLanguage:hasType("family") then
end
-- Substrates are treated as child languages of "undetermined".
 
if EtymologyLanguage:getCode() == "qfa-sub" then
 
EtymologyLanguage = require("Module:languages").getByCode("und")
function EtymologyLanguage:getAncestors()
if not self._ancestorObjects then
self._ancestorObjects = {}
for _, ancestor in ipairs(self._rawData.ancestors or {}) do
table.insert(self._ancestorObjects, export.getByCode(ancestor) or require("Module:languages").getByCode(ancestor))
end
end
-- True etymology-only families (e.g. "ira-old") still need to grab the family code.
familyCode = data.parent
end
end
-- Delete cached _type table to prevent the new object's hasType method from finding it via the metatable, as it only includes the parent's types.
return self._ancestorObjects
EtymologyLanguage._type = nil
end


function EtymologyLanguage:getWikidataItem()
if not EtymologyLanguage then
local item = self._rawData.wikidata_item
return nil
if type(item) == "number" then
return "Q" .. item
else
return item
end
end
end


function EtymologyLanguage:getWikipediaArticle()
EtymologyLanguage.__index = EtymologyLanguage
return self._rawData.wikipedia_article or
(self:getWikidataItem() and mw.wikibase and
    mw.wikibase.sitelink(self:getWikidataItem(), 'enwiki')) or
    self._rawData.canonicalName
end


function EtymologyLanguage:makeWikipediaLink()
local lang = {_code = code}
return "[[w:" .. self:getWikipediaArticle() .. "|" .. self:getCanonicalName() .. "]]"
end


-- Parent is full language.
if not EtymologyLanguage._stack then
-- Create stack, accessed with rawData metamethod.
lang._stack = {EtymologyLanguage._rawData, data}
lang._rawData = setmetatable({}, {
__index = function(t, k)
-- Data that isn't inherited from the parent.
local noInherit = {aliases = true, varieties = true, otherNames = true, main_code = true}
if noInherit[k] then
return lang._stack[#lang._stack][k]
end
-- Data that is appended by each generation.
local append = {type = true}
if append[k] then
local parts = {}
for i = 1, #lang._stack do
table.insert(parts, lang._stack[i][k])
end
if type(parts[1]) == "string" then
return table.concat(parts, ", ")
end
-- Otherwise, iterate down the stack, looking for a match.
else
local i = #lang._stack
while not lang._stack[i][k] and i > 1 do
i = i - 1
end
return lang._stack[i][k]
end
end,
-- Retain immutability (as writing to rawData will break functionality).
__newindex = function()
error("table from mw.loadData is read-only")
end
})
-- Non-etymological code is the parent code.
lang._fullCode = EtymologyLanguage._code
-- Parent is etymology language.
else
-- Copy over rawData and stack to the new object, and add new layer to stack.
lang._rawData = EtymologyLanguage._rawData
lang._stack = EtymologyLanguage._stack
table.insert(lang._stack, data)
-- Copy non-etymological code.
lang._fullCode = EtymologyLanguage._fullCode
end


function EtymologyLanguage:toJSON()
lang._familyCode = familyCode
local ret = {
canonicalName = self:getCanonicalName(),
categoryName = self:getCategoryName("nocap"),
code = self._code,
otherNames = self:getOtherNames(true),
aliases = self:getAliases(),
varieties = self:getVarieties(),
parent = self._rawData.parent,
type = self:getType(),
}
return require("Module:JSON").toJSON(ret)
end
 


function EtymologyLanguage:getRawData()
return setmetatable(lang, EtymologyLanguage)
return self._rawData
end
end
EtymologyLanguage.__index = EtymologyLanguage
function export.makeObject(code, data)
return data and setmetatable({ _rawData = data, _code = code }, EtymologyLanguage) or nil
end


function export.getByCode(code)
function export.getByCode(code)
return export.makeObject(code, mw.loadData("Module:etymology languages/data")[code])
return export.makeObject(code)
end
end


function export.getByCanonicalName(name)
local byName = mw.loadData("Module:etymology languages/canonical names")
local code = byName and byName[name] or
byName[name:gsub(" [Ss]ubstrate$", "")] or
byName[name:gsub("^a ", "")] or
byName[name:gsub("^a ", ""):gsub(" [Ss]ubstrate$", "")]


function export.getByCanonicalName(name)
local code = mw.loadData("Module:etymology languages/by name")[name]
if not code then
if not code then
return nil
return nil
end
end
 
return export.makeObject(code, mw.loadData("Module:etymology languages/data")[code])
return export.makeObject(code)
end
end


return export
return export
Retrieved from "https://linguifex.com/wiki/Special:MobileDiff/473987"