● Home ● Random ● Nearby ● Log in ● Settings ● Donate ● About Wikipedia ● Disclaimers

View source for Module:Template wrapper

← Module:Template wrapper You do not have permission to edit this page, for the following reason:

This page is currently protected so that only template editors and administrators can edit it.

Why is the page protected?

Some templates and site interface pages are permanently protected due to visibility. Most templates can be edited by anyone.
The reason for protection can be found in the protection log. If there are no relevant entries in the protection log, the page may have been moved after being protected.

What can I do?

Discuss this page with others.
For move-protected pages, see requested moves.
Request that the page's protection level be reduced.
Find out more about how to get started editing Wikipedia.
If you have noticed an error or have a suggestion for a simple, non-controversial change, you can submit an edit request by clicking the button below and following the instructions. An administratorortemplate editor may then make the change on your behalf. Please check the talk page first in case the issue is already being discussed.
Submit an edit request
If you wrote any text, please save it temporarily to your device until you can edit this page.

You can view and copy the source of this page:

require('strict');

local error_msg = '<span style=\"font-size:100%\" class=\"error\"><code style=\"color:inherit; border:inherit; padding:inherit;\">&#124;_template=</code> missing or empty</span>';


--[[--------------------------< I S _ I N _ T A B L E >--------------------------------------------------------

scan through tbl looking for value; return true if found, false else

]]

local function is_in_table (tbl, value)
    for k, v in pairs (tbl) do
        if v == value then return true end
    end
    return false;
end


--[[--------------------------< A D D _ P A R A M E T E R >----------------------------------------------------

adds parameter name and its value to args table according to the state of boolean list argument; kv pair for
template execution; k=v string for template listing.

]]

local function add_parameter (k, v, args, list)
 if list then
  table.insert( args, table.concat ({k, '=', v}));      -- write parameter names and values to args table as string
 else
  args[<span class="ltr">k</span>] = v;               -- copy parameters to args table
 end
end


