lua-class/class-oop.lua at main · lodsdev/lua-class · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
--[[
    Author: https://github.com/lodsdev
    Version: 2.0.0
]]

local classes = {}
local interfaces = {}

local function table_copy(t, st)
    local newTbl = {}
    for i, v in pairs(t) do
        if (not newTbl[i]) then
            newTbl[i] = v
        end
    end
    if (st) then
        newTbl.super = st
        newTbl.baseClassName = st.__name -- make sure to copy all properties added in createClass()
        setmetatable(newTbl, { __index = newTbl.super })
    end
    return newTbl
end

local function table_implements(t, t2)
    local newTbl = {}
    for k, v in ipairs(t2) do
        t[#t+1] = v
    end
    newTbl = table_copy(t)
    return newTbl
end

local function createClass(className, structure, superClass)
    if (classes[className]) then
        error('Class ' .. className .. ' already exists.', 2)
    end

    local newClass = structure
    newClass.__name = className

    if (superClass) then
        newClass.super = superClass
        newClass.baseClassName = superClass.__name
        setmetatable(newClass, { __index = superClass })
    end

    classes[className] = newClass
    return newClass
end

function interface(interfaceName)
    local newInterface = {}

    setmetatable(newInterface, {
        __call = function(self, ...)
            if (interfaces[interfaceName]) then
                error('Interface ' .. interfaceName .. ' already exists.', 2)
            end

            local newInstance = ...
            interfaces[interfaceName] = newInstance
            return newInstance
        end
    })

    newInterface.extends = function(self, superInterfaceName)
        return function(subInterface)
            local superInterface = interfaces[superInterfaceName]
            local newInstance = table_implements(subInterface, superInterface)

            if (interfaces[interfaceName]) then
                error('Interface ' .. interfaceName .. ' already exists.', 2)
            end

            interfaces[interfaceName] = newInstance
            return newInstance
        end
    end

    return newInterface
end

function class(className)
    local newClasse = {}
    local modifiers = {
        extends = function(self, superClassName)
            return function(subClass)
                local superClass = classes[superClassName]
                local classCreated = createClass(className, subClass, superClass)
                return classCreated
            end
        end,

        implements = function(self, ...)
            local interfacesNames = {...}
            return function(subClass)
                local classeCreated = createClass(className, subClass)

                for _, v in pairs(interfacesNames) do
                    if (not interfaces[v]) then
                        error('Interface ' .. v .. ' not found', 2)
                    end

                    for _, method in pairs(interfaces[v]) do
                        if (not subClass[method]) then
                            error('Interface ' .. v .. ' not implemented, method ' .. method .. ' not found', 2)
                        end
                    end
                end

                return classeCreated
            end
        end
    }

    setmetatable(newClasse, {
        __index = function (self, key)
            if (modifiers[key]) then
                return modifiers[key]
            end

            if (classes[className]) then
                return classes[className][key]
            end

            error('Class ' .. className .. ' not found', 2)
        end,

        __call = function(self, ...)
            if (classes[className]) then
                error('Class ' .. className .. ' already exists.', 2)
            end

            local newInstance = createClass(className, ...)
            return newInstance
        end
    })

    return newClasse
end

function new(className)
    return function(...)
        local classe = classes[className]
        if (not classe) then
            error('Class ' .. className .. ' not found', 2)
        end

        local super = classe.super
        local newObj = table_copy(classe, super)
        if (newObj.constructor) then
            newObj:constructor(...)
        end

        return newObj
    end
end

function derivedFrom(instance, className)
    local class = classes[className]
    if(not class) then
        error("Class \"" .. className .. "\" not found", 2)
    end

    if instance and (className == instance.baseClassName) then
        return true
    end

    return false
end

function instanceOf(instance, className)
    local classe = classes[className]
    if (not classe) then
        error('Class ' .. className .. ' not found', 2)
    end

    if (instance.__name == className) then
        return true
    end

    return false
end