Difference between revisions of "Module:Test"

From RimWorld Wiki
Jump to navigation Jump to search
m (Undo revision 85725 by Dr. Strangelove (talk))
Tag: Undo
m
 
(53 intermediate revisions by the same user not shown)
Line 1: Line 1:
---@diagnostic disable: lowercase-global
+
DefInfo = {}
local p = {}
+
local wiki = {}
 +
 
 +
local function runTime()
 +
  return string.format("%i", os.clock() * 1000)
 +
end
  
 
------------------------------------------------------------------
 
------------------------------------------------------------------
Line 7: Line 11:
  
 
if mw then
 
if mw then
  ENV = "wiki"
+
 
 
   log = mw.log
 
   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()))
  
  util = require("Module:Test/lib/util")
 
  search = require("Module:Test/lib/search")
 
 
else
 
else
  ENV = "dev"
 
  
   mw = {}
+
   logDevStore = {}
  log = {}
 
  
   inspect = require './module/lib/inspect'
+
   log = function(str)
  util = require("./module/lib/util")
+
     table.insert(logDevStore, str)
  search = require("./module/lib/search")
 
  diet = require("./module/data/diet")
 
 
 
  function pp(tbl, title) -- pretty print tables
 
     util.hl(title)
 
    print(inspect(tbl))
 
 
   end
 
   end
  
   -- (re)define used mw functions that don't exist in dev environment
+
   logObject = function(obj, prefix)
  mw.logObject = function(obj, prefix)
 
 
     if prefix then
 
     if prefix then
 
       assert(type(prefix) == "string")
 
       assert(type(prefix) == "string")
       table.insert(log, prefix .. " = " .. inspect(obj))
+
       table.insert(logDevStore, prefix .. " = " .. Inspect(obj))
 
     else
 
     else
       table.insert(log, inspect(obj))
+
       table.insert(logDevStore, Inspect(obj))
 
     end
 
     end
 
   end
 
   end
  
   mw.dumpObject = function(arg)
+
   function pp(tbl, title) -- pretty print tables
     return inspect(arg)
+
    Util.hl(title)
 +
     print(Inspect(tbl))
 
   end
 
   end
  
   mw.log = function(arg)
+
   local timeDataStart = runTime()
    table.insert(log, arg)
 
  end
 
end
 
  
---------------
+
  Data    = require "data/data"
-- load data --
 
---------------
 
  
if ENV == "dev" then
+
   local timeDataEnd = runTime()
   data = loadfile("./data.lua")()
+
   log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
   -- diet = loadfile("./diet.lua")()
 
elseif ENV == "wiki" then
 
  data = mw.loadData('Module:Test/data')
 
end
 
  
version = data.version
+
  Util    = require "lib/util"
 +
  Search  = require "lib/search"
 +
  Inspect = require "lib/inspect"
 +
  VF      = require "data/virtual"
  
------------------
+
  log(string.format('@%ims, modules loaded', runTime()))
-- virtual keys --
 
------------------
 
  
local virtual_store = {}
+
end
local virtual_keys = {
 
  ["Pawn"] = {
 
 
 
    function (def)
 
      virtField = "lives_in"
 
      biomes = {}
 
      for k,v in pairs(data) do
 
        prefix = string.match(k, '(.+):')
 
        if prefix == "BiomeDef" then
 
          table.insert(biomes, v)
 
        end
 
      end
 
 
 
      local list = {}
 
      for _,biome in pairs(biomes) do
 
        for animal,_ in pairs(biome.wildAnimals or {}) do
 
          if def.defName == animal then
 
            table.insert(list, biome.label)
 
          end
 
        end
 
      end
 
 
 
      if #list > 0 then
 
        def._virtual_[virtField] = list
 
      end
 
    end,
 
 
 
    function (def)
 
      virtField = "diet"
 
      diet = def.race.foodType
 
      flags = {}
 
      virtual_store.diet = {}
 
 
 
      for _,foodType in ipairs(diet) do
 
        if type(util.diet.foodType[foodType]) == "boolean" then
 
          flags[foodType] = true
 
        else
 
          for foodItem,_ in pairs(util.diet.foodType[foodType]) do
 
            flags[foodItem] = true
 
          end
 
        end
 
      end
 
 
 
      for flag,_ in pairs(flags) do
 
        table.insert(virtual_store.diet, flag)
 
      end
 
 
 
      if #virtual_store.diet > 0 then
 
        def._virtual_[virtField] = virtual_store.diet
 
      end
 
    end,
 
 
 
  }
 
}
 
  
 
