Difference between revisions of "Module:Test"

From RimWorld Wiki
Jump to navigation Jump to search
m (fix the fix)
m
 
(97 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- redefine the print function to use mw.log
+
DefInfo = {}
print = mw.log
+
local wiki = {}
  
---------------
+
local function runTime()
-- load data --
+
  return string.format("%i", os.clock() * 1000)
---------------
+
end
  
-- wiki environment --
+
------------------------------------------------------------------
 +
-- deal with differences between MediaWiki and dev environments --
 +
------------------------------------------------------------------
  
local Biomes = mw.loadData('Module:Test/data/biomes')
+
if mw then
--local Buildings = mw.loadData('Module:Test/data/buildings')
 
local Races = mw.loadData('Module:Test/data/races')
 
  
-- dev environment --
+
  log = mw.log
 +
  logObject = mw.logObject
  
--local Biomes = loadfile("./data/BiomeDefs.lua")()
+
  local timeDataStart = runTime()
--local Buildings = loadfile("./data/ThingDefs_Buildings.lua")()
+
 
--local Races = loadfile("./data/ThingDefs_Races.lua")()
+
  Data  = mw.loadData('Module:Test/data')
  
-- aggregate the categories --
+
  local timeDataEnd = runTime()
 +
  log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
  
local data = {}
+
  Util  = require("Module:Test/lib/util")
data["Biomes"] = Biomes
+
  Search = require("Module:Test/lib/search")
--data["Buildings"] = Buildings
+
  VF    = require("Module:Test/data/virtual")
data["Races"] = Races
 
  
------------------------
+
  log(string.format('@%ims, modules loaded', runTime()))
-- pretty print table --
 
------------------------
 
  
--[[ procedure: tprint ]]--
+
else
  
function tprint (tbl, indent)
+
  logDevStore = {}
   if not indent then indent = 0 end
+
 
   for k, v in pairs(tbl) do
+
  log = function(str)
    formatting = string.rep("  ", indent) .. k .. ": "
+
    table.insert(logDevStore, str)
     if type(v) == "table" then
+
   end
      print(formatting)
+
 
       tprint(v, indent+1)
+
   logObject = function(obj, prefix)
    elseif type(v) == 'boolean' then
+
     if prefix then
      print(formatting .. tostring(v))
+
      assert(type(prefix) == "string")
 +
       table.insert(logDevStore, prefix .. " = " .. Inspect(obj))
 
     else
 
     else
       print(formatting .. v)
+
       table.insert(logDevStore, Inspect(obj))
 
     end
 
     end
 
   end
 
   end
end
 
  
-----------------------------
+
  function pp(tbl, title) -- pretty print tables
-- small utility functions --
+
    Util.hl(title)
-----------------------------
+
    print(Inspect(tbl))
 +
  end
 +
 
 +
  local timeDataStart = runTime()
 +
 
 +
  Data    = require "data/data"
 +
 
 +
  local timeDataEnd = runTime()
 +
  log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
 +
 
 +
  Util    = require "lib/util"
 +
  Search  = require "lib/search"
 +
  Inspect = require "lib/inspect"
 +
  VF      = require "data/virtual"
  
--[[ function: shallowcopy ]]--
+
  log(string.format('@%ims, modules loaded', runTime()))
  
function shallowcopy(original_table)
 
    local orig_type = type(original_table)
 
    local copy
 
    if orig_type == 'table' then
 
        copy = {}
 
        for orig_key, orig_value in pairs(original_table) do
 
            copy[orig_key] = orig_value
 
        end
 
    else -- number, string, boolean, etc
 
        copy = original_table
 
    end
 
    return copy
 
 
end
 
end
  
--[[ function: reverse_numeric_table ]]--
+
-----------------------
 +
-- private functions --
 +
-----------------------
  
function reverse_numeric_table(tbl)
+
function DefInfo.vardefine(name, value, frame)
    local reversed_table = {}
+
  assert(name, "vardefine: missing argument #1 (variable to definePrefix)")
    local length = #tbl
+
  assert(type(name) == "string", string.format("vardefine: bad argument #1 (string expected, got %s)", type(name)))
    for i,v in ipairs(tbl) do
+
  assert(value, "vardefine: missing argument #2 (value to assign)")
        reversed_table[length + 1 - i] = v
+
  assert(type(value) == "string" or type(value) == "number" or type(value) =="boolean", string.format("vardefine: bad argument #2 (string, number or boolean expected, got %s)", type(value)))
    end
+
  assert(frame, "vardefine: 'frame' missing")
    return reversed_table
+
  frame:callParserFunction('#vardefine', name, value)
 
end
 
end
  
--[[ function: count ]]--
+
function DefInfo.expandDef(def, runMe)
 
+
  if not runMe then return nil end
-- '#' operator seems to work for numerically indexed tables so it can be used instead
+
   local vFuncs = VF
-- this count function counts all the keys (of any type)
+
   for fName,func in pairs(vFuncs) do
local function count(tbl, key_type)
+
     if func(def) then
   local length = 0;
+
       log(string.format('@%ims, expandDef: %s expanded with %s', runTime(), def.defName, fName))
   for k,v in pairs(tbl) do
 
     if key_type then
 
       if type(k) == key_type then
 
        length = length + 1
 
      end
 
    else
 
      length = length + 1
 
 
     end
 
     end
 
   end
 
   end
  return length
 
 
end
 
end
  
--[[ function: find_key_name_of_value ]]--
+
function DefInfo.mergeParents(baseDef, ignoreKeys)
local function find_key_name_of_value(value, tbl)
+
   local ancestorIDs = {}
   for k,v in pairs(tbl) do
+
  local mergedDef = {}
     if v == value then return k end
+
  local def = baseDef
 +
 
 +
  while def._.ParentName do
 +
    local parentID = def._.DefCategory .. ":" .. def._.ParentName
 +
    table.insert(ancestorIDs, parentID)
 +
     def = Data[parentID]
 
   end
 
   end
end
 
  
--[[ function: search_table_recursive ]]--
+
  ancestorIDs = Util.table.reverse(ancestorIDs)
 +
  table.insert(ancestorIDs, baseDef._.DefCategory .. ":" .. baseDef.defName)
  
-- returns the value found by first occurrence of a key within a table (recursive)
+
   for _,parentID in ipairs(ancestorIDs) do
local function search_table_recursive(key, tbl)
+
     Util.table.overwrite(mergedDef, Data[parentID], ignoreKeys)
   for k, v in pairs(tbl) do
 
     if k == key then return v
 
    elseif type(v) == "table" then
 
      local found = search_table_recursive(key, v)
 
      if found then return found end
 
    end
 
 
   end
 
   end
 +
 +
  return mergedDef
 
end
 
end
  
--[[ function: find_parent_table ]]--
+
function DefInfo.getDef(defID, expandVF)
 +
  if expandVF ~= false then expandVF = true end
  
-- returns the parent table of an element specified by key, value (recursive)
+
  local ignoreKeys = {"Abstract", "Name", "ParentName"}
local function find_parent_table(key, value, tbl)
+
  local baseDef
   for k, v in pairs(tbl) do
+
  local def
     if k == key and v == value then return tbl
+
 
     elseif type(v) == "table" then
+
  if not defID then return nil end
       local found = find_parent_table(key, value, v)
+
 
       if found then return found end
+
   for _,def in pairs(Data) do
 +
     if def.defName == defID then
 +
      baseDef = def
 +
      break
 +
     elseif string.upper(def.label or '') == string.upper(defID) then
 +
       baseDef = def
 +
       break
 
     end
 
     end
 
   end
 
   end
end
 
  
--[[ procedure: vardefine ]]--
+
  if not baseDef then return nil end
 +
 
 +
  def = DefInfo.mergeParents(baseDef, ignoreKeys)
  
local function vardefine(var_name, var_value)
+
   DefInfo.expandDef(def, expandVF)
  local fName = "vardefine"
 
  assert(var_name, string.format("bad argument #1 to '%s' (argument missing, name of variable to define)", fName))
 
   assert(var_name == "string", string.format("bad argument #1 to '%s' (string expected, got %s)", fName, type(var_name)))
 
  assert(var_value, string.format("bad argument #2 to '%s' (argument missing, value to assign to variable)", fName))
 
  assert(var_value == "string" or var_value == "number", string.format("bad argument #2 to '%s' (string or number expected, got %s)", fName, type(var_value)))
 
  
   frame:callParserFunction('#vardefine', var_name, var_value)
+
   return def
 
end
 
end
  
--[[ procedure: overwrite_first_table_with_second ]]--
+
local function setPrefix(tbl, parentKey)
 +
  local mt = getmetatable(tbl) or {}
  
local function overwrite_first_table_with_second(first_table, second_table, ignore_keys)
+
  for k,v in pairs(tbl) do
   ignore_keys = ignore_keys or {}
+
    local prefix = parentKey .. "_" .. k
 +
    if type(v) == 'table' then
 +
      setPrefix(v, prefix)
 +
    else
 +
      mt[k] = prefix
 +
    end
 +
   end
  
   for k,v in pairs(second_table) do
+
   setmetatable(tbl, mt)
    local ignore = false
+
end
  
    for _, ignored_key in ipairs(ignore_keys) do
+
local function definePrefixed(tbl, frame)
      if k == ignored_key then ignore = true end
+
  for k,v in pairs(tbl) do
    end
+
     if type(v) ~= 'table' then
 
+
      local mt = getmetatable(tbl)
     if not ignore then
+
      log(string.format('%s = %s', mt[k], tostring(v)))
      if type(v) == "table" then
+
      if mw then DefInfo.vardefine(mt[k], v, frame) end
        if type(first_table[k]) == "table" then
+
    else
          overwrite_first_table_with_second(first_table[k], v)
+
      definePrefixed(v, frame)
        else
 
          first_table[k] = {}
 
          overwrite_first_table_with_second(first_table[k], v)
 
        end
 
      else
 
        first_table[k] = v
 
      end
 
 
     end
 
     end
 
   end
 
   end
Line 168: Line 166:
  
 
----------------------
 
----------------------
-- dataset specific --
+
-- public interface --
 
----------------------
 
----------------------
  
--[[ function: find_def_table ]]--
+
function wiki.count(frame)
 
+
   local query = wiki.query(frame)
local function find_def_table(def)
+
  if type(wiki.queried) == 'table' then -- WARNING: checks a variable that is set in wiki.query (ugly)
   -- hidden variables: data
+
    return Util.table.count(wiki.queried)
  for k1,v1 in pairs(data) do
 
    if type(v1) == "table" then
 
      for k2,v2 in pairs(v1) do
 
        if k2 == def then return v2 end
 
      end
 
    end
 
 
   end
 
   end
 
end
 
end
  
local function find_def_category_table(def)
+
function wiki.query(frame)
  for k1,v1 in pairs(data) do
 
    if type(v1) == "table" then
 
      for k2,v2 in pairs(v1) do
 
        if k2 == def then return v1 end
 
      end
 
    end
 
  end
 
end
 
  
--[[ function: merge_def_with_parents ]]--
+
  local argLen = Util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc
  
local function merge_def_with_parents(def, ignore_keys)
+
  if not frame.args['defName'] and not frame.args['label'] then
   -- hidden variables: ParentName and global data
+
    logObject(frame.args, string.format('query @ %ims: missing an identifying argument (defName or label)\nframe.args', runTime()))
 +
    return nil
 +
   end
  
   local def_table = find_def_table(def)
+
   local def = DefInfo.getDef(frame.args['defName']) or DefInfo.getDef(frame.args['label'])
  local def_category_table = find_def_category_table(def)
 
  local parent_names = {}
 
  local parent_name = def_table["ParentName"]
 
  local parent_table = def_category_table[parent_name]
 
  
   while parent_name do
+
   if not def then
     table.insert(parent_names, parent_name)
+
     logObject(frame.args, string.format("query @ %ims: Def not found\nframe.args", runTime()))
     parent_name = parent_table["ParentName"]
+
     return nil
    parent_table = def_category_table[parent_name]
 
 
   end
 
   end
  
   local inheritance_chain = shallowcopy(reverse_numeric_table(parent_names))
+
   if def and argLen == 0 then
  table.insert(inheritance_chain, def)
+
    logObject(def, string.format("['%s:%s'] @ %ims", def._.DefCategory, def.defName, runTime()))
 
+
     return nil
  local merged = {}
 
  local chain_length = #inheritance_chain
 
  for i,v in ipairs(inheritance_chain) do
 
     overwrite_first_table_with_second(merged, def_category_table[inheritance_chain[i]], ignore_keys)
 
 
   end
 
   end
  
   return merged
+
   local processedDef = def
end
 
  
--------------------------------
+
  for i,arg in ipairs(frame.args) do -- arguments
-- publicly exposed functions --
+
    arg = tonumber(arg) or arg -- frame.args are always strings on MediaWiki so convert back the numbers
--------------------------------
 
  
local p = {}
+
    if i == argLen and frame.args["sibling"] then
 +
      processedDef = Search.find({nil, frame.args["sibling"]} , processedDef)
 +
      if not processedDef then
 +
        logObject(frame.args, string.format("query @ %ims: bad argument 'sibling' ('%s' not found')\nframe.args", runTime(), frame.args["sibling"]))
 +
        return nil
 +
      else
 +
        processedDef = Search.meta.parent.table[arg]
 +
        if not processedDef then
 +
          logObject(frame.args, string.format("query @ %ims: bad argument #%i ('%s' is not a sibling of '%s')", runTime(), i, arg, frame.args["sibling"]))
 +
          return nil
 +
        end
 +
      end
 +
    end
  
function p.query(frame)
+
    if i < argLen or i == argLen and not frame.args["sibling"] then
  local fName = "query"
+
      processedDef = Search.find(arg, processedDef)
 +
      if not processedDef then
 +
        logObject(frame.args, string.format("query @ %ims: bad argument #%i ('%s' not found)\nframe.args", runTime(), i, frame.args[i]))
 +
        return nil
 +
      else
 +
        if type(processedDef) ~= 'table' and i < argLen then
 +
          log(string.format("query @ %ims: warning Def ['%s'] argument #%i ('%s' returns a value, all extra arguments ignored)", runTime(), def['label'], i, frame.args[i]))
 +
          return processedDef
 +
        end
 +
      end
 +
    end
  
  if not (frame.args["defName"] or frame.args["label"]) then
+
   end -- for arguments
    assert(frame.args["defName"], string.format("bad argument to '%s' (missing named argument 'defName' or 'label' needed to find a Def)", fName))
 
   end
 
  
  local def_table
+
   if type(processedDef) == "table" then
  local def_arg
+
     log(string.format("@%ims, query: table vardefined", runTime()))
   if frame.args["defName"] then
+
     setPrefix(processedDef, frame.args[argLen])
     def_table = find_def_table(frame.args["defName"])
+
     definePrefixed(processedDef, frame)
     if def_table then
+
     wiki.queried = processedDef -- WARNING: sets a variable that is used in another function wiki.count (ugly)
      def_arg = frame.args["defName"]
+
     return nil
      def_table = merge_def_with_parents(frame.args["defName"], {"ParentName", "Abstract"})
 
     end
 
  end
 
  if not def_table then
 
    def_table = find_parent_table(find_key_name_of_value(frame.args["label"], frame.args), frame.args["label"], data["Races"])
 
     if def_table then
 
      def_arg = frame.args["label"]
 
      def_table = merge_def_with_parents(def_table["defName"], {"ParentName", "Abstract"})
 
     end
 
 
   end
 
   end
  
   assert(def_table, "Def not found")
+
   log(string.format("@%ims, query: %s printed", runTime(), type(processedDef)))
 +
  return processedDef
 +
end
  
  local numbered_args_length = count(frame.args, "number")
+
------------------------------------
  if numbered_args_length == 0 then
+
-- simulate MediaWiki environment --
    tprint(def_table)
+
------------------------------------
  else
 
    local filtered = def_table
 
    for i=1, numbered_args_length do
 
      filtered = search_table_recursive(frame.args[i], filtered)
 
      assert(frame.args[i], string.format("bad argument to '%s' (missing numeric argument #%i)", fName, i))
 
      assert(filtered, string.format("'%s' not found in '%s'", frame.args[i], def_arg))
 
      if filtered then
 
        if (type(filtered) == "string" or type(filtered) == "number") and (i < numbered_args_length) then
 
          error(string.format("too many numeric arguments to '%s' ('%s' already found in '%s')", fName, frame.args[i], def_arg))
 
        end
 
      else
 
        error(string.format("'%s' not found in '%s'", v, def_arg))
 
      end
 
    end
 
    return filtered
 
  end
 
  
 +
if not mw then
 +
  local simframe = { ["args"] = {} }
 +
  simframe.args['label'] = 'ancient cryptosleep casket'
 +
--~  simframe.args[1] = 'verbs'
 +
--~  simframe.args[2] = 'label'
 +
  wiki.query(simframe)
 
end
 
end
  
-------------
+
if not mw then
-- logging --
+
  Util.hl("DefInfo log")
-------------
+
  for _,v in ipairs(logDevStore) do
 +
    print(v)
 +
  end
 +
end
  
--mw.log("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")
+
------------
print("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")
+
-- return --
 +
------------
  
return p
+
if mw then
 +
  return wiki
 +
else
 +
  return DefInfo
 +
end

Latest revision as of 09:56, 18 May 2021

This module is used for development.

Purpose

This module is used to query information from the uploaded and parsed game files.

Its main purpose is to populate the infoboxes.

Usage

A note on the order of named parameters. All of the parameters that look like ...=... are called named parameters and their order is not important (this is true for all templates).

query

{{#invoke:Test|query|<def ID>[|...|][|tag|][|sibling=...]}}

The work-horse. Output varies based on use:

If only the <def ID> parameter is set, it will show the whole Def in the log.
If simple values are queried it will return them.
If lists are queried it will return nothing but call {{#vardefine}} on all the simple values within it. What got defined can be seen in the page's log.

Named parameters:

<def ID>
This parameter identifies the Def so it is mandatory. It can take two forms, if both are defined then defName takes preference.
defName=<defName>
<defName> (case sensitive) should be replaced with the actual defName of a Def.
label=<label>
<label> (case insensitive) should be replaced with the actual label of a Def.
[sibling=...] (optional) (case sensitive)
Allows querying for something if we know its sibling's value (works only for values at the moment).

Anonymous parameters:

[|...|] (optional) (case sensitive)
Anonymous paramaters before the last one ([tag]) are here to help uniquely identify it. If the [tag] is already unique within a Def tree, then these additional parameters are not needed.
[|tag|] (optional) (case sensitive)
The final anonymous parameter defines what is to be queried.

count

{{#invoke:Test|count|<def ID>[|...|][|tag|][|sibling=...]}}

Parameters are the same as for query. It's basically a wrapped up query that behaves a bit differently.

The difference is in how it handles lists. If a list is queried, unlike query, it will return the length of the list.

How-to

Take a look at a Def

{{#invoke:Test|query|label=desert}}

Data is in the log.

Retrieve a simple value

{{#invoke:Test|query|defName=Caribou|description}}

A large member of the deer family, well-adapted to life in cold climates. Caribou can be milked, but refuse to carry packs.

Dealing with lists

{{#invoke:Test|query|defName=Mech_Scyther|tools}}

When a list is retrieved there will be no output but the log will contain a list of defined variables.

For convenience the list is reprinted here:

tools_1_linkedBodyPartsGroup = LeftBlade
tools_1_cooldownTime = 2
tools_1_label = left blade
tools_1_DPS = 10
tools_1_power = 20
tools_1_capacities_1 = Cut
tools_1_capacities_2 = Stab
tools_2_linkedBodyPartsGroup = RightBlade
tools_2_cooldownTime = 2
tools_2_label = right blade
tools_2_DPS = 10
tools_2_power = 20
tools_2_capacities_1 = Cut
tools_2_capacities_2 = Stab
tools_3_linkedBodyPartsGroup = HeadAttackTool
tools_3_capacities_1 = Blunt
tools_3_label = head
tools_3_DPS = 4.5
tools_3_chanceFactor = 0.2
tools_3_power = 9
tools_3_cooldownTime = 2

All of the above can be accessed with the use of {{#var:...}}.

{{#var:tools_1_DPS}}

10

DPS is not a normal member of this table but has been added with Lua. Let's call it a virtual field.

Retrieve something if a sibling is known

{{#invoke:Test|query|label=guinea pig|minAge|sibling=AnimalAdult}}

0.3


DefInfo = {}
local wiki = {}

local function runTime()
  return string.format("%i", os.clock() * 1000)
end

------------------------------------------------------------------
-- deal with differences between MediaWiki and dev environments --
------------------------------------------------------------------

if mw then

  log = mw.log
  logObject = mw.logObject

  local timeDataStart = runTime()
  
  Data   = mw.loadData('Module:Test/data')

  local timeDataEnd = runTime()
  log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))

  Util   = require("Module:Test/lib/util")
  Search = require("Module:Test/lib/search")
  VF     = require("Module:Test/data/virtual")

  log(string.format('@%ims, modules loaded', runTime()))

else

  logDevStore = {}

  log = function(str)
    table.insert(logDevStore, str)
  end

  logObject = function(obj, prefix)
    if prefix then
      assert(type(prefix) == "string")
      table.insert(logDevStore, prefix .. " = " .. Inspect(obj))
    else
      table.insert(logDevStore, Inspect(obj))
    end
  end

  function pp(tbl, title) -- pretty print tables
    Util.hl(title)
    print(Inspect(tbl))
  end

  local timeDataStart = runTime()

  Data    = require "data/data"

  local timeDataEnd = runTime()
  log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))

  Util    = require "lib/util"
  Search  = require "lib/search"
  Inspect = require "lib/inspect"
  VF      = require "data/virtual"

  log(string.format('@%ims, modules loaded', runTime()))

end

-----------------------
-- private functions --
-----------------------

function DefInfo.vardefine(name, value, frame)
  assert(name, "vardefine: missing argument #1 (variable to definePrefix)")
  assert(type(name) == "string", string.format("vardefine: bad argument #1 (string expected, got %s)", type(name)))
  assert(value, "vardefine: missing argument #2 (value to assign)")
  assert(type(value) == "string" or type(value) == "number" or type(value) =="boolean", string.format("vardefine: bad argument #2 (string, number or boolean expected, got %s)", type(value)))
  assert(frame, "vardefine: 'frame' missing")
  frame:callParserFunction('#vardefine', name, value)
end

function DefInfo.expandDef(def, runMe)
  if not runMe then return nil end
  local vFuncs = VF
  for fName,func in pairs(vFuncs) do
    if func(def) then
      log(string.format('@%ims, expandDef: %s expanded with %s', runTime(), def.defName, fName))
    end
  end
end

function DefInfo.mergeParents(baseDef, ignoreKeys)
  local ancestorIDs = {}
  local mergedDef = {}
  local def = baseDef

  while def._.ParentName do
    local parentID = def._.DefCategory .. ":" .. def._.ParentName
    table.insert(ancestorIDs, parentID)
    def = Data[parentID]
  end

  ancestorIDs = Util.table.reverse(ancestorIDs)
  table.insert(ancestorIDs, baseDef._.DefCategory .. ":" .. baseDef.defName)

  for _,parentID in ipairs(ancestorIDs) do
    Util.table.overwrite(mergedDef, Data[parentID], ignoreKeys)
  end

  return mergedDef
end

function DefInfo.getDef(defID, expandVF)
  if expandVF ~= false then expandVF = true end

  local ignoreKeys = {"Abstract", "Name", "ParentName"}
  local baseDef
  local def

  if not defID then return nil end

  for _,def in pairs(Data) do
    if def.defName == defID then
      baseDef = def
      break
    elseif string.upper(def.label or '') == string.upper(defID) then
      baseDef = def
      break
    end
  end

  if not baseDef then return nil end

  def = DefInfo.mergeParents(baseDef, ignoreKeys)

  DefInfo.expandDef(def, expandVF)

  return def
end

local function setPrefix(tbl, parentKey)
  local mt = getmetatable(tbl) or {}

  for k,v in pairs(tbl) do
    local prefix = parentKey .. "_" .. k
    if type(v) == 'table' then
      setPrefix(v, prefix)
    else
      mt[k] = prefix
    end
  end

  setmetatable(tbl, mt)
end

local function definePrefixed(tbl, frame)
  for k,v in pairs(tbl) do
    if type(v) ~= 'table' then
      local mt = getmetatable(tbl)
      log(string.format('%s = %s', mt[k], tostring(v)))
      if mw then DefInfo.vardefine(mt[k], v, frame) end
    else
      definePrefixed(v, frame)
    end
  end
end

----------------------
-- public interface --
----------------------

function wiki.count(frame)
  local query = wiki.query(frame)
  if type(wiki.queried) == 'table' then -- WARNING: checks a variable that is set in wiki.query (ugly)
    return Util.table.count(wiki.queried)
  end
end

function wiki.query(frame)

  local argLen = Util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc

  if not frame.args['defName'] and not frame.args['label'] then
    logObject(frame.args, string.format('query @ %ims: missing an identifying argument (defName or label)\nframe.args', runTime()))
    return nil
  end

  local def = DefInfo.getDef(frame.args['defName']) or DefInfo.getDef(frame.args['label'])

  if not def then
    logObject(frame.args, string.format("query @ %ims: Def not found\nframe.args", runTime()))
    return nil
  end

  if def and argLen == 0 then
    logObject(def, string.format("['%s:%s'] @ %ims", def._.DefCategory, def.defName, runTime()))
    return nil
  end

  local processedDef = def

  for i,arg in ipairs(frame.args) do -- arguments
    arg = tonumber(arg) or arg -- frame.args are always strings on MediaWiki so convert back the numbers

    if i == argLen and frame.args["sibling"] then
      processedDef = Search.find({nil, frame.args["sibling"]} , processedDef)
      if not processedDef then
        logObject(frame.args, string.format("query @ %ims: bad argument 'sibling' ('%s' not found')\nframe.args", runTime(), frame.args["sibling"]))
        return nil
      else
        processedDef = Search.meta.parent.table[arg]
        if not processedDef then
          logObject(frame.args, string.format("query @ %ims: bad argument #%i ('%s' is not a sibling of '%s')", runTime(), i, arg, frame.args["sibling"]))
          return nil
        end
      end
    end

    if i < argLen or i == argLen and not frame.args["sibling"] then
      processedDef = Search.find(arg, processedDef)
      if not processedDef then
        logObject(frame.args, string.format("query @ %ims: bad argument #%i ('%s' not found)\nframe.args", runTime(), i, frame.args[i]))
        return nil
      else
        if type(processedDef) ~= 'table' and i < argLen then
          log(string.format("query @ %ims: warning Def ['%s'] argument #%i ('%s' returns a value, all extra arguments ignored)", runTime(), def['label'], i, frame.args[i]))
          return processedDef
        end
      end
    end

  end -- for arguments

  if type(processedDef) == "table" then
    log(string.format("@%ims, query: table vardefined", runTime()))
    setPrefix(processedDef, frame.args[argLen])
    definePrefixed(processedDef, frame)
    wiki.queried = processedDef -- WARNING: sets a variable that is used in another function wiki.count (ugly)
    return nil
  end

  log(string.format("@%ims, query: %s printed", runTime(), type(processedDef)))
  return processedDef
end

------------------------------------
-- simulate MediaWiki environment --
------------------------------------

if not mw then
  local simframe = { ["args"] = {} }
  simframe.args['label'] = 'ancient cryptosleep casket'
--~   simframe.args[1] = 'verbs'
--~   simframe.args[2] = 'label'
  wiki.query(simframe)
end

if not mw then
  Util.hl("DefInfo log")
  for _,v in ipairs(logDevStore) do
    print(v)
  end
end

------------
-- return --
------------

if mw then
  return wiki
else
  return DefInfo
end