(refactor) rewrite using Teal (#52)

.github/workflows/test.yml

@@ -8,7 +8,7 @@ jobs:
 
     strategy:
       matrix:
-        luaVersion: ["5.1.5", "5.2.4", "luajit-2.1.0-beta3", "luajit-openresty"]
+        luaVersion: ["5.1", "5.2", "5.3", "5.4", "luajit", "luajit-openresty"]
 
     steps:
     - uses: actions/checkout@master

.luacheckrc

@@ -0,0 +1,3 @@
+max_line_length=false
+unused_args=false
+

Makefile

@@ -0,0 +1,17 @@
+all: gen check test
+
+dev:
+	luarocks install busted
+	luarocks install tl
+
+gen:
+	tl gen inspect.tl
+
+check:
+	luacheck inspect.lua
+
+test:
+	busted
+
+
+

inspect.lua

@@ -1,11 +1,29 @@
-local inspect ={
+local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local math = _tl_compat and _tl_compat.math or math; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table
-  _VERSION = 'inspect.lua 3.1.0',
+local inspect = {Options = {}, }
-  _URL     = 'http://github.com/kikito/inspect.lua',
+
-  _DESCRIPTION = 'human-readable representations of tables',
+
-  _LICENSE = [[
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+inspect._VERSION = 'inspect.lua 3.1.0'
+inspect._URL = 'http://github.com/kikito/inspect.lua'
+inspect._DESCRIPTION = 'human-readable representations of tables'
+inspect._LICENSE = [[
   MIT LICENSE
 
-    Copyright (c) 2013 Enrique García Cota
+  Copyright (c) 2022 Enrique García Cota
 
   Permission is hereby granted, free of charge, to any person obtaining a
   copy of this software and associated documentation files (the
@@ -26,19 +44,17 @@ local inspect ={
   TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ]]
-}
-
-local tostring = tostring
-
 inspect.KEY = setmetatable({}, { __tostring = function() return 'inspect.KEY' end })
 inspect.METATABLE = setmetatable({}, { __tostring = function() return 'inspect.METATABLE' end })
 
+local tostring = tostring
+
 local function rawpairs(t)
    return next, t, nil
 end
 
--- Apostrophizes the string if it has quotes, but not aphostrophes
+
--- Otherwise, it returns a regular quoted string
+
 local function smartQuote(str)
    if str:match('"') and not str:match("'") then
       return "'" .. str .. "'"
@@ -46,12 +62,12 @@ local function smartQuote(str)
    return '"' .. str:gsub('"', '\\"') .. '"'
 end
 
--- \a => '\\a', \0 => nil
+
 local shortControlCharEscapes = {
    ["\a"] = "\\a", ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
    ["\r"] = "\\r", ["\t"] = "\\t", ["\v"] = "\\v", ["\127"] = "\\127",
 }
-local longControlCharEscapes = {["\127"]="\127"} -- \a => nil, \0 => \000, 31 => \031
+local longControlCharEscapes = { ["\127"] = "\127" }
 for i = 0, 31 do
    local ch = string.char(i)
    if not shortControlCharEscapes[ch] then
@@ -59,49 +75,51 @@ for i=0, 31 do
       longControlCharEscapes[ch] = string.format("\\%03d", i)
    end
 end
---longControlCharEscapes["\127"]="\\127"
 
 local function escape(str)
-  return (str:gsub("\\", "\\\\")
+   return (str:gsub("\\", "\\\\"):
-             :gsub("(%c)%f[0-9]", longControlCharEscapes)
+   gsub("(%c)%f[0-9]", longControlCharEscapes):
-             :gsub("%c", shortControlCharEscapes))
+   gsub("%c", shortControlCharEscapes))
 end
 
 local function isIdentifier(str)
-  return type(str) == 'string' and str:match( "^[_%a][_%a%d]*$" )
+   return type(str) == "string" and not not str:match("^[_%a][_%a%d]*$")
 end
 
+local flr = math.floor
 local function isSequenceKey(k, sequenceLength)
-  return type(k) == 'number'
+   return type(k) == "number" and
-     and 1 <= k
+   flr(k) == k and
-     and k <= sequenceLength
+   1 <= (k) and
-     and math.floor(k) == k
+   k <= sequenceLength
 end
 
 local defaultTypeOrders = {
    ['number'] = 1, ['boolean'] = 2, ['string'] = 3, ['table'] = 4,
-  ['function'] = 5, ['userdata'] = 6, ['thread'] = 7
+   ['function'] = 5, ['userdata'] = 6, ['thread'] = 7,
 }
 
 local function sortKeys(a, b)
    local ta, tb = type(a), type(b)
 
-  -- strings and numbers are sorted numerically/alphabetically
-  if ta == tb and (ta == 'string' or ta == 'number') then return a < b end
 
-  local dta, dtb = defaultTypeOrders[ta], defaultTypeOrders[tb]
+   if ta == tb and (ta == 'string' or ta == 'number') then
-  -- Two default types are compared according to the defaultTypeOrders table
+      return (a) < (b)
-  if dta and dtb then return defaultTypeOrders[ta] < defaultTypeOrders[tb]
-  elseif dta     then return true  -- default types before custom ones
-  elseif dtb     then return false -- custom types after default ones
    end
 
-  -- custom types are sorted out alphabetically
+   local dta, dtb = defaultTypeOrders[ta], defaultTypeOrders[tb]
+
+   if dta and dtb then return defaultTypeOrders[ta] < defaultTypeOrders[tb]
+   elseif dta then return true
+   elseif dtb then return false
+   end
+
+
    return ta < tb
 end
 
--- For implementation reasons, the behavior of rawlen & # is "undefined" when
+
--- tables aren't pure sequences. So we implement our own # operator.
+
 local function getSequenceLength(t)
    local len = 1
    local v = rawget(t, len)
@@ -128,7 +146,7 @@ end
 local function countTableAppearances(t, tableAppearances)
    tableAppearances = tableAppearances or {}
 
-  if type(t) == 'table' then
+   if type(t) == "table" then
       if not tableAppearances[t] then
          tableAppearances[t] = 1
          for k, v in rawpairs(t) do
@@ -144,27 +162,27 @@ local function countTableAppearances(t, tableAppearances)
    return tableAppearances
 end
 
-local copySequence = function(s)
+local function makePath(path, a, b)
-  local copy, len = {}, #s
+   local newPath = {}
-  for i=1, len do copy[i] = s[i] end
+   local len = #path
-  return copy, len
+   for i = 1, len do newPath[i] = path[i] end
-end
+
+   newPath[len + 1] = a
+   newPath[len + 2] = b
 
-local function makePath(path, ...)
-  local keys = {...}
-  local newPath, len = copySequence(path)
-  for i=1, #keys do
-    newPath[len + i] = keys[i]
-  end
    return newPath
 end
 
-local function processRecursive(process, item, path, visited)
+
+local function processRecursive(process,
+   item,
+   path,
+   visited)
    if item == nil then return nil end
    if visited[item] then return visited[item] end
 
    local processed = process(item, path)
-  if type(processed) == 'table' then
+   if type(processed) == "table" then
       local processedCopy = {}
       visited[item] = processedCopy
       local processedKey
@@ -177,7 +195,7 @@ local function processRecursive(process, item, path, visited)
       end
 
       local mt = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
-    if type(mt) ~= 'table' then mt = nil end -- ignore not nil/table __metatable field
+      if type(mt) ~= 'table' then mt = nil end
       setmetatable(processedCopy, mt)
       processed = processedCopy
    end
@@ -186,19 +204,29 @@ end
 
 
 
--------------------------------------------------------------------
+
 
 local Inspector = {}
+
+
+
+
+
+
+
+
+
+
 local Inspector_mt = { __index = Inspector }
 
-function Inspector:puts(...)
+function Inspector:puts(a, b, c, d, e)
-  local args   = {...}
    local buffer = self.buffer
    local len = #buffer
-  for i=1, #args do
+   buffer[len + 1] = a
-    len = len + 1
+   buffer[len + 2] = b
-    buffer[len] = args[i]
+   buffer[len + 3] = c
-  end
+   buffer[len + 4] = d
+   buffer[len + 5] = e
 end
 
 function Inspector:down(f)
@@ -208,7 +236,8 @@ function Inspector:down(f)
 end
 
 function Inspector:tabify()
-  self:puts(self.newline, string.rep(self.indent, self.level))
+   self:puts(self.newline,
+   string.rep(self.indent, self.level))
 end
 
 function Inspector:alreadyVisited(v)
@@ -226,8 +255,15 @@ function Inspector:getId(v)
    return tostring(id)
 end
 
+
+function Inspector:putValue(_)
+end
+
 function Inspector:putKey(k)
-  if isIdentifier(k) then return self:puts(k) end
+   if isIdentifier(k) then
+      self:puts(k)
+      return
+   end
    self:puts("[")
    self:putValue(k)
    self:puts("]")
@@ -274,9 +310,9 @@ function Inspector:putTable(t)
          end
       end)
 
-    if nonSequentialKeysLength > 0 or type(mt) == 'table' then -- result is multi-lined. Justify closing }
+      if nonSequentialKeysLength > 0 or type(mt) == 'table' then
          self:tabify()
-    elseif sequenceLength > 0 then -- array tables have one extra space before closing }
+      elseif sequenceLength > 0 then
          self:puts(' ')
       end
 
@@ -286,7 +322,6 @@ end
 
 function Inspector:putValue(v)
    local tv = type(v)
-
    if tv == 'string' then
       self:puts(smartQuote(escape(v)))
    elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
@@ -299,12 +334,13 @@ function Inspector:putValue(v)
    end
 end
 
--------------------------------------------------------------------
+
+
 
 function inspect.inspect(root, options)
    options = options or {}
 
-  local depth   = options.depth   or math.huge
+   local depth = options.depth or (math.huge)
    local newline = options.newline or '\n'
    local indent = options.indent or '  '
    local process = options.process
@@ -321,7 +357,7 @@ function inspect.inspect(root, options)
       maxIds = {},
       newline = newline,
       indent = indent,
-    tableAppearances = countTableAppearances(root)
+      tableAppearances = countTableAppearances(root),
    }, Inspector_mt)
 
    inspector:putValue(root)
