Difference between revisions of "Module:Test"

From RimWorld Wiki
Jump to navigation Jump to search
m
m
Line 1: Line 1:
 +
----------------------------------------------
 +
-- deal with differences in the environment --
 +
----------------------------------------------
 +
 
if mw then
 
if mw then
 
   ENV = "wiki"
 
   ENV = "wiki"
 +
  INFO = false
 +
  log = mw.log
 +
 +
  util = require("Module:Test/lib/util")
 +
  search = require("Module:Test/lib/search")
 +
 +
  function pinspect() end
 
else
 
else
 +
  ENV = "dev"
 +
  INFO = true
 +
 
   mw = {}
 
   mw = {}
   ENV = "dev"
+
   log = {}
 +
 
 +
  inspect = require './lib/inspect'
 +
  util = require("./lib/util")
 +
  search = require("./lib/search")
 +
 
 +
  function pinspect(tbl, title)
 +
    if INFO then
 +
      util.hl(title)
 +
      print(inspect(tbl))
 +
    end
 +
  end
 +
 
 +
  -- define used mw functions that don't exist
 +
  mw.logObject = function(obj, prefix)
 +
    if prefix then
 +
      assert(type(prefix) == "string")
 +
      table.insert(log, prefix .. " = " .. inspect(obj))
 +
    else
 +
      table.insert(log, inspect(obj))
 +
    end
 +
  end
 +
 
 +
  mw.dumpObject = function(arg)
 +
    return inspect(arg)
 +
  end
 +
 
 +
  mw.log = function(arg)
 +
    table.insert(log, arg)
 +
  end
 
end
 
end
 
INFO = true
 
  
 
---------------
 
---------------
Line 44: Line 85:
 
   }
 
   }
 
}
 
}
 
--------------------
 
-- load libraries --
 
--------------------
 
 
log_entries = {}
 
 
if ENV == "dev" then
 
  inspect = require './lib/inspect'
 
  util = require("./lib/util")
 
  search = require("./lib/search")
 
 
  function pinspect(tbl, title)
 
    if INFO then
 
      util.hl(title)
 
      print(inspect(tbl))
 
    end
 
  end
 
 
  mw.logObject = function(arg)
 
    table.insert(log_entries, inspect(arg))
 
  end
 
 
  mw.dumpObject = function(arg)
 
    return inspect(arg)
 
  end
 
 
  log = function(arg)
 
    table.insert(log_entries, arg)
 
  end
 
end
 
 
if ENV == "wiki" then
 
  INFO = false
 
  log = mw.log
 
  util = require("Module:Test/lib/util")
 
  search = require("Module:Test/lib/search")
 
  function pinspect() end
 
end
 
  
 
-------------
 
-------------
Line 138: Line 140:
  
  
local function get(id_pair)
+
function get_def(defName)
   local res = search.conductor(id_pair, data)
+
   local base_def_table
  if not res then
+
  local def_category
    log("Def not found")
+
 
     return nil
+
  for catK,_ in pairs(data) do
 +
    for defK,def in pairs(data[catK]) do
 +
      if defK == defName then
 +
        base_def_table = def
 +
        def_category = catK
 +
      end
 +
     end
 
   end
 
   end
  
   local base_def_table = res.parent.table
+
   if not base_def_table then return nil end
   local def = merge_def(base_def_table, res.ancestors[2], {"ParentName", "Abstract"})
+
 
 +
   local def = merge_def(base_def_table, def_category, {"ParentName", "Abstract"})
  
 
   -- add virtual keys
 
   -- add virtual keys
   if virtual_keys[res.ancestors[2]] then
+
   if virtual_keys[def_category] then
 
     def._virtual = {}
 
     def._virtual = {}
     for k,func in pairs(virtual_keys[res.ancestors[2]]) do
+
     for k,func in pairs(virtual_keys[def_category]) do
 
       def._virtual[k] = func(def, data.Biomes)
 
       def._virtual[k] = func(def, data.Biomes)
 
     end
 
     end
 
   end
 
   end
  
 +
--~  mw.logObject(def, "def")
 
   return def
 
   return def
 
end
 
end
Line 165: Line 175:
 
local p = {}
 
local p = {}
  
 +
 +
