lenix 1.3.0 → 1.3.2

package/lua/_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"
+

package/lua/index.lua

@@ -0,0 +1,322 @@
+assert(_VERSION == "Lua 5.4", "THIS MODULE REQUIRES Lua 5.4")
+
+
+---@alias MemberKey string | "get" | "set" | "constructor"
+---@alias Member ShorthandedMemberValue | MemberEntries | Getter | Setter | Constructor
+---@alias ShorthandedMemberValue number | string | boolean | fun(self: unknown, ...: unknown): unknown?
+---@alias MemberEntries {[1]: MemberValue, [2]?: MemberFlag, [3]?: MemberFlag, [4]?: MemberFlag, [5]?: MemberFlag, [6]?: MemberFlag}
+---@alias MemberValue number | string | boolean | table | nil | fun(self: unknown, ...: unknown): unknown
+---@alias MemberFlag boolean | nil
+---@alias Getter fun(self: unknown): unknown
+---@alias Setter fun(self: unknown, value: unknown): nil
+---@alias Constructor fun(self: unknown, super: fun(...: any): unknown, ...: unknown): unknown
+---@alias Members table<string, PropertyFlags>
+---@alias MembersValues table<string, MemberValue>
+---@alias RawMembers table<MemberKey, Member>
+
+---@class PropertyFlags
+---@field private MemberFlag
+---@field static MemberFlag
+---@field final MemberFlag
+---@field virtual MemberFlag
+---@field override MemberFlag
+
+---@param Members RawMembers
+---@param Parent? unknown
+local class<const> = function (Members, Parent)
+  ---@type Members
+  local members<const> = {}
+  ---@type MembersValues
+  local membersValues<const> = {}
+  local default<const> = function(existingValue, defaultValue)
+    if existingValue ~= nil then
+      return existingValue
+    else return defaultValue end
+  end
+  ---@type table<string, Getter>
+  local getters<const> = {}
+  ---@type table<string, Setter>
+  local setters<const> = {}
+
+  for memberKey, member in pairs(Members) do
+    assert(member ~= nil, ("syntax error: expected member, got `%s`"):format(type(member)))
+    if memberKey == "constructor" then
+      if type(member) ~= "function" then error(("syntax error: constructor expected `function`, got `%s`"):format(type(member))) end
+    elseif memberKey == "get" then
+      if type(member) ~= "table" then error(("syntax error: get expected `table`, got `%s`"):format(type(member))) end
+      ---@cast member table<string, Getter>
+      for getterKey, getter in pairs(member) do
+        if type(getter) ~= "function" then error(("syntax error: the getters(`%s`) can be only a `function`, got `%s`"):format(getterKey, type(getter))) end
+        local getterInfo<const> = debug.getinfo(getter, "u")
+        if getterInfo.nparams ~= 1 then error(("syntax error: the getters(`%s`) can not have parameters (excluding `self`)"):format(getterKey)) end
+        getters[getterKey] = getter
+      end
+    elseif memberKey == "set" then
+      if type(member) ~= "table" then error(("syntax error: set expected `table`, got `%s`"):format(type(member))) end
+      ---@cast member table<string, Setter>
+      for setterKey, setter in pairs(member) do
+        if type(setter) ~= "function" then error(("syntax error: the setters(`%s`) can be only a `function`, got `%s`"):format(setterKey, type(setter))) end
+        local getterInfo<const> = debug.getinfo(setter, "u")
+        if getterInfo.nparams ~= 2 then error(("syntax error: the setters(`%s`) must have exactly one parameter (excluding `self`)"):format(setterKey)) end
+        setters[setterKey] = setter
+      end
+    else
+      members[memberKey] = {}
+      if type(member) == "table" then
+        membersValues[memberKey] = member[1]
+        members[memberKey] = {
+          private = default(member[2], true),
+          static = default(member[3], false),
+          final = default(member[4], false),
+          virtual = default(member[5], false),
+          override = default(member[6], true),
+        }
+      else
+        membersValues[memberKey] = member
+        members[memberKey] = {
+          private = true,
+          static = false,
+          final = true,
+          virtual = false,
+          override = false,
+        }
+      end
+    end
+  end
+
+  for memberKey, member in pairs(members) do
+    if member.override then
+      if not Parent or not Parent.__extended then
+        error(("cannot override `%s`: no parent class was derived"):format(memberKey))
+      end
+
+      local parentMember<const> = Parent.__extended.members[memberKey]
+      if not parentMember then
+        error(("override failed: no such `%s` parent method"):format(memberKey))
+      end
+
+      if not parentMember.virtual then
+        error(("override denied: the parent method `%s` is not virtual"):format(memberKey))
+      end
+    end
+  end
+
+  if Parent and Parent.__extended then
+    for memberKey, member in pairs(Parent.__extended.members) do
+      if not members[memberKey] then
+        members[memberKey] = member
+        membersValues[memberKey] = Parent.__extended.membersValues[memberKey]
+      else
+        if not members[memberKey].override then
+          error(("method `%s` already exists in parent, did you mean to use the override flag"):format(memberKey))
+        end
+      end
+    end
+
+    for getterKey, getter in pairs(Parent.__extended.getters) do
+      if not getters[getterKey] then
+        getters[getterKey] = getter
+      end
+    end
+
+    for setterKey, setter in pairs(Parent.__extended.setters) do
+      if not setters[setterKey] then
+        setters[setterKey] = setter
+      end
+    end
+  end
+
+  return setmetatable({
+    __extended = {
+      members = members,
+      membersValues = membersValues,
+      getters = getters,
+      setters = setters
+    },
+    new = function(self, ...)
+      ---@type MembersValues
+      local instance<const> = {}
+      for memberKey, member in pairs(members) do
+        if not member.static then
+          instance[memberKey] = membersValues[memberKey]
+        end
+      end
+
+      if Members.constructor and not Parent then
+        Members.constructor(instance, nil, ...)
+      elseif Members.constructor and Parent then
+        local super<const> = function(...)
+          local parentInstance<const> = Parent:new(...)
+
+          local parentMetatable<const> = debug.getmetatable(parentInstance)
+          if parentMetatable and parentMetatable.__instance then
+            for memberKey, memberValue in pairs(parentMetatable.__instance) do
+              local parentMember<const> = Parent.__extended.members[memberKey]
+              if members[memberKey] and members[memberKey].override then
+              elseif parentMember and not parentMember.private then
+                instance[memberKey] = memberValue
+              end
+            end
+          end
+
+          return parentInstance
+        end
+        Members.constructor(instance, super, ...)
+      else error("no constructor was provided") end
+
+      for memberKey, member in pairs(members) do
+        if not instance[memberKey] and not member.static and not member.private then
+          error(("the `%s` was not instantiated in constructor"):format(memberKey))
+        end
+      end
+
+      if Parent and Parent.__extended then
+        for memberKey, member in pairs(Parent.__extended.members) do
+          if not instance[memberKey] and not member.static and not member.private then
+            error(("derived member `%s` was not instantiated"):format(memberKey))
+          end
+        end
+      end
+
+      return setmetatable({}, {
+        __metatable = "access denied",
+        __instance = instance,
+        __index = function(_, memberKey)
+          local member<const> = members[memberKey]
+          if not member then 
+            if getters[memberKey] then
+              return getters[memberKey](instance)
+            elseif Parent and Parent.__extended then
+              local parentMember<const> = Parent.__extended.members[memberKey]
+              if parentMember then
+                if parentMember.private then
+                  error(("`%s` is not a public member"):format(memberKey))
+                end
+                return instance[memberKey]
+              end
+            elseif setters[memberKey] then
+              error(("`%s` setter can not be accessed"):format(memberKey))
+            end
+            error(("`%s` does not exist"):format(memberKey))  
+          end
+          assert(not member.private, ("`%s` is not a public member"):format(memberKey))
+          assert(not member.static, ("`%s` is a static member"):format(memberKey))
+
+          local value<const> = instance[memberKey]
+          if type(value) == "function" then
+            return function(_, ...)
+              return value(instance, ...)
+            end
+          end
+
+          return value
+        end,
+        __newindex = function(_, memberKey, memberValue)
+          if setters[memberKey] then
+            setters[memberKey](instance, memberValue)
+            return
+          end
+
+          local member = members[memberKey]
+
+          if not member and Parent and Parent.__extended then
+            member = Parent.__extended.members[memberKey]
+          end
+
+          if not member then 
+            if getters[memberKey] then
+              error(("getters can not be modified: at `%s`"):format(memberKey))
+            end
+            error(("`%s` does not exist"):format(memberKey))
+          end
+
+          assert(not member.private, ("`%s` is not a public member"):format(memberKey))
+          assert(not member.static, ("`%s` is a static member"):format(memberKey))
+          assert(not member.final, ("`%s` is a readonly member"):format(memberKey))
+
+          instance[memberKey] = memberValue
+        end
+      })
+    end
+  }, {
+    __metatable = "access denied",
+    __index = function(self, memberKey)
+      local member<const> = members[memberKey]
+      if not member then
+        if getters[memberKey] then
+          return getters[memberKey](membersValues)
+        elseif Parent then
+          return Parent[memberKey]
+        elseif setters[memberKey] then
+          error(("setters can not be accessed: at `%s`"):format(memberKey))
+        end
+        error(("`%s` does not exist"):format(memberKey))
+      end
+      assert(not member.private, ("`%s` is not a public member"):format(memberKey))
+      assert(member.static, ("`%s` is not a static member"):format(memberKey))
+      local value<const> = membersValues[memberKey]
+
+      if type(value) == "function" then
+        return function(...)
+          return value(membersValues, ...)
+        end
+      end
+
+      return value
+    end,
+    __newindex = function(self, memberKey, memberValue)
+      local member<const> = members[memberKey]
+      if not member then
+        if setters[memberKey] then
+          setters[memberKey](membersValues, memberValue)
+          return
+        elseif Parent then
+          Parent[memberKey] = memberValue
+          return
+        elseif getters[memberKey] then
+          error(("getters can not be modified: at `%s`"):format(memberKey))
+        end
+        error(("`%s` does not exist"):format(memberKey))
+      end
+      assert(not member.private, ("`%s` is not a public member"):format(memberKey))
+      assert(member.static, ("`%s` is not a static member"):format(memberKey))
+      assert(not member.final, ("`%s` is a readonly member"):format(memberKey))
+      membersValues[memberKey] = memberValue
+    end
+  })
+end
+
+
+-- annotation tests section
+local private<const>, static<const>, final<const>, virtual<const>, override<const> = true, true, true, true, true
+class({
+  property1 = 10,
+  property4 = {10},
+  property7 = {10, private, false, final, false, override},
+  property2 = "hello",
+  property5 = {"hello"},
+  property8 = {"hello", false, static, false, virtual, false},
+  property3 = true,
+  property6 = {true},
+  property9 = {true, private, false, final, false, override},
+  property10 = nil, -- SYNTAX ERROR
+  property11 = {nil},
+  property12 = {nil, false, static, false, virtual, false},
+  method1 = function(self) end,
+  method2 = {function(self) end},
+  method3 = {function(self) end, private, false, final, false, override},
+  get = {
+    getter1 = function(self)
+      return self.property1
+    end,
+  },
+  set = {
+    setter1 = function(self, value)
+      self.property1 = value
+    end,
+  },
+  constructor = function(self, super, value)
+    super(value)
+    self.property1 = value
+  end
+})