@@ -329,7 +365,10 @@ function inspect.inspect(root, options)
    return table.concat(inspector.buffer)
 end
 
-setmetatable(inspect, { __call = function(_, ...) return inspect.inspect(...) end })
+setmetatable(inspect, {
+   __call = function(_, root, options)
+      return inspect.inspect(root, options)
+   end,
+})
 
 return inspect
-

inspect.tl

@@ -0,0 +1,374 @@
+-- inspect.tl
+local record inspect
+   _VERSION: string
+   _URL: string
+   _DESCRIPTION: string
+   _LICENSE: string
+   KEY: table
+   METATABLE: table
+
+   type ProcessFunction = function(any, {any}): any
+
+   record Options
+      depth: integer
+      newline: string
+      indent: string
+      process: ProcessFunction
+   end
+end
+
+inspect._VERSION = 'inspect.lua 3.1.0'
+inspect._URL     = 'http://github.com/kikito/inspect.lua'
+inspect._DESCRIPTION = 'human-readable representations of tables'
+inspect._LICENSE = [[
+  MIT LICENSE
+
+  Copyright (c) 2022 Enrique García Cota
+
+  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.
+]]
+inspect.KEY       = setmetatable({}, {__tostring = function(): string return 'inspect.KEY' end})
+inspect.METATABLE = setmetatable({}, {__tostring = function(): string return 'inspect.METATABLE' end})
+
+local tostring = tostring
+
+local function rawpairs(t: table): function, table, nil
+   return next, t, nil
+end
+
+-- Apostrophizes the string if it has quotes, but not aphostrophes
+-- Otherwise, it returns a regular quoted string
+local function smartQuote(str: string): string
+   if str:match('"') and not str:match("'") then
+      return "'" .. str .. "'"
+   end
+   return '"' .. str:gsub('"', '\\"') .. '"'
+end
+
+-- \a => '\\a', \0 => '\\0', 31 => '\31'
+local shortControlCharEscapes: {string:string} = {
+   ["\a"] = "\\a",  ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
+   ["\r"] = "\\r",  ["\t"] = "\\t", ["\v"] = "\\v", ["\127"] = "\\127",
+}
+local longControlCharEscapes: {string:string} = {["\127"]="\127"} -- \a => nil, \0 => \000, 31 => \031
+for i=0, 31 do
+   local ch: string = string.char(i)
+   if not shortControlCharEscapes[ch] then
+      shortControlCharEscapes[ch] = "\\"..i
+      longControlCharEscapes[ch]  = string.format("\\%03d", i)
+   end
+end
+
+local function escape(str: string): string
+   return (str:gsub("\\", "\\\\")
+              :gsub("(%c)%f[0-9]", longControlCharEscapes)
+              :gsub("%c", shortControlCharEscapes))
+end
+
+local function isIdentifier(str: any): boolean
+   return str is string and not not str:match("^[_%a][_%a%d]*$")
+end
+
+local flr = math.floor
+local function isSequenceKey(k: any, sequenceLength: integer): boolean
+   return k is number
+      and flr(k) == k
+      and 1 <= (k)
+      and k <= sequenceLength
+end
+
+local defaultTypeOrders: {string:integer} = {
+   ['number']   = 1, ['boolean']  = 2, ['string'] = 3, ['table'] = 4,
+   ['function'] = 5, ['userdata'] = 6, ['thread'] = 7
+}
+
+local function sortKeys(a:any, b:any): boolean
+   local ta, tb: string, string = type(a), type(b)
+
+   -- strings and numbers are sorted numerically/alphabetically
+   if ta == tb and (ta == 'string' or ta == 'number') then
+      return (a as string) < (b as string)
+   end
+
+   local dta, dtb: integer, integer = defaultTypeOrders[ta], defaultTypeOrders[tb]
+   -- Two default types are compared according to the defaultTypeOrders table
+   if dta and dtb then return defaultTypeOrders[ta] < defaultTypeOrders[tb]
+   elseif dta     then return true  -- default types before custom ones
+   elseif dtb     then return false -- custom types after default ones
+   end
+
+   -- custom types are sorted out alphabetically
+   return ta < tb
+end
+
+-- For implementation reasons, the behavior of rawlen & # is "undefined" when
+-- tables aren't pure sequences. So we implement our own # operator.
+local function getSequenceLength(t: table): integer
+   local len: integer = 1
+   local v: any = rawget(t, len)
+   while v ~= nil do
+      len = len + 1
+      v = rawget(t,len)
+   end
+   return len - 1
+end
+
+local function getNonSequentialKeys(t: table): {any}, integer, integer
+   local keys, keysLength: {any}, integer = {}, 0
+   local sequenceLength: integer = getSequenceLength(t)
+   for k,_ in rawpairs(t) do
+      if not isSequenceKey(k, sequenceLength) then
+         keysLength = keysLength + 1
+         keys[keysLength] = k
+      end
+   end
+   table.sort(keys, sortKeys)
+   return keys, keysLength, sequenceLength
+end
+
+local function countTableAppearances(t: any, tableAppearances: {any:integer}): {any:integer}
+   tableAppearances = tableAppearances or {}
+
+   if t is table then
+      if not tableAppearances[t] then
+         tableAppearances[t] = 1
+         for k,v in rawpairs(t) do
+            countTableAppearances(k, tableAppearances)
+            countTableAppearances(v, tableAppearances)
+         end
+         countTableAppearances(getmetatable(t), tableAppearances)
+      else
+         tableAppearances[t] = tableAppearances[t] + 1
+      end
+   end
+
+   return tableAppearances
+end
+
+local function makePath(path: {any}, a: any, b: any): {any}
+   local newPath: {any} = {}
+   local len: integer = #path
+   for i=1, len do newPath[i] = path[i] end
+
+   newPath[len + 1] = a
+   newPath[len + 2] = b
+
+   return newPath
+end
+
+
+local function processRecursive(process: inspect.ProcessFunction,
+                                item: any,
+                                path: {any},
+                                visited: {any:any}): any
+   if item == nil then return nil end
+   if visited[item] then return visited[item] end
+
+   local processed: any = process(item, path)
+   if processed is table then
+      local processedCopy = {}
+      visited[item] = processedCopy
+      local processedKey: any
+
+      for k,v in rawpairs(processed) do
+         processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
+         if processedKey ~= nil then
+            processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
+         end
+      end
+
+      local mt  = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
+      if type(mt) ~= 'table' then mt = nil end -- ignore not nil/table __metatable field
+      setmetatable(processedCopy, mt as metatable<{any:any}>)
+      processed = processedCopy
+   end
+   return processed
+end
+
+
+
+-------------------------------------------------------------------
+
+local type Inspector = record
+   depth: integer
+   level: integer
+   buffer: {string}
+   ids: {any:integer}
+   maxIds: {any:integer}
+   newline: string
+   indent: string
+   tableAppearances: {table: integer}
+end
+
+local Inspector_mt = {__index = Inspector}
+
+function Inspector:puts(a:string, b:string, c:string, d:string, e:string): nil
+   local buffer: {string} = self.buffer
+   local len: integer     = #buffer
+   buffer[len+1] = a
+   buffer[len+2] = b
+   buffer[len+3] = c
+   buffer[len+4] = d
+   buffer[len+5] = e
+end
+
+function Inspector:down(f: function()): nil
+   self.level = self.level + 1
+   f()
+   self.level = self.level - 1
+end
+
+function Inspector:tabify(): nil
+   self:puts(self.newline,
+   string.rep(self.indent, self.level))
+end
+
+function Inspector:alreadyVisited(v: any): boolean
+   return self.ids[v] ~= nil
+end
+
+function Inspector:getId(v: any): string
+   local id: integer = self.ids[v]
+   if not id then
+      local tv: string = type(v)
+      id              = (self.maxIds[tv] or 0) + 1
+      self.maxIds[tv] = id
+      self.ids[v]     = id
+   end
+   return tostring(id)
+end
+
+-- dummy function; defined later
+function Inspector:putValue(_: any):nil
+end
+
+function Inspector:putKey(k: any): nil
+   if isIdentifier(k) then
+      self:puts(k as string)
+      return
+   end
+   self:puts("[")
+   self:putValue(k)
+   self:puts("]")
+end
+
+function Inspector:putTable(t: table): nil
+   if t == inspect.KEY or t == inspect.METATABLE then
+      self:puts(tostring(t))
+   elseif self:alreadyVisited(t) then
+      self:puts('<table ', self:getId(t), '>')
+   elseif self.level >= self.depth then
+      self:puts('{...}')
+   else
+      if self.tableAppearances[t] > 1 then self:puts('<', self:getId(t), '>') end
+
+      local nonSequentialKeys, nonSequentialKeysLength, sequenceLength = getNonSequentialKeys(t)
+      local mt = getmetatable(t)
+
+      self:puts('{')
+      self:down(function()
+         local count = 0
+         for i=1, sequenceLength do
+            if count > 0 then self:puts(',') end
+            self:puts(' ')
+            self:putValue(t[i])
+            count = count + 1
+         end
+
+         for i=1, nonSequentialKeysLength do
+            local k = nonSequentialKeys[i]
+            if count > 0 then self:puts(',') end
+            self:tabify()
+            self:putKey(k)
+            self:puts(' = ')
+            self:putValue(t[k])
+            count = count + 1
+         end
+
+         if type(mt) == 'table' then
+            if count > 0 then self:puts(',') end
+            self:tabify()
+            self:puts('<metatable> = ')
+            self:putValue(mt)
+         end
+      end)
+
+      if nonSequentialKeysLength > 0 or type(mt) == 'table' then -- result is multi-lined. Justify closing }
+         self:tabify()
+      elseif sequenceLength > 0 then -- array tables have one extra space before closing }
+         self:puts(' ')
+      end
+
+      self:puts('}')
+   end
+end
+
+function Inspector:putValue(v: any)
+   local tv: string = type(v)
+   if tv == 'string' then
+      self:puts(smartQuote(escape(v as string)))
+   elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
+          tv == 'cdata' or tv == 'ctype' then
+      self:puts(tostring(v as number))
+   elseif tv == 'table' then
+      self:putTable(v as table)
+   else
+      self:puts('<', tv, ' ', self:getId(v), '>')
+   end
+end
+
+-------------------------------------------------------------------
+
+
+function inspect.inspect(root: any, options: inspect.Options): string
+   options       = options or {}
+
+   local depth: integer  = options.depth   or (math.huge as integer)
+   local newline: string = options.newline or '\n'
+   local indent: string  = options.indent  or '  '
+   local process: inspect.ProcessFunction = options.process
+
+   if process then
+      root = processRecursive(process, root, {}, {})
+   end
+
+   local inspector = setmetatable({
+      depth            = depth,
+      level            = 0,
+      buffer           = {},
+      ids              = {},
+      maxIds           = {},
+      newline          = newline,
+      indent           = indent,
+      tableAppearances = countTableAppearances(root)
+   } as Inspector, Inspector_mt)
+
+   inspector:putValue(root)
+
+   return table.concat(inspector.buffer)
+end
+
+setmetatable(inspect, {
+   __call = function(_, root: any, options: inspect.Options): string
+      return inspect.inspect(root, options)
+   end
+})
+
+return inspect