Compare commits

..

4 Commits
master ... eLua

  1. 47
      .travis.yml
  2. 34
      CHANGELOG.md
  3. 68
      README.md
  4. 174
      inspect.lua
  5. 23
      rockspecs/inspect-3.0-1.rockspec
  6. 23
      rockspecs/inspect-3.0-2.rockspec
  7. 23
      rockspecs/inspect-3.0-3.rockspec
  8. 23
      rockspecs/inspect-3.0-4.rockspec
  9. 23
      rockspecs/inspect-3.1.1-0.rockspec
  10. 259
      spec/inspect_spec.lua

@ -1,34 +1,35 @@
language: python
sudo: false
language: erlang
env:
- LUA="lua=5.1"
- LUA="lua=5.2"
- LUA="lua=5.3"
- LUA="luajit=2.0"
- LUA="luajit=2.1"
global:
- LUAROCKS_BASE=luarocks-2.0.13
matrix:
- LUA=lua5.1 LUA_DEV=liblua5.1-dev LUA_VER=5.1 LUA_SFX=5.1 LUA_INCDIR=/usr/include/lua5.1
- LUA=lua5.2 LUA_DEV=liblua5.2-dev LUA_VER=5.2 LUA_SFX=5.2 LUA_INCDIR=/usr/include/lua5.2
- LUA=luajit LUA_DEV=libluajit-5.1-dev LUA_VER=5.1 LUA_SFX=jit LUA_INCDIR=/usr/include/luajit-2.0
before_install:
- pip install hererocks
- hererocks lua_install -r^ --$LUA
- export PATH=$PATH:$PWD/lua_install/bin # Add directory with all installed binaries to PATH
- if [ $LUA = "luajit" ]; then
sudo add-apt-repository ppa:mwild1/ppa -y && sudo apt-get update -y;
fi
- sudo apt-get install $LUA
- sudo apt-get install $LUA_DEV
- lua$LUA_SFX -v
# Install a recent luarocks release
- wget http://luarocks.org/releases/$LUAROCKS_BASE.tar.gz
- tar zxvpf $LUAROCKS_BASE.tar.gz
- cd $LUAROCKS_BASE
- ./configure
--lua-version=$LUA_VER --lua-suffix=$LUA_SFX --with-lua-include="$LUA_INCDIR"
- sudo make
- sudo make install
- cd $TRAVIS_BUILD_DIR
install:
- luarocks install luacheck
- luarocks install busted
- luarocks install luacov
- luarocks install luacov-coveralls
- sudo -E luarocks install busted
script:
- luacheck --std max+busted *.lua spec
- busted --verbose --coverage
after_success:
- luacov-coveralls --exclude $TRAVIS_BUILD_DIR/lua_install
branches:
except:
- gh-pages
- sudo -E busted -v
notifications:
email:

@ -1,36 +1,4 @@
## v3.1.1
* Better handling of LuaJIT's `ctype` and `cdata` values (#34, thanks @akopytov)
## v3.1.0
* Fixes bug: all control codes are escaped correctly (instead of only the named ones such as \n).
Example: \1 becomes \\1 (or \\001 when followed by a digit)
* Fixes bug when using the `process` option in recursive tables
* Overriding global `tostring` with inspect no longer results in an error.
* Simplifies id generation, using less tables and metatables.
## v3.0.3
* Fixes a bug which sometimes displayed struct-like parts of tables as sequence-like due
to the way rawlen/the # operator are implemented.
## v3.0.2
* Fixes a bug when a table was garbage-collected while inspect was trying to render it
## v3.0.1
* Fixes a bug when dealing with tables which have a __len metamethod in Lua >= 5.2
## v3.0.0
The basic functionality remains as before, but there's one backwards-incompatible change if you used `options.filter`.
* **Removed** `options.filter`
* **Added** `options.process`, which can be used to do the same as `options.filter`, and more.
* **Added** two new constants, `inspect.METATABLE` and `inspect.KEY`
* **Added** `options.indent` & `options.newline`.
## v2.0.0
v2.0.0
* Ability to deal with LuaJit's custom types
* License change from BSD to MIT

