19745365775

Committed 27 Nov 2025 06:39PM UTC coverage: 95.851% (-1.9%) from 97.727%

Build # 19745365775

Build Type

push

github

Committed by

web-flow

Commit Message

Support for extensions (#29)

Run Details

46 of 56 new or added lines in 1 file covered. (82.14%)

6 existing lines in 1 file now uncovered.

462 of 482 relevant lines covered (95.85%)

21.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.85

/LibTSMClass.lua

--- LibTSMClass Library
-- Allows for OOP in lua through the implementation of classes. Many features of proper classes are supported including
-- inhertiance, polymorphism, and virtual methods.
-- @author TradeSkillMaster Team (admin@tradeskillmaster.com)
-- @license MIT

local MINOR_REVISION = 2
local Lib = {} ---@class LibTSMClass
local private = {
        classInfo = {},
        extensionInfo = {},
        instInfo = {},
        constructTbl = nil,
        tempTable = {},
}
-- Set the keys as weak so that class extensions and instances of classes can be GC'd (classes are never GC'd)
local WEAK_KEY_MT = { __mode = "k" }
setmetatable(private.extensionInfo, WEAK_KEY_MT)
setmetatable(private.instInfo, WEAK_KEY_MT)
local SPECIAL_PROPERTIES = {
        __init = true,
        __tostring = true,
        __dump = true,
}
local RESERVED_KEYS = {
        __super = true,
        __isa = true,
        __class = true,
        __name = true,
        __as = true,
        __static = true,
        __private = true,
        __protected = true,
        __abstract = true,
        __closure = true,
        __extend = true,
}
local DEFAULT_INST_FIELDS = {
        __init = function(self)
                -- Do nothing
        end,
        __tostring = function(self)
                return private.instInfo[self].str
        end,
        __dump = function(self)
                private.InstDump(self)
        end,
}
local DUMP_KEY_PATH_DELIM = "\001"



-- ============================================================================
-- Public Library Functions
-- ============================================================================

---@class Class

---@alias ClassProperties
---|'"ABSTRACT"' # An abstract class cannot be directly instantiated

---Defines a new class.
---@generic T: Class
---@param name `T` The name of the class
---@param superclass? any The superclass
---@param ... ClassProperties Properties to define the class with
---@return T
function Lib.DefineClass(name, superclass, ...)
        if type(name) ~= "string" then
                error("Invalid class name: "..tostring(name), 2)
        end
        if superclass ~= nil and (type(superclass) ~= "table" or not private.classInfo[superclass]) then
                error("Invalid superclass: "..tostring(superclass), 2)
        end
        local abstract = false
        for i = 1, select('#', ...) do
                local modifier = select(i, ...)
                if modifier == "ABSTRACT" then
                        abstract = true
                else
                        error("Invalid modifier: "..tostring(modifier), 2)
                end
        end

        local class = setmetatable({}, private.CLASS_MT)
        private.classInfo[class] = {
                name = name,
                static = {},
                superStatic = {},
                superclass = superclass,
                abstract = abstract,
                referenceType = nil,
                subclassed = false,
                extended = false,
                methodProperties = nil, -- Set as needed
                inClassFunc = 0,
                instances = setmetatable({}, WEAK_KEY_MT),
        }
        while superclass do
                local superclassInfo = private.classInfo[superclass]
                for key, value in pairs(superclassInfo.static) do
                        if not private.classInfo[class].superStatic[key] then
                                private.classInfo[class].superStatic[key] = {
                                        class = superclass,
                                        value = value,
                                        properties = superclassInfo.methodProperties and superclassInfo.methodProperties[key] or nil,
                                }
                        end
                end
                if superclassInfo.extended then
                        error("Cannot subclass a class after it's extended", 2)
                end
                superclassInfo.subclassed = true
                superclass = superclass.__super
        end
        return class
end

---Constructs a class from an existing table, preserving its keys.
---@generic T
---@param tbl table The table with existing keys to preserve
---@param class T The class to construct
---@param ... any Arguments to pass to the constructor
---@return T
function Lib.ConstructWithTable(tbl, class, ...)
        private.constructTbl = tbl
        local inst = class(...)
        assert(not private.constructTbl and inst == tbl, "Internal error")
        return inst