package/lua/lenix-0.1.0-1.rockspec

@@ -0,0 +1,25 @@
+package = "lenix"
+version = "0.1.0-1"
+
+source = {
+   url = "git+https://github.com/lenixdev/lenix.git",
+   tag = "v0.1.0"
+}
+
+description = {
+   summary = "Lua OOP class module similar to TypeScript/JavaScript/Java/C++ classes",
+   detailed = "Lua object oriented programming class module with support for constructors, getters, setters, inheritance, static members, private members, final members, and virtual/override methods.",
+   homepage = "https://github.com/lenixdev/lenix/lua",
+   license = "MIT"
+}
+
+dependencies = {
+   "lua == 5.4"
+}
+
+build = {
+   type = "builtin",
+   modules = {
+      lenix = "index.lua"
+   }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lenix",
-  "version": "1.3.0",
-  "description": "Helpful modules for the software engineers",
+  "version": "1.3.2",
+  "description": "The Monorepo for the software engineering community",
   "author": "Lenix",
   "license": "GPL-3.0",
   "type": "module",
@@ -15,21 +15,24 @@
     "fxmanifest",
     "api",
     "oop",
-    "class"
+    "class",
+    "eslint",
+    "linter"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lenixdev/lenix.git"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./ts/dist/index.js",
+  "types": "./ts/dist/index.d.ts",
   "bin": {
-    "mac-lua-modules": "bin/mac-lua_modules.sh",
-    "lenix": "./bin/dist/lint.mjs"
+    "mac-lua-modules": "lua/mac-lua-modules.sh",
+    "lenix": "./lint/dist/lint.mjs"
   },
   "files": [
-    "dist",
-    "bin"
+    "ts/dist",
+    "lua",
+    "lint"
   ],
   "dependencies": {
     "@eslint/js": "^10.0.1",
@@ -48,6 +51,7 @@
     "typescript": "^5.3.3"
   },
   "scripts": {
-    "build": "tsc -p src/fxmanifest/tsconfig.json && tsc-alias && tsc -p bin/tsconfig.json"
+    "build": "tsc -p ts/fxmanifest/tsconfig.json && tsc-alias && tsc -p lint/tsconfig.json",
+    "bump": "pnpm version patch"
   }
 }