Editing Module:Test

Jump to navigation Jump to search

Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then save the changes below to finish undoing the edit.

Latest revision Your text
Line 1: Line 1:
−
DefInfo = {}
+
ENV = "wiki" -- "dev" or "wiki"
−
local wiki = {}
+
INFO = true
  
−
local function runTime()
+
mw = mw or {}
−
  return string.format("%i", os.clock() * 1000)
+
if ENV == "dev" then log = print
−
end
+
elseif ENV == "wiki" then log = mw.log end
 +
---------------
 +
-- load data --
 +
---------------
  
−
------------------------------------------------------------------
+
data = {}
−
-- deal with differences between MediaWiki and dev environments --
 
−
------------------------------------------------------------------
 
  
−
if mw then
+
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
  
−
  log = mw.log
+
------------------
−
  logObject = mw.logObject
+
-- virtual keys --
 +
------------------
  
−
  local timeDataStart = runTime()
+
-- this could be implemented with metatable events
−
 
+
-- they get added in get(id_pair)
−
  Data  = mw.loadData('Module:Test/data')
 
  
−
  local timeDataEnd = runTime()
+
local virtual_keys = {
−
   log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
+
   ["Races"] = {
−
 
+
    ["lives_in"] = function (race, biomes)
−
  Util  = require("Module:Test/lib/util")
+
      local list = {}
−
  Search = require("Module:Test/lib/search")
+
      for biome_key, biome in pairs(biomes) do
−
  VF    = require("Module:Test/data/virtual")
+
        for _,animal in ipairs(biome.wildAnimals) do
−
 
+
          if race.defName == animal then
−
   log(string.format('@%ims, modules loaded', runTime()))
+
            table.insert(list, biome_key)
 +
          end
 +
        end
 +
      end
 +
      return list
 +
    end
 +
   }
 +
}
  
−
else
+
--------------------
 +
-- load libraries --
 +
--------------------
  
−
   logDevStore = {}
+
if ENV == "dev" then
 +
  inspect = require './lib/inspect'
 +
  util = require("./lib/util")
 +
   search = require("./lib/search")
  
−
   log = function(str)
+
   function pinspect(tbl, title)
−
    table.insert(logDevStore, str)
+
     if INFO then
−
  end
+
       util.hl(title)
−
 
+
       print(inspect(tbl))
−
  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
 
   end
 
   end
 +
end
  
−
   function pp(tbl, title) -- pretty print tables
+
if ENV == "wiki" then
−
    Util.hl(title)
+
   INFO = false
−
    print(Inspect(tbl))
+
  util = require("Module:Test/lib/util")
−
  end
+
  search = require("Module:Test/lib/search")
 +
  function pinspect() end
 +
end
  
−
  local timeDataStart = runTime()
+
-------------
 +
-- private --
 +
-------------
  
−
   Data    = require "data/data"
+
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)))
  
−
   local timeDataEnd = runTime()
+
   frame:callParserFunction('#vardefine', var_name, var_value)
−
  log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
+
end
  
−
  Util    = require "lib/util"
 
−
  Search  = require "lib/search"
 
−
  Inspect = require "lib/inspect"
 
−
  VF      = require "data/virtual"
 
  
−
   log(string.format('@%ims, modules loaded', runTime()))
+
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
 
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)
+
local function merge_def(base_def_table, def_category, ignore_keys)
−
  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 ancestors = {}
−
   local ancestorIDs = {}
+
   local parent_name = base_def_table["ParentName"]
−
   local mergedDef = {}
+
   local parent_table = data[def_category][parent_name]
−
   local def = baseDef
 
  
−
   while def._.ParentName do
+
   while parent_name do
−
    local parentID = def._.DefCategory .. ":" .. def._.ParentName
+
     table.insert(ancestors, parent_name)
−
     table.insert(ancestorIDs, parentID)
+
     parent_name = parent_table["ParentName"]
−
     def = Data[parentID]
+
    parent_table = data[def_category][parent_name]
 
   end
 
   end
  
−
   ancestorIDs = Util.table.reverse(ancestorIDs)
+
   local inheritance_chain = util.shallowcopy(util.reverse_numeric_table(ancestors))
−
   table.insert(ancestorIDs, baseDef._.DefCategory .. ":" .. baseDef.defName)
+
   table.insert(inheritance_chain, base_def_table.defName)
  
−
   for _,parentID in ipairs(ancestorIDs) do
+
  local merged = {}
−
     Util.table.overwrite(mergedDef, Data[parentID], ignoreKeys)
+
   for i,v in ipairs(inheritance_chain) do
 +
     util.overwrite_first_table_with_second(merged, data[def_category][inheritance_chain[i]], ignore_keys)
 
   end
 
   end
  
−
   return mergedDef
+
   return merged
 
end
 
end
  
−
function DefInfo.getDef(defID, expandVF)
 
−
  if expandVF ~= false then expandVF = true end
 
  
−
   local ignoreKeys = {"Abstract", "Name", "ParentName"}
+
local function get(id_pair)
−
  local baseDef
+
   local res = search.conductor(id_pair, data)
−
   local def
