Module:scripts: Difference between revisions

Jump to navigation Jump to search

Module:scripts (view source)

Revision as of 23:48, 10 January 2025

5,859 bytes added ,  10 January 2025
no edit summary
No edit summary
No edit summary
Line 1: Line 1:
local m_str_utils = require("Module:string utilities")
local export = {}
 
local combining_classes_module = "Module:Unicode data/combining classes"
local data_module = "Module:scripts/data"
local json_module = "Module:JSON"
local language_like_module = "Module:language-like"
local load_module = "Module:load"
local scripts_by_name_module = "Module:scripts/by name"
local scripts_chartoscript_module = "Module:scripts/charToScript"
local string_utilities_module = "Module:string utilities"
local table_module = "Module:table"
local writing_systems_module = "Module:writing systems"
local writing_systems_data_module = "Module:writing systems/data"


local concat = table.concat
local concat = table.concat
local explode = m_str_utils.explode_utf8
local get_by_code -- Defined below.
local gsplit = m_str_utils.gsplit
local gmatch = string.gmatch
local insert = table.insert
local make_object -- Defined below.
local match = string.match
local match = string.match
local require = require
local select = select
local select = select
local split = m_str_utils.split
local setmetatable = setmetatable
local toNFC = mw.ustring.toNFC
local toNFC = mw.ustring.toNFC
local toNFD = mw.ustring.toNFD
local toNFD = mw.ustring.toNFD
Line 12: Line 27:
local toNFKD = mw.ustring.toNFKD
local toNFKD = mw.ustring.toNFKD
local type = type
local type = type
local ugsub = m_str_utils.gsub
local umatch = m_str_utils.match


local export = {}
--[==[
Loaders for functions in other modules, which overwrite themselves with the target function when called. This ensures modules are only loaded when needed, retains the speed/convenience of locally-declared pre-loaded functions, and has no overhead after the first call, since the target functions are called directly in any subsequent calls.]==]
local function category_name_has_suffix(...)
category_name_has_suffix = require(language_like_module).categoryNameHasSuffix
return category_name_has_suffix(...)
end
local function category_name_to_code(...)
category_name_to_code = require(language_like_module).categoryNameToCode
return category_name_to_code(...)
end
local function deep_copy(...)
deep_copy = require(table_module).deepCopy
return deep_copy(...)
end
local function explode(...)
explode = require(string_utilities_module).explode_utf8
return explode(...)
end
local function get_writing_system(...)
get_writing_system = require(writing_systems_module).getByCode
return get_writing_system(...)
end
local function keys_to_list(...)
keys_to_list = require(table_module).keysToList
return keys_to_list(...)
end
local function load_data(...)
load_data = require(load_module).load_data
return load_data(...)
end
local function split(...)
split = require(string_utilities_module).split
return split(...)
end
local function to_json(...)
to_json = require(json_module).toJSON
return to_json(...)
end
local function ugsub(...)
ugsub = require(string_utilities_module).gsub
return ugsub(...)
end
local function umatch(...)
umatch = require(string_utilities_module).match
return umatch(...)
end
 
--[==[
Loaders for objects, which load data (or some other object) into some variable, which can then be accessed as "foo or get_foo()", where the function get_foo sets the object to "foo" and then returns it. This ensures they are only loaded when needed, and avoids the need to check for the existence of the object each time, since once "foo" has been set, "get_foo" will not be called again.]==]
local scripts_by_name
local function get_scripts_by_name()
scripts_by_name, get_scripts_by_name = load_data(scripts_by_name_module), nil
return scripts_by_name
end
local scripts_data
local function get_scripts_data()
scripts_data, get_scripts_data = load_data(data_module), nil
return scripts_data
end
local scripts_suffixes
local function get_scripts_suffixes()
scripts_suffixes, get_scripts_suffixes = {
"script",
"code",
"notation",
"letters",
"numerals",
"semaphore",
}, nil
for _, v in pairs(load_data(writing_systems_data_module)) do
insert(scripts_suffixes, v[1])
end
return scripts_suffixes
end


local Script = {}
local Script = {}
Script.__index = Script


