Module:Lua class

"یَمہٕ ماڈیوٗلُک دَستاویز ییٚہِ Module:Lua class/دَستاویز جاے بَناونہٕ"

local classes, instances = {}, {} -- registry of all complete/internal class and instance objects (with some exceptions)
local inst_private_mts, inst_public_mts = {}, {} -- for each class since they are immutable

local una_metamethods = {__ipairs=1, __pairs=1, __tostring=1, __unm=1}
local bin_metamethods = {__add=1, __concat=1, __div=1, __eq=1, __le=1, __lt=1, __mod=1, __mul=1, __pow=1, __sub=1}
local oth_metamethods = {__call=1, __index=1, __newindex=1, __init=1}
local not_metamethods = {__name=1, __bases=1, __methods=1, __slots=1, __protected=1} -- and __class


local function private_read(self_private, key)
	if not not_metamethods[key] then
		return instances[self_private][key]
	end
	error('unauthorized read attempt of internal "' .. key .. '"')
end

local function private_read_custom(self_private, key)
	if not not_metamethods[key] then
		local self = instances[self_private]
		local value = self.__class.__index(self_private, key)
		if value == nil then
			value = self[key]
		end
		return value
	end
	error('unauthorized read attempt of internal "' .. key .. '"')
end

local function private_write(self_private, key, value)
	local self = instances[self_private]
	if not classes[self.__class].__methods[key] and key:sub(1,2) ~= '__' then
		self[key] = value
	else
		error('forbidden write attempt {' .. key .. ': ' .. tostring(value) .. '} to immutable instance method')
	end
end

local function private_write_custom(self_private, key, value)
	local self = instances[self_private]
	if not classes[self.__class].__methods[key] and key:sub(1,2) ~= '__' then
		if not self.__class.__newindex(self_private, key, value) then
			self[key] = value
		end
	else
		error('forbidden write attempt {' .. key .. ': ' .. tostring(value) .. '} to immutable instance method')
	end
end

local function objtostr(obj)
	local copy = {}
	for key, val in pairs(obj) do
		copy[key] = type(val) == 'function' and 'function' or val
	end
	return mw.text.jsonEncode(copy, mw.text.JSON_PRETTY)
end

local inst_mt = {
	__index = function (self, key)
		return self.__class[key]
	end,
	__tostring = objtostr--
}

local function public_read(self_public, key)
	if key:sub(1,1) ~= '_' then
		return instances[instances[self_public]][key]
	end
	error('unauthorized read attempt of nonpublic "' .. key .. '"')
end

local function public_read_custom(self_public, key)
	if key:sub(1,1) ~= '_' then
		local self = instances[instances[self_public]]
		local value = self.__class.__index(instances[self_public], key)
		if value == nil then
			value = self[key]
		end
		return value
	end
	error('unauthorized read attempt of nonpublic "' .. key .. '"')
end

local function public_write(self_public, key, value)
	if key:sub(1,1) ~= '_' then
		local self = instances[instances[self_public]]
		local cls = classes[self.__class]
		if not cls.__methods[key] then
			if self[key] ~= nil or cls.__slots[key] then
				self[key] = value
			else
				error('public item creation attempt {' .. key .. ': ' .. tostring(value) .. '} not expected by __slots')
			end
		else
			error('forbidden write attempt {' .. key .. ': ' .. tostring(value) .. '} to immutable instance method')
		end
	else
		error('unauthorized write attempt of nonpublic {' .. key .. ': ' .. tostring(value) .. '}')
	end
end

local function public_write_custom(self_public, key, value)
	if key:sub(1,1) ~= '_' then
		local self = instances[instances[self_public]]
		local cls = classes[self.__class]
		if not cls.__methods[key] then
			if not cls.__newindex(instances[self_public], key, value) then
				if self[key] ~= nil or cls.__slots[key] then
					self[key] = value
				else
					error('public item creation attempt {' .. key .. ': ' .. tostring(value) .. '} not expected by __slots')
				end
			end
		else
			error('forbidden write attempt {' .. key .. ': ' .. tostring(value) .. '} to immutable instance method')
		end
	else
		error('unauthorized write attempt of nonpublic {' .. key .. ': ' .. tostring(value) .. '}')
	end
end