+
  if not res then
 +
    log("Def not found")
 +
    return nil
 +
   end
  
−
   if not defID then return nil end
+
   local base_def_table = res.parent.value
 +
  local def = merge_def(base_def_table, res.ancestors[2], {"ParentName", "Abstract"})
  
−
   for _,def in pairs(Data) do
+
   -- add virtual keys
−
    if def.defName == defID then
+
  if virtual_keys[res.ancestors[2]] then
−
      baseDef = def
+
    def._virtual = {}
−
      break
+
    for k,func in pairs(virtual_keys[res.ancestors[2]]) do
−
    elseif string.upper(def.label or '') == string.upper(defID) then
+
      def._virtual[k] = func(def, data.Biomes)
−
      baseDef = def
 
−
      break
 
 
     end
 
     end
 
   end
 
   end
−
 
−
  if not baseDef then return nil end
 
−
 
−
  def = DefInfo.mergeParents(baseDef, ignoreKeys)
 
−
 
−
  DefInfo.expandDef(def, expandVF)
 
  
 
   return def
 
   return def
 
end
 
end
  
−
local function setPrefix(tbl, parentKey)
+
-------------------------------------------------------------------
−
  local mt = getmetatable(tbl) or {}
+
-- simulate MediaWiki/Scribunto module invocation using 'frame'  --
 +
-------------------------------------------------------------------
  
−
  for k,v in pairs(tbl) do
+
local simframe = { ["args"] = {} }
−
    local prefix = parentKey .. "_" .. k
 
−
    if type(v) == 'table' then
 
−
      setPrefix(v, prefix)
 
−
    else
 
−
      mt[k] = prefix
 
−
    end
 
−
  end
 
  
−
  setmetatable(tbl, mt)
+
simframe.args[1] = "Fox_Fennec"
−
end
+
--~ simframe.args[2] = "4"
 +
--~ simframe.args[3] = "1"
  
−
local function definePrefixed(tbl, frame)
+
frame = frame or simframe
−
  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 --
+
-- public & related --
 
----------------------
 
----------------------
  
−
function wiki.count(frame)
+
-- frame.args are always strings on MediaWiki so convert them back to numbers
−
  local query = wiki.query(frame)
+
pinspect(frame.args, "frame.args before")
−
   if type(wiki.queried) == 'table' then -- WARNING: checks a variable that is set in wiki.query (ugly)
+
for k,arg in pairs(frame.args) do
−
    return Util.table.count(wiki.queried)
+
   frame.args[k] = tonumber(arg) or arg
−
  end
 
 
end
 
end
 +
pinspect(frame.args, "frame.args after")
  
−
function wiki.query(frame)
+
local p = {}
−
 
 
−
  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
+
function p.query(frame)
−
     logObject(frame.args, string.format('query @ %ims: missing an identifying argument (defName or label)\nframe.args', runTime()))
+
   if not frame.args[1] then
 +
     log("missing argument #1 needed to identify a Def (defName or label can be used)")
 
     return nil
 
     return nil
 
   end
 
   end
  
−
   local def = DefInfo.getDef(frame.args['defName']) or DefInfo.getDef(frame.args['label'])
+
   local def = get({"defName", frame.args[1]}) or get({"label", frame.args[1]})
−
 
+
   return def
−
   if not def then
+
end
−
    logObject(frame.args, string.format("query @ %ims: Def not found\nframe.args", runTime()))
 
−
    return nil
 
−
  end
 
  
−
  if def and argLen == 0 then
+
function p.logObject(frame)
−
    logObject(def, string.format("['%s:%s'] @ %ims", def._.DefCategory, def.defName, runTime()))
+
  return p.query(frame)
−
    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
 
end
  
−
------------------------------------
+
-------------
−
-- simulate MediaWiki environment --
+
-- dev log --
−
------------------------------------
+
-------------
  
−
if not mw then
+
if ENV == "dev" then
−
   local simframe = { ["args"] = {} }
+
   local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
−
   simframe.args['label'] = 'ancient cryptosleep casket'
+
   print("--" .. string.rep("-", #clock) .. "--")
−
--~   simframe.args[1] = 'verbs'
+
   print("- " .. clock .. " -")
−
--~  simframe.args[2] = 'label'
+
  print("--" .. string.rep("-", #clock) .. "--")
−
  wiki.query(simframe)
 
 
end
 
end
  
−
if not mw then
+
return p
−
  Util.hl("DefInfo log")
 
−
  for _,v in ipairs(logDevStore) do
 
−
    print(v)
 
−
  end
 
−
end
 
−
 
 
−
------------
 
−
-- return --
 
−
------------
 
−
 
 
−
if mw then
 
−
  return wiki
 
−
else
 
−
  return DefInfo
 
−
end
 

Please note that all contributions to RimWorld Wiki are considered to be released under the CC BY-SA 3.0 (see RimWorld Wiki:Copyrights for details). If you do not want your writing to be edited mercilessly and redistributed at will, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource. Do not submit copyrighted work without permission!

Cancel Editing help (opens in new window)

Templates used on this page:

Retrieved from "https://rimworldwiki.com/wiki/Module:Test"