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 = {}
+
----------------------------------------------
−
local wiki = {}
+
-- deal with differences in the environment --
−
 
+
----------------------------------------------
−
local function runTime()
 
−
  return string.format("%i", os.clock() * 1000)
 
−
end
 
−
 
 
−
------------------------------------------------------------------
 
−
-- deal with differences between MediaWiki and dev environments --
 
−
------------------------------------------------------------------
 
  
 
if mw then
 
if mw then
−
 
+
  ENV = "wiki"
 
   log = mw.log
 
   log = mw.log
−
  logObject = mw.logObject
 
  
−
   local timeDataStart = runTime()
+
   util = require("Module:Test/lib/util")
−
    
+
   search = require("Module:Test/lib/search")
−
  Data  = mw.loadData('Module:Test/data')
+
else
−
 
+
   ENV = "dev"
−
   local timeDataEnd = runTime()
 
−
  log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
 
  
−
   Util  = require("Module:Test/lib/util")
+
   mw = {}
−
  Search = require("Module:Test/lib/search")
+
   log = {}
−
   VF    = require("Module:Test/data/virtual")
 
  
−
   log(string.format('@%ims, modules loaded', runTime()))
+
   inspect = require './lib/inspect'
 +
  util = require("./lib/util")
 +
  search = require("./lib/search")
 +
  diet = require("./data/diet")
  
−
else
+
   function pinspect(tbl, title)
−
 
+
     util.hl(title)
−
   logDevStore = {}
+
    print(inspect(tbl))
−
 
 
−
  log = function(str)
 
−
     table.insert(logDevStore, str)
 
 
   end
 
   end
  
−
   logObject = function(obj, prefix)
+
   -- define used mw functions that don't exist in dev environment
 +
  mw.logObject = function(obj, prefix)
 
     if prefix then
 
     if prefix then
 
       assert(type(prefix) == "string")
 
       assert(type(prefix) == "string")
−
       table.insert(logDevStore, prefix .. " = " .. Inspect(obj))
+
       table.insert(log, prefix .. " = " .. inspect(obj))
 
     else
 
     else
−
       table.insert(logDevStore, Inspect(obj))
+
       table.insert(log, inspect(obj))
 
     end
 
     end
 
   end
 
   end
  
−
   function pp(tbl, title) -- pretty print tables
+
   mw.dumpObject = function(arg)
−
    Util.hl(title)
+
     return inspect(arg)
−
     print(Inspect(tbl))
 
 
   end
 
   end
  
−
   local timeDataStart = runTime()
+
   mw.log = function(arg)
 +
    table.insert(log, arg)
 +
  end
 +
end
  
−
  Data    = require "data/data"
+
---------------
 +
-- load data --
 +
---------------
  
−
   local timeDataEnd = runTime()
+
data = {}
−
   log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
+
 
 +
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
 +
  }
 +
}
  
−
  Util    = require "lib/util"
+
-------------
−
  Search  = require "lib/search"
+
-- private --
−
  Inspect = require "lib/inspect"
+
-------------
−
  VF      = require "data/virtual"
 
  
−
   log(string.format('@%ims, modules loaded', runTime()))
+
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
 
end
  
−
-----------------------
 
−
-- private functions --
 
−
-----------------------
 
  
−
function DefInfo.vardefine(name, value, frame)
+
local function search_parent_def_table(key, def_table)
−
  assert(name, "vardefine: missing argument #1 (variable to definePrefix)")
+
   local ParentName = getParentName(def_table)
−
   assert(type(name) == "string", string.format("vardefine: bad argument #1 (string expected, got %s)", type(name)))
+
   if not ParentName then return nil end
−
   assert(value, "vardefine: missing argument #2 (value to assign)")
+
   local parentdef_table = search_table_recursive(ParentName, data)
−
   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)))
+
   if not parentdef_table then return nil end
−
   assert(frame, "vardefine: 'frame' missing")
 
−
  frame:callParserFunction('#vardefine', name, value)
 
−
end
 
  
−
function DefInfo.expandDef(def, runMe)
+
  local found = search_table_recursive(key, parentdef_table)
−
   if not runMe then return nil end
+
   if found then return found
−
   local vFuncs = VF
+
   else
−
  for fName,func in pairs(vFuncs) do
+
    found = search_parent_def_table(key, parentdef_table)
−
     if func(def) then
+
     if found then return found end
−
      log(string.format('@%ims, expandDef: %s expanded with %s', runTime(), def.defName, fName))
 
−
    end
 
 
   end
 
   end
 
end
 
end
  
−
function DefInfo.mergeParents(baseDef, ignoreKeys)
 
−
  local ancestorIDs = {}
 
−
  local mergedDef = {}
 
−
  local def = baseDef
 
  
−
   while def._.ParentName do