local function constructor(wrapper, ...)
	if select('#', ...) ~= 1 then
		error('incorrect instance constructor syntax, should be: Class{arg1, arg2..., kw1=kwarg1, kw2=kwarg2...}')
	end
	local self = {} -- __new
	local cls_private = classes[classes[wrapper]] and classes[wrapper] or wrapper
	self.__class = cls_private

	local self_private = {} -- wrapper
	local cls = classes[cls_private]

	local mt = inst_private_mts[cls]
	if not mt then
		mt = {}
		mt.__index = cls.__index and private_read_custom or private_read
		mt.__newindex = cls.__newindex and private_write_custom or private_write
		for key in pairs(una_metamethods) do
			mt[key] = cls[key]
		end
		mt.__call = cls.__call
		mt.__metatable = 'unauthorized access attempt of wrapper object metatable'

		inst_private_mts[cls] = mt
	end

	setmetatable(self_private, mt)
	instances[self_private] = self

	local __init = cls.__init
	if __init and __init(self_private, ...) then
		error('__init must not return a var-list')
	end

	for key in pairs(cls.__methods) do
		self[key] = function (...) return cls[key](self_private, ...) end
	end

	setmetatable(self, inst_mt)

	local self_public = {}

	mt = inst_public_mts[cls]
	if not mt then
		mt = {}
		mt.__index = cls.__index and public_read_custom or public_read
		mt.__newindex = cls.__newindex and public_write_custom or public_write
		for key in pairs(una_metamethods) do
			if cls[key] then
				mt[key] = function (a) return cls[key](instances[a]) end
			end
		end
		for key in pairs(bin_metamethods) do
			if cls[key] then
				mt[key] = function (a, b) return cls[key](instances[a], instances[b]) end
			end
		end
		mt.__call = function (self_public, ...) return cls.__call(instances[self_public], ...) end
		mt.__metatable = 'unauthorized access attempt of wrapper object metatable'

		inst_public_mts[cls] = mt
	end

	setmetatable(self_public, mt)
	instances[self_public] = self_private
	return self_public
end


local function multi_inheritance(cls, key)
	for i, base in ipairs(cls.__bases) do
		if key:sub(1,1) ~= '_' or base.__protected[key] or key:sub(1,2) == '__' and key ~= '__name' then
			local value = base[key]
			if value ~= nil then
				return value
			end
		end
	end
end

local cls_mt = {
	__index = multi_inheritance,
	__tostring = objtostr--
}

local cls_private_mt = {
	__call = constructor,
	__index = function (cls_private, key)
		if not not_metamethods[key] then
			local cls = classes[cls_private]
			local value = cls[key]
			if type(value) == 'table' and not cls.__slots[key] then
				return mw.clone(value) -- because class items are immutable by default
			end
			return value
		end
		error('unauthorized read attempt of internal "' .. key .. '"')
	end,
	__newindex = function (cls_private, key, value)
		local cls = classes[cls_private]
		if cls.__slots[key] then
			cls[key] = value
		else
			error('write attempt {' .. key .. ': ' .. tostring(value) .. '} not expected by __slots')
		end
	end,
	__metatable = 'unauthorized access attempt of wrapper object metatable'
}

local cls_public_mt = {
	__call = constructor,
	__index = function (cls_public, key)
		if key:sub(1,1) ~= '_' then
			local value = classes[classes[cls_public]][key]
			if type(value) == 'table' then
				return mw.clone(value) -- all class items are immutable in the public scope
			end
			return value
		end
		error('unauthorized read attempt of nonpublic "' .. key .. '"')
	end,
	__newindex = function (cls_public, key, value)
		error('forbidden write attempt of {' .. key .. ': ' .. tostring(value) .. '} that is immutable in the public scope')
	end,
	__metatable = 'unauthorized access attempt of wrapper object metatable'
}