end

---Gets instance properties from an instance string for debugging purposes.
---@param instStr string The string representation of the instance
---@param maxDepth number The maximum depth to recurse into tables
---@param tableLookupFunc? fun(tbl: table): string? A lookup function which is used to get debug information for an unknown table
---@return string? @The properties dumped as a multiline string
function Lib.GetDebugInfo(instStr, maxDepth, tableLookupFunc)
        local inst = nil
        for obj, info in pairs(private.instInfo) do
                if info.str == instStr then
                        inst = obj
                        break
                end
        end
        if not inst then
                return nil
        end
        assert(not next(private.tempTable))
        private.InstDump(inst, private.tempTable, maxDepth, tableLookupFunc)
        local result = table.concat(private.tempTable, "\n")
        wipe(private.tempTable)
        return result
end



-- ============================================================================
-- Instance Metatable
-- ============================================================================

private.INST_MT = {
        __newindex = function(self, key, value)
                if RESERVED_KEYS[key] then
                        error("Can't set reserved key: "..tostring(key), 2)
                end
                if private.classInfo[self.__class].static[key] ~= nil then
                        private.classInfo[self.__class].static[key] = value
                elseif not private.instInfo[self].hasSuperclass then
                        -- We just set this directly on the instance table for better performance
                        rawset(self, key, value)
                else
                        private.instInfo[self].fields[key] = value
                end
        end,
        __index = function(self, key)
                -- This method is super optimized since it's used for every class instance access, meaning function calls and
                -- table lookup is kept to an absolute minimum, at the expense of readability and code reuse.
                local instInfo = private.instInfo[self]

                -- Check if this key is an instance field first, since this is the most common case
                local res = instInfo.fields[key]
                if res ~= nil then
                        instInfo.currentClass = nil
                        return res
                end

                -- Check if it's a special field / method
                if key == "__super" then
                        if not instInfo.hasSuperclass then
                                error("The class of this instance has no superclass", 2)
                        end
                        -- The class of the current class method we are in, or nil if we're not in a class method.
                        local methodClass = instInfo.methodClass
                        -- We can only access the superclass within a class method and will use the class which defined that method
                        -- as the base class to jump to the superclass of, regardless of what class the instance actually is.
                        if not methodClass then
                                error("The superclass can only be referenced within a class method", 2)
                        end
                        return private.InstAs(self, private.classInfo[instInfo.currentClass or methodClass].superclass)
                elseif key == "__as" then
                        return private.InstAs
                elseif key == "__closure" then
                        return private.InstClosure
                end

                -- Reset the current class since we're not continuing the __super chain
                local class = instInfo.currentClass or instInfo.class
                instInfo.currentClass = nil

                -- Check if this is a static key
                local classInfo = private.classInfo[class]
                res = classInfo.static[key]
                if res ~= nil then
                        return res
                end

                -- Check if it's a static field in the superclass
                local superStaticRes = classInfo.superStatic[key]
                if superStaticRes then
                        res = superStaticRes.value
                        return res
                end

                -- Check if this field has a default value
                res = DEFAULT_INST_FIELDS[key]
                if res ~= nil then
                        return res
                end

                return nil
        end,
        __tostring = function(self)
                return self:__tostring()
        end,
        __metatable = false,
}



-- ============================================================================
-- Class Metatable
-- ============================================================================