-----------------------
 
-----------------------
Line 124: Line 70:
 
-----------------------
 
-----------------------
  
local function vardefine(name, value)
+
function DefInfo.vardefine(name, value, frame)
  local f_name = "vardefine"
+
   assert(name, "vardefine: missing argument #1 (variable to definePrefix)")
   assert(name, string.format("bad argument #1 to '%s' (argument missing, name of variable to define)", f_name))
+
   assert(type(name) == "string", string.format("vardefine: bad argument #1 (string expected, got %s)", type(name)))
   assert(type(name) == "string", string.format("bad argument #1 to '%s' (string expected, got %s)", f_name, type(name)))
+
   assert(value, "vardefine: missing argument #2 (value to assign)")
   assert(value, string.format("bad argument #2 to '%s' (argument missing, value to assign to variable)", f_name))
+
   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(value == "string" or value == "number", string.format("bad argument #2 to '%s' (string or number expected, got %s)", f_name, type(value)))
+
  assert(frame, "vardefine: 'frame' missing")
 
 
 
   frame:callParserFunction('#vardefine', name, value)
 
   frame:callParserFunction('#vardefine', name, value)
 
end
 
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
  
local function mergeParents(baseDef, ignoreKeys)
+
function DefInfo.mergeParents(baseDef, ignoreKeys)
 
   local ancestorIDs = {}
 
   local ancestorIDs = {}
 
   local mergedDef = {}
 
   local mergedDef = {}
Line 143: Line 97:
 
     local parentID = def._.DefCategory .. ":" .. def._.ParentName
 
     local parentID = def._.DefCategory .. ":" .. def._.ParentName
 
     table.insert(ancestorIDs, parentID)
 
     table.insert(ancestorIDs, parentID)
     def = data[parentID]
+
     def = Data[parentID]
 
   end
 
   end
  
   ancestorIDs = util.table.reverse(ancestorIDs)
+
   ancestorIDs = Util.table.reverse(ancestorIDs)
 
   table.insert(ancestorIDs, baseDef._.DefCategory .. ":" .. baseDef.defName)
 
   table.insert(ancestorIDs, baseDef._.DefCategory .. ":" .. baseDef.defName)
  
 
   for _,parentID in ipairs(ancestorIDs) do
 
   for _,parentID in ipairs(ancestorIDs) do
     util.table.overwrite(mergedDef, data[parentID], ignoreKeys)
+
     Util.table.overwrite(mergedDef, Data[parentID], ignoreKeys)
 
   end
 
   end
  
Line 156: Line 110:
 
end
 
end
  
 +
function DefInfo.getDef(defID, expandVF)
 +
  if expandVF ~= false then expandVF = true end
  
function getDef(defIDsuffix, defIDprefix)
 
 
   local ignoreKeys = {"Abstract", "Name", "ParentName"}
 
   local ignoreKeys = {"Abstract", "Name", "ParentName"}
 
   local baseDef
 
   local baseDef
   local mergedDef
+
   local def
  
   if defIDprefix then
+
   if not defID then return nil end
    local defID = defIDprefix .. ":" .. defIDsuffix
+
 
    baseDef = data[defID]
+
   for _,def in pairs(Data) do
    assert(not baseDef, string.format("getDef: Def '%s' not found", defID))
+
    if def.defName == defID then
   else
+
       baseDef = def
    for defID,def in pairs(data) do
+
       break
      -- WARNING: this depends on there not being any preexisting colons in the relevant substrings
+
    elseif string.upper(def.label or '') == string.upper(defID) then
       prefix = string.match(defID, '(.+):')
+
      baseDef = def
       suffix = string.match(defID, ':(.+)')
+
       break
      if suffix == defIDsuffix then
 
        assert(not baseDef, string.format("getDef: Def conflict (more than one '%s')", defIDsuffix))
 
        baseDef = def
 
       end
 
 
     end
 
     end
    assert(baseDef, string.format("getDef: Def '%s' not found", defIDsuffix))
 
 
   end
 
   end
  
   mergedDef = mergeParents(baseDef, ignoreKeys)
+
   if not baseDef then return nil end
 +
 
 +
  def = DefInfo.mergeParents(baseDef, ignoreKeys)
  
   if virtual_keys[mergedDef.category] then