function class(...)
	local args = {...}
	local cls = {} -- internal

	local idx
	if type(args[1]) == 'string' then
		cls.__name = args[1]
		idx = 2
	else
		idx = 1
	end

	cls.__bases = {}
	for i = idx, #args-1 do
		cls.__bases[#cls.__bases+1] = classes[classes[args[i]]]
	end

	local kwargs = args[#args]
	assert(kwargs, 'a (sub)class must have at least one functional method')
	if kwargs.__name or kwargs.__bases then
		error('__name and unpacked __bases must be passed as optional first args to "class"')
	end

	cls.__slots = {}
	if kwargs.__slots then
		for i, slot in ipairs(kwargs.__slots) do
			if slot:sub(1,2) ~= '__' then
				cls.__slots[slot] = true
			else
				error('slot "' .. slot .. '" has forbidden namespace')
			end
		end
		kwargs.__slots = nil
	end
	local mt = {
		__index = function (__slots, key) -- multi_inheritance
			for i, base in ipairs(cls.__bases) do
				if key:sub(1,1) ~= '_' or base.__protected[key] then
					if base.__slots[key] then
						return true
					end
				end
			end
		end
	}
	setmetatable(cls.__slots, mt)

	cls.__protected = {}
	if kwargs.__protected then
		for i, key in ipairs(kwargs.__protected) do
			if key:sub(1,1) == '_' and key:sub(2,2) ~= '_' then
				cls.__protected[key] = true
			else
				error('the namespace of "' .. key .. '" is not manually protectable')
			end
		end
		kwargs.__protected = nil
	end
	mt = {
		__index = function (__protected, key)
			for i, base in ipairs(cls.__bases) do
				if base.__protected[key] then
					return true
				end
			end
		end
	}
	setmetatable(cls.__protected, mt)

	if kwargs.__methods then
		error('__classmethods and __staticmethods should be passed as optional items instead of __methods')
	end

	local cls_private = {} -- wrapper
	setmetatable(cls_private, cls_private_mt)
	classes[cls_private] = cls

	if kwargs.__classmethods then
		for i, key in ipairs(kwargs.__classmethods) do
			local func = kwargs[key]
			cls[key] = function (...) return func(cls_private, ...) end
			kwargs[key] = nil
		end
		kwargs.__classmethods = nil
	end

	local staticmethods = {}
	if kwargs.__staticmethods then
		for i, key in ipairs(kwargs.__staticmethods) do
			staticmethods[key] = true
		end
		kwargs.__staticmethods = nil
	end

	cls.__methods = {}
	for i, base in ipairs(cls.__bases) do
		for key in pairs(base.__methods) do
			if key:sub(1,1) ~= '_' or base.__protected[key] then
				cls.__methods[key] = true
			end
		end
	end

	local valid = false
	for key, val in pairs(kwargs) do
		if key:sub(1,2) == '__' and not una_metamethods[key] and not bin_metamethods[key] and not oth_metamethods[key] then
			error('unrecognized metamethod or unauthorized internal item {' .. key .. ': ' .. tostring(val) .. '}')
		end
		cls[key] = val
		if type(val) == 'function' then
			if not staticmethods[key] and key:sub(1,2) ~= '__' then
				cls.__methods[key] = true
			end
			if key ~= '__init' then -- __init does not qualify to a functional/proper class
				valid = true
			end
		end
	end
	assert(valid, 'a (sub)class must have at least one functional method')

	setmetatable(cls, cls_mt)

	local cls_public = {}
	setmetatable(cls_public, cls_public_mt)
	classes[cls_public] = cls_private
	return cls_public
end


local function rissubclass1(class, classinfo)
	if class == classinfo then
		return true
	end
	for i, base in ipairs(class.__bases) do
		if rissubclass1(base, classinfo) then
			return true
		end
	end
	return false
end

local function rissubclass2(class, classinfo)
	if type(classinfo) == 'table' then
		if classes[classinfo] then
			return rissubclass1(class, classes[classes[classinfo]])
		end
		for i = 1, #classinfo do
			if rissubclass2(class, classinfo[i]) then
				return true
			end
		end
		return false
	end
	error('arg2 is neither a class nor recursive sequence of classes')
end

function issubclass(class, classinfo)
	class = classes[class]
	if class then
		return rissubclass2(classes[class] or class, classinfo)
	end
	error('arg1 is not a class')
end

function isinstance(instance, classinfo)
	instance = instances[instance]
	if instance then
		return rissubclass2(classes[instance.__class], classinfo)
	end
	error('arg1 is not an instance')
end

local type = type
_G.type = function (value)
	local t = type(value)
	if t == 'table' then
		if classes[value] then
			return 'class'
		elseif instances[value] then
			return classes[instances[value].__class].__name or 'instance'
		end
	end
	return t
end

return classes, instances--