+
local function merge_def(base_def_table, def_category, ignore_keys)
−
    local parentID = def._.DefCategory .. ":" .. def._.ParentName
+
 
−
     table.insert(ancestorIDs, parentID)
+
   local ancestors = {}
−
     def = Data[parentID]
+
  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
 
   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"}
+
function get_def(defName)
−
   local baseDef
+
   local base_def_table
−
   local def
+
   local def_category
  
−
   if not defID then return nil end
+
   for catK,_ in pairs(data) do
−
 
+
    for defK,def in pairs(data[catK]) do
−
  for _,def in pairs(Data) do
+
      if defK == defName then
−
    if def.defName == defID then
+
        base_def_table = def
−
      baseDef = def
+
        def_category = catK
−
      break
+
       end
−
    elseif string.upper(def.label or '') == string.upper(defID) then
 
−
       baseDef = def
 
−
      break
 
 
     end
 
     end
 
   end
 
   end
  
−
   if not baseDef then return nil end
+
   if not base_def_table then return nil end
  
−
   def = DefInfo.mergeParents(baseDef, ignoreKeys)
+
   local def = merge_def(base_def_table, def_category, {"ParentName", "Abstract"})
  
−
   DefInfo.expandDef(def, expandVF)
+
   -- 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
 
   return def
 
end
 
end
  
−
local function setPrefix(tbl, parentKey)
 
−
  local mt = getmetatable(tbl) or {}
 
  
−
   for k,v in pairs(tbl) do
+
function getLabel(defName)
−
     local prefix = parentKey .. "_" .. k
+
  local label
−
    if type(v) == 'table' then
+
   for catK,_ in pairs(data) do
−
      setPrefix(v, prefix)
+
     for defK,def in pairs(data[catK]) do
−
    else
+
      if def["defName"] == defName then label = def["label"] end
−
      mt[k] = prefix
 
 
     end
 
     end
 +
  end
 +
  return label
 +
end
 +
 +
function linkString(string)
 +
  return "[[" .. string .. "]]"
 +
end
 +
 +
------------
 +
-- public --
 +
------------
 +
 +
local p = {}
 +
 +
function p.linkString(frame)
 +
  local link = linkString(frame.args[1])
 +
 +
  if not frame.args[1] then
 +
    mw.logObject(frame.args, "frame.args")
 +
    mw.log("missing argument #1 (string)")
 
   end
 
   end
  
−
   setmetatable(tbl, mt)
+
   return label
 
end
 
end
  
−
local function definePrefixed(tbl, frame)
+
 
−
   for k,v in pairs(tbl) do
+
-- will expect frame.args[1] to be defName
−
    if type(v) ~= 'table' then
+
function p.getLabel(frame)
−
      local mt = getmetatable(tbl)
+
   local label = getLabel(frame.args[1])
−
      log(string.format('%s = %s', mt[k], tostring(v)))
+
 
−
      if mw then DefInfo.vardefine(mt[k], v, frame) end
+
  if not label then
−
    else
+
    mw.logObject(frame.args, "frame.args")
−
      definePrefixed(v, frame)
+
    mw.log(string.format("'%s' not found", frame.args[1]))
−
    end
 
 
   end
 
   end
 +
 +
  return label
 
end
 
end
  
−
----------------------
+
-- will expect frame.args[1] to be the label
−
-- public interface --
+
function p.getDefName(frame)
−
----------------------
+
  local defName
 +
  for catK,_ in pairs(data) do
 +
    for defK,def in pairs(data[catK]) do
 +
      if def["label"] then
 +
        if string.upper(def["label"]) == string.upper(frame.args[1]) then defName = defK end
 +
      end
 +
    end
 +
  end
  
−
function wiki.count(frame)
+
  if not defName then
−
  local query = wiki.query(frame)
+
    mw.logObject(frame.args, "frame.args")
−
  if type(wiki.queried) == 'table' then -- WARNING: checks a variable that is set in wiki.query (ugly)
+
    mw.log(string.format("'%s' not found", frame.args[1]))
−
    return Util.table.count(wiki.queried)
 
 
   end
 
   end
 +
 +
  return defName
 
end
 
end
  
−
function wiki.query(frame)
+
function p.count(frame)
 +
  local query = p.query(frame)
 +
  return #query
 +
end
  
−
  local argLen = Util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc
+
-- one function to rule them all, and in the darkness bind them
 +
function p.query(frame)
  
−
   if not frame.args['defName'] and not frame.args['label'] then
+
  -- implement shitloads of checks for arguments and the log so we know what's going on
−
     logObject(frame.args, string.format('query @ %ims: missing an identifying argument (defName or label)\nframe.args', runTime()))