-- will check frame.args[1] for the label
 +
function p.getDefName(frame)
 +
  local defName
 +
  for catK,_ in pairs(data) do
 +
    for defK,def in pairs(data[catK]) do
 +
      if def["label"] == frame.args[1] then defName = defK end
 +
    end
 +
  end
 +
 +
  if not defName then
 +
    mw.logObject(frame.args, "frame.args")
 +
    mw.log(string.format("'%s' not found", frame.args[1]))
 +
  end
 +
 +
  return defName
 +
end
  
 
-- one function to rule them all, and in the darkness bind them
 
-- one function to rule them all, and in the darkness bind them
 
function p.query(frame)
 
function p.query(frame)
 +
 +
  -- implement shitloads of checks for arguments and the log so we know what's going on
 +
  -- use them as a kind of usage guide
 +
 
   if not frame.args[1] then
 
   if not frame.args[1] then
     log("missing argument #1 (needed to identify a Def, defName or label can be used)")
+
     mw.logObject(frame.args, "frame.args")
 +
    mw.log("missing argument #1 (defName)")
 +
    return nil
 +
  end
 +
 
 +
  local def = get_def(frame.args[1])
 +
 
 +
  if not def then
 +
    mw.logObject(frame.args, "frame.args")
 +
    mw.log(string.format("bad argument #1 ('%s' not found)", frame.args[1]))
 
     return nil
 
     return nil
 
   end
 
   end
  
   local def = get({"defName", frame.args[1]}) or get({"label", frame.args[1]})
+
   local prune = def
  local pruned = def
 
  
 
   local arg_count = #frame.args
 
   local arg_count = #frame.args
Line 189: Line 228:
 
         -- sibling_value
 
         -- sibling_value
 
         if frame.args["sibling_value"] then
 
         if frame.args["sibling_value"] then
           pruned = search.conductor({nil, frame.args["sibling_value"]} , pruned)
+
           prune = search.conductor({nil, frame.args["sibling_value"]} , prune)
           if not pruned then
+
           if not prune then
             log(string.format("bad argument 'sibling_value' ('%s' not found in '%s')", frame.args["sibling_value"], frame.args[i-1]))
+
             mw.log(string.format("bad argument 'sibling_value' ('%s' not found in '%s')", frame.args["sibling_value"], frame.args[i-1]))
 
             return nil
 
             return nil
 
           else
 
           else
             pruned = pruned.parent.table[arg]
+
             prune = prune.parent.table[arg]
             if not pruned then
+
             if not prune then
               log(string.format("bad argument #%i ('%s' is not a sibling of '%s')", i, arg, frame.args["sibling_value"]))
+
               mw.log(string.format("bad argument #%i ('%s' is not a sibling of '%s')", i, arg, frame.args["sibling_value"]))
 
             end
 
             end
 
           end
 
           end
 
         else
 
         else
           pruned = search.conductor(arg, pruned)
+
           prune = search.conductor(arg, prune)
           if not pruned then
