Module:languages: Difference between revisions

This module implements fetching of language-specific information and processing text in a given language.

There are two types of languages: full languages and etymology-only languages. The essential difference is that only

their parent (in the parent-child inheritance sense), and for etymology-only languages with another etymology-only

language as their parent, a full language can always be derived by following the parent links upwards. For example,

An example of an etymology-only language with another etymology-only parent is "Northumbrian Old English", code

It is important to distinguish language ''parents'' from language ''ancestors''. The parent-child relationship is one

of containment, i.e. if X is a child of Y, X is considered a variety of Y. On the other hand, the ancestor-descendant

of Latin. However, Late Latin does *NOT* have Classical Latin as its parent because Late Latin is *not* a variety of

ancestor-descendant relationship, and Late Latin's ancestor is given as Classical Latin. It is also important to note

that sometimes an etymology-only language is actually the conceptual ancestor of its parent language. This happens,

language has the etymology-only variant listed as an ancestor. This allows a Latin term to inherit from Old Latin

using the {{tl|inh}} template (where in this template, "inheritance" refers to ancestral inheritance, i.e. inheritance

functions in [[Module:languages]] and [[Module:etymology languages]] to convert a language's canonical name to a

{Language} object (depending on whether the canonical name refers to a full or etymology-only language).

Textual strings belonging to a given language come in several different ''text variants'':

# The ''input text'' is what the user supplies in wikitext, in the parameters to {{tl|m}}, {{tl|l}}, {{tl|ux}},

# The ''transcribed text'' (or ''transcription'') is the result of transcribing the source translit text, where

# The ''sort key'' is the text used in sort keys for determining the placing of pages in categories they belong to. The

# There are other text variants that occur in usexes (specifically, there are normalized variants of several of the

The following methods exist on {Language} objects to convert between different text variants:

local export = {}

local families_module = "Module:families"

local json_module = "Module:JSON"

local language_like_module = "Module:language-like"

local load_module = "Module:load"

local scripts_module = "Module:scripts"

local string_encode_entities_module = "Module:string/encode entities"

local string_utilities_module = "Module:string utilities"

local table_module = "Module:table"

local insert = table.insert

local ipairs = ipairs

local make_object -- Defined below.

local match = string.match

local select = select

local setmetatable = setmetatable

local type = type

local unstrip = mw.text.unstrip

local Hant_chars

end

end

local function doTempSubstitutions(text, subbedChars, keepCarets, noTrim)

-- Clone so that we don't insert any extra patterns into the table in package.loaded. For some reason, using require seems to keep memory use down; probably because the table is always cloned.

if keepCarets then

insert(patterns, "((\\+)%^)")

end

-- Pre-substitution, of "[[" and "]]", which makes pattern matching more accurate.

local i = #subbedChars

for _, pattern in ipairs(patterns) do

end)

end

return text, subbedChars

end

local byte3 = floor(i / 64) % 64 + 128

local byte4 = i % 64 + 128

end

return text

end

local function checkNoEntities(self, text)

local textNoEnc = decode_entities(text)

return text

else

if not check_object("script", true, sc) or sc:getCode() == "None" then

return self:findBestScript(text)

end

end

end

-- If there are language-specific substitutes given in the data module, use those.

if type(substitution_data) == "table" then

-- If a script is specified, run this function with the script-specific data before continuing.

local sc_code = sc:getCode()

-- Substitution data with key 1 in the outer table may be given as a fallback.

end

if substitution_data.from then

for i, from in ipairs(substitution_data.from) do

-- Normalize each loop, to ensure multi-stage substitutions work correctly.

if substitution_data.remove_diacritics then

text = sc:toFixedNFD(text)

-- Convert exceptions to PUA.

text = text:gsub("\242[\128-\191]*", substitutes)

end

end

elseif type(substitution_data) == "string" then

local module = safe_require("Module:" .. substitution_data)

if module then

if function_name == "tr" then

else

end

else

error("Substitution data '" .. substitution_data .. "' does not match an existing module.")

end

end

-- Don't normalize to NFC if this is the inner loop or if a module returned nil.

if recursed or not text then

end

-- Fix any discouraged sequences created during the substitution process, and normalize into the final form.

end

-- See [[Module:languages/data]].

sections = {text}

else

sections = split(text, "\244[\128-\143][\128-\191]*", true)

end

for _, section in ipairs(sections) do

if gsub(section, "%s+", "") ~= "" then

if sub and subbedChars then

local noSub

if match(section, pattern .. "%z?") then

noSub = true

end

end

text = sub

break

end

text = sub and gsub(text, pattern_escape(section), replacement_escape(sub), 1) or text

end

end

end

text, rep = gsub(text, "\\\\(\\*^)", "\3%1")

until rep == 0

:gsub(pattern or "%^", repl or "")