@ -2,10 +2,8 @@ inspect.lua
===========
[![Build Status](https://travis-ci.org/kikito/inspect.lua.png?branch=master)](https://travis-ci.org/kikito/inspect.lua)
[![Coverage Status](https://coveralls.io/repos/github/kikito/inspect.lua/badge.svg?branch=master)](https://coveralls.io/github/kikito/inspect.lua?branch=master)
This library transforms any Lua value into a human-readable representation. It is especially useful for debugging errors in tables.
This function transform any Lua table into a human-readable representation of that table.
The objective here is human understanding (i.e. for debugging), not serialization or compactness.
@ -126,7 +124,7 @@ assert(inspect(t5, {depth = 2}) == [[{
`options.depth` defaults to infinite (`math.huge`).
#### options.newline & options.indent
### options.newline & options.indent
These are the strings used by `inspect` to respectively add a newline and indent each level of a table.
@ -144,7 +142,7 @@ assert(inspect(t) == [[{
assert(inspect(t, {newline='@', indent="++"}), "{@++a = {@++++b = 1@++}@}"
```
#### options.process
### options.process
`options.process` is a function which allow altering the passed object before transforming it into a string.
A typical way to use it would be to remove certain values so that they don't appear at all.
@ -184,17 +182,17 @@ end
assert(inspect(t, {process = remove_mt}) == "{ 1, 2, 3 }")
```
The previous exaple only works for a particular metatable. If you want to make *all* metatables, you can use the `path` parameter to check
wether the last element is `inspect.METATABLE`, and return `nil` instead of the item:
The previous exaple only works for a particular metatable. If you want to make *all* metatables, you can use `path`:
``` lua
local t, mt = ... -- (defined as before)
local remove_all_metatables = function(item, path)
if path[#path] ~= inspect.METATABLE then return item end
if path[#path] ~= '<metatable>' then return item end
end
assert(inspect(t, {process = remove_all_metatables}) == "{ 1, 2, 3 }")
-- Removes all metatables
assert(inspect(t, {process = remove_mt}) == "{ 1, 2, 3 }")
```
Filter a value:
@ -213,6 +211,40 @@ assert(inspect(info, {process = anonymize_password}) == [[{
}]])
```
Sometimes it might be convenient to "filter out" some parts of the output. The `options.filter` option can do that.
`options.filter` accepts a table of values. Any value on that table will be rendered as `<filtered>`. This is useful for hiding things like long complex tables that are not interesting for the task at hand, for example an unuseful complex metatable.
local person = {name = 'peter'}
setmetatable(person, complex_mt)
inspect(x, {filter = {complex_mt}}) == [[{
name = "peter",
<metatable> = <filtered>
}]]
`options.filter` can also be a function. The function must return true for the values that must be filtered out.
local isEvenNumber = function(x) return type(x) == 'number' and x % 2 == 0 end
inspect({1,2,3,4,5}, {filter = isEvenNumber}) == "{ 1, <filtered>, 3, <filtered>, 5 }"
Gotchas / Warnings
==================
@ -221,19 +253,15 @@ This method is *not* appropriate for saving/restoring tables. It is meant to be
Installation
============
If you are using luarocks, just run
luarocks install inspect
Otherwise, you can just copy the inspect.lua file somewhere in your projects (maybe inside a /lib/ folder) and require it accordingly.
Just copy the inspect.lua file somewhere in your projects (maybe inside a /lib/ folder) and require it accordingly.
Remember to store the value returned by require somewhere! (I suggest a local variable named inspect, although others might like table.inspect)
local inspect = require 'inspect'
-- or --
local inspect = require 'lib.inspect'
table.inspect = require 'inspect'
Also, make sure to read the license; the text of that license file must appear somewhere in your projects' files. For your convenience, it's included at the begining of inspect.lua.
Also, make sure to read the license file; the text of that license file must appear somewhere in your projects' files.
Specs
=====
@ -242,12 +270,4 @@ This project uses [busted](http://olivinelabs.com/busted/) for its specs. If you
busted
Change log
==========
Read it on the CHANGELOG.md file

@ -1,5 +1,5 @@
local inspect ={
_VERSION = 'inspect.lua 3.1.0',
_VERSION = 'inspect.lua 2.0.0',
_URL = 'http://github.com/kikito/inspect.lua',
_DESCRIPTION = 'human-readable representations of tables',
_LICENSE = [[
@ -28,15 +28,9 @@ local inspect ={
]]
}
local tostring = tostring
inspect.KEY = setmetatable({}, {__tostring = function() return 'inspect.KEY' end})
inspect.METATABLE = setmetatable({}, {__tostring = function() return 'inspect.METATABLE' end})
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)
@ -46,35 +40,28 @@ local function smartQuote(str)
return '"' .. str:gsub('"', '\\"') .. '"'
end
-- \a => '\\a', \0 => '\\0', 31 => '\31'
local shortControlCharEscapes = {
["\a"] = "\\a", ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
local controlCharsTranslation = {
["\a"] = "\\a", ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
["\r"] = "\\r", ["\t"] = "\\t", ["\v"] = "\\v"
}
local longControlCharEscapes = {} -- \a => nil, \0 => \000, 31 => \031
for i=0, 31 do
local ch = string.char(i)
if not shortControlCharEscapes[ch] then
shortControlCharEscapes[ch] = "\\"..i
longControlCharEscapes[ch] = string.format("\\%03d", i)
end
end
local function escapeChar(c) return controlCharsTranslation[c] end
local function escape(str)
return (str:gsub("\\", "\\\\")
:gsub("(%c)%f[0-9]", longControlCharEscapes)
:gsub("%c", shortControlCharEscapes))
local result = str:gsub("\\", "\\\\"):gsub("(%c)", escapeChar)
return result
end
local function isIdentifier(str)
return type(str) == 'string' and str:match( "^[_%a][_%a%d]*$" )
end
local function isSequenceKey(k, sequenceLength)
return type(k) == 'number'
and 1 <= k
and k <= sequenceLength
and math.floor(k) == k
local function isArrayKey(k, length)
return type(k) == 'number' and 1 <= k and k <= length
end
local function isDictionaryKey(k, length)
return not isArrayKey(k, length)
end
local defaultTypeOrders = {
@ -99,38 +86,47 @@ local function sortKeys(a, b)
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)
while v ~= nil do
len = len + 1
v = rawget(t,len)
local function getDictionaryKeys(t)
local keys, length = {}, #t
for k,_ in pairs(t) do
if isDictionaryKey(k, length) then table.insert(keys, k) end
end
return len - 1
table.sort(keys, sortKeys)
return keys
end
local function getNonSequentialKeys(t)
local keys, keysLength = {}, 0
local sequenceLength = getSequenceLength(t)
for k,_ in rawpairs(t) do
if not isSequenceKey(k, sequenceLength) then
keysLength = keysLength + 1
keys[keysLength] = k
end
local function getToStringResultSafely(t, mt)
local __tostring = type(mt) == 'table' and rawget(mt, '__tostring')
local str, ok
if type(__tostring) == 'function' then
ok, str = pcall(__tostring, t)
str = ok and str or 'error: ' .. tostring(str)
end
table.sort(keys, sortKeys)
return keys, keysLength, sequenceLength
if type(str) == 'string' and #str > 0 then return str end
end
local maxIdsMetaTable = {
__index = function(self, typeName)
rawset(self, typeName, 0)
return 0
end
}
local idsMetaTable = {
__index = function (self, typeName)
local col = setmetatable({}, {__mode = "kv"})
rawset(self, typeName, col)
return col
end
}
local function countTableAppearances(t, tableAppearances)
tableAppearances = tableAppearances or {}
tableAppearances = tableAppearances or setmetatable({}, {__mode = "k"})
if type(t) == 'table' then
if not tableAppearances[t] then
tableAppearances[t] = 1
for k,v in rawpairs(t) do
for k,v in pairs(t) do
countTableAppearances(k, tableAppearances)
countTableAppearances(v, tableAppearances)
end
@ -158,25 +154,22 @@ local function makePath(path, ...)
return newPath
end
local function processRecursive(process, item, path, visited)
local function processRecursive(process, item, path)
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
local processedCopy = {}
visited[item] = processedCopy
local processedKey
for k,v in rawpairs(processed) do
processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
for k,v in pairs(processed) do
processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY))
if processedKey ~= nil then
processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey))
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
local mt = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE))
setmetatable(processedCopy, mt)
processed = processedCopy
end
@ -184,7 +177,6 @@ local function processRecursive(process, item, path, visited)
end
-------------------------------------------------------------------
local Inspector = {}
@ -196,7 +188,7 @@ function Inspector:puts(...)
local len = #buffer
for i=1, #args do
len = len + 1
buffer[len] = args[i]
buffer[len] = tostring(args[i])
end
end
@ -210,19 +202,24 @@ function Inspector:tabify()
self:puts(self.newline, string.rep(self.indent, self.level))
end
function Inspector:commaControl(needsComma)
if needsComma then self:puts(',') end
return true
end
function Inspector:alreadyVisited(v)
return self.ids[v] ~= nil
return self.ids[type(v)][v] ~= nil
end
function Inspector:getId(v)
local id = self.ids[v]
local tv = type(v)
local id = self.ids[tv][v]
if not id then
local tv = type(v)
id = (self.maxIds[tv] or 0) + 1
id = self.maxIds[tv] + 1
self.maxIds[tv] = id
self.ids[v] = id
self.ids[tv][v] = id
end
return tostring(id)
return id
end
function Inspector:putKey(k)
@ -242,40 +239,44 @@ function Inspector:putTable(t)
else
if self.tableAppearances[t] > 1 then self:puts('<', self:getId(t), '>') end
local nonSequentialKeys, nonSequentialKeysLength, sequenceLength = getNonSequentialKeys(t)
local dictKeys = getDictionaryKeys(t)
local length = #t
local mt = getmetatable(t)
local to_string_result = getToStringResultSafely(t, mt)
self:puts('{')
self:down(function()
local count = 0
for i=1, sequenceLength do
if count > 0 then self:puts(',') end
if to_string_result then
self:puts(' -- ', escape(to_string_result))
if length >= 1 then self:tabify() end
end
local needsComma = false
for i=1, length do
needsComma = self:commaControl(needsComma)
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
for _,k in ipairs(dictKeys) do
needsComma = self:commaControl(needsComma)
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
if mt then
needsComma = self:commaControl(needsComma)
self:tabify()
self:puts('<metatable> = ')
self:putValue(mt)
end
end)
if nonSequentialKeysLength > 0 or type(mt) == 'table' then -- result is multi-lined. Justify closing }
if #dictKeys > 0 or mt then -- dictionary table. Justify closing }
self:tabify()
elseif sequenceLength > 0 then -- array tables have one extra space before closing }
elseif length > 0 then -- array tables have one extra space before closing }
self:puts(' ')
end
@ -288,13 +289,12 @@ function Inspector:putValue(v)
if tv == 'string' then
self:puts(smartQuote(escape(v)))
elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
tv == 'cdata' or tv == 'ctype' then
elseif tv == 'number' or tv == 'boolean' or tv == 'nil' then
self:puts(tostring(v))
elseif tv == 'table' then
elseif tv == 'table' or tv == 'romtable' then
self:putTable(v)
else
self:puts('<', tv, ' ', self:getId(v), '>')
self:puts('<',tv,' ',self:getId(v),'>')
end
end
@ -302,22 +302,20 @@ end
function inspect.inspect(root, options)
options = options or {}
local depth = options.depth or math.huge
local depth = options.depth or math.huge
local process = options.process
local newline = options.newline or '\n'
local indent = options.indent or ' '
local process = options.process
if process then
root = processRecursive(process, root, {}, {})
root = processRecursive(process, root, {})
end
local inspector = setmetatable({
depth = depth,
level = 0,
buffer = {},
ids = {},
maxIds = {},
level = 0,
ids = setmetatable({}, idsMetaTable),
maxIds = setmetatable({}, maxIdsMetaTable),
newline = newline,
indent = indent,
tableAppearances = countTableAppearances(root)

@ -1,23 +0,0 @@
package = "inspect"
version = "3.0-1"
source = {
url = "https://github.com/kikito/inspect.lua/archive/v3.0.0.tar.gz",
dir = "inspect.lua-3.0.0"
}
description = {
summary = "Lua table visualizer, ideal for debugging",
detailed = [[
inspect will print out your lua tables nicely so you can debug your programs quickly. It sorts keys by type and name and handles recursive tables properly.
]],
homepage = "https://github.com/kikito/inspect.lua",
license = "MIT <http://opensource.org/licenses/MIT>"
}
dependencies = {
"lua >= 5.1"
}
build = {
type = "builtin",
modules = {
inspect = "inspect.lua"
}
}

@ -1,23 +0,0 @@
package = "inspect"
version = "3.0-2"
source = {
url = "https://github.com/kikito/inspect.lua/archive/v3.0.1.tar.gz",
dir = "inspect.lua-3.0.1"
}
description = {
summary = "Lua table visualizer, ideal for debugging",
detailed = [[
inspect will print out your lua tables nicely so you can debug your programs quickly. It sorts keys by type and name and handles recursive tables properly.
]],
homepage = "https://github.com/kikito/inspect.lua",
license = "MIT <http://opensource.org/licenses/MIT>"
}
dependencies = {
"lua >= 5.1"
}
build = {
type = "builtin",
modules = {
inspect = "inspect.lua"
}
}

@ -1,23 +0,0 @@
package = "inspect"
version = "3.0-3"
source = {
url = "https://github.com/kikito/inspect.lua/archive/v3.0.2.tar.gz",
dir = "inspect.lua-3.0.2"
}
description = {
summary = "Lua table visualizer, ideal for debugging",
detailed = [[
inspect will print out your lua tables nicely so you can debug your programs quickly. It sorts keys by type and name and handles recursive tables properly.
]],
homepage = "https://github.com/kikito/inspect.lua",
license = "MIT <http://opensource.org/licenses/MIT>"
}
dependencies = {
"lua >= 5.1"
}
build = {
type = "builtin",
modules = {
inspect = "inspect.lua"
}
}

@ -1,23 +0,0 @@
package = "inspect"
version = "3.0-4"
source = {
url = "https://github.com/kikito/inspect.lua/archive/v3.0.3.tar.gz",
dir = "inspect.lua-3.0.3"
}
description = {
summary = "Lua table visualizer, ideal for debugging",
detailed = [[
inspect will print out your lua tables nicely so you can debug your programs quickly. It sorts keys by type and name and handles recursive tables properly.
]],
homepage = "https://github.com/kikito/inspect.lua",
license = "MIT <http://opensource.org/licenses/MIT>"
}
dependencies = {
"lua >= 5.1"
}
build = {
type = "builtin",
modules = {
inspect = "inspect.lua"
}
}

@ -1,23 +0,0 @@
package = "inspect"
version = "3.1.1-0"
source = {
url = "https://github.com/kikito/inspect.lua/archive/v3.1.1.tar.gz",
dir = "inspect.lua-3.1.1"
}
description = {
summary = "Lua table visualizer, ideal for debugging",
detailed = [[
inspect will print out your lua tables nicely so you can debug your programs quickly. It sorts keys by type and name and handles recursive tables properly.
]],
homepage = "https://github.com/kikito/inspect.lua",
license = "MIT <http://opensource.org/licenses/MIT>"
}
dependencies = {
"lua >= 5.1"
}
build = {
type = "builtin",
modules = {
inspect = "inspect.lua"
}
}

@ -1,127 +1,83 @@
local inspect = require 'inspect'
local unindent = require 'spec.unindent'
local is_luajit, ffi = pcall(require, 'ffi')
local has_rawlen = type(_G.rawlen) == 'function'
describe( 'inspect', function()
describe('numbers', function()
it('works', function()
assert.equals("1", inspect(1))
assert.equals("1.5", inspect(1.5))
assert.equals("-3.14", inspect(-3.14))
assert.equals(inspect(1), "1")
assert.equals(inspect(1.5), "1.5")
assert.equals(inspect(-3.14), "-3.14")
end)
end)
describe('strings', function()
it('puts quotes around regular strings', function()
assert.equals('"hello"', inspect("hello"))
assert.equals(inspect("hello"), '"hello"')
end)
it('puts apostrophes around strings with quotes', function()
assert.equals("'I have \"quotes\"'", inspect('I have "quotes"'))
assert.equals(inspect('I have "quotes"'), "'I have \"quotes\"'")
end)
it('uses regular quotes if the string has both quotes and apostrophes', function()
assert.equals('"I have \\"quotes\\" and \'apostrophes\'"', inspect("I have \"quotes\" and 'apostrophes'"))
assert.equals(inspect("I have \"quotes\" and 'apostrophes'"), '"I have \\"quotes\\" and \'apostrophes\'"')
end)
it('escapes newlines properly', function()
assert.equals('"I have \\n new \\n lines"', inspect('I have \n new \n lines'))
assert.equals(inspect('I have \n new \n lines'), '"I have \\n new \\n lines"')
end)
it('escapes tabs properly', function()
assert.equals('"I have \\t a tab character"', inspect('I have \t a tab character'))
assert.equals(inspect('I have \t a tab character'), '"I have \\t a tab character"')
end)
it('escapes backspaces properly', function()
assert.equals('"I have \\b a back space"', inspect('I have \b a back space'))
end)
it('escapes unnamed control characters with 1 or 2 digits', function()
assert.equals('"Here are some control characters: \\0 \\1 \\6 \\17 \\27 \\31"',
inspect('Here are some control characters: \0 \1 \6 \17 \27 \31'))
end)
it('escapes unnamed control characters with 3 digits when they are followed by numbers', function()
assert.equals('"Control chars followed by digits \\0001 \\0011 \\0061 \\0171 \\0271 \\0311"',
inspect('Control chars followed by digits \0001 \0011 \0061 \0171 \0271 \0311'))
assert.equals(inspect('I have \b a back space'), '"I have \\b a back space"')
end)
it('backslashes its backslashes', function()
assert.equals('"I have \\\\ a backslash"', inspect('I have \\ a backslash'))
assert.equals('"I have \\\\\\\\ two backslashes"', inspect('I have \\\\ two backslashes'))
assert.equals('"I have \\\\\\n a backslash followed by a newline"',
inspect('I have \\\n a backslash followed by a newline'))
assert.equals(inspect('I have \\ a backslash'), '"I have \\\\ a backslash"')
assert.equals(inspect('I have \\\\ two backslashes'), '"I have \\\\\\\\ two backslashes"')
assert.equals(inspect('I have \\\n a backslash followed by a newline'), '"I have \\\\\\n a backslash followed by a newline"')
end)
end)
it('works with nil', function()
assert.equals('nil', inspect(nil))
assert.equals(inspect(nil), 'nil')
end)
it('works with functions', function()
assert.equals('{ <function 1>, <function 2>, <function 1> }', inspect({ print, type, print }))
assert.equals(inspect({ print, type, print }), '{ <function 1>, <function 2>, <function 1> }')
end)
it('works with booleans', function()
assert.equals('true', inspect(true))
assert.equals('false', inspect(false))
assert.equals(inspect(true), 'true')
assert.equals(inspect(false), 'false')
end)
if is_luajit then
it('works with luajit cdata', function()
assert.equals('{ cdata<int>: PTR, ctype<int>, cdata<int>: PTR }',
inspect({ ffi.new("int", 1), ffi.typeof("int"), ffi.typeof("int")(1) }):gsub('(0x%x+)','PTR'))
describe('luajit cdata', function()
it('works with luajit cdata', function()
assert.equals(inspect({ ffi.new("int", 1), ffi.typeof("int"), ffi.typeof("int")(1) }), '{ <cdata 1>, <cdata 2>, <cdata 3> }')
end)
end)
end
describe('tables', function()
it('works with simple array-like tables', function()
assert.equals("{ 1, 2, 3 }", inspect({1,2,3}))
assert.equals(inspect({1,2,3}), "{ 1, 2, 3 }" )
end)
it('works with nested arrays', function()
assert.equals('{ "a", "b", "c", { "d", "e" }, "f" }', inspect({'a','b','c', {'d','e'}, 'f'}))
assert.equals(inspect({'a','b','c', {'d','e'}, 'f'}), '{ "a", "b", "c", { "d", "e" }, "f" }' )
end)
if has_rawlen then
it('handles arrays with a __len metatable correctly (ignoring the __len metatable and using rawlen)', function()
local arr = setmetatable({1,2,3}, {__len = function() return nil end})
assert.equals("{ 1, 2, 3,\n <metatable> = {\n __len = <function 1>\n }\n}", inspect(arr))
end)
it('handles tables with a __pairs metamethod (ignoring the __pairs metamethod and using next)', function()
local t = setmetatable({ {}, name = "yeah" }, { __pairs = function() end })
assert.equals(
unindent([[{ {},
name = "yeah",
<metatable> = {
__pairs = <function 1>
}
}]]),
inspect(t))
end)
end
it('works with simple dictionary tables', function()
assert.equals("{\n a = 1,\n b = 2\n}", inspect({a = 1, b = 2}))
end)
it('identifies tables with no number 1 as struct-like', function()
assert.equals(unindent([[{
[2] = 1,
[25] = 1,
id = 1
}
]]), inspect({[2]=1,[25]=1,id=1}))
end)
it('identifies numeric non-array keys as dictionary keys', function()
assert.equals("{ 1, 2,\n [-1] = true\n}", inspect({1, 2, [-1] = true}))
assert.equals("{ 1, 2,\n [1.5] = true\n}", inspect({1, 2, [1.5] = true}))
assert.equals(inspect({a = 1, b = 2}), "{\n a = 1,\n b = 2\n}")
end)
it('sorts keys in dictionary tables', function()
@ -130,7 +86,7 @@ describe( 'inspect', function()
[coroutine.create(function() end)] = 1,
[14] = 1, [{c=2}] = 1, [true]= 1
}
assert.equals(unindent([[
assert.equals(inspect(t), unindent([[
{ 1, 2, 3,
[14] = 1,
[true] = 1,
@ -142,30 +98,30 @@ describe( 'inspect', function()
[<function 1>] = 1,
[<thread 1>] = 1
}
]]), inspect(t))
]]))
end)
it('works with nested dictionary tables', function()
assert.equals(unindent([[{
assert.equals(inspect( {d=3, b={c=2}, a=1} ), unindent([[{
a = 1,
b = {
c = 2
},
d = 3
}]]), inspect( {d=3, b={c=2}, a=1} ))
}]]))
end)
it('works with hybrid tables', function()
assert.equals(unindent([[
assert.equals(
inspect({ 'a', {b = 1}, 2, c = 3, ['ahoy you'] = 4 }),
unindent([[
{ "a", {
b = 1
}, 2,
["ahoy you"] = 4,
c = 3
}
]]), inspect({ 'a', {b = 1}, 2, c = 3, ['ahoy you'] = 4 }))
]]))
end)
it('displays <table x> instead of repeating an already existing table', function()
@ -174,7 +130,7 @@ describe( 'inspect', function()
a[4] = b
a[5] = a
a[6] = b
assert.equals('<1>{ 1, 2, 3, <2>{ "a", "b", "c", <table 1> }, <table 1>, <table 2> }', inspect(a))
assert.equals(inspect(a), '<1>{ 1, 2, 3, <2>{ "a", "b", "c", <table 1> }, <table 1>, <table 2> }')
end)
describe('The depth parameter', function()
@ -182,7 +138,7 @@ describe( 'inspect', function()
local keys = { [level5] = true }
it('has infinite depth by default', function()
assert.equals(unindent([[
assert.equals(inspect(level5), unindent([[
{ 1, 2, 3,
a = {
b = {
@ -194,24 +150,24 @@ describe( 'inspect', function()
}
}
}
]]), inspect(level5))
]]))
end)
it('is modifiable by the user', function()
assert.equals(unindent([[
assert.equals(inspect(level5, {depth = 2}), unindent([[
{ 1, 2, 3,
a = {
b = {...}
}
}
]]), inspect(level5, {depth = 2}))
]]))
assert.equals(unindent([[
assert.equals(inspect(level5, {depth = 1}), unindent([[
{ 1, 2, 3,
a = {...}
}
]]), inspect(level5, {depth = 1}))
]]))
assert.equals(unindent([[
assert.equals(inspect(level5, {depth = 4}), unindent([[
{ 1, 2, 3,
a = {
b = {
@ -221,13 +177,13 @@ describe( 'inspect', function()
}
}
}
]]), inspect(level5, {depth = 4}))
]]))
assert.equals("{...}", inspect(level5, {depth = 0}))
assert.equals(inspect(level5, {depth = 0}), "{...}")
end)
it('respects depth on keys', function()
assert.equals(unindent([[
assert.equals(inspect(keys, {depth = 4}), unindent([[
{
[{ 1, 2, 3,
a = {
@ -237,7 +193,7 @@ describe( 'inspect', function()
}
}] = true
}
]]), inspect(keys, {depth = 4}))
]]))
end)
end)
@ -245,7 +201,7 @@ describe( 'inspect', function()
it('changes the substring used for newlines', function()
local t = {a={b=1}}
assert.equal("{@ a = {@ b = 1@ }@}", inspect(t, {newline='@'}))
assert.equal(inspect(t, {newline='@'}), "{@ a = {@ b = 1@ }@}")
end)
end)
@ -253,7 +209,7 @@ describe( 'inspect', function()
it('changes the substring used for indenting', function()
local t = {a={b=1}}
assert.equal("{\n>>>a = {\n>>>>>>b = 1\n>>>}\n}", inspect(t, {indent='>>>'}))
assert.equal(inspect(t, {indent='>>>'}), "{\n>>>a = {\n>>>>>>b = 1\n>>>}\n}")
end)
end)
@ -262,56 +218,56 @@ describe( 'inspect', function()
it('removes one element', function()
local names = {'Andrew', 'Peter', 'Ann' }
local removeAnn = function(item) if item ~= 'Ann' then return item end end
assert.equals('{ "Andrew", "Peter" }', inspect(names, {process = removeAnn}))
assert.equals(inspect(names, {process = removeAnn}), '{ "Andrew", "Peter" }')
end)
it('uses the path', function()
local names = {'Andrew', 'Peter', 'Ann' }
local removeThird = function(item, path) if path[1] ~= 3 then return item end end
assert.equals('{ "Andrew", "Peter" }', inspect(names, {process = removeThird}))
assert.equals(inspect(names, {process = removeThird}), '{ "Andrew", "Peter" }')
end)
it('replaces items', function()
local names = {'Andrew', 'Peter', 'Ann' }
local filterAnn = function(item) return item == 'Ann' and '<filtered>' or item end
assert.equals('{ "Andrew", "Peter", "<filtered>" }', inspect(names, {process = filterAnn}))
assert.equals(inspect(names, {process = filterAnn}), '{ "Andrew", "Peter", "<filtered>" }')
end)
it('nullifies metatables', function()
local mt = {'world'}
local t = setmetatable({'hello'}, mt)
local removeMt = function(item) if item ~= mt then return item end end
assert.equals('{ "hello" }', inspect(t, {process = removeMt}))
assert.equals(inspect(t, {process = removeMt}), '{ "hello" }')
end)
it('nullifies metatables using their paths', function()
local mt = {'world'}
local t = setmetatable({'hello'}, mt)
local removeMt = function(item, path) if path[#path] ~= inspect.METATABLE then return item end end
assert.equals('{ "hello" }', inspect(t, {process = removeMt}))
assert.equals(inspect(t, {process = removeMt}), '{ "hello" }')
end)
it('nullifies the root object', function()
local names = {'Andrew', 'Peter', 'Ann' }
local removeNames = function(item) if item ~= names then return item end end
assert.equals('nil', inspect(names, {process = removeNames}))
assert.equals(inspect(names, {process = removeNames}), 'nil')
end)
it('changes keys', function()
local dict = {a = 1}
local changeKey = function(item) return item == 'a' and 'x' or item end
assert.equals('{\n x = 1\n}', inspect(dict, {process = changeKey}))
local changeKey = function(item, path) return item == 'a' and 'x' or item end
assert.equals(inspect(dict, {process = changeKey}), '{\n x = 1\n}')
end)
it('nullifies keys', function()
local dict = {a = 1, b = 2}
local removeA = function(item) return item ~= 'a' and item or nil end
assert.equals('{\n b = 2\n}', inspect(dict, {process = removeA}))
local removeA = function(item, path) return item ~= 'a' and item or nil end
assert.equals(inspect(dict, {process = removeA}), '{\n b = 2\n}')
end)
it('prints inspect.KEY & inspect.METATABLE', function()
local t = {inspect.KEY, inspect.METATABLE}
assert.equals("{ inspect.KEY, inspect.METATABLE }", inspect(t))
assert.equals(inspect(t), "{ inspect.KEY, inspect.METATABLE }")
end)
it('marks key paths with inspect.KEY and metatables with inspect.METATABLE', function()
@ -325,7 +281,7 @@ describe( 'inspect', function()
inspect(t, {process = addItem})
assert.same({
assert.same(items, {
{item = t, path = {}},
{item = {a=1}, path = {{a=1}, inspect.KEY}},
{item = 'a', path = {{a=1}, inspect.KEY, 'a', inspect.KEY}},
@ -336,15 +292,9 @@ describe( 'inspect', function()
{item = {c=3}, path = {{a=1}, inspect.METATABLE}},
{item = 'c', path = {{a=1}, inspect.METATABLE, 'c', inspect.KEY}},
{item = 3, path = {{a=1}, inspect.METATABLE, 'c'}}
}, items)
})
end)
it('handles recursive tables correctly', function()
local tbl = { 1,2,3}
tbl.loop = tbl
inspect(tbl, { process=function(x) return x end})
end)
end)
describe('metatables', function()
@ -352,7 +302,7 @@ describe( 'inspect', function()
it('includes the metatable as an extra hash attribute', function()
local foo = { foo = 1, __mode = 'v' }
local bar = setmetatable({a = 1}, foo)
assert.equals(unindent([[
assert.equals(inspect(bar), unindent([[
{
a = 1,
<metatable> = {
@ -360,101 +310,60 @@ describe( 'inspect', function()
foo = 1
}
}
]]), inspect(bar))
]]))
end)
it('can be used on the __tostring metamethod of a table without errors', function()
local f = function(x) return inspect(x) end
local tbl = setmetatable({ x = 1 }, { __tostring = f })
assert.equals(unindent([[
{
x = 1,
it('includes the __tostring metamethod if it exists', function()
local foo = { foo = 1, __tostring = function() return 'hello\nworld' end }
local bar = setmetatable({a = 1}, foo)
assert.equals(inspect(bar), unindent([[
{ -- hello\nworld
a = 1,
<metatable> = {
__tostring = <function 1>
__tostring = <function 1>,
foo = 1
}
}
]]), tostring(tbl))
end)
it('does not allow collecting weak tables while they are being inspected', function()
collectgarbage('stop')
finally(function() collectgarbage('restart') end)
local shimMetatable = {
__mode = 'v',
__index = function() return {} end,
}
local function shim() return setmetatable({}, shimMetatable) end
local t = shim()
t.key = shim()
assert.equals(unindent([[
{
key = {
<metatable> = <1>{
__index = <function 1>,
__mode = "v"
}
},
<metatable> = <table 1>
}
]]), inspect(t))
]]))
end)
it('ignores metatables with __metatable field set to non-nil and non-table type', function()
local function process(item) return item end
local function inspector(data) return inspect(data, {process=process}) end
local foo = setmetatable({}, {__metatable=false})
local bar = setmetatable({}, {__metatable=true})
local baz = setmetatable({}, {__metatable=10})
local spam = setmetatable({}, {__metatable=nil})
local eggs = setmetatable({}, {__metatable={}})
assert.equals(unindent('{}'), inspector(foo))
assert.equals(unindent('{}'), inspector(bar))
assert.equals(unindent('{}'), inspector(baz))
assert.equals(unindent([[
{
<metatable> = {}
}
]]), inspector(spam))
assert.equals(unindent([[
{
<metatable> = {}
it('includes an error string if __tostring metamethod throws an error', function()
local foo = { foo = 1, __tostring = function() error('hello', 0) end }
local bar = setmetatable({a = 1}, foo)
assert.equals(inspect(bar), unindent([[
{ -- error: hello
a = 1,
<metatable> = {
__tostring = <function 1>,
foo = 1
}
}
]]), inspector(eggs))
]]))
end)
describe('When a table is its own metatable', function()
it('accepts a table that is its own metatable without stack overflowing', function()
local x = {}
setmetatable(x,x)
assert.equals(unindent([[
assert.equals(inspect(x), unindent([[
<1>{
<metatable> = <table 1>
}
]]), inspect(x))
]]))
end)
it('can invoke the __tostring method without stack overflowing', function()
local t = {}
t.__index = t
setmetatable(t,t)
assert.equals(unindent([[
assert.equals(inspect(t), unindent([[
<1>{
__index = <table 1>,
<metatable> = <table 1>
}
]]), inspect(t))
]]))
end)
end)
end)
end)
it('allows changing the global tostring', function()
local save = _G.tostring
_G.tostring = inspect
local s = tostring({1, 2, 3})
_G.tostring = save
assert.equals("{ 1, 2, 3 }", s)
end)
end)

Loading…
Cancel
Save