+
   DefInfo.expandDef(def, expandVF)
    mergedDef._virtual_ = {}
 
    for k,func in ipairs(virtual_keys[mergedDef.category]) do
 
      func(mergedDef)
 
    end
 
  end
 
  
   return mergedDef
+
   return def
 
end
 
end
  
 +
local function setPrefix(tbl, parentKey)
 +
  local mt = getmetatable(tbl) or {}
  
----------------------
+
   for k,v in pairs(tbl) do
-- public interface --
+
    local prefix = parentKey .. "_" .. k
----------------------
 
 
 
local function setMeta(table, parentKey)
 
  local mw = {}
 
   for k,v in pairs(table) do
 
 
 
 
     if type(v) == 'table' then
 
     if type(v) == 'table' then
       setMeta(v, parentKey .. "_" .. k)
+
       setPrefix(v, prefix)
 
     else
 
     else
       mw[k] = parentKey .. "_" .. k
+
       mt[k] = prefix
 
     end
 
     end
 
   end
 
   end
   setmetatable(table, mw)
+
 
 +
   setmetatable(tbl, mt)
 
end
 
end
  
 
+
local function definePrefixed(tbl, frame)
local function defineRecursive(tbl)
 
 
   for k,v in pairs(tbl) do
 
   for k,v in pairs(tbl) do
 
     if type(v) ~= 'table' then
 
     if type(v) ~= 'table' then
 
       local mt = getmetatable(tbl)
 
       local mt = getmetatable(tbl)
       mw.log(string.format("%s = %s", mt[k], v))
+
       log(string.format('%s = %s', mt[k], tostring(v)))
       vardefine(mt[k], v)
+
       if mw then DefInfo.vardefine(mt[k], v, frame) end
     else  
+
     else
       defineRecursive(v)
+
       definePrefixed(v, frame)
 
     end
 
     end
 
   end
 
   end
 
end
 
end
  
 +
----------------------
 +
-- public interface --
 +
----------------------
  
-- procedure
+
function wiki.count(frame)
function p.define(frame)
+
   local query = wiki.query(frame)
  local argLen = util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc
+
   if type(wiki.queried) == 'table' then -- WARNING: checks a variable that is set in wiki.query (ugly)
   local tbl = p.query(frame)
+
     return Util.table.count(wiki.queried)
   if type(tbl) == 'table' then
 
    setMeta(tbl, frame.args[argLen])
 
     defineRecursive(tbl)
 
 
   end
 
   end
 
end
 
end
  
 +
function wiki.query(frame)
  
function p.getDefName(frame)
+
  local argLen = Util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc
  local defName
 
  local label = frame.args[1]
 
  
   if not label then
+
   if not frame.args['defName'] and not frame.args['label'] then
     mw.logObject(frame.args, "frame.args")
+
     logObject(frame.args, string.format('query @ %ims: missing an identifying argument (defName or label)\nframe.args', runTime()))
    mw.log("getDefName: missing argument #1 (label)")
 
 
     return nil
 
     return nil
 
   end
 
   end
  
   for defID,def in pairs(data) do
+
   local def = DefInfo.getDef(frame.args['defName']) or DefInfo.getDef(frame.args['label'])
    if string.upper(def.label or "") == string.upper(label) then
 
      defName = def.defName
 
    end
 
  end
 
  
   if not defName then
+
   if not def then
     mw.logObject(frame.args, "frame.args")
+
     logObject(frame.args, string.format("query @ %ims: Def not found\nframe.args", runTime()))
    mw.log(string.format("getDefName: '%s' not found", label))
 
  end
 
 
 
  return defName
 
end
 
 
 
 
 
function p.count(frame)
 
  local query = p.query(frame)
 
  if type(query) == 'table' then
 
    return #query
 
  else
 
    return type(query)
 
  end
 
end
 
 
 
 
 
function p.query(frame)
 
  local argLen = util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc
 
 
 
  -- implement expressive argument checks so we know what's going on
 
  -- use them as a kind of usage guide (give as much info as possible)
 
 
 
  if not frame.args[1] then
 
    mw.logObject(frame.args, "frame.args")
 
    mw.log("query: missing argument #1 (defName or Name, for abstract Defs)")
 
 
     return nil
 
     return nil
 
   end
 
   end
  
   local def = getDef(frame.args[1])
+
   if def and argLen == 0 then
 