+
  -- use them as a kind of usage guide (give as much info as possible)
 +
  -- if wrong arguments are passed to private functions they will cause errors (they better)
 +
 
 +
   if not frame.args[1] then
 +
     mw.logObject(frame.args, "frame.args")
 +
    mw.log("missing argument #1 (defName)")
 
     return nil
 
     return nil
 
   end
 
   end
  
−
   local def = DefInfo.getDef(frame.args['defName']) or DefInfo.getDef(frame.args['label'])
+
   local def = get_def(frame.args[1])
  
 
   if not def then
 
   if not def then
−
     logObject(frame.args, string.format("query @ %ims: Def not found\nframe.args", runTime()))
+
     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
  
−
   if def and argLen == 0 then
+
   local prune = def
−
    logObject(def, string.format("['%s:%s'] @ %ims", def._.DefCategory, def.defName, runTime()))
+
 
−
     return nil
+
  -- #frame.args won't work as expected, check the doc
−
  end
+
  local arg_count = util.count(frame.args, "number")
 +
 
 +
  -- look at all the beautiful ifs!
 +
  for i,arg in ipairs(frame.args) do
 +
    -- frame.args are always strings on MediaWiki so convert the numbers back to numbers
 +
    arg = tonumber(arg) or arg
 +
 
 +
     -- do stuff for additional arguments
 +
    if i > 1 then
  
−
  local processedDef = def
+
      -- special checks for the final argument
 +
      if i == arg_count then
  
−
  for i,arg in ipairs(frame.args) do -- arguments
+
        -- sibling
−
    arg = tonumber(arg) or arg -- frame.args are always strings on MediaWiki so convert back the numbers
+
        if frame.args["sibling"] then
 +
          prune = search.conductor({nil, frame.args["sibling"]} , prune)
 +
          if not prune then
 +
            mw.logObject(frame.args, "frame.args")
 +
            mw.log(string.format("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("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("bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
 +
            return nil
 +
          else
 +
            prune = prune.value
 +
          end
 +
        end
  
−
    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
 
       else
−
         processedDef = Search.meta.parent.table[arg]
+
         prune = search.conductor(arg, 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("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
  
−
    if i < argLen or i == argLen and not frame.args["sibling"] then
+
  end
−
      processedDef = Search.find(arg, processedDef)
+
 
−
      if not processedDef then
+
  if type(prune) == "table" then mw.logObject(prune) end
−
        logObject(frame.args, string.format("query @ %ims: bad argument #%i ('%s' not found)\nframe.args", runTime(), i, frame.args[i]))
+
  return prune
−
        return nil
+
end
−
      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]))
+
-- simulate MediaWiki/Scribunto module invocation using 'frame'  --
−
          return processedDef
+
-------------------------------------------------------------------
−
        end
+
 
−
      end
+
local simframe = { ["args"] = {} }
−
    end
+
 
 +
simframe.args[1] = "GuineaPig"
 +
simframe.args[2] = "lives_in"
 +
 
 +
frame = frame or simframe
  
−
  end -- for arguments
+
if ENV == "dev" then
  
−
   if type(processedDef) == "table" then
+
   local lives_in = p.query(frame)
−
    log(string.format("@%ims, query: table vardefined", runTime()))
+
  for i,biome in ipairs(lives_in) do
−
    setPrefix(processedDef, frame.args[argLen])
+
     lives_in[i] = linkString(getLabel(biome))
−
    definePrefixed(processedDef, frame)
 
−
     wiki.queried = processedDef -- WARNING: sets a variable that is used in another function wiki.count (ugly)
 
−
    return nil
 
 
   end
 
   end
  
−
   log(string.format("@%ims, query: %s printed", runTime(), type(processedDef)))
+
   pinspect(p.query(frame))
−
   return processedDef
+
  pinspect(lives_in)
 +
--~  pinspect(p.getLabel(frame))
 +
   print(linkString("foo"))
 +
 
 
end
 
end
  
−
------------------------------------
+
local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
−
-- simulate MediaWiki environment --
+
mw.log("--" .. string.rep("-", #clock) .. "--")
−
------------------------------------
+
mw.log("- " .. clock .. " -")
 +
mw.log("--" .. string.rep("-", #clock) .. "--")
  
−
if not mw then
+
----------------------------------------
−
  local simframe = { ["args"] = {} }
+
-- simulate wiki log while developing --
−
  simframe.args['label'] = 'ancient cryptosleep casket'
+
----------------------------------------
−
--~  simframe.args[1] = 'verbs'
 
−
--~  simframe.args[2] = 'label'
 
−
  wiki.query(simframe)
 
−
end
 
  
−
if not mw then
+
if ENV == "dev" then
−
   Util.hl("DefInfo log")
+
   util.hl("log")
−
   for _,v in ipairs(logDevStore) do
+
   for _,v in ipairs(log) do
 
     print(v)
 
     print(v)
 
   end
 
   end
 
end
 
end
  
−
------------
+
return p
−
-- 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"