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 p = {}
−
local wiki = {}
 
−
 
 
−
local function runTime()
 
−
  return string.format("%i", os.clock() * 1000)
 
−
end
 
  
 
------------------------------------------------------------------
 
------------------------------------------------------------------
Line 11: Line 6:
  
 
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()
+
   mw = {}
−
   log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
+
   log = {}
  
−
   Util   = require("Module:Test/lib/util")
+
   inspect = require './lib/inspect'
−
   Search = require("Module:Test/lib/search")
+
   util = require("./lib/util")
−
   VF    = require("Module:Test/data/virtual")
+
   search = require("./lib/search")
 +
   diet = require("./data/diet")
  
−
   log(string.format('@%ims, modules loaded', runTime()))
+
   function pp(tbl, title) -- pretty print tables
−
 
+
    util.hl(title)
−
else
+
     print(inspect(tbl))
−
 
 
−
  logDevStore = {}
 
−
 
 
−
  log = function(str)
 
−
     table.insert(logDevStore, str)
 
 
   end
 
   end
  
−
   logObject = function(obj, prefix)
+
   -- (re)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
 +
 
 +
  mw.log = function(arg)
 +
     table.insert(log, arg)
 
   end
 
   end
 +
end
 +
 +
---------------
 +
-- load data --
 +
---------------
 +
 +
if ENV == "dev" then
 +
  data = loadfile("../output.lua")()
 +
  diet = loadfile("./data/diet.lua")()
 +
elseif ENV == "wiki" then
 +
  data = mw.loadData('Module:Test/data')
 +
end
 +
 +
version = data.version
 +
 +
------------------
 +
-- virtual keys --
 +
------------------
 +
 +
local virtual_store = {}
 +
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
 +
 +
      def._virtual_[virtField] = list
 +
    end,
 +
 +
    function (def)
 +
      virtField = "foodTypes"
 +
      foodTypes = def.race.foodType
 +
      flags = {}
 +
      virtual_store.diet = {}
 +
 +
      if util.diet.foodType[foodType] ~= "table" then
 +
        return nil
 +
      end
  
−
  local timeDataStart = runTime()
+
      for _,foodType in ipairs(foodTypes) do
 +
        for foodItem,_ in pairs(util.diet.foodType[foodType]) do
 +
          flags[foodItem] = true
 +
        end
 +
      end
  
−
  Data    = require "data/data"
+
      for flag,_ in pairs(flags) do
 +
        table.insert(virtual_store.diet, flag)
 +
      end
  
−
  local timeDataEnd = runTime()
+
      def._virtual_[virtField] = virtual_store.diet
−
  log(string.format('@%ims, data loaded in %ims', timeDataEnd, timeDataEnd - timeDataStart))
+
    end,
  
−
  Util    = require "lib/util"
+
    function (def)
−
  Search  = require "lib/search"
+
      virtField = "foodTypesExpanded"
−
  Inspect = require "lib/inspect"
+
      flags = {}
−
  VF      = require "data/virtual"
+
      eats = {}
  
−
  log(string.format('@%ims, modules loaded', runTime()))
+
      for _,def in pairs(data) do
 +
        if def.defName and def.ingestible and def.ingestible.foodType then
 +
            for _,ingestible in ipairs(def.ingestible.foodType) do
 +
              for _,dietV in ipairs(virtual_store.diet) do
 +
                if ingestible == dietV then
 +
                  flags[def.defName] = true
 +
                end
 +
              end
 +
            end
 +
          end
 +
        end
  
−
end
+
      for flag,_ in pairs(flags) do
 +
        table.insert(eats, flag)
 +
      end
 +
 
 +
      def._virtual_[virtField] = eats
 +
    end,
 +
 
 +
  }
 +
}
  
 
-----------------------
 
-----------------------
Line 70: Line 143:
 
-----------------------
 
-----------------------
  
−
function DefInfo.vardefine(name, value, frame)
+
local function vardefine(name, value)
−
   assert(name, "vardefine: missing argument #1 (variable to definePrefix)")
+
  local f_name = "vardefine"
−
   assert(type(name) == "string", string.format("vardefine: bad argument #1 (string expected, got %s)", type(name)))
+
   assert(var_name, string.format("bad argument #1 to '%s' (argument missing, name of variable to define)", f_name))
−
   assert(value, "vardefine: missing argument #2 (value to assign)")