+
     logObject(def, string.format("['%s:%s'] @ %ims", def._.DefCategory, def.defName, runTime()))
  if not def then
 
     mw.logObject(frame.args, "frame.args")
 
    mw.log(string.format("query: bad argument #1 ('%s' not found)", frame.args[1]))
 
 
     return nil
 
     return nil
 
   end
 
   end
  
   local prune = def
+
   local processedDef = def
  
 
   for i,arg in ipairs(frame.args) do -- arguments
 
   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
 
     arg = tonumber(arg) or arg -- frame.args are always strings on MediaWiki so convert back the numbers
  
     -- NOTE: might consider doing something about the if tree (trim it down a bit)
+
     if i == argLen and frame.args["sibling"] then
 
+
      processedDef = Search.find({nil, frame.args["sibling"]} , processedDef)
    if i > 1 then -- additional arguments
+
      if not processedDef then
 
+
        logObject(frame.args, string.format("query @ %ims: bad argument 'sibling' ('%s' not found')\nframe.args", runTime(), frame.args["sibling"]))
      if i == argLen then -- if final argument
+
        return nil
 
+
      else
        if frame.args["sibling"] then -- sibling
+
        processedDef = Search.meta.parent.table[arg]
          prune = search.conductor({nil, frame.args["sibling"]} , prune)
+
        if not processedDef then
          if not prune then
+
          logObject(frame.args, string.format("query @ %ims: bad argument #%i ('%s' is not a sibling of '%s')", runTime(), i, arg, frame.args["sibling"]))
            mw.logObject(frame.args, "frame.args")
 
            mw.log(string.format("query: bad argument 'sibling' ('%s' not found in '%s')", frame.args["sibling"], frame.args[i-1]))
 
            return nil
 
          else
 
            prune = prune.parent.table[arg]
 
            if not prune then
 
              mw.logObject(frame.args, "frame.args")
 
              mw.log(string.format("query: bad argument #%i ('%s' is not a sibling of '%s')", i, arg, frame.args["sibling"]))
 
            end
 
          end
 
        else
 
          prune = search.conductor(arg, prune)
 
          if not prune then
 
            mw.logObject(frame.args, "frame.args")
 
            mw.log(string.format("query: bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
 
            return nil
 
          else
 
            prune = prune.value
 
          end
 
        end -- sibling
 
 
 
      else -- if not final argument
 
        prune = search.conductor(arg, prune)
 
        if not prune then
 
          mw.logObject(frame.args, "frame.args")
 
          mw.log(string.format("query: bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
 
 
           return nil
 
           return nil
        else
 
          prune = prune.value
 
 
         end
 
         end
 
       end
 
       end
 +
    end
  
     end -- additional arguments
+
    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
 
   end -- for arguments
  
   if type(prune) == "table" then
+
   if type(processedDef) == "table" then
     setMeta(prune, frame.args[argLen])
+
     log(string.format("@%ims, query: table vardefined", runTime()))
     defineRecursive(prune)
+
    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
 
   end
  
   return prune
+
  log(string.format("@%ims, query: %s printed", runTime(), type(processedDef)))
 +
   return processedDef
 
end
 
end
  
---------------------------------
+
------------------------------------
-- simulate module invocation  --
+
-- simulate MediaWiki environment --
---------------------------------
+
------------------------------------
 
 
local simframe = { ["args"] = {} }
 
frame = frame or simframe
 
 
 
--~ simframe.args[1] = "Penoxycyline"
 
simframe.args[1] = "Mech_Scyther"
 
simframe.args[2] = "tools"
 
-- simframe.args[3] = "1"
 
--~ simframe.args[3] = 3
 
 
 
if ENV == "dev" then
 
 
 
  print(p.query(frame))
 
  
 +
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
  
local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
+
if not mw then
mw.log("--" .. string.rep("-", #clock) .. "--")
+
   Util.hl("DefInfo log")
mw.log("- " .. clock .. " -")
+
   for _,v in ipairs(logDevStore) do
mw.log("--" .. string.rep("-", #clock) .. "--")
 
 
 
----------------------------------------
 
-- simulate wiki log while developing --
 
----------------------------------------
 
 
 
if ENV == "dev" then
 
   util.hl("log")
 
   for _,v in ipairs(log) do
 
 
     print(v)
 
     print(v)
 
   end
 
   end
 
end
 
end
  
return p -- return module
+
------------
 +
-- return --
 +
------------
 +
 
 +
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