From f7137765438f149cbae6f3b18da45dce75a25336 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 14 Jun 2024 12:16:12 -0400
Subject: Move Lua modules for 'require' to indra/newview/scripts/lua/require.

Make viewer_manifest.py copy them into the viewer install image.

Make the require() function look for them there.
---
 indra/newview/scripts/lua/require/util.lua | 69 ++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 indra/newview/scripts/lua/require/util.lua

(limited to 'indra/newview/scripts/lua/require/util.lua')

diff --git a/indra/newview/scripts/lua/require/util.lua b/indra/newview/scripts/lua/require/util.lua
new file mode 100644
index 0000000000..bfbfc8637c
--- /dev/null
+++ b/indra/newview/scripts/lua/require/util.lua
@@ -0,0 +1,69 @@
+-- utility functions, in alpha order
+
+local util = {}
+
+-- Allow MyClass(ctor args...) equivalent to MyClass:new(ctor args...)
+-- Usage:
+-- local MyClass = {}
+-- function MyClass:new(...)
+--     ...
+-- end
+-- ...
+-- util.classctor(MyClass)
+-- or if your constructor is named something other than MyClass:new(), e.g.
+-- MyClass:construct():
+-- util.classctor(MyClass, MyClass.construct)
+-- return MyClass
+function util.classctor(class, ctor)
+    -- get the metatable for the passed class
+    local mt = getmetatable(class)
+    if mt == nil then
+        -- if it doesn't already have a metatable, then create one
+        mt = {}
+        setmetatable(class, mt)
+    end
+    -- now that class has a metatable, set its __call method to the specified
+    -- constructor method (class.new if not specified)
+    mt.__call = ctor or class.new
+end
+
+-- check if array-like table contains certain value
+function util.contains(t, v)
+    return table.find(t, v) ~= nil
+end
+
+-- reliable count of the number of entries in table t
+-- (since #t is unreliable)
+function util.count(t)
+    local count = 0
+    for _ in pairs(t) do
+        count += 1
+    end
+    return count
+end
+
+-- cheap test whether table t is empty
+function util.empty(t)
+    return not next(t)
+end
+
+-- recursive table equality
+function util.equal(t1, t2)
+    if not (type(t1) == 'table' and type(t2) == 'table') then
+        return t1 == t2
+    end
+    -- both t1 and t2 are tables: get modifiable copy of t2
+    local temp = table.clone(t2)
+    for k, v in pairs(t1) do
+        -- if any key in t1 doesn't have same value in t2, not equal
+        if not util.equal(v, temp[k]) then
+            return false
+        end
+        -- temp[k] == t1[k], delete temp[k]
+        temp[k] = nil
+    end
+    -- All keys in t1 have equal values in t2; t2 == t1 if there are no extra keys in t2
+    return util.empty(temp)
+end
+
+return util
-- 
cgit v1.2.3


From a80b9487dc7c893f5e96f48f15140a5f82b99e30 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 23 Aug 2024 17:18:14 -0400
Subject: Allow UI to have lazily-loaded submodules.

Equip UI with an __index metamethod. When someone references an unknown
key/field in UI, require() that module and cache it for future reference.

Add util.setmetamethods() as a way to find or create a metatable on a
specified table containing specified metamethods.

Exercise the new functionality by referencing UI.popup in test_popup.lua.
---
 indra/newview/scripts/lua/require/util.lua | 46 +++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 10 deletions(-)

(limited to 'indra/newview/scripts/lua/require/util.lua')

diff --git a/indra/newview/scripts/lua/require/util.lua b/indra/newview/scripts/lua/require/util.lua
index bfbfc8637c..a000359226 100644
--- a/indra/newview/scripts/lua/require/util.lua
+++ b/indra/newview/scripts/lua/require/util.lua
@@ -15,16 +15,9 @@ local util = {}
 -- util.classctor(MyClass, MyClass.construct)
 -- return MyClass
 function util.classctor(class, ctor)
-    -- get the metatable for the passed class
-    local mt = getmetatable(class)
-    if mt == nil then
-        -- if it doesn't already have a metatable, then create one
-        mt = {}
-        setmetatable(class, mt)
-    end
-    -- now that class has a metatable, set its __call method to the specified
-    -- constructor method (class.new if not specified)
-    mt.__call = ctor or class.new
+    -- set class's __call metamethod to the specified constructor function
+    -- (class.new if not specified)
+    util.setmetamethods{class, __call=(ctor or class.new)}
 end
 
 -- check if array-like table contains certain value
@@ -66,4 +59,37 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
+-- Find or create the metatable for a specified table (a new empty table if
+-- omitted), and to that metatable assign the specified keys.
+-- Setting multiple keys at once is more efficient than a function to set only
+-- one at a time, e.g. setametamethod().
+-- t = util.setmetamethods{__index=readfunc, __len=lenfunc}
+-- returns a new table with specified metamethods __index, __len
+-- util.setmetamethods{t, __call=action}
+-- finds or creates the metatable for existing table t and sets __call
+-- util.setmetamethods{table=t, __call=action}
+-- same as util.setmetamethods{t, __call=action}
+function util.setmetamethods(specs)
+    -- first determine the target table
+    assert(not (specs.table and specs[1]),
+           "Pass setmetamethods table either as positional or table=, not both")
+    local t = specs.table or specs[1] or {}
+    -- remove both ways of specifying table, leaving only the metamethods
+    specs.table = nil
+    specs[1] = nil
+    local mt = getmetatable(t)
+    if not mt then
+        -- t doesn't already have a metatable: just set specs
+        setmetatable(t, specs)
+    else
+        -- t already has a metatable: copy specs into it
+        local key, value
+        for key, value in pairs(specs) do
+            mt[key] = value
+        end
+    end
+    -- having set or enriched t's metatable, return t
+    return t
+end
+
 return util
-- 
cgit v1.2.3


From 2e815acb529159f5b6f0a4365a2eaf64d35330cc Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 23 Aug 2024 21:28:03 -0400
Subject: Encapsulate the lazy submodule idiom as util.submoduledir().

---
 indra/newview/scripts/lua/require/util.lua | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'indra/newview/scripts/lua/require/util.lua')

diff --git a/indra/newview/scripts/lua/require/util.lua b/indra/newview/scripts/lua/require/util.lua
index a000359226..40737a159a 100644
--- a/indra/newview/scripts/lua/require/util.lua
+++ b/indra/newview/scripts/lua/require/util.lua
@@ -92,4 +92,23 @@ function util.setmetamethods(specs)
     return t
 end
 
+-- On the passed module (i.e. table), set an __index metamethod such that
+-- referencing module.submodule lazily requires(path/submodule).
+-- The loaded submodule is cached in the module table so it need not be passed
+-- to require() again.
+-- 'path', like any require() string, can be relative to LuaRequirePath.
+-- Returns the enriched module, permitting e.g.
+-- mymod = util.submoduledir({}, 'mymod')
+function util.submoduledir(module, path)
+    return util.setmetamethods{
+        module,
+        __index=function(t, key)
+            local mod = require(`{path}/{key}`)
+            -- cache the submodule
+            t[key] = mod
+            return mod
+        end
+    }
+end
+
 return util
-- 
cgit v1.2.3