--[==[Returns the script code of the script. Example: {{lua|"Cyrl"}} for Cyrillic.]==]
--[==[Returns the script code of the script. Example: {{lua|"Cyrl"}} for Cyrillic.]==]
Line 26: Line 125:
--[==[Returns the canonical name of the script. This is the name used to represent that script on Wiktionary. Example: {{lua|"Cyrillic"}} for Cyrillic.]==]
--[==[Returns the canonical name of the script. This is the name used to represent that script on Wiktionary. Example: {{lua|"Cyrillic"}} for Cyrillic.]==]
function Script:getCanonicalName()
function Script:getCanonicalName()
return self._rawData[1] or self._rawData.canonicalName
return self._data[1]
end
end


Line 34: Line 133:
end
end


function Script:getOtherNames(onlyOtherNames)
function Script:getAliases()
return require("Module:language-like").getOtherNames(self, onlyOtherNames)
Script.getAliases = require(language_like_module).getAliases
return self:getAliases()
end
 
function Script:getVarieties(flatten)
Script.getVarieties = require(language_like_module).getVarieties
return self:getVarieties(flatten)
end
end


function Script:getAliases()
function Script:getOtherNames()
return self._rawData.aliases or {}
Script.getOtherNames = require(language_like_module).getOtherNames
return self:getOtherNames()
end
end


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


Line 50: Line 157:
local code = self._ietf_subtag
local code = self._ietf_subtag
if code == nil then
if code == nil then
code = self._rawData.ietf_subtag or match(self._code, "[^%-]+$")
code = self._data.ietf_subtag or match(self:getCode(), "[^%-]+$")
self._ietf_subtag = code
self._ietf_subtag = code
end
end
Line 57: Line 164:


--[==[Returns the parent of the script. Example: {{lua|"Arab"}} for {{lua|"fa-Arab"}}. It returns {{lua|"top"}} for scripts without a parent, like {{lua|"Latn"}}, {{lua|"Grek"}}, etc.]==]
--[==[Returns the parent of the script. Example: {{lua|"Arab"}} for {{lua|"fa-Arab"}}. It returns {{lua|"top"}} for scripts without a parent, like {{lua|"Latn"}}, {{lua|"Grek"}}, etc.]==]
function Script:getParent()
function Script:getParentCode()
return self._rawData.parent
return self._data.parent
end
end


function Script:getSystemCodes()
function Script:getSystemCodes()
if not self._systemCodes then
if not self._systemCodes then
local system_codes = self._rawData[2]
local system_codes = self._data[3]
if type(system_codes) == "table" then
if type(system_codes) == "table" then
self._systemCodes = system_codes
self._systemCodes = system_codes
elseif type(system_codes) == "string" then
elseif type(system_codes) == "string" then
self._systemCodes = split(system_codes, "%s*,%s*", true)
self._systemCodes = split(system_codes, ",", true, true)
else
else
self._systemCodes = {}
self._systemCodes = {}
Line 77: Line 184:
function Script:getSystems()
function Script:getSystems()
if not self._systemObjects then
if not self._systemObjects then
local m_systems = require("Module:writing systems")
self._systemObjects = {}
self._systemObjects = {}
for _, system in ipairs(self:getSystemCodes()) do
for _, ws in ipairs(self:getSystemCodes()) do
insert(self._systemObjects, get_writing_system(system))
table.insert(self._systemObjects, m_systems.getByCode(ws))
end
end
end
end
return self._systemObjects
return self._systemObjects
end
end
Line 103: Line 207:
end
end


--function Script:getAllNames()
--[==[Returns a table of types as a lookup table (with the types as keys).
-- return self._rawData.names
--end
 
--[==[Given a list of types as strings, returns true if the script has all of them.  


Currently the only possible type is {script}; use {{lua|hasType("script")}} to determine if an object that
Currently, the only possible type is {script}.]==]
may be a language, family or script is a script.
function Script:getTypes()
]==]
function Script:hasType(...)
local types = self._types
local types = self._types
if types == nil then
if types == nil then
types = {script = true}
types = {script = true}
local rawtypes = self._rawData.type
local rawtypes = self._data.type
if rawtypes then
if rawtypes then
for rawtype in gsplit(rawtypes, "%s*,%s*", true) do
for t in gmatch(rawtypes, "[^,]+") do
types[rawtype] = true
types[t] = true
end
end
end
end
self._types = types
self._types = types
end
end
for i = 1, arg.n do
return types
if not types[arg[i]] then
end
return false
 