+
           if not prune then
             log(string.format("bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
+
             mw.log(string.format("bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
 
             return nil
 
             return nil
 
           else
 
           else
             pruned = pruned.value
+
             prune = prune.value
 
           end
 
           end
 
         end
 
         end
  
 
       else
 
       else
         pruned = search.conductor(arg, pruned)
+
         prune = search.conductor(arg, prune)
         if not pruned then
+
         if not prune then
           log(string.format("bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
+
           mw.log(string.format("bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
 
           return nil
 
           return nil
 
         else
 
         else
           pruned = pruned.value
+
           prune = prune.value
 
         end
 
         end
 
       end
 
       end
Line 223: Line 262:
 
   end
 
   end
  
   if type(pruned) == "table" then mw.logObject(pruned) end
+
   if type(prune) == "table" then mw.logObject(prune) end
   return pruned
+
   return prune
 
end
 
end
  
Line 241: Line 280:
 
local simframe = { ["args"] = {} }
 
local simframe = { ["args"] = {} }
  
simframe.args[1] = "Hare"
+
simframe.args[1] = "Fox_Fennec"
simframe.args[2] = "race"
+
simframe.args[2] = "minAge"
--~ simframe.args["sibling_value"] = "AnimalJuvenile"
+
simframe.args["sibling_value"] = "AnimalJuvenilee"
  
 
frame = frame or simframe
 
frame = frame or simframe
Line 261: Line 300:
  
 
local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
 
local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
log("--" .. string.rep("-", #clock) .. "--")
+
mw.log("--" .. string.rep("-", #clock) .. "--")
log("- " .. clock .. " -")
+
mw.log("- " .. clock .. " -")
log("--" .. string.rep("-", #clock) .. "--")
+
mw.log("--" .. string.rep("-", #clock) .. "--")
  
 
if ENV == "dev" then
 
if ENV == "dev" then
 
   util.hl("log")
 
   util.hl("log")
   for _,v in ipairs(log_entries) do
+
   for _,v in ipairs(log) do
 
     print(v)
 
     print(v)
 
   end
 
   end

Revision as of 00:56, 16 April 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}}

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}}

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}}


----------------------------------------------
-- deal with differences in the environment --
----------------------------------------------

if mw then
  ENV = "wiki"
  INFO = false
  log = mw.log

  util = require("Module:Test/lib/util")
  search = require("Module:Test/lib/search")

  function pinspect() end
else
  ENV = "dev"
  INFO = true

  mw = {}
  log = {}

  inspect = require './lib/inspect'
  util = require("./lib/util")
  search = require("./lib/search")

  function pinspect(tbl, title)
    if INFO then
      util.hl(title)
      print(inspect(tbl))
    end
  end

  -- define used mw functions that don't exist
  mw.logObject = function(obj, prefix)
    if prefix then
      assert(type(prefix) == "string")
      table.insert(log, prefix .. " = " .. inspect(obj))
    else
      table.insert(log, inspect(obj))
    end
  end

  mw.dumpObject = function(arg)
    return inspect(arg)
  end

  mw.log = function(arg)
    table.insert(log, arg)
  end
end

---------------
-- load data --
---------------

data = {}

if ENV == "dev" then
  data["Biomes"] = loadfile("./data/BiomeDefs.lua")()
  data["Races"] = loadfile("./data/ThingDefs_Races.lua")()
elseif ENV == "wiki" then
  data["Biomes"] = mw.loadData('Module:Test/data/biomes')
  data["Races"] = mw.loadData('Module:Test/data/races')
end

------------------
-- virtual keys --
------------------

-- this could be implemented with metatable events
-- they get added in get(id_pair)

local virtual_keys = {
  ["Races"] = {
    ["lives_in"] = function (race, biomes)
      local list = {}
      for biome_key, biome in pairs(biomes) do
        for _,animal in ipairs(biome.wildAnimals) do
          if race.defName == animal then
            table.insert(list, biome_key)
          end
        end
      end
      return list
    end
  }
}

-------------
-- private --
-------------

local function vardefine(name, value)
  local f_name = "vardefine"
  assert(var_name, string.format("bad argument #1 to '%s' (argument missing, name of variable to define)", f_name))
  assert(var_name == "string", string.format("bad argument #1 to '%s' (string expected, got %s)", f_name, type(var_name)))
  assert(var_value, string.format("bad argument #2 to '%s' (argument missing, value to assign to variable)", f_name))
  assert(var_value == "string" or var_value == "number", string.format("bad argument #2 to '%s' (string or number expected, got %s)", f_name, type(var_value)))

  frame:callParserFunction('#vardefine', var_name, var_value)
end


local function search_parent_def_table(key, def_table)
  local ParentName = getParentName(def_table)
  if not ParentName then return nil end
  local parentdef_table = search_table_recursive(ParentName, data)
  if not parentdef_table then return nil end

  local found = search_table_recursive(key, parentdef_table)
  if found then return found
  else
    found = search_parent_def_table(key, parentdef_table)
    if found then return found end
  end
end


local function merge_def(base_def_table, def_category, ignore_keys)

  local ancestors = {}
  local parent_name = base_def_table["ParentName"]
  local parent_table = data[def_category][parent_name]

  while parent_name do
    table.insert(ancestors, parent_name)
    parent_name = parent_table["ParentName"]
    parent_table = data[def_category][parent_name]
  end

  local inheritance_chain = util.shallowcopy(util.reverse_numeric_table(ancestors))
  table.insert(inheritance_chain, base_def_table.defName)

  local merged = {}
  for i,v in ipairs(inheritance_chain) do
    util.overwrite_first_table_with_second(merged, data[def_category][inheritance_chain[i]], ignore_keys)
  end

  return merged
end


function get_def(defName)
  local base_def_table
  local def_category

  for catK,_ in pairs(data) do
    for defK,def in pairs(data[catK]) do
      if defK == defName then
        base_def_table = def
        def_category = catK
      end
    end
  end

  if not base_def_table then return nil end

  local def = merge_def(base_def_table, def_category, {"ParentName", "Abstract"})

  -- add virtual keys
  if virtual_keys[def_category] then
    def._virtual = {}
    for k,func in pairs(virtual_keys[def_category]) do
      def._virtual[k] = func(def, data.Biomes)
    end
  end

--~   mw.logObject(def, "def")
  return def
end

------------
-- public --
------------

local p = {}


-- will check frame.args[1] for the label
function p.getDefName(frame)
  local defName
  for catK,_ in pairs(data) do
    for defK,def in pairs(data[catK]) do
      if def["label"] == frame.args[1] then defName = defK end
    end
  end

  if not defName then
    mw.logObject(frame.args, "frame.args")
    mw.log(string.format("'%s' not found", frame.args[1]))
  end

  return defName
end

-- one function to rule them all, and in the darkness bind them
function p.query(frame)

  -- implement shitloads of checks for arguments and the log so we know what's going on
  -- use them as a kind of usage guide

  if not frame.args[1] then
    mw.logObject(frame.args, "frame.args")
    mw.log("missing argument #1 (defName)")
    return nil
  end

  local def = get_def(frame.args[1])

  if not def then
    mw.logObject(frame.args, "frame.args")
    mw.log(string.format("bad argument #1 ('%s' not found)", frame.args[1]))
    return nil
  end

  local prune = def

  local arg_count = #frame.args

  -- look at all the beautiful ifs!
  for i,arg in ipairs(frame.args) do

    -- do stuff for additional arguments
    if i > 1 then

      -- special checks for the final argument
      if i == arg_count then

        -- sibling_value
        if frame.args["sibling_value"] then
          prune = search.conductor({nil, frame.args["sibling_value"]} , prune)
          if not prune then
            mw.log(string.format("bad argument 'sibling_value' ('%s' not found in '%s')", frame.args["sibling_value"], frame.args[i-1]))
            return nil
          else
            prune = prune.parent.table[arg]
            if not prune then
              mw.log(string.format("bad argument #%i ('%s' is not a sibling of '%s')", i, arg, frame.args["sibling_value"]))
            end
          end
        else
          prune = search.conductor(arg, prune)
          if not prune then
            mw.log(string.format("bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
            return nil
          else
            prune = prune.value
          end
        end

      else
        prune = search.conductor(arg, prune)
        if not prune then
          mw.log(string.format("bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
          return nil
        else
          prune = prune.value
        end
      end

    end

  end

  if type(prune) == "table" then mw.logObject(prune) end
  return prune
end

function p.logObject(frame)
  mw.logObject(get(frame))
end

function p.dumpObject(frame)
  return mw.dumpObject(get(frame))
end

-------------------------------------------------------------------
-- simulate MediaWiki/Scribunto module invocation using 'frame'  --
-------------------------------------------------------------------

local simframe = { ["args"] = {} }

simframe.args[1] = "Fox_Fennec"
simframe.args[2] = "minAge"
simframe.args["sibling_value"] = "AnimalJuvenilee"

frame = frame or simframe

-- frame.args are always strings on MediaWiki so convert them back to numbers
for k,arg in pairs(frame.args) do
  frame.args[k] = tonumber(arg) or arg
end

if ENV == "dev" then
  print(p.query(frame))
end

----------------------------------------
-- simulate wiki log while developing --
----------------------------------------

local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
mw.log("--" .. string.rep("-", #clock) .. "--")
mw.log("- " .. clock .. " -")
mw.log("--" .. string.rep("-", #clock) .. "--")

if ENV == "dev" then
  util.hl("log")
  for _,v in ipairs(log) do
    print(v)
  end

end

return p