Module:User:Theknightwho/scripts/serialized

local export = {}

local get_value = require("Module:User:Theknightwho/3").get_value local make_table = require("Module:User:Theknightwho/3").make_table

local Script = {}

--[==[Returns the script code of the language. Example: lua for Cyrillic.]==] function Script:getCode return self._code end

--[==[Returns the canonical name of the script. This is the name used to represent that script on Wiktionary. Example: lua for Cyrillic.]==] function Script:getCanonicalName return get_value(self._rawData, nil, 1) or get_value(self._rawData, nil, "canonicalName") end

--[==[Returns the display form of the script. For scripts, this is the same as the value returned by, i.e. it reads "NAME script" (e.g. lua). For regular and etymology languages, this is the same as the canonical name, and for families, it reads "NAME languages" (e.g. lua). The displayed text used in  is always the same as the display form.]==] function Script:getDisplayForm return self:getCategoryName("nocap") end

function Script:getOtherNames(onlyOtherNames) return require("Module:language-like").getOtherNames(self, onlyOtherNames) end

function Script:getAliases return get_value(self._rawData, nil, "aliases") or {} end

function Script:getVarieties(flatten) return require("Module:language-like").getVarieties(self, flatten) end

--[==[Returns the parent of the script. Example: lua for lua and lua for lua. It returns lua for scripts without a parent, like lua, lua, etc.]==] function Script:getParent return get_value(self._rawData, nil, "parent") end

function Script:getSystemCodes if not self._systemCodes then local codes = get_value(self._rawData, nil, 2) if type(codes) == "table" then self._systemCodes = codes elseif type(codes) == "string" then self._systemCodes = mw.text.split(codes, "%s*,%s*") else self._systemCodes = {} end end return self._systemCodes end

function Script:getSystems if not self._systemObjects then local m_systems = require("Module:writing systems") self._systemObjects = {} for _, ws in ipairs(self:getSystemCodes) do			table.insert(self._systemObjects, m_systems.getByCode(ws)) end end return self._systemObjects end

--function Script:getAllNames --	return self._rawData.names --end

--[==[Given a list of types as strings, returns true if the script has all of them. Possible types are explained in Module:scripts/data.]==] function Script:hasType(...) if not self._type then self._type = {script = true} local type = get_value(self._rawData, nil, "type") if type then for _, type in ipairs(mw.text.split(type, "%s*,%s*")) do				self._type[type] = true end end end for _, type in ipairs{...} do		if not self._type[type] then return false end end return true end

--[==[Returns the name of the main category of that script. Example: lua for Cyrillic, whose category is at Category:Cyrillic script. Unless optional argument  is given, the script name at the beginning of the returned value will be capitalized. This capitalization is correct for category names, but not if the script name is lowercase and the returned value of this function is used in the middle of a sentence. (For example, the script with the code  has the name , which should remain lowercase when used as part of the category name Category:Translingual letters in flag semaphore but should be capitalized in Category:Flag semaphore templates.) If you are considering using  , use   instead.]==] function Script:getCategoryName(nocap) local name = get_value(self._rawData, nil, 1) or get_value(self._rawData, nil, "canonicalName") -- If the name already has "code" or "semaphore" in it, don't add it. -- No names contain "script". if not name:find("[Cc]ode$") and not name:find("[Ss]emaphore$") then name = name .. " script" end if not nocap then name = mw.getContentLanguage:ucfirst(name) end return name end

function Script:makeCategoryLink return "" .. self:getDisplayForm .. "" end