end
--[==[Given a list of types as strings, returns true if the script has all of them.
end
 
return true
Use {{lua|hasType("script")}} to determine if an object that may be a language, family or script is a script.]==]
function Script:hasType(...)
Script.hasType = require(language_like_module).hasType
return self:hasType(...)
end
end


Line 136: Line 237:
function Script:getCategoryName(nocap)
function Script:getCategoryName(nocap)
local name = self:getCanonicalName()
local name = self:getCanonicalName()
if category_name_has_suffix(name, scripts_suffixes or get_scripts_suffixes()) then
-- If the name already has "script", "code" or "semaphore" at the end, don't add it.
if not (
name:find("[ %-][Ss]cript$") or
name:find("[ %-][Cc]ode$") or
name:find("[ %-][Ss]emaphore$")
) then
name = name .. " script"
name = name .. " script"
end
end
Line 155: Line 250:
end
end


--[==[Returns the {{lua|wikipedia_article}} item in the script's data file, or else calls {{lua|Script:getCategoryName()}}.]==]
--[==[Returns the Wikidata item id for the script or <code>nil</code>. This corresponds to the the second field in the data modules.]==]
function Script:getWikipediaArticle()
function Script:getWikidataItem()
return self._rawData.wikipedia_article or self:getCategoryName()
Script.getWikidataItem = require(language_like_module).getWikidataItem
return self:getWikidataItem()
end
 
--[==[
Returns the name of the Wikipedia article for the script. `project` specifies the language and project to retrieve
the article from, defaulting to {"enwiki"} for the English Wikipedia. Normally if specified it should be the project
code for a specific-language Wikipedia e.g. "zhwiki" for the Chinese Wikipedia, but it can be any project, including
non-Wikipedia ones. If the project is the English Wikipedia and the property {wikipedia_article} is present in the data
module it will be used first. In all other cases, a sitelink will be generated from {:getWikidataItem} (if set). The
resulting value (or lack of value) is cached so that subsequent calls are fast. If no value could be determined, and
`noCategoryFallback` is {false}, {:getCategoryName} is used as fallback; otherwise, {nil} is returned. Note that if
`noCategoryFallback` is {nil} or omitted, it defaults to {false} if the project is the English Wikipedia, otherwise
to {true}. In other words, under normal circumstances, if the English Wikipedia article couldn't be retrieved, the
return value will fall back to a link to the script's category, but this won't normally happen for any other project.
]==]
function Script:getWikipediaArticle(noCategoryFallback, project)
Script.getWikipediaArticle = require(language_like_module).getWikipediaArticle
return self:getWikipediaArticle(noCategoryFallback, project)
end
 
--[==[Returns the name of the Wikimedia Commons category page for the script.]==]
function Script:getCommonsCategory()
Script.getCommonsCategory = require(language_like_module).getCommonsCategory
return self:getCommonsCategory()
end
end


Line 169: Line 288:
'''Note:''' You should never assume that text consists 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.]==]
'''Note:''' You should never assume that text consists 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)
function Script:countCharacters(text)
local charset = self._rawData.characters
local charset = self._data.characters
if charset == nil then
if charset == nil then
return 0
return 0
Line 177: Line 296:


function Script:hasCapitalization()
function Script:hasCapitalization()
return not not self._rawData.capitalized
return not not self._data.capitalized
end
end


function Script:hasSpaces()
function Script:hasSpaces()
return self._rawData.spaces ~= false
return self._data.spaces ~= false
end
end


function Script:isTransliterated()
function Script:isTransliterated()
return self._rawData.translit ~= false
return self._data.translit ~= false
end
end