private.CLASS_MT = {
        __newindex = function(self, key, value)
                if type(key) ~= "string" then
                        error("Can't index class with non-string key", 2)
                end
                local classInfo = private.classInfo[self]
                if classInfo.subclassed or classInfo.extended then
                        error("Can't modify classes after they are subclassed or extended", 2)
                end
                if classInfo.static[key] then
                        error("Can't modify or override static members", 2)
                end
                if RESERVED_KEYS[key] then
                        error("Reserved word: "..key, 2)
                end
                local isFunction = type(value) == "function"
                local methodProperty = classInfo.referenceType
                local isStatic = methodProperty == "STATIC"
                classInfo.referenceType = nil
                if isFunction and isStatic then
                        -- We are defining a static class function
                        classInfo.methodProperties = classInfo.methodProperties or {}
                        classInfo.methodProperties[key] = "STATIC"
                        -- We wrap static methods so that we can allow private or protected access within them
                        classInfo.static[key] = function(...)
                                classInfo.inClassFunc = classInfo.inClassFunc + 1
                                return private.StaticFuncReturnHelper(classInfo, value(...))
                        end
                elseif isFunction and not isStatic then
                        -- We are defining a class method
                        local superclass = classInfo.superclass
                        while superclass do
                                local superclassInfo = private.classInfo[superclass]
                                local superclassMethodProperty = superclassInfo.methodProperties and superclassInfo.methodProperties[key] or nil
                                if superclassInfo.static[key] ~= nil or superclassMethodProperty ~= nil then
                                        if superclassInfo.static[key] ~= nil and type(superclassInfo.static[key]) ~= "function" then
                                                error(format("Attempting to override non-method superclass property (%s) with method", key), 2)
                                        end
                                        if superclassMethodProperty == nil then
                                                -- Can only override public methods with public methods
                                                if methodProperty ~= nil then
                                                        error(format("Overriding a public superclass method (%s) can only be done with a public method", key), 2)
                                                end
                                        elseif superclassMethodProperty == "ABSTRACT" then
                                                -- Can only override abstract methods with protected methods
                                                if methodProperty ~= "PROTECTED" then
                                                        error(format("Overriding an abstract superclass method (%s) can only be done with a protected method", key), 2)
                                                end
                                        elseif superclassMethodProperty == "PROTECTED" then
                                                -- Can only override protected methods with protected methods
                                                if methodProperty ~= "PROTECTED" then
                                                        error(format("Overriding a protected superclass method (%s) can only be done with a protected method", key), 2)
                                                end
                                        elseif superclassMethodProperty == "STATIC" then
                                                -- Can't override static properties with methods
                                                error(format("Can't override static superclass property (%s) with method", key), 2)
                                        elseif superclassMethodProperty == "PRIVATE" then
                                                -- Can't override private methods
                                                error(format("Can't override private superclass method (%s)", key), 2)
                                        else
                                                -- luacov: disable
                                                -- Should never get here
                                                error("Unexpected superclassMethodProperty: "..tostring(superclassMethodProperty))
                                                -- luacov: enable
                                        end
                                        -- Just need to go up the superclass tree until we find the first one which references this key
                                        break
                                end
                                superclass = superclassInfo.superclass
                        end
                        local isPrivate, isProtected = false, false
                        if methodProperty ~= nil then
                                classInfo.methodProperties = classInfo.methodProperties or {}
                                classInfo.methodProperties[key] = methodProperty
                                if methodProperty == "PRIVATE" then
                                        isPrivate = true
                                elseif methodProperty == "PROTECTED" then
                                        isProtected = true
                                elseif methodProperty == "ABSTRACT" then
                                        -- Just need to set the property
                                        return
                                else
                                        -- luacov: disable
                                        -- Should never get here
                                        error("Unknown method property: "..tostring(methodProperty))
                                        -- luacov: enable
                                end
                        end
                        -- We wrap class methods so that within them, the instance appears to be of the defining class
                        classInfo.static[key] = function(inst, ...)
                                local instInfo = private.instInfo[inst]
                                if not instInfo or not instInfo.isClassLookup[self] then
                                        error(format("Attempt to call class method on non-object (%s)", tostring(inst)), 2)
                                end
                                local prevMethodClass = instInfo.methodClass
                                if isPrivate and prevMethodClass ~= self and (prevMethodClass ~= nil or classInfo.inClassFunc == 0) then
                                        error(format("Attempting to call private method (%s) from outside of class", key), 2)
                                end
                                if isProtected and prevMethodClass == nil and classInfo.inClassFunc == 0 then
                                        error(format("Attempting to call protected method (%s) from outside of class", key), 2)
                                end
                                instInfo.methodClass = self
                                classInfo.inClassFunc = classInfo.inClassFunc + 1
                                return private.InstMethodReturnHelper(prevMethodClass, instInfo, classInfo, value(inst, ...))
                        end
                elseif not isFunction then
                        -- We are defining a static property (shouldn't be explicitly marked as static)
                        if isStatic then
                                error("Unnecessary __static for non-function class property", 2)
                        end
                        classInfo.static[key] = value
                end
        end,
        __index = function(self, key)
                local classInfo = private.classInfo[self]
                if classInfo.referenceType ~= nil then
                        error("Can't index into property table", 2)
                end
                if key == "__isa" then
                        return private.ClassIsA
                elseif key == "__name" then
                        return classInfo.name
                elseif key == "__super" then
                        return classInfo.superclass
                elseif key == "__static" then
                        classInfo.referenceType = "STATIC"
                        return self
                elseif key == "__private" then
                        classInfo.referenceType = "PRIVATE"
                        return self
                elseif key == "__protected" then
                        classInfo.referenceType = "PROTECTED"
                        return self
                elseif key == "__abstract" then
                        if not classInfo.abstract then
                                error("Can only define abstract methods on abstract classes", 2)
                        end
                        classInfo.referenceType = "ABSTRACT"
                        return self
                elseif key == "__extend" then
                        return private.ClassExtend
                elseif classInfo.static[key] ~= nil then
                        return classInfo.static[key]
                elseif classInfo.superStatic[key] then
                        return classInfo.superStatic[key].value
                end
                error(format("Invalid static class key (%s)", tostring(key)), 2)
        end,
        __tostring = function(self)
                return "class:"..private.classInfo[self].name
        end,
        __call = function(self, ...)
                if private.classInfo[self].abstract then
                        error("Attempting to instantiate an abstract class", 2)
                end
                -- Create a new instance of this class
                local inst = private.constructTbl or {}
                local instStr = strmatch(tostring(inst), "table:[^1-9a-fA-F]*([0-9a-fA-F]+)")
                setmetatable(inst, private.INST_MT)
                local classInfo = private.classInfo[self]
                local hasSuperclass = classInfo.superclass and true or false
                private.instInfo[inst] = {
                        class = self,
                        fields = {
                                __class = self,
                                __isa = private.InstIsA,
                        },
                        str = classInfo.name..":"..instStr,
                        isClassLookup = {},
                        hasSuperclass = hasSuperclass,
                        currentClass = nil,
                        closures = {},
                }
                classInfo.instances[inst] = true
                if not hasSuperclass then
                        -- Set the static members directly on this object for better performance
                        for key, value in pairs(classInfo.static) do
                                if not SPECIAL_PROPERTIES[key] then
                                        rawset(inst, key, value)
                                end
                        end
                end
                -- Check that all the abstract methods have been defined
                assert(not next(private.tempTable))
                local c = self
                while c do
                        private.instInfo[inst].isClassLookup[c] = true
                        c = private.classInfo[c].superclass
                        if c and private.classInfo[c] and private.classInfo[c].methodProperties then
                                for methodName, property in pairs(private.classInfo[c].methodProperties) do
                                        if property == "ABSTRACT" then
                                                private.tempTable[methodName] = true
                                        end
                                end
                        end
                end
                for methodName in pairs(private.tempTable) do
                        if type(classInfo.static[methodName]) ~= "function" then
                                -- Check the superclasses
                                local found = false
                                local c2 = self
                                while c2 and not found do
                                        c2 = private.classInfo[c2].superclass
                                        if c2 and private.classInfo[c2] and private.classInfo[c2].static[methodName] then
                                                found = true
                                        end
                                end
                                if not found then
                                        wipe(private.tempTable)
                                        error("Missing abstract method: "..tostring(methodName), 2)
                                end
                        end
                end
                wipe(private.tempTable)
                if private.constructTbl then
                        -- Re-set all the object attributes through the proper metamethod
                        assert(not next(private.tempTable))
                        for k, v in pairs(inst) do
                                private.tempTable[k] = v
                        end
                        for k, v in pairs(private.tempTable) do
                                rawset(inst, k, nil)
                                inst[k] = v
                        end
                        wipe(private.tempTable)
                        private.constructTbl = nil
                end
                if select("#", inst:__init(...)) > 0 then
                        error("__init(...) must not return any values", 2)
                end
                return inst
        end,
        __metatable = false,
}



-- ============================================================================
-- Extension Metatable
-- ============================================================================

private.EXTENSION_MT = {
        __newindex = function(self, key, value)
                if type(key) ~= "string" then
                        error("Can't index class extension with non-string key", 2)
                elseif type(value) ~= "function" then
                        error("Can only add class methods via class extension", 2)
                elseif RESERVED_KEYS[key] then
                        error("Reserved word: "..key, 2)
                end
                local class = private.extensionInfo[self].class
                local classInfo = private.classInfo[class]
                if classInfo.subclassed then
                        error("Can't add extension methods after a class is subclassed", 2)
                end
                local testClass = class
                while testClass do
                        local testClassInfo = private.classInfo[testClass]
                        if testClassInfo.static[key] ~= nil then
                                error("Can't modify or override class members from extension", 2)
                        end
                        testClass = testClassInfo.superclass
                end
                -- Don't need to wrap extension methods because they are treated as if they are outside
                -- the class as far as access restrictions are concerned and don't need to worry about
                -- virtual methods since extensions only support non-subclassed classes.
                classInfo.static[key] = value
                -- Add the new method directly to all previously-created instances
                for inst in pairs(classInfo.instances) do
                        rawset(inst, key, value)
                end
        end,
        __index = function()
                error("Extension objects are write-only", 2)
        end,
        __tostring = function(self)
                return "classExtension:"..private.classInfo[private.extensionInfo[self].class].name
        end,
        __metatable = false,
}



-- ============================================================================
-- Helper Functions
-- ============================================================================

function private.ClassIsA(class, targetClass)
        while class do
                if class == targetClass then return true end
                class = class.__super
        end
end

function private.ClassExtend(class)
        local classInfo = private.classInfo[class]
        if not classInfo then
                error("__extend() must be called with `:` to pass the class", 2)
        elseif classInfo.subclassed then
                error("Can't add extension methods after a class is subclassed", 2)
        end
        classInfo.extended = true
        local extensionObj = setmetatable({}, private.EXTENSION_MT)
        private.extensionInfo[extensionObj] = {
                class = class,
        }
        return extensionObj
end

function private.InstMethodReturnHelper(class, instInfo, classInfo, ...)
        -- Reset methodClass and decrement inClassFunc now that the function returned
        instInfo.methodClass = class
        classInfo.inClassFunc = classInfo.inClassFunc - 1
        return ...
end

function private.StaticFuncReturnHelper(classInfo, ...)
        -- Decrement inClassFunc now that the function returned
        classInfo.inClassFunc = classInfo.inClassFunc - 1
        return ...
end

function private.InstIsA(inst, targetClass)
        return private.instInfo[inst].isClassLookup[targetClass]
end

function private.InstAs(inst, targetClass)
        local instInfo = private.instInfo[inst]
        -- Clear currentClass while we perform our checks so we can better recover from errors
        instInfo.currentClass = nil
        if not targetClass then
                error(format("Requested class does not exist"), 2)
        elseif not instInfo.isClassLookup[targetClass] then
                error(format("Object is not an instance of the requested class (%s)", tostring(targetClass)), 2)
        end
        -- For classes with no superclass, we don't go through the __index metamethod, so can't use __as
        if not instInfo.hasSuperclass then
                error("The class of this instance has no superclass", 2)
        end
        -- We can only access the superclass within a class method.
        if not instInfo.methodClass then
                error("The superclass can only be referenced within a class method", 2)
        end
        instInfo.currentClass = targetClass
        return inst
end

function private.InstClosure(inst, methodName)
        local instInfo = private.instInfo[inst]
        local methodClass = instInfo.methodClass
        if not methodClass then
                error("Closures can only be created within a class method", 2)
        elseif instInfo.currentClass then
                error("Cannot create closure as superclass", 2)
        end
        -- Check for this method on the class
        local classInfo = private.classInfo[instInfo.class]
        local methodFunc = classInfo.static[methodName]
        if methodFunc then
                -- If this method is private, make sure we're within the class
                if classInfo.methodProperties and classInfo.methodProperties[methodName] == "PRIVATE" and instInfo.class ~= methodClass then
                        error("Attempt to create closure for private virtual method", 2)
                end
        else
                -- Check for this method on the superclass
                local superInfo = classInfo.superStatic[methodName]
                if superInfo then
                        if superInfo.properties == "PRIVATE" and not private.classInfo[methodClass].static[methodName] then
                                error("Attempt to create closure for private superclass method", 2)
                        end
                        methodFunc = superInfo.value
                end
        end
        if type(methodFunc) ~= "function" then
                error("Attempt to create closure for non-method field", 2)
        end
        local methodClassInfo = private.classInfo[methodClass]
        local cacheKey = tostring(methodClass).."."..methodName
        if not instInfo.closures[cacheKey] then
                instInfo.closures[cacheKey] = function(...)
                        if instInfo.methodClass == methodClass then
                                -- We're already within a method of the class, so just call the method normally
                                return methodFunc(inst, ...)
                        else
                                -- Pretend we are within the class which created the closure
                                local prevClass = instInfo.methodClass
                                instInfo.methodClass = methodClass
                                methodClassInfo.inClassFunc = methodClassInfo.inClassFunc + 1
                                return private.InstMethodReturnHelper(prevClass, instInfo, methodClassInfo, methodFunc(inst, ...))
                        end
                end
        end
        return instInfo.closures[cacheKey]
end

function private.InstDump(inst, resultTbl, maxDepth, tableLookupFunc)
        local context = {
                resultTbl = resultTbl,
                maxDepth = maxDepth or 2,
                maxTableEntries = 100,
                tableLookupFunc = tableLookupFunc,
                tableRefs = {},
                depth = 0,
        }

        -- Build up our table references via a breadth-first search
        local bfsQueueKeyPath = {""}
        local bfsQueueDepth = {0}
        local bfsQueueValue = {inst}
        while #bfsQueueKeyPath > 0 do
                local keyPath = tremove(bfsQueueKeyPath, 1)
                local depth = tremove(bfsQueueDepth, 1)
                local value = tremove(bfsQueueValue, 1)
                if not context.tableRefs[value] then
                        context.tableRefs[value] = keyPath
                        if depth <= context.maxDepth and not private.classInfo[value] then
                                if private.instInfo[value] then
                                        local instInfo = private.instInfo[value]
                                        value = instInfo.hasSuperclass and instInfo.fields or value
                                end
                                for k, v in pairs(value) do
                                        if type(v) == "table" and (type(k) == "string" or type(k) == "number") and not strfind(k, DUMP_KEY_PATH_DELIM, nil, true) then
                                                tinsert(bfsQueueKeyPath, keyPath..DUMP_KEY_PATH_DELIM..k)
                                                tinsert(bfsQueueDepth, depth + 1)
                                                tinsert(bfsQueueValue, v)
                                        end
                                end
                        end
                end
        end

        private.InstDumpVariable("self", inst, context, "")
end

function private.InstDumpVariable(key, value, context, strKeyPath)
        if strfind(key, DUMP_KEY_PATH_DELIM, nil, true) then
                -- Ignore keys with our deliminator in them
                return
        end
        if type(value) == "table" and private.classInfo[value] then
                -- This is a class
                private.InstDumpKeyValue(key, "\""..tostring(value).."\"", context)
        elseif type(value) == "table" then
                local refKeyPath = context.tableRefs[value]
                if not refKeyPath then
                        return
                end
                if refKeyPath ~= strKeyPath then
                        local refValue = "\"REF{"..gsub(refKeyPath, DUMP_KEY_PATH_DELIM, ".").."}\""
                        private.InstDumpKeyValue(key, refValue, context)
                elseif private.instInfo[value] then
                        -- This is an instance of a class
                        if context.depth <= context.maxDepth then
                                -- Recurse into the class
                                local instInfo = private.instInfo[value]
                                local tbl = instInfo.hasSuperclass and instInfo.fields or value
                                private.InstDumpLine(key.." = <"..instInfo.str.."> {", context)
                                context.depth = context.depth + 1
                                for key2, value2 in pairs(tbl) do
                                        if type(key2) == "string" or type(key2) == "number" or type(key2) == "boolean" then
                                                private.InstDumpVariable(key2, value2, context, strKeyPath..DUMP_KEY_PATH_DELIM..key2)
                                        end
                                end
                                context.depth = context.depth - 1
                                private.InstDumpLine("}", context)
                        else
                                private.InstDumpKeyValue(key, "\""..tostring(value).."\"", context)
                        end
                else
                        local isEmpty = true
                        for _, value2 in pairs(value) do
                                local valueType = type(value2)
                                if valueType == "string" or valueType == "number" or valueType == "boolean" or valueType == "table" then
                                        isEmpty = false
                                        break
                                end
                        end
                        if isEmpty then
                                local info = context.tableLookupFunc and context.tableLookupFunc(value) or nil
                                if info and context.depth <= context.maxDepth then
                                        -- Display the table values
                                        private.InstDumpKeyValue(key, "{", context)
                                        context.depth = context.depth + 1
                                        for _, line in ipairs({strsplit("\n", info)}) do
                                                private.InstDumpLine(line, context)
                                        end
                                        context.depth = context.depth - 1
                                        private.InstDumpLine("}", context)
                                elseif info then
                                        private.InstDumpKeyValue(key, "{ ... }", context)
                                else
                                        private.InstDumpKeyValue(key, "{}", context)
                                end
                        else
                                if context.depth <= context.maxDepth then
                                        -- Recurse into the table
                                        private.InstDumpKeyValue(key, "{", context)
                                        context.depth = context.depth + 1
                                        local numTableEntries = 0
                                        for key2, value2 in pairs(value) do
                                                if numTableEntries >= context.maxTableEntries then
                                                        break
                                                end
                                                if type(key2) == "string" or type(key2) == "number" or type(key2) == "boolean" then
                                                        numTableEntries = numTableEntries + 1
                                                        private.InstDumpVariable(key2, value2, context, strKeyPath..DUMP_KEY_PATH_DELIM..key2)
                                                end
                                        end
                                        context.depth = context.depth - 1
                                        private.InstDumpLine("}", context)
                                else
                                        private.InstDumpKeyValue(key, "{ ... }", context)
                                end
                        end
                end
        elseif type(value) == "string" then
                private.InstDumpKeyValue(key, "\""..value.."\"", context)
        elseif type(value) == "number" or type(value) == "boolean" then
                private.InstDumpKeyValue(key, value, context)
        end
end

function private.InstDumpLine(line, context)
        line = strrep("  ", context.depth)..line
        if context.resultTbl then
                tinsert(context.resultTbl, line)
        else
                print(line)
        end
end

function private.InstDumpKeyValue(key, value, context)
        key = tostring(key)
        if key == "" then
                key = "\"\""
        end
        if not context.resultTbl then
                key = "|cff88ccff"..key.."|r"
        end
        value = tostring(value)
        local line = format("%s = %s", key, value)
        private.InstDumpLine(line, context)
end



-- ============================================================================
-- Initialization Code
-- ============================================================================

do
        -- Register with LibStub
        local libStubTbl = LibStub:NewLibrary("LibTSMClass", MINOR_REVISION)
        if libStubTbl then
                for k, v in pairs(Lib) do
                        libStubTbl[k] = v
                end
        end
        -- Return the library and our private table for unit testing
        return {Lib, private}
end

TradeSkillMaster / LibTSMClass / 19745365775

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous