Module:languages: Difference between revisions

their "bare display" form by taking the right part of two-part links and removing double brackets), but when this

happens is unclear to me [FIXME]. Some languages have a chop-up-and-paste-together scheme that sends parts of the

[[Module:languages/data]]) they receive the full input text, but preprocessed in certain ways. (The wisdom of this is

still unclear to me.)

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 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 function pattern_escape(...)

return pattern_escape(...)

end

local function replacement_escape(...)

return replacement_escape(...)

end

local function normalize_code(code)

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, "((\\+)%^)")

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

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

if module then

if function_name == "tr" then

else

end

else

-- Split the text into sections, based on the presence of temporarily substituted formatting characters, then iterate over each one to apply substitutions. This avoids putting PUA characters through language-specific modules, which may be unequipped for them.

local fail, cats, sections = nil, {}

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

sections = {text}

else

if sub and subbedChars then

local noSub

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

noSub = true

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

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

form = "a " .. form

end

form = form .. " substrate"

end

if wm_langs == nil then

wm_langs = self._data.wikimedia_codes

self._wikimediaLanguageCodes = wm_langs

end

function Language:makeWikipediaLink()

end

local codes = self:getScriptCodes()

if codes[1] == "All" then

else

scripts = {}

first_sc = get_script(first_sc)

local charset = first_sc.characters

end

-- Remove all formatting characters.

text = get_plaintext(text)

-- Try to match every script against the text,

local count = charset and length - ulen(ugsub(text, "[" .. charset .. "]+", "")) or 0

return sc

end

end

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()

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

-- Check if the text is a listed unsupported title.

if unsupportedTitles[text] then

return "Unsupported titles/" .. unsupportedTitles[text], nil, {}

local fail, cats

text = normalize(text, sc)

text = umatch(text, "^[¿¡]?(.-[^%s%p].-)%s*[؟?!;՛՜ ՞ ՟？！︖︕।॥။၊་།]?$") or text

-- Escape unsupported characters so they can be used in titles. ` is used as a delimiter for this, so a raw use of it in an unsupported title is also escaped here to prevent interference; this is only done with unsupported titles, though, so inclusion won't in itself mean a title is treated as unsupported (which is why it's excluded from the earlier test).

if unsupported then

text = text:gsub("[#<>%[%]_`{|}\239]\191?\189?", unsupported_characters)

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

end

sc = checkScript(text, self, sc)

end

local sort_key = self._data.sort_key

if not sc:sortByScraping() then

local fail, cats

text = normalize(text, sc)

text = removeCarets(text, sc)

return gsub(m1, "\244[\128-\191]*", "")

end)

break

end

:gsub("\4", ":")

end

return text, fail, cats, subbedChars

sc = checkScript(text, self, sc)

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

return nil, true, {}

end

-- Remove any strip markers.

text = unstrip(text)

-- Get the display text with the keepCarets flag set.

local fail, cats, subbedChars

-- Transliterate (using the module override if applicable).

if not text then

end

-- If the script does not use capitalization, then capitalize any letters of the transliteration which are immediately preceded by a caret (and remove the caret).

function export.getDataModuleName(code)

local letter = match(code, "^(%l)%l%l?$")

#code == 2 and "languages/data/2" or

"languages/data/3/" .. letter

end

get_data_module_name = export.getDataModuleName

varieties = "unique",

wikipedia_article = "unique",

}

local function __index(self, k)

local stack, key_type = getmetatable(self), key_types[k]

end

end

local function __newindex()

error("table is read-only")

end

local function __pairs(self)

-- Iterate down the stack, caching keys to avoid duplicate returns.

end

end

local __ipairs = require(table_module).indexIpairs

function make_stack(data)

local stack = {

return setmetatable({}, stack), stack

end

return make_stack(data)

end

local function get_stack(data)

local stack = getmetatable(data)

return stack and type(stack) == "table" and stack[make_stack] and stack or nil

end

--[==[

<span style="color: #BA0000">This function is not for use in entries or other content pages.</span>

return data

end

function Language:loadInExtraData()

-- Only full languages have extra data.

local modulename = get_extra_data_module_name(code)

-- No data cached as false.

end

function export.makeObject(code, data, dontCanonicalizeAliases)

local data_type = type(data)

lang._mainCode = code

end

local parent_data = parent._data

if parent_data == nil then

end

lang._data = data

return setmetatable(lang, parent)

end

--[==[Finds the language whose code matches the one provided. If it exists, it returns a <code class="nf">Language</code> object representing the language. Otherwise, it returns {{code|lua|nil}}, unless <code class="n">paramForError</code> is given, in which case an error is generated. If <code class="n">paramForError</code> is {{code|lua|true}}, a generic error message mentioning the bad code is generated; otherwise <code class="n">paramForError</code> should be a string or number specifying the parameter that the code came from, and this parameter will be mentioned in the error message along with the bad code. If <code class="n">allowEtymLang</code> is specified, etymology-only language codes are allowed and looked up along with normal language codes. If <code class="n">allowFamily</code> is specified, language family codes are allowed and looked up along with normal language codes.]==]

function export.getByCode(code, paramForError, allowEtymLang, allowFamily)

if type(code) ~= "string" then

local typ

end

local norm_code = normalize_code(code)

-- Get the data, checking for etymology-only languages if allowEtymLang is set.

-- If no data was found and allowFamily is set, check the family data. If the main family data was found, make the object with [[Module:families]] instead, as family objects have different methods. However, if it's an etymology-only family, use make_object in this module (which handles object inheritance), and the family-specific methods will be inherited from the parent object.

if data == nil and allowFamily then

data = load_data("Module:families/data")[norm_code]

if data ~= nil then

end

end

end

function export.finalizeData(data, main_type, variety)

local fields = {"type"}

entity.parent, entity[3], entity.family = entity[3], entity.family

-- Give the type "regular" iff not a variety and no other types are assigned.

entity.type = "regular"

end