+
   assert(var_name == "string", string.format("bad argument #1 to '%s' (string expected, got %s)", f_name, type(var_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(var_value, string.format("bad argument #2 to '%s' (argument missing, value to assign to variable)", f_name))
−
  assert(frame, "vardefine: 'frame' missing")
+
   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', name, value)
+
 
 +
   frame:callParserFunction('#vardefine', var_name, var_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
 
  
−
function DefInfo.mergeParents(baseDef, ignoreKeys)
+
local function mergeParents(baseDef, ignoreKeys)
 
   local ancestorIDs = {}
 
   local ancestorIDs = {}
 
   local mergedDef = {}
 
   local mergedDef = {}
Line 97: Line 162:
 
     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 110: Line 175:
 
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 def
+
   local mergedDef
  
−
   if not defID then return nil end
+
   if defIDprefix then
 +
    local defID = defIDprefix .. ":" .. defIDsuffix
 +
    baseDef = data[defID]
 +
    assert(not baseDef, string.format("getDef: Def '%s' not found", defID))
 +
  else
 +
    for defID,def in pairs(data) do
 +
      -- WARNING: this depends on there not being any preexisting colons in the relevant substrings
 +
      prefix = string.match(defID, '(.+):')
 +
      suffix = string.match(defID, ':(.+)')
 +
      if suffix == defIDsuffix then
 +
        assert(not baseDef, string.format("getDef: Def conflict (more than one '%s')", defIDsuffix))
 +
        baseDef = def
 +
      end
 +
    end
 +
    assert(baseDef, string.format("getDef: Def '%s' not found", defIDsuffix))
 +
  end
  
−
   for _,def in pairs(Data) do
+
   mergedDef = mergeParents(baseDef, ignoreKeys)
−
    if def.defName == defID then
+
 
−
      baseDef = def
+
  if virtual_keys[mergedDef.category] then
−
      break
+
    mergedDef._virtual_ = {}
−
     elseif string.upper(def.label or '') == string.upper(defID) then
+
     for k,func in ipairs(virtual_keys[mergedDef.category]) do
−
      baseDef = def
+
      func(mergedDef)
−
      break
 
 
     end
 
     end
 
   end
 
   end
  
−
   if not baseDef then return nil end
+
   return mergedDef
 +
end
  
−
  def = DefInfo.mergeParents(baseDef, ignoreKeys)
 
  
−
  DefInfo.expandDef(def, expandVF)
+
----------------------
 +
-- public interface --
 +
----------------------
  
−
   return def
+
function p.getDefName(frame)
−
end
+
   local defName
 +
  local label = frame.args[1]
  
−
local function setPrefix(tbl, parentKey)
+
  if not label then
−
  local mt = getmetatable(tbl) or {}
+
    mw.logObject(frame.args, "frame.args")
 +
    mw.log("getDefName: missing argument #1 (label)")
 +
    return nil
 +
  end
  
−
   for k,v in pairs(tbl) do
+
   for defID,def in pairs(data) do
−
     local prefix = parentKey .. "_" .. k
+
     if string.upper(def.label or "") == string.upper(label) then
−
    if type(v) == 'table' then
+
       defName = def.defName
−
      setPrefix(v, prefix)
 
−
    else
 
−
       mt[k] = prefix
 
 
     end
 
     end
 
   end
 
   end
  
−
   setmetatable(tbl, mt)
+
   if not defName then
−
end
+
    mw.logObject(frame.args, "frame.args")
 +
    mw.log(string.format("getDefName: '%s' not found", label))
 +
  end
  
−
local function definePrefixed(tbl, frame)
+
   return defName
−
   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
 
end
  
−
----------------------
 
−
-- public interface --
 
−
----------------------
 
  
−
function wiki.count(frame)
+
function p.count(frame)
−
   local query = wiki.query(frame)
+
   local query = p.query(frame)
−
   if type(wiki.queried) == 'table' then -- WARNING: checks a variable that is set in wiki.query (ugly)
+
   return #query
−
    return Util.table.count(wiki.queried)
 
−
  end
 
 
end
 
end
  
−
function wiki.query(frame)
 
  
−
   local argLen = Util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc
+
function p.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
+
  -- implement expressive argument checks 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 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 = DefInfo.getDef(frame.args['defName']) or DefInfo.getDef(frame.args['label'])
+
   local def = getDef(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("query: 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
 
−
  end
 
  
−
   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
  
−
     if i == argLen and frame.args["sibling"] then
+
     -- NOTE: might consider doing something about the if tree (trim it down a bit)
−
      processedDef = Search.find({nil, frame.args["sibling"]} , processedDef)
+
 
−
      if not processedDef then
+
    if i > 1 then -- additional arguments
−
        logObject(frame.args, string.format("query @ %ims: bad argument 'sibling' ('%s' not found')\nframe.args", runTime(), frame.args["sibling"]))
+
 
−
        return nil
+
      if i == argLen then -- if final argument
−
      else
+
 
−
        processedDef = Search.meta.parent.table[arg]
+
        if frame.args["sibling"] then -- sibling
−
        if not processedDef then
+
          prune = search.conductor({nil, frame.args["sibling"]} , prune)
−
          logObject(frame.args, string.format("query @ %ims: bad argument #%i ('%s' is not a sibling of '%s')", runTime(), i, arg, frame.args["sibling"]))
+
          if not prune then
 +
            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
 
  
−
     if i < argLen or i == argLen and not frame.args["sibling"] then
+
     end -- additional arguments
−
      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(processedDef) == "table" then
+
   if type(prune) == "table" then mw.logObject(prune) end
−
    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 prune
−
   return processedDef
 
 
end
 
end
  
−
------------------------------------
+
---------------------------------
−
-- simulate MediaWiki environment --
+
-- simulate module invocation  --
−
------------------------------------
+
---------------------------------
 +
 
 +
local simframe = { ["args"] = {} }
 +
frame = frame or simframe
 +
 
 +
--~ simframe.args[1] = "fennec fox"
 +
simframe.args[1] = "Fox_Fennec"
 +
simframe.args[2] = "MoveSpeed"
 +
--~ simframe.args[3] = 3
 +
 
 +
if ENV == "dev" then
 +
 
 +
--~  p.query(frame)
 +
  pp(p.query(frame))
 +
--~  pp(p.getDefName(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
  
−
if not mw then
+
local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
−
   Util.hl("DefInfo log")
+
mw.log("--" .. string.rep("-", #clock) .. "--")
−
   for _,v in ipairs(logDevStore) do
+
mw.log("- " .. clock .. " -")
 +
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
 

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"