|
|
| Line 1: |
Line 1: |
| -- This module provides easy processing of arguments passed to Scribunto from
| |
| -- #invoke. It is intended for use by other Lua modules, and should not be
| |
| -- called from #invoke directly.
| |
|
| |
|
| local libraryUtil = require('libraryUtil')
| |
| local checkType = libraryUtil.checkType
| |
|
| |
| local arguments = {}
| |
|
| |
| -- Generate four different tidyVal functions, so that we don't have to check the
| |
| -- options every time we call it.
| |
|
| |
| local function tidyValDefault(key, val)
| |
| if type(val) == 'string' then
| |
| val = val:match('^%s*(.-)%s*$')
| |
| if val == '' then
| |
| return nil
| |
| else
| |
| return val
| |
| end
| |
| else
| |
| return val
| |
| end
| |
| end
| |
|
| |
| local function tidyValTrimOnly(key, val)
| |
| if type(val) == 'string' then
| |
| return val:match('^%s*(.-)%s*$')
| |
| else
| |
| return val
| |
| end
| |
| end
| |
|
| |
| local function tidyValRemoveBlanksOnly(key, val)
| |
| if type(val) == 'string' then
| |
| if val:find('%S') then
| |
| return val
| |
| else
| |
| return nil
| |
| end
| |
| else
| |
| return val
| |
| end
| |
| end
| |
|
| |
| local function tidyValNoChange(key, val)
| |
| return val
| |
| end
| |
|
| |
| local function matchesTitle(given, title)
| |
| local tp = type( given )
| |
| return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
| |
| end
| |
|
| |
| local translate_mt = { __index = function(t, k) return k end }
| |
|
| |
| function arguments.getArgs(frame, options)
| |
| checkType('getArgs', 1, frame, 'table', true)
| |
| checkType('getArgs', 2, options, 'table', true)
| |
| frame = frame or {}
| |
| options = options or {}
| |
|
| |
| --[[
| |
| -- Set up argument translation.
| |
| --]]
| |
| options.translate = options.translate or {}
| |
| if getmetatable(options.translate) == nil then
| |
| setmetatable(options.translate, translate_mt)
| |
| end
| |
| if options.backtranslate == nil then
| |
| options.backtranslate = {}
| |
| for k,v in pairs(options.translate) do
| |
| options.backtranslate[v] = k
| |
| end
| |
| end
| |
| if options.backtranslate and getmetatable(options.backtranslate) == nil then
| |
| setmetatable(options.backtranslate, {
| |
| __index = function(t, k)
| |
| if options.translate[k] ~= k then
| |
| return nil
| |
| else
| |
| return k
| |
| end
| |
| end
| |
| })
| |
| end
| |
|
| |
| --[[
| |
| -- Get the argument tables. If we were passed a valid frame object, get the
| |
| -- frame arguments (fargs) and the parent frame arguments (pargs), depending
| |
| -- on the options set and on the parent frame's availability. If we weren't
| |
| -- passed a valid frame object, we are being called from another Lua module
| |
| -- or from the debug console, so assume that we were passed a table of args
| |
| -- directly, and assign it to a new variable (luaArgs).
| |
| --]]
| |
| local fargs, pargs, luaArgs
| |
| if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
| |
| if options.wrappers then
| |
| --[[
| |
| -- The wrappers option makes Module:Arguments look up arguments in
| |
| -- either the frame argument table or the parent argument table, but
| |
| -- not both. This means that users can use either the #invoke syntax
| |
| -- or a wrapper template without the loss of performance associated
| |
| -- with looking arguments up in both the frame and the parent frame.
| |
| -- Module:Arguments will look up arguments in the parent frame
| |
| -- if it finds the parent frame's title in options.wrapper;
| |
| -- otherwise it will look up arguments in the frame object passed
| |
| -- to getArgs.
| |
| --]]
| |
| local parent = frame:getParent()
| |
| if not parent then
| |
| fargs = frame.args
| |
| else
| |
| local title = parent:getTitle():gsub('/sandbox$', '')
| |
| local found = false
| |
| if matchesTitle(options.wrappers, title) then
| |
| found = true
| |
| elseif type(options.wrappers) == 'table' then
| |
| for _,v in pairs(options.wrappers) do
| |
| if matchesTitle(v, title) then
| |
| found = true
| |
| break
| |
| end
| |
| end
| |
| end
| |
|
| |
| -- We test for false specifically here so that nil (the default) acts like true.
| |
| if found or options.frameOnly == false then
| |
| pargs = parent.args
| |
| end
| |
| if not found or options.parentOnly == false then
| |
| fargs = frame.args
| |
| end
| |
| end
|