--[==[Returns true if the script is (sometimes) sorted by scraping page content, meaning that it is sensitive to changes in capitalization during sorting.]==]
--[==[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()
function Script:sortByScraping()
return not not self._rawData.sort_by_scraping
return not not self._data.sort_by_scraping
end
end


--[==[Returns the text direction. Horizontal scripts return {{lua|"ltr"}} (left-to-right) or {{lua|"rtl"}} (right-to-left), while vertical scripts return {{lua|"vertical-ltr"}} (vertical left-to-right) or {{lua|"vertical-rtl"}} (vertical right-to-left).]==]
--[==[Returns the text direction. Horizontal scripts return {{lua|"ltr"}} (left-to-right) or {{lua|"rtl"}} (right-to-left), while vertical scripts return {{lua|"vertical-ltr"}} (vertical left-to-right) or {{lua|"vertical-rtl"}} (vertical right-to-left).]==]
function Script:getDirection()
function Script:getDirection()
return self._rawData.direction or "ltr"
return self._data.direction or "ltr"
end
end


function Script:getRawData()
function Script:getData()
return self._rawData
return self._data
end
end


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


Line 210: Line 329:
function Script:fixDiscouragedSequences(text)
function Script:fixDiscouragedSequences(text)
if self:hasNormalizationFixes() then
if self:hasNormalizationFixes() then
local norm_fixes = self._rawData.normalizationFixes
local norm_fixes = self._data.normalizationFixes
local to = norm_fixes.to
local to = norm_fixes.to
if to then
if to then
Line 222: Line 341:


do
do
local combiningClasses
local combining_classes
-- Obtain the list of default combining classes.
local function get_combining_classes()
combining_classes, get_combining_classes = load_data(combining_classes_module), nil
return combining_classes
end
-- Implements a modified form of Unicode normalization for instances where there are identified deficiencies in the default Unicode combining classes.
-- Implements a modified form of Unicode normalization for instances where there are identified deficiencies in the default Unicode combining classes.
Line 229: Line 354:
return text
return text
end
end
local norm_fixes = self._rawData.normalizationFixes
local norm_fixes = self._data.normalizationFixes
local new_classes = norm_fixes.combiningClasses
local new_classes = norm_fixes.combiningClasses
if not (new_classes and umatch(text, "[" .. norm_fixes.combiningClassCharacters .. "]")) then
if not (new_classes and umatch(text, "[" .. norm_fixes.combiningClassCharacters .. "]")) then
return text
return text
end
end
-- Obtain the list of default combining classes.
combiningClasses = combiningClasses or mw.loadData("Module:scripts/data/combiningClasses")
text = explode(text)
text = explode(text)
-- Manual sort based on new combining classes.
-- Manual sort based on new combining classes.
Line 241: Line 364:
for i = 2, #text do
for i = 2, #text do
local char = text[i]
local char = text[i]
local class = new_classes[char] or combiningClasses[char]
local class = new_classes[char] or (combining_classes or get_combining_classes())[char]
if class then
if class then
repeat
repeat
i = i - 1
i = i - 1
local prev = text[i]
local prev = text[i]
if (new_classes[prev] or combiningClasses[prev] or 0) < class then
if (new_classes[prev] or (combining_classes or get_combining_classes())[prev] or 0) < class then
break
break
end
end
Line 273: Line 396:
end
end


function Script:toJSON()
function Script:toJSON(opts)
if not self._types then
self:hasType()
end
local types = {}
for type in pairs(self._types) do
table.insert(types, type)
end
local ret = {
local ret = {
canonicalName = self:getCanonicalName(),
canonicalName = self:getCanonicalName(),
categoryName = self:getCategoryName("nocap"),
categoryName = self:getCategoryName("nocap"),
code = self._code,
code = self:getCode(),
otherNames = self:getOtherNames(true),
parent = self:getParentCode(),
systems = self:getSystemCodes(),
aliases = self:getAliases(),
aliases = self:getAliases(),
varieties = self:getVarieties(),
varieties = self:getVarieties(),
type = types,
otherNames = self:getOtherNames(),
type = keys_to_list(self:getTypes()),
direction = self:getDirection(),
direction = self:getDirection(),
characters = self:getCharacters(),
characters = self:getCharacters(),
parent = self:getParent(),
ietfSubtag = self:getIETFSubtag(),
systems = self:getSystemCodes(),
wikidataItem = self:getWikidataItem(),
wikipediaArticle = self._rawData.wikipedia_article,
wikipediaArticle = self:getWikipediaArticle(true),
}
}
-- Use `deep_copy` when returning a table, so that there are no editing restrictions imposed by `mw.loadData`.
return opts and opts.lua_table and deep_copy(ret) or to_json(ret, opts)
end
return require("Module:JSON").toJSON(ret)
function export.makeObject(code, data)
local data_type = type(data)
if data_type ~= "table" then
error(("bad argument #2 to 'makeObject' (table expected, got %s)"):format(data_type))
end
return setmetatable({_data = data, _code = code, characters = data.characters}, Script)
end
end
make_object = export.makeObject


Script.__index = Script
--[==[
Finds the script whose code matches the one provided. If it exists, it returns a {Script} object representing the
function export.makeObject(code, data, useRequire)
script. Otherwise, it returns {nil}.]==]
return data and setmetatable({
function export.getByCode(code)
_rawData = data,
local data = (scripts_data or get_scripts_data())[code]
_code = code,
return data ~= nil and make_object(code, data) or nil
characters = data.characters
}, Script) or nil
end
end
get_by_code = export.getByCode


--[==[Finds the script whose code matches the one provided. If it exists, it returns a {{lua|Script}} object representing the script. Otherwise, it returns {{lua|nil}}, unless <span class="n">paramForError</span> is given, in which case an error is generated. If <code class="n">paramForError</code> is {{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.]==]
--[==[
function export.getByCode(code, paramForError, disallowNil, useRequire)
Look for the script whose canonical name (the name used to represent that script on Wiktionary) matches the one
if code == nil and not disallowNil then
provided. If it exists, it returns a {Script} object representing the script. Otherwise, it returns {nil}. The
canonical name of scripts should always be unique (it is an error for two scripts on Wiktionary to share the same
canonical name), so this is guaranteed to give at most one result.]==]
function export.getByCanonicalName(name)
if name == nil then
return nil
return nil
end
end
local code = (scripts_by_name or get_scripts_by_name())[name]
local data
if code == nil then
if useRequire then
return nil
data = require("Module:scripts/data")[code]
else
data = mw.loadData("Module:scripts/data")[code]
end
end
return get_by_code(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
end


function export.getByCanonicalName(name, useRequire)
--[==[
local code
Look for the script whose category name (the name used in categories for that script) matches the one provided.
if useRequire then
If it exists, it returns a {Script} object representing the script. Otherwise, it returns {nil}. In almost all cases,
code = require("Module:scripts/by name")[name]
the category name for a script is its canonical name plus the word "script", e.g. "Cyrillic" has the category name
else
"Cyrillic script". Where a canonical name ends with "script", "code" or "semaphore", the category name is identical
code = mw.loadData("Module:scripts/by name")[name]
to the canonical name.]==]
function export.getByCategoryName(name)
if name == nil then
return nil
end
end
local code = category_name_to_code(
return export.getByCode(code, nil, nil, useRequire)
name,
" script",
scripts_by_name or get_scripts_by_name(),
scripts_suffixes or get_scripts_suffixes()
)
if code == nil then
return nil
end
return get_by_code(code)
end
end


Line 354: Line 484:
]==]
]==]
function export.charToScript(char)
function export.charToScript(char)
return require("Module:scripts/charToScript").charToScript(char)
export.charToScript = require(scripts_chartoscript_module).charToScript
return export.charToScript(char)
end
end


Line 362: Line 493:
language-agnostically. Specifically, it works as follows:
language-agnostically. Specifically, it works as follows:
Convert each character to a codepoint. Iterate the counter for the script code if the codepoint is in the list
Convert each character to a codepoint. Increment the counter for the 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.
of individual characters, or if it is in one of the defined ranges in the 4096-character block that it belongs to.
Line 377: Line 508:
]==]
]==]
function export.findBestScriptWithoutLang(text, none_is_last_resort_only)
function export.findBestScriptWithoutLang(text, none_is_last_resort_only)
return require("Module:scripts/charToScript").findBestScriptWithoutLang(text, none_is_last_resort_only)
export.findBestScriptWithoutLang = require(scripts_chartoscript_module).findBestScriptWithoutLang
return export.findBestScriptWithoutLang(text, none_is_last_resort_only)
end
end


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

Navigation menu