Jump to content

Module:scripts

ពីWiktionary
This module is not ready for use.
This module may not work properly, because it has not been completed and is being kept for tests and improvement. Its arguments, functions and results may change without warning.

It is advisable not to use this module as of yet. You may edit this page or discuss possible changes.

This module is used to retrieve and manage Wiktionary's various writing systems and the information associated with them. See Wiktionary:Scripts for more information.

The information itself is stored in Module:scripts/data. This module should not be used directly by any other module, the data should only be accessed through the functions provided by Module:scripts.

Finding and retrieving scripts

[កែប្រែ]

The module exports a number of functions that are used to find scripts.

getScriptByCode

[កែប្រែ]

getScriptByCode(code)

Finds the script whose code matches the one provided. If it exists, it returns a Script object representing the script. Otherwise, it returns nil.

Script objects

[កែប្រែ]

A Script object is returned from one of the functions above. It is a Lua representation of a script and the data associated with it. It has a number of methods that can be called on it, using the : syntax. For example:

local m_scripts = require("Module:scripts")
local sc = m_scripts.getScriptByCode("Latn")
local name = sc:getCanonicalName()
-- "name" will now be "Latin"

Script:getCode

[កែប្រែ]

:getCode()

Returns the script code of the language. Example: "Cyrl" for Cyrillic.

Script:getCanonicalName

[កែប្រែ]

:getCanonicalName()

Returns the canonical name of the script. This is the name used to represent that script on Wiktionary. Example: "Cyrillic" for Cyrillic.

Script:getAllNames

[កែប្រែ]

:getAllNames()

Returns a table of all names that the script is known by, including the canonical name. The names are not guaranteed to be unique, sometimes more than one script is known by the same name. Example: {"Latin", "Roman"} for the Latin script.

Script:isTextIn

[កែប្រែ]

:isTextIn(text)

Checks whether the given text contains one or more characters of this script. Returns true if so, false if not.

Script:getCategoryName

[កែប្រែ]

:getCategoryName()

Returns the name of the main category of that script. Example: "Cyrillic script" for Cyrillic, whose category is at Category:Cyrillic script.


local export = {}
local Script = {}

function Script:getCode()
	return self._code
end

function Script:getCanonicalName()
	return self._rawData.canonicalName
end

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 self._rawData.aliases or {}
end

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

function Script:getParent()
	return self._rawData.parent
end

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

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


function Script:getType()
	return "script"
end


function Script:getCategoryName(nocap)
	local name = self._rawData.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 "[[:Category:" .. self:getCategoryName() .. "|" .. self:getDisplayForm() .. "]]"
end


function Script:getWikipediaArticle()
	return self._rawData.wikipedia_article or self:getCategoryName()
end


function Script:getCharacters()
	if self._rawData.characters then
		return self._rawData.characters
	else
		return nil
	end
end


function Script:countCharacters(text)
	if not self._rawData.characters then
		return 0
	else
		local _, num = mw.ustring.gsub(text, "[" .. self._rawData.characters .. "]", "")
		return num
	end
end

function Script:getDirection()
	local direction = self._rawData.direction
	if not direction then
		return nil
	else
		return direction
	end
end


function Script:getRawData()
	return self._rawData
end


function Script:toJSON()
	local ret = {
		canonicalName = self:getCanonicalName(),
		categoryName = self:getCategoryName("nocap"),
		code = self._code,
		otherNames = self:getOtherNames(true),
		aliases = self:getAliases(),
		varieties = self:getVarieties(),
		type = self:getType(),
		direction = self:getDirection(),
		characters = self:getCharacters(),
		parent = self:getParent(),
		systems = self._rawData.systems or {},
		wikipediaArticle = self._rawData.wikipedia_article,
	}
	
	return require("Module:JSON").toJSON(ret)
end


Script.__index = Script


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


function export.getByCode(code, paramForError, disallowNil)
	if code == nil and not disallowNil then
		return nil
	end
	if code == "IPAchar" then
		require("Module:debug/track")("IPAchar")
	end
	local retval = export.makeObject(code, mw.loadData("Module:scripts/data")[code])
	if not retval and paramForError then
		require("Module:languages").err(code, paramForError, "script code", nil, "not real lang")
	end
	return retval
end

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

-- Find the best script to use, based on the characters of a string.
-- If forceDetect is set, run the detection algorithm even if there's only one
-- possible script; in that case, if the text isn't in the script, the return
-- value will be None.
function export.findBestScript(text, lang, forceDetect)
	if not text or not lang or not lang.getScripts then
		return export.getByCode("None")
	end
	
	local scripts = lang:getScripts()
	
	if not scripts[2] and not forceDetect then
		return scripts[1]
	end
	
	return require("Module:scripts/findBestScript")(export, text, lang, scripts, forceDetect)
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

function export.findBestScriptWithoutLang(text)
	return require("Module:scripts/charToScript").findBestScriptWithoutLang(text)
end

return export