--[==[Returns the lua item in the language's data file, or else calls lua.]==] function Script:getWikipediaArticle return get_value(self._rawData, nil, "wikipedia_article") or self:getCategoryName end

--[==[Returns the regex defining the script's characters from the language's data file. This can be used to search for words consisting only of this script, but see the warning above.]==] function Script:getCharacters return get_value(self._rawData, nil, "characters") end

--[==[Returns the number of characters in the text that are part of this script. Note: You should never rely on text consisting entirely of the same script. Strings may contain spaces, punctuation and even wiki markup or HTML tags. HTML tags will skew the counts, as they contain Latin-script characters. So it's best to avoid them.]==] function Script:countCharacters(text) local characters = self:getCharacters if not characters then return 0 -- Due to the number of Chinese characters, a different determination method is used when differentiating between traditional ("Hant") and simplified ("Hans") Chinese. elseif self:getCode == "Hant" or self:getCode == "Hans" then local charData, num = self:getCode == "Hant" and require("Module:zh/data/ts/serialized") or require("Module:zh/data/st/serialized"), 0 charData = charData:sub(1, charData:len / 2) for char in text:gmatch("[\194-\244][\128-\191]*") do			if charData:find(char) then num = num + 1 end end return num else local _, num = mw.ustring.gsub(text, "[" .. characters .. "]", "") return num end end

function Script:hasCapitalization return not not get_value(self._rawData, nil, "capitalized") end

function Script:hasSpaces return get_value(self._rawData, nil, "spaces") ~= false end

function Script:isTransliterated return get_value(self._rawData, nil, "translit") ~= false end

--[==[Returns true if the script is (sometimes) sorted by scraping page content, meaning that it is sensitive to changes in capitalization during sorting.]==] function Script:sortByScraping return not not get_value(self._rawData, nil, "sort_by_scraping") end

--[==[Returns the text direction, if any. Currently, left-to-right scripts are unmarked, while most right-to-left scripts have direction specified as lua and Mongolian as lua.]==] function Script:getDirection return get_value(self._rawData, nil, "direction") end

function Script:getRawData return make_table(self._rawData) end

--[==[Returns lua if the script contains characters that require fixes to Unicode normalization under certain circumstances, lua if it doesn't.]==] function Script:hasNormalizationFixes return not not get_value(self._rawData, nil, "normalizationFixes") end

--[==[Corrects discouraged sequences of Unicode characters to the encouraged equivalents.]==] function Script:fixDiscouragedSequences(text) if self:hasNormalizationFixes then local from = get_value(self._rawData, nil, "normalizationFixes", "from") local to = get_value(self._rawData, nil, "normalizationFixes", "to") if from and to then local gsub = require("Module:string utilities").gsub for i, from in ipairs(from) do				text = gsub(text, from, to[i] or "") end end end return text end

-- Implements a modified form of Unicode normalization for instances where there are identified deficiencies in the default Unicode combining classes. local function fixNormalization(text, self) if self:hasNormalizationFixes then local combiningClassFixes = get_value(self._rawData, nil, "normalizationFixes", "combiningClasses") if combiningClassFixes then local charsToFix = table.concat(require("Module:table").keysToList(combiningClassFixes)) if require("Module:string utilities").match(text, "[" .. charsToFix .. "]") then local codepoint, u = mw.ustring.codepoint, mw.ustring.char -- Obtain the list of default combining classes. local combiningClasses = mw.loadData("Module:scripts/data/combiningClasses") -- For each character that needs fixing, find all characters with combining classes equal to or lower than its default class, but greater than its new class (i.e. intermediary characters). for charToFix, newCombiningClass in pairs(combiningClassFixes) do					local intermediaryChars = {} for character, combiningClass in pairs(combiningClasses) do						if newCombiningClass < combiningClass and combiningClass <= combiningClasses[codepoint(charToFix)] then table.insert(intermediaryChars, u(character)) end end -- Swap the character with any intermediary characters that are immediately before it. text = require("Module:string utilities").gsub(text, "([" .. table.concat(intermediaryChars) .. "]+)(" .. charToFix .. ")", "%2%1")				end end end end return text end

function Script:toFixedNFC(text) return fixNormalization(mw.ustring.toNFC(text), self) end

function Script:toFixedNFD(text) return fixNormalization(mw.ustring.toNFD(text), self) end

function Script:toFixedNFKC(text) return fixNormalization(mw.ustring.toNFKC(text), self) end

function Script:toFixedNFKD(text) return fixNormalization(mw.ustring.toNFKD(text), self) end

function Script:toJSON if not self._type then self:hasType end local types = {} for type in pairs(self._type) do		table.insert(types, type) end local ret = { canonicalName = self:getCanonicalName, categoryName = self:getCategoryName("nocap"), code = self:getCode, otherNames = self:getOtherNames(true), aliases = self:getAliases, varieties = self:getVarieties, type = types, direction = self:getDirection, characters = self:getCharacters, parent = self:getParent, systems = self:getSystemCodes, wikipediaArticle = get_value(self._rawData, nil, "wikipedia_article"), }	return require("Module:JSON").toJSON(ret) end

Script.__index = Script function export.makeObject(code, data, useRequire) return data and setmetatable({_rawData = data, _code = code}, Script) or nil end

--[==[Finds the script whose code matches the one provided. If it exists, it returns a lua object representing the script. Otherwise, it returns lua, unless paramForError is given, in which case an error is generated. If  is lua, a generic error message mentioning the bad code is generated; otherwise   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.]==] function export.getByCode(code, paramForError, disallowNil, useRequire) if code == nil and not disallowNil then return nil end if code == "IPAchar" then require("Module:debug/track")("IPAchar") end local data = get_value(require("Module:User:Theknightwho/scripts/data/serialized"), true, code) local retval = export.makeObject(code, data, useRequire) if not retval and paramForError then require("Module:languages/error")(code, paramForError, "script code", nil, "not real lang") end return retval end

function export.getByCanonicalName(name, useRequire) local code if useRequire then code = require("Module:scripts/by name")[name] else code = mw.loadData("Module:scripts/by name")[name] end return export.getByCode(code, nil, nil, useRequire) end

--[==[	Takes a codepoint or a character and finds the script code (if any) that is	appropriate for it based on the codepoint, using the data module Module:scripts/recognition data. The data module was generated from the patterns in Module:scripts/data using Module:User:Erutuon/script recognition.

Converts the character to a codepoint. Returns a script code if the codepoint is in the list of individual characters, or if it is in one of the defined ranges in the 4096-character block that it belongs to, else returns "None". ]==] function export.charToScript(char) return require("Module:scripts/charToScript").charToScript(char) end

--[==[Returns the code for the script that has the greatest number of characters in. Useful for script tagging text that is unspecified for language. Uses Module:scripts/recognition data to determine a script code for a character language-agnostically.]==] function export.findBestScriptWithoutLang(text) return require("Module:scripts/charToScript").findBestScriptWithoutLang(text) end

return export