--[[--------------------------< A L I A S _ M A P _ G E T >----------------------------------------------------

returns a table of local template (parent frame) parameter names and the target template names that match where
in [key]=<value> pairs where:
 [key] is local template parameter name (an alias)
 <value> is target template parameter name (the canonical parameter name used in the working template)

The parameter |_alias-map= has the form:
 |_alias-map=<list>
where <list> is a comma-separated list of alias / canonical parameter name pairs in the form
 <from> : <to>
where:
 <from> is the local template's parameter name (alias)
 <to> is the target template's parameter name (canonical)
 for enumerated parameters place an octothorp (#) where the enumerator digits are placed in the parameter names:
  <from#> : <to#>

]]

local function alias_map_get (_alias_map)
 local T = mw.text.split (_alias_map, '%s*,%s*');       -- convert the comma-separated list into a table of alias pairs
 local mapped_aliases = {};             -- mapped aliases will go here
 local l_name, t_name;              -- parameter names
 
 for _, alias_pair in ipairs (<span class="ltr">T</span>) do           -- loop through the table of alias pairs
  l_name, t_name = alias_pair:match ('(.-)%s*:%s*(.+)');     -- from each pair, get local and target parameter names
  if l_name and t_name then            -- if both are set
   if tonumber (l_name) then
    l_name = tonumber (l_name);          -- convert number-as-text to a number
   end
   mapped_aliases[l_name] = t_name;         -- add them to the map table
  end
 end

 return mapped_aliases;
end


--[[--------------------------< F R A M E _ A R G S _ G E T >--------------------------------------------------

Fetch the wrapper template's 'default' and control parameters; adds default parameters to args

returns content of |_template= parameter (name of the working template); nil else

]]

local function frame_args_get (frame_args, args, list)
 local template;

 for k, v in pairs (frame_args) do           -- here we get the wrapper template's 'default' parameters
  if 'string' == type (<span class="ltr">k</span>) and (v and ('' ~= v)) then      -- do not pass along positional or empty parameters
   if '_template' == k then
    template = v;             -- save the name of template that we are wrapping
   elseif '_exclude' ~= k and '_reuse' ~= k and '_include-positional' ~= k  and '_alias-map' ~= k then -- these already handled so ignore here; 
    add_parameter (k, v, args, list);        -- add all other parameters to args in the style dictated by list
   end
  end
 end

 return template;               -- return contents of |_template= parameter
end


--[=[--------------------------< P F R A M E _ A R G S _ G E T >------------------------------------------------

Fetches the wrapper template's 'live' parameters; adds live parameters that aren't members of the exclude table to
args table; positional parameters may not be excluded

no return value

]=]

local function pframe_args_get (pframe_args, args, exclude, _include_positional, list)
 for k, v in pairs (pframe_args) do
  if 'string' == type (<span class="ltr">k</span>) and not is_in_table (exclude, k) then   -- do not pass along excluded parameters
   if v and ('' ~= v) then            -- pass along only those parameters that have assigned values
    if 'unset' == v:lower() then         -- special keyword to unset 'default' parameters set in the wrapper template
     v = '';              -- unset the value in the args table
    end
    add_parameter (k, v, args, list)        -- add all other parameters to args in the style dictated by list; alias map only supported for local-template parameters
   end
  end
 end

 if _include_positional then
  for i, v in ipairs (pframe_args) do          -- pass along positional parameters
   if 'unset' == v:lower() then          -- special keyword to unset 'default' parameters set in the wrapper template
    v = '';               -- unset the value in the args table
   end
   add_parameter (i, v, args, list);
  end
 end
end


--[[--------------------------< _ M A I N >--------------------------------------------------------------------

Collect the various default and live parameters into args styled according to boolean list.

returns name of the working or listed template or nil for an error message

]]

local function _main (frame, args, list)
 local template;
 local exclude = {};               -- table of parameter names for parameters that are not passed to the working template
 local reuse_list = {};              -- table of pframe parameter names whose values are modified before they are passed to the working template as the same name
 local alias_map = {};              -- table that maps parameter aliases to working template canonical parameter names
 local _include_positional;
 
 if frame.args._exclude and ('' ~= frame.args._exclude) then     -- if there is |_exclude= and it's not empty
  exclude = mw.text.split (frame.args._exclude, "%s*,%s*");    -- make a table from its contents
 end
                    -- TODO: |_reuse= needs a better name (|_reuse=)
 if frame.args._reuse and ('' ~= frame.args._reuse) then     -- if there is |_reuse= and it's not empty
  reuse_list = mw.text.split (frame.args._reuse, "%s*,%s*");    -- make a table from its contents
 end

 if frame.args['_alias-map'] and ('' ~= frame.args['_alias-map']) then  -- if there is |_alias-map= and it's not empty
  alias_map = alias_map_get (frame.args['_alias-map']);     -- make a table from its contents
 end

 template = frame_args_get (frame.args, args, list);       -- get parameters provided in the {{#invoke:template wrapper|...|...}}
 if nil == template or '' == template then         -- this is the one parameter that is required by this module
  return nil;                -- not present, tell calling function to emit an error message
 end
 
 _include_positional = 'yes' == frame.args['_include-positional'];   -- when true pass all positional parameters along with non-excluded named parameters to ...
                    -- ... the working template; positional parameters are not excludable
                    
 local _pframe_args = frame:getParent().args;        -- here we get the wrapper template's 'live' parameters from pframe.args
 local pframe_args = {};              -- a local table that we can modify

 for k, v in pairs (_pframe_args) do           -- make a copy that we can modify
  pframe_args[<span class="ltr">k</span>] = v;
 end
 
-- here we look for pframe parameters that are aliases of canonical parameter names; when found
-- we replace the alias with the canonical.  We do this here because the reuse_list works on
-- canonical parameter names so first we convert alias parameter names to canonical names and then
-- we remove those canonical names from the pframe table that are reused (provided to the working
-- template through the frame args table)

 for k, v in pairs (alias_map) do           -- k is alias name, v is canonical name
  if pframe_args[<span class="ltr">k</span>] then             -- if pframe_args has parameter with alias name
   pframe_args[<span class="ltr">v</span>] = _pframe_args[<span class="ltr">k</span>];         -- create new canonical name with alias' value
   pframe_args[<span class="ltr">k</span>] = nil;            -- unset the alias
  end
 end

 for k, v in pairs (pframe_args) do           -- do enumerated parameter alias -> canonical translation
  if 'string' == type (<span class="ltr">k</span>) then           -- only named parameters can be enumerated
   if alias_map[k..'#'] then           -- non-enumerated alias matches enumerated parameter pattern? enumerator at end only
    pframe_args[alias_map[k..'#']:gsub('#', '')] = v;    -- remove '#' and copy parameter to pframe_args table
    pframe_args[<span class="ltr">k</span>] = nil;           -- unset the alias
   elseif k:match ('%d+') then           -- if this parameter name contains digits
    local temp = k:gsub ('%d+', '#');        -- make a copy; digits replaced with single '#'
    local enum = k:match ('%d+');         -- get the enumerator
    
    if alias_map[temp] then           -- if this parameter is a recognized enumerated alias
     pframe_args[alias_map[temp]:gsub('#', enum)] = v;   -- use canonical name and replace '#' with enumerator and add to pframe_args
     pframe_args[<span class="ltr">k</span>] = nil;          -- unset the alias
    end
   end
  end
 end

-- pframe parameters that are _reused are 'reused' have the form something like this:
-- |chapter=[[wikisource:{{{chapter}}}|{{{chapter}}}]]
-- where a parameter in the wrapping template is modified and then passed to the working template
-- using the same parameter name (in this example |chapter=)

                    -- remove parameters that will be reused
 for k, v in ipairs (reuse_list) do           -- k is numerical index, v is canonical parameter name to ignore
  if pframe_args[<span class="ltr">v</span>] then             -- if pframe_args has parameter that should be ignored
   pframe_args[<span class="ltr">v</span>] = nil;            -- unset the ignored parameter
  end
 end

 pframe_args_get (pframe_args, args, exclude, _include_positional, list); -- add parameters and values to args that are not listed in the exclude table

 return template;               -- args now has all default and live parameters, return working template name
end


--[[--------------------------< W R A P >----------------------------------------------------------------------

Template entry point.  Call this function to 'execute' the working template

]]

local function wrap (frame)
 local args = {};               -- table of default and live parameters and their values to be passed to the wrapped template
 local template;                -- the name of the working template

 template = _main (frame, args, false);          -- get default and live parameters and the name of the working template
 if not template then              -- template name is required
  return error_msg;              -- emit error message and abandon if template name not present
 end

 return frame:expandTemplate {title=template, args=args};     -- render the working template
end


--[[--------------------------< L I S T >----------------------------------------------------------------------

Template entry point.  Call this function to 'display' the source for the working template.  This function added
as a result of a TfD here: Wikipedia:Templates_for_discussion/Log/2018_April_28#Module:PassArguments

This function replaces a similarly named function which was used in {{cite compare}} and {{cite compare2}}

Values in the args table are numerically indexed strings in the form 'name=value'

]]

local function list(frame, do_link)
 local args = {};      -- table of default and live parameters and their values to be passed to the listed template
 local template;       -- the name of the listed template

 template = _main (frame, args, true); -- get default and live parameters and the name of the listed template
 if not template then     -- template name is required
  return error_msg;     -- emit error message and abandon if template name not present
 end
 if do_link then
  template = ('[[%s|%s]]'):format(frame:expandTemplate{ title='Transclude', args = {template} }, template)
 end
 table.sort(args)
 for i = 1, #args do
  local stripped = args[<span class="ltr">i</span>]:match('^' .. i .. '=([^=]*)$')
  if stripped then args[<span class="ltr">i</span>] = stripped else break end
 end
 return frame:preprocess(table.concat({
  '<code style="color:inherit; background:inherit; border:none;">&#123;&#123;',
  template,
  ('<wbr><nowiki>|%s</nowiki>'):rep(#args):format(unpack(args)), '&#125;&#125;</code>'})); -- render the template
end

local function link (frame)
 return list(frame, true)
end

--[[--------------------------< E X P O R T E D   F U N C T I O N S >------------------------------------------
]]

return {
 link = link,
 list = list,
 wrap = wrap,
 };

Pages transcluded onto the current version of this page (help): ●Template:Citation (view source) (protected) ●Template:Cite wikisource (view source) (template editor protected) ●Template:Cite wikisource/make link (view source) (template editor protected) ●Template:High-use (view source) (template editor protected) ●Template:Para (view source) (template editor protected) ●Template:Param (view source) (semi-protected) ●Template:Plain link (view source) (protected) ●Template:Sandbox other (view source) (template editor protected) ●Template:Template link code (view source) (template editor protected) ●Template:Template link expanded (view source) (protected) ●Template:Tld (view source) (template editor protected) ●Template:Tlx (view source) (protected) ●Template:Transclude (view source) (template editor protected) ●Template:Uir (view source) (template editor protected) ●Template:User in New Zealand (view source) (semi-protected) ●Template:User in region (view source) (template editor protected) ●Template:Userbox (view source) (template editor protected) ●Template:Userbox table bottom (view source) (template editor protected) ●Template:Userbox table top (view source) (template editor protected) ●Template:Userbox table userbox (view source) (template editor protected) ●Template:Var (view source) (template editor protected) ●Template:What links here (view source) (template editor protected) ●Template:Yesno (view source) (protected) ●Template:Yy (view source) (template editor protected) ●Template:Yybottom (view source) (template editor protected) ●Template:Yytop (view source) (template editor protected) ●Module:Arguments (view source) (protected) ●Module:Category handler (view source) (protected) ●Module:Category handler/blacklist (view source) (protected) ●Module:Category handler/config (view source) (protected) ●Module:Category handler/data (view source) (protected) ●Module:Category handler/shared (view source) (protected) ●Module:Citation/CS1 (view source) (protected) ●Module:Citation/CS1/COinS (view source) (protected) ●Module:Citation/CS1/Configuration (view source) (protected) ●Module:Citation/CS1/Date validation (view source) (protected) ●Module:Citation/CS1/Identifiers (view source) (protected) ●Module:Citation/CS1/Utilities (view source) (protected) ●Module:Citation/CS1/Whitelist (view source) (protected) ●Module:Citation/CS1/styles.css (view source) (protected) ●Module:Color contrast (view source) (template editor protected) ●Module:Color contrast/colors (view source) (template editor protected) ●Module:Documentation (view source) (template editor protected) ●Module:Documentation/config (view source) (template editor protected) ●Module:Documentation/styles.css (view source) (template editor protected) ●Module:Effective protection expiry (view source) (protected) ●Module:Effective protection level (view source) (protected) ●Module:File link (view source) (template editor protected) ●Module:GetParameters (view source) (template editor protected) ●Module:High-use (view source) (template editor protected) ●Module:Message box (view source) (protected) ●Module:Message box/configuration (view source) (protected) ●Module:Message box/ombox.css (view source) (protected) ●Module:Namespace detect/config (view source) (protected) ●Module:Namespace detect/data (view source) (protected) ●Module:Protection banner (view source) (template editor protected) ●Module:Protection banner/config (view source) (template editor protected) ●Module:String (view source) (protected) ●Module:String2 (view source) (template editor protected) ●Module:Template link general (view source) (protected) ●Module:Template wrapper (view source) (template editor protected) ●Module:Template wrapper/doc (edit) ●Module:Transclusion count (view source) (template editor protected) ●Module:Transclusion count/data/T (view source) (semi-protected) ●Module:Userbox (view source) (template editor protected) ●Module:Yesno (view source) (protected) Return to Module:Template wrapper. Retrieved from "https://en.wikipedia.org/wiki/Module:Template_wrapper"

Languages

This page is not available in other languages.

●Privacy policy ●About Wikipedia ●Disclaimers ●Contact Wikipedia ●Code of Conduct ●Developers ●Statistics ●Cookie statement ●Terms of Use ●Desktop