:gsub("\3", "\\")

end

-- Add article and " substrate" to substrates that lack them.

if self:getFamilyCode() == "qfa-sub" then

form = "a " .. form

end

form = form .. " substrate"

end

Language.hasType = require(language_like_module).hasType

return self:hasType(...)

end

if wm_langs == nil then

wm_langs = self._data.wikimedia_codes

self._wikimediaLanguageCodes = wm_langs

end

function Language:makeWikipediaLink()

end

Language.getCommonsCategory = require(language_like_module).getCommonsCategory

return self:getCommonsCategory()

end

local codes = self:getScriptCodes()

if codes[1] == "All" then

else

scripts = {}

first_sc = get_script(first_sc)

local charset = first_sc.characters

end

local t, s, found = 0, 0

-- This is faster than using mw.ustring.gmatch directly.

found = true

if Hant_chars[ch] then

-- Count characters by removing everything in the script's charset and comparing to the original length.

local charset = sc.characters

if count >= length then

end

if type(family) == "table" then

family = family:getCode()

end

return true

end

return true

-- If the family isn't a real family (e.g. creoles) check any ancestors.

local ancestors = self:getAncestors()

for _, ancestor in ipairs(ancestors) do

end

end

end

end

for _, parent in ipairs(self:getParentChain()) do

return true

end

end

end

end

--[==[Given a list of language objects or codes, returns true if at least one of them is an ancestor. This includes any etymology-only children of that ancestor. If the language's ancestor(s) are etymology-only languages, it will also return true for those language parent(s) (e.g. if Vulgar Latin is the ancestor, it will also return true for its parent, Latin). However, a parent is excluded from this if the ancestor is also ancestral to that parent (e.g. if Classical Persian is the ancestor, Persian would return false, because Classical Persian is also ancestral to Persian).]==]

function Language:hasAncestor(...)

local function iterateOverAncestorTree(node, func, parent_check)

local ancestors = node:getAncestors()

local ancestorsParents = {}

for _, ancestor in ipairs(ancestors) do

if ret then

return ret

end

local chain = self._ancestorChain

if chain == nil then

local ancestors = step:getAncestors()

step = #ancestors == 1 and ancestors[1] or nil

end

self._ancestorChain = chain

end

if type(lang) == "string" then

lang = get_by_code(lang, nil, true)

end

end

end

local function fetch_children(self, fmt)

local self_code, children = self._code, {}

for code, lang in pairs(m_etym_data) do

if name == nil then

name = self:getCanonicalName()

-- Only add " language" if a full language.

if self:hasType("full") then

--[==[Creates a link to the category; the link text is the canonical name.]==]

function Language:makeCategoryLink()

end

function Language:getStandardCharacters(sc)

if type(standard_chars) ~= "table" then

return standard_chars

end

if (not text) or text == "" then

end

unsupported = true

-- If it looks like an interwiki link.

if (

load_data("Module:data/namespaces")[prefix] or

end

if unsupported then

:gsub("%f[^%z/]%.%.?%f[%z/]", function(m)

end)

:gsub("~~~+", function(m)

end)

end

end

--[==[Generates alternative forms using a specified method, and returns them as a table. If no method is specified, returns a table containing only the input term.]==]

end

sc = checkScript(text, self, sc)

end

function Language:makeSortKey(text, sc)

if (not text) or text == "" then

end

text = ugsub(text, "[\194\173\226\128\170-\226\128\174\226\129\166-\226\129\169]", "")

text = gsub(unstrip(text), "<[^<>]+>", "")

text = sc:toFixedNFD(text)

end

if not sc:sortByScraping() then

text = ulower(text)

end

if not sc:sortByScraping() then

text = sc:toFixedNFC(text)

end

-- Remove parentheses, as long as they are either preceded or followed by something.

text = escape_risky_characters(text)

end

local function processDisplayText(text, self, sc, keepCarets, keepPrefixes)

local subbedChars = {}

sc = checkScript(text, self, sc)

text = normalize(text, sc)

text = removeCarets(text, sc)

while true do

local prefix = gsub(text, "^(.-):.+", function(m1)

end)

break

end

end)

end

end

end

--[==[Make the display text (i.e. what is displayed on the page).]==]

function Language:makeDisplayText(text, sc, keepPrefixes)

end

text = escape_risky_characters(text)

end

'''Known bugs''':

* This function assumes {tr(s1) .. tr(s2) == tr(s1 .. s2)}. When this assertion fails, wikitext markups like <nowiki>'''</nowiki> can cause wrong transliterations.

function Language:transliterate(text, sc, module_override)

-- If there is no text, or the language doesn't have transliteration data and there's no override, return nil.

end

-- If the script is not transliteratable (and no override is given), return nil.

if not (sc:isTransliterated() or module_override) then

-- temporary tracking to see if/when this gets triggered