lenix 1.3.3 → 1.3.4

package/lua/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lenix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lua/src/_dev/firstAttempt.lua

@@ -0,0 +1,202 @@
+local class<const> = function (fields)
+  local defined<const> = {}
+  local private<const> = fields.private or {}
+  local getter<const> = fields.get or {}
+  local setter<const> = fields.set or {}
+  local accessor<const> = fields.accessor or {}
+  local privates<const> = { static = {}, instance = {} }
+  local setProperties<const> = { static = {}, instance = {} }
+  local getProperties<const> = { static = {}, instance = {} }
+
+  local isVariableEligible<const> = function (variable, valueType, value)
+    if defined[variable] then
+      print(("`%s` is already defined"):format(variable))
+      return
+    elseif type(value) ~= valueType and valueType ~= "any" then
+      print(("type mismatch for `%s`, expected `%s`, got `%s`"):format(variable, valueType, type(value)))
+      return
+    end
+    defined[variable] = true
+    if valueType == "any" then
+      print(("variable `%s` implicitly has type `%s`"):format(variable, valueType, type(value)))
+    end
+    return true
+  end
+
+  local fieldPairs<const> = {
+    {private, privates},
+    {getter, getProperties},
+    {setter, setProperties},
+    {accessor, nil}
+  }
+
+  for _, pair in ipairs(fieldPairs) do
+    local source, target = pair[1], pair[2]
+    for variable, values in pairs(source) do
+      -- getPropertyValue
+      local value<const> = type(values) == "table" and values[1]
+      -- getPropertyType
+      local valueType<const> = type(values) == "table" and values[2] or "any"
+      local staticValue<const> = values and values[3] or false
+      if isVariableEligible(variable, valueType, value) then
+        -- fill table with keys and values
+        if target then
+          if staticValue then
+            target["static"][variable] = value
+          else
+            target["instance"][variable] = value
+          end
+        else
+          if staticValue then
+            getProperties["static"][variable] = value
+            setProperties["static"][variable] = value
+          else
+            getProperties["instance"][variable] = value
+            setProperties["instance"][variable] = value
+          end
+        end
+      end
+    end
+  end
+
+  return setmetatable({
+    new = function (self, ...)
+      local newInstanceArgs = {...}
+      print(self)
+      local constructor<const> = fields.constructor
+      constructor(self, nil, ...)
+      return setmetatable({}, {
+        __index = function (_, variableKey)
+          if getter["instance"][variableKey] then
+            return getProperties["instance"][variableKey]
+          elseif accessor["instance"][variableKey] then
+            return getProperties["instance"][variableKey]
+          end
+        end,
+      })
+    end
+  }, {
+    __index = function(_, variableKey)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      -- isPropertyExist
+      if getter[variableKey] ~= nil then
+        if isStatic(getter, variableKey, "get") then
+          -- returnPropertyValue
+          return getProperties["static"][variableKey]
+        end
+      elseif accessor[variableKey] ~= nil then
+        if isStatic(accessor, variableKey, "accessor") then
+          return getProperties["static"][variableKey]
+        end
+      elseif private[variableKey] ~= nil then
+        print(("cannot read the private property `%s`"):format(variableKey))
+      elseif setter[variableKey] ~= nil then
+        print(("the setter only property `%s` can not be accessed"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end,
+    __newindex = function (_, variableKey, variableValue)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      if setter[variableKey] ~= nil then
+        if not isStatic(setter, variableKey, "set") then
+          local valueType = setter[variableKey][2] or "any"
+          if type(variableValue) ~= valueType and valueType ~= "any" then
+            print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+            return
+          end
+        end
+        getProperties["static"][variableKey] = variableValue
+      elseif accessor[variableKey] ~= nil then
+        if not isStatic(accessor, variableKey, "accessor") then
+          local valueType = accessor[variableKey][2] or "any"
+          if type(variableValue) ~= valueType and valueType ~= "any" then
+            print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+            return
+          end
+        end
+        getProperties["static"][variableKey] = variableValue
+      elseif getter[variableKey] ~= nil then
+        print(("the getter only property `%s `can not be set"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end
+  })
+end
+
+myClass = class({
+  private = {
+    height = {197, "number"},
+  },
+  get = {
+    blood = {"O+", "any"},
+  },
+  set = {
+    date = {2005, "number"},
+  },
+  accessor = {
+    age = {20, "number"},
+    name = {"Lenix", "string"},
+    getBlood = {function(self) return self end, "function"}
+  },
+  constructor = function(self, super, name, age)
+    self.name = name
+    self.age = age
+  end
+})
+
+
+local Person = myClass:new("Dev", 21)
+print(Person.name, Person.age)
+-- Person.date = 2005
+-- print(Person.date)
+-- print(Person.age)
+-- Person.age = 21
+
+-- print(myClass.height)
+-- print(myClass.blood)
+-- myClass.date = 2026
+-- print(myClass.age)
+-- myClass.age = 21
+-- print(myClass.age)
+-- print(myClass.name)
+-- myClass.name = "Dev"
+-- print(myClass.name)
+-- print(myClass.getBlood())
+-- myClass.getBlood = function() return true end
+-- print(myClass.getBlood())
+
+
+
+
+__index = function(_, variableKey)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      -- isPropertyExist
+      if getter[variableKey] ~= nil then
+        -- returnPropertyValue
+        return getProperties[variableKey]
+      elseif accessor[variableKey] ~= nil then
+        return getProperties[variableKey]
+      elseif private[variableKey] ~= nil then
+        print(("cannot read the private property `%s`"):format(variableKey))
+      elseif setter[variableKey] ~= nil then
+        print(("the setter only property `%s` are forbidden to be accessed"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end,
+    __newindex = function (_, variableKey, variableValue)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      if setter[variableKey] ~= nil then
+        local valueType = setter[variableKey][2] or "any"
+        if type(variableValue) ~= valueType and valueType ~= "any" then
+          print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+          return
+        end
+        getProperties[variableKey] = variableValue
+      elseif accessor[variableKey] ~= nil then
+        local valueType = accessor[variableKey][2] or "any"
+        if type(variableValue) ~= valueType and valueType ~= "any" then
+          print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+          return
+        end
+        getProperties[variableKey] = variableValue
+      elseif getter[variableKey] ~= nil then
+        print(("the getter only property `%s `can not be set"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end

package/lua/src/_dev/secondAttempt.lua

@@ -0,0 +1,166 @@
+assert(_VERSION == "Lua 5.4", "THIS MODULE REQUIRES Lua 5.4")
+
+local class<const> = function (fields)
+  local definedProperties<const> = {}
+  local promisedToBeConstructed<const> = {}
+  local private<const> = fields.private or {}
+  local getter<const> = fields.get or {}
+  local setter<const> = fields.set or {}
+  local accessor<const> = fields.accessor or {}
+  local privates<const> = {}
+  local setProperties<const> = {}
+  local getProperties<const> = {}
+
+  local isVariableEligible<const> = function (propertyKey, propertyType, propertyValue)
+    if definedProperties[propertyKey] then
+      print(("`%s` is already defined"):format(propertyKey))
+      return
+    elseif type(propertyValue) ~= propertyType and propertyType ~= "any" and propertyValue ~= nil then
+      error(("type mismatch for `%s`, defined `%s`, appointed `%s`"):format(propertyKey, propertyType, type(propertyValue)))
+      return
+    end
+    definedProperties[propertyKey] = true
+    if propertyType == "any" then
+      print(("variable `%s` implicitly has type `%s`"):format(propertyKey, propertyType, type(propertyValue)))
+    end
+    if propertyValue == nil and propertyType ~= "nil" then
+      promisedToBeConstructed[propertyKey] = true
+    end
+    return true
+  end
+
+  local fieldPairs<const> = {
+    {private, privates},
+    {getter, getProperties},
+    {setter, setProperties},
+    {accessor, nil}
+  }
+
+  for _, pair in ipairs(fieldPairs) do
+    local field<const>, properties<const> = pair[1], pair[2]
+    for propertyKey, propertyValues in pairs(field) do
+      -- getPropertyValue
+      local propertyValue<const> = type(propertyValues) == "table" and propertyValues[1]
+      -- getPropertyType
+      assert(type(propertyValues) == 'table', ("syntax error at `%s`, expected `%s`, got `%s`"):format(propertyKey, "table", type(propertyValues)))
+      local propertyType<const> = propertyValues[2]
+      if isVariableEligible(propertyKey, propertyType, propertyValue) then
+        -- fill table with keys and values
+        if properties then
+          properties[propertyKey] = propertyValue
+        else
+          -- for the accessor, filling the get and set permission
+          getProperties[propertyKey], setProperties[propertyKey] = propertyValue, propertyValue
+          setter[propertyKey], getter[propertyKey] = accessor[propertyKey], accessor[propertyKey]
+        end
+      end
+    end
+  end
+
+  local get<const> = function (self, propertyKey)
+    if definedProperties[propertyKey] then
+      if getter[propertyKey] then
+        if type(self[propertyKey]) == 'function' then
+          return function(...) return self[propertyKey](self, ...) end
+        end
+        return self[propertyKey]
+      elseif private[propertyKey] then
+        print(("private property `%s` is not allowed to be accessed"):format(propertyKey))
+      else print(("tried to get the `%s` set-only property"):format(propertyKey)) end
+    else
+      print(("`%s` property does not exist"):format(propertyKey))
+    end
+  end
+  local set<const> = function (self, propertyKey, propertyValue)
+    if definedProperties[propertyKey] then
+      if setter[propertyKey] then
+        if type(propertyValue) == setter[propertyKey][2] or setter[propertyKey][2] == "any" then
+          self[propertyKey] = propertyValue
+        else print(("`%s` is not assignable to `%s`: on `%s`"):format(type(propertyValue), setter[propertyKey][2], propertyKey)) end
+      elseif private[propertyKey] then
+        print(("private property `%s` is not allowed to be assigned"):format(propertyKey))
+      else print(("tried to set the `%s` get-only property"):format(propertyKey)) end
+    else
+      print(("`%s` property does not exist"):format(propertyKey))
+    end
+  end
+
+  return setmetatable({
+    new = function(self, ...)
+      local instance<const> = {}
+
+      for _, pair in pairs(fieldPairs) do
+        for propertyKey, propertyValue in pairs(pair[2] or {}) do
+          instance[propertyKey] = propertyValue
+        end
+      end
+
+      setmetatable(instance, getmetatable(self))
+
+      if fields.constructor then
+        fields.constructor(instance, nil, ...)
+      else error('no constructor was provided') end
+
+      -- Constructor has finished, now validate
+      for propertyKey in pairs(promisedToBeConstructed) do
+        if instance[propertyKey] == nil then
+          error(('the `%s` was not instantiated in constructor as promised'):format(propertyKey))
+        end
+      end
+
+      return setmetatable({}, {
+        __index = function(_, propertyKey)
+          return get(instance, propertyKey)
+        end,
+        __newindex = function(_, propertyKey, varValue)
+          set(instance, propertyKey, varValue)
+        end
+      })
+    end
+  }, { })
+end
+
+local myClass<const> = class({
+  private = {
+    height = {nil, "number"},
+  },
+  get = {
+    blood = {nil, "string"},
+    getHeight = {function(self, new)
+      self.setHeight(self, new)
+      return self.height
+    end, "function"}
+  },
+  set = {
+    setHeight = {
+      function(new)
+        self.height = new
+      end, "function"
+    },
+  },
+  accessor = {
+    name = {nil, "string"},
+    age = {nil, "number"},
+  },
+  constructor = function(self, super, name, age, height, blood)
+    self.name = name
+    self.age = age
+    self.height = height
+    self.blood = blood
+  end
+})
+
+
+local Class<const> = myClass:new("Lenix", 20, 197, "O+")
+Class.setHeight = function(self, new)
+  self.height = new
+end
+
+
+
+print(Class.getHeight(198))
+
+
+
+
+

package/lua/src/_dev/tests.lua

@@ -0,0 +1,298 @@
+--[[ These are the tests that we have tried to get working with Lua-OOP, if you have any suggestions or improvements, please let us know. ]]
+
+local User = class({
+  name = {nil, false},
+  age = {nil, false},
+  constructor = function(self, super, name, age)
+    self.name = name
+    self.age = age
+  end
+})
+local u = User:new("Alice", 25)
+assert(u.name == "Alice" and u.age == 25, "Test 1 failed")
+local User = class({
+  password = {nil, true},  -- private
+  constructor = function(self, super, pwd)
+    self.password = pwd
+  end
+})
+local u = User:new("secret")
+local ok = pcall(function() print(u.password) end)
+assert(not ok, "Test 2 failed: private property accessible")
+
+-- Test 3: Private property accessible internally
+local User = class({
+  password = {nil, true},
+  getPassword = {function(self) return self.password end, false},
+  constructor = function(self, super, pwd)
+    self.password = pwd
+  end
+})
+local u = User:new("secret")
+assert(u.getPassword() == "secret", "Test 3 failed")
+local User = class({
+  count = {0, false, true},  -- static
+  name = {nil, false},
+  constructor = function(self, super, name)
+    self.name = name
+  end
+})
+User.count = 5
+local u = User:new("Alice")
+local ok = pcall(function() print(u.count) end)
+assert(not ok, "Test 4 failed: static accessible on instance")
+assert(User.count == 5, "Test 4 failed: static not on class")
+
+-- Test 5: Instance properties on instance, not class
+local ok2 = pcall(function() print(User.name) end)
+assert(not ok2, "Test 5 failed: instance accessible on class")
+local User = class({
+  id = {1, false, false, true},  -- immutable
+  constructor = function(self, super, id)
+    self.id = id
+  end
+})
+local u = User:new(100)
+local ok = pcall(function() u.id = 999 end)
+assert(not ok, "Test 6 failed: immutable modified")
+assert(u.id == 100, "Test 6 failed: immutable changed")
+
+-- Test 7: Mutable property can be changed
+local User = class({
+  name = {nil, false, false, false},  -- mutable
+  constructor = function(self, super, name)
+    self.name = name
+  end
+})
+local u = User:new("Alice")
+u.name = "Bob"
+assert(u.name == "Bob", "Test 7 failed")
+local User = class({
+  _value = {0, true},
+  get = {
+    value = function(self) return self._value * 2 end
+  },
+  constructor = function(self, super, val)
+    self._value = val
+  end
+})
+local u = User:new(5)
+assert(u.value == 10, "Test 8 failed")
+
+-- Test 9: Setter works
+local User = class({
+  _value = {0, true},
+  getValue = {function(self) return self._value end, false},  -- Add getter
+  set = {
+    value = function(self, val) self._value = val * 2 end
+  },
+  constructor = function(self) self._value = 0 end
+})
+local u = User:new()
+u.value = 5
+assert(u.getValue() == 10, "Test 9 failed")
+
+-- Test 10: Getter can't be modified (correct version)
+local User = class({
+  _value = {0, true},
+  get = {
+    value = function(self) return self._value end  -- Getter only, no setter
+  },
+  constructor = function(self) self._value = 10 end
+})
+local u = User:new()
+local ok = pcall(function() u.value = 20 end)  -- Try to set getter-only property
+assert(not ok, "Test 10 failed: getter modified")
+
+local Parent = class({
+  id = {1, false},
+  constructor = function(self, super, id)
+    self.id = id
+  end
+})
+local Child = class({
+  name = {nil, false},
+  constructor = function(self, super, name, id)
+    super(id)
+    self.name = name
+  end
+}, Parent)
+local c = Child:new("Alice", 100)
+assert(c.id == 100 and c.name == "Alice", "Test 11 failed")
+
+-- Test 12: Child inherits parent getters
+local Parent = class({
+  value = {10, false},
+  get = {
+    getValue = function(self) return self.value end
+  },
+  constructor = function(self, super, val)
+    self.value = val
+  end
+})
+local Child = class({
+  name = {nil, false},
+  constructor = function(self, super, name, val)
+    super(val)
+    self.name = name
+  end
+}, Parent)
+local c = Child:new("Test", 42)
+assert(c.getValue == 42, "Test 12 failed")
+
+-- Test 13: Child inherits parent setters
+local Parent = class({
+  _value = {0, true},
+  getValue = {function(self) return self._value end, false},
+  set = {
+    value = function(self, val) self._value = val * 2 end
+  },
+  constructor = function(self)
+    self._value = 0
+  end
+})
+local Child = class({
+  name = {nil, false},
+  constructor = function(self, super, name)
+    super()
+    self.name = name
+  end
+}, Parent)
+local c = Child:new("Test")
+c.value = 5
+assert(c.getValue() == 10, "Test 13 failed")
+local Parent = class({
+  secret = {nil, true},  -- private
+  constructor = function(self, super, sec)
+    self.secret = sec
+  end
+})
+local Child = class({
+  name = {nil, false},
+  constructor = function(self, super, name, sec)
+    super(sec)
+    self.name = name
+  end
+}, Parent)
+local c = Child:new("Alice", "password")
+local ok = pcall(function() print(c.secret) end)
+assert(not ok, "Test 14 failed: parent private accessible")
+
+-- Test 15: Parent immutable property blocked in child
+local Parent = class({
+  id = {1, false, false, true},  -- immutable
+  constructor = function(self, super, id)
+    self.id = id
+  end
+})
+local Child = class({
+  constructor = function(self, super, id)
+    super(id)
+  end
+}, Parent)
+local c = Child:new(100)
+local ok = pcall(function() c.id = 999 end)
+assert(not ok, "Test 15 failed: parent immutable modified")
+local Parent = class({
+  greet = {function(self) return "Hello from parent" end, false, false, false, true},
+  constructor = function(self) end
+})
+local Child = class({
+  greet = {function(self) return "Hello from child" end, false, false, true, false, true},
+  constructor = function(self, super) super() end
+}, Parent)
+local c = Child:new()
+print(c.greet())  -- Should print "Hello from child", probably prints "Hello from parent"
+local Grandparent = class({
+  id = {1, false},
+  constructor = function(self, super, id)
+    self.id = id
+  end
+})
+local Parent = class({
+  name = {nil, false},
+  constructor = function(self, super, name, id)
+    super(id)
+    self.name = name
+  end
+}, Grandparent)
+local Child = class({
+  age = {nil, false},
+  constructor = function(self, super, age, name, id)
+    super(name, id)
+    self.age = age
+  end
+}, Parent)
+local c = Child:new(20, "Alice", 100)
+assert(c.id == 100 and c.name == "Alice" and c.age == 20, "Test 17 failed")
+local Parent = class({
+  count = {0, false, true},  -- static
+  constructor = function(self) end
+})
+local Child = class({
+  constructor = function(self, super) super() end
+}, Parent)
+assert(Child.count == 0, "Test 18 failed")
+-- This might fail - test it
+
+local User = class({
+  name = {nil, false},
+  greet = {function(self) return "Hello " .. self.name end, false},
+  constructor = function(self, super, name)
+    self.name = name
+  end
+})
+local u = User:new("Alice")
+assert(u.greet() == "Hello Alice", "Test 19 failed")
+
+-- Test 20: Static methods work
+local User = class({
+  create = {function(self, name) return "Created " .. name end, false, true}, -- 481
+  constructor = function(self) end
+})
+assert(User.create("Alice") == "Created Alice", "Test 20 failed")
+local User = class({
+  name = {nil, false},
+  constructor = function(self, super, name)
+    self.name = name
+  end
+})
+local u1 = User:new("Alice")
+local u2 = User:new("Bob")
+u1.name = "Charlie"
+assert(u1.name == "Charlie" and u2.name == "Bob", "Test 21 failed")
+
+-- Test 22: Metatable protection
+local User = class({
+  constructor = function(self) end
+})
+local u = User:new()
+local mt = getmetatable(u)
+assert(mt == "access denied", "Test 22 failed: metatable exposed")
+
+-- Test 23: Constructor validation
+local User = class({
+  name = {nil, false},
+  age = {nil, false},
+  constructor = function(self, super, name)
+    self.name = name
+    -- Forgot to set age
+  end
+})
+local ok = pcall(function() User:new("Alice") end)
+assert(not ok, "Test 23 failed: validation missed unset property")
+
+
+local Parent = class({
+  greet = {function(self) return "Hello from parent" end, false, false, false, true}, 
+  constructor = function(self) end
+})
+
+local Child = class({
+  greet = {function(self) return "Hello from child" end, false, false, false, false, true},
+  constructor = function(self, super) super() end
+}, Parent)
+
+local c = Child:new()
+print(c.greet())  -- Should print "Hello from child"
+