Module:UserLinks: Difference between revisions

From the Croc Wiki, the Croc encyclopedia
Jump to navigationJump to search

Module:UserLinks (view source)

Revision as of 14:49, January 21, 2022

13,745 bytes added ,  2 years ago
m
45 revisions imported from wikipedia:Module:UserLinks
m (caps fix)
m (45 revisions imported from wikipedia:Module:UserLinks)
 
(36 intermediate revisions by 7 users not shown)
Line 1:
--------------------------------------------------------------------------------
local ToolbarBuilder = require('Module:Toolbar')
-- UserLinks --
local u = {} -- Table for user-data helper strings.
-- This module creates a list of links about a given user. It can be used on --
-- its own or from a template. See the /doc page for more documentation. --
--------------------------------------------------------------------------------
 
-- Require necessary modules
-- Define a custom error message for this module.
local yesno = require('Module:Yesno')
local function err(msg, cat)
cat = (cat and ('[[Category:' .. cat .. ']]')) or ''
return '<span class="error">[[Module:UserLinks]] error: ' .. msg .. '.</span>' .. cat
end
 
-- Lazily initialise modules that we might or might not need
--------------------------------------------------------------------------------------------------
local mExtra -- [[Module:UserLinks/extra]]
-- Below are the helper strings available for writing user link functions. --
local mArguments -- [[Module:Arguments]]
-- If the project name has not been specified, all the project strings will be --
local mToolbar -- [[Module:Toolbar]]
-- the blank string, ''. If the username is not specified, the module outputs an error. --
local mCategoryHandler -- [[Module:Category handler]]
-- Either way, there is no need to worry about escaping nil values when using the --
local mTableTools -- [[Module:TableTools]]
-- helper strings. --
local interwikiTable -- [[Module:InterwikiTable]], loaded with mw.loadData
-- --
-- u.username The plain username --
-- u.usernameHtml The username html-encoded. Spaces are encoded with plus signs. --
-- --
-- u.project The plain project name. --
-- u.projectColon The project name with two colons surrounding it, i.e. ":project:" --
-- --
-- If you want more strings, you can define them in the generateUserDataStrings --
-- function below. --
--------------------------------------------------------------------------------------------------
 
-- Load shared helper functions
local function makeUserLink()
local mShared = require('Module:UserLinks/shared')
return '[[' .. u.projectColon .. 'User:' .. u.username .. '|' .. u.username .. ']]'
local raiseError = mShared.raiseError
end
local maybeLoadModule = mShared.maybeLoadModule
local makeWikitextError = mShared.makeWikitextError
local makeWikilink = mShared.makeWikilink
local makeUrlLink = mShared.makeUrlLink
local makeFullUrlLink = mShared.makeFullUrlLink
local message = mShared.message
 
local functionp makeTalkLink()= {}
return '[[' .. u.projectColon .. 'User talk:' .. u.username .. '|talk]]'
end
 
--------------------------------------------------------------------------------
local function makeContribsLink()
-- Link table
return '[[' .. u.projectColon .. 'Special:Contributions/' .. u.username .. '|contribs]]'
--------------------------------------------------------------------------------
end
 
local function makeCountLinkp.getLinks(snippets)
--[=[
return '[//tools.wmflabs.org/xtools/pcount/index.php?name=' .. u.usernameHtml .. '&lang=en&wiki=wikipedia count]'
-- Get a table of links that can be indexed with link codes. The table
end
-- returned is blank, but links are added to it on demand when it is
-- indexed. This is made possible by the metatable and by the various link
-- functions, some of which are defined here, and some of which are defined
-- at [[Module:UserLinks/extra]].
--]=]
local links, linkFunctions = {}, {}
 
----------------------------------------------------------------------------
local function makeMovesLink()
-- Link functions
return '[[' .. u.projectColon .. 'Special:Log/move/' .. u.username .. '|page&nbsp;moves]]'
--
end
-- The following functions make the links from the link codes and the user
-- data snippets. New link functions should be added below the existing
-- functions.
----------------------------------------------------------------------------
 
local function makeLogsLinklinkFunctions.u(snippets)
-- User page
return '[[' .. u.projectColon .. 'Special:Log/' .. u.username .. '|logs]]'
return makeWikilink(
end
snippets.interwiki,
2,
snippets.username,
snippets.username
)
end
 
local function makeBlockLogLinklinkFunctions.t(snippets)
-- User talk page
local url = mw.uri.fullUrl('Special:Log/block', 'page=User:' .. u.usernameHtml)
return makeWikilink(
return '[' .. tostring(url) .. ' block&nbsp;log]'
snippets.interwiki,
end
3,
snippets.username,
message('display-talk')
)
end
 
local function makeBlocksLinklinkFunctions.c(snippets)
-- Contributions
return '[[' .. u.projectColon .. 'Special:Log/block/' .. u.username .. '|blocks]]'
return makeWikilink(
end
snippets.interwiki,
-1,
'Contribs/' .. snippets.username,
message('display-contributions')
)
end
function linkFunctions.c64(snippets)
-- Contributions
local first64 = snippets.username:match('^%x+:%x+:%x+:%x+:')
or snippets.username:match('^%x+:%x+:%x+:')
or snippets.username:match('^%x+:%x+:')
or snippets.username:match('^%x+:')
return first64 and makeWikilink(
snippets.interwiki,
-1,
'Contribs/' .. first64 .. ':/64',
'(/64)'
) or ''
end
 
local function makeBlockUserLinklinkFunctions.ct(snippets)
-- Edit count
return '[[' .. u.projectColon .. 'Special:Block/' .. u.username .. '|block&nbsp;user]]'
return makeUrlLink(
end
{
host = 'xtools.wmflabs.org',
path = '/ec/',
query = {
username = snippets.username,
project = snippets.toolLang .. '.' .. snippets.projectLong .. '.org'
}
},
message('display-count')
)
end
 
local function makeCentralAuthLinklinkFunctions.m(snippets)
-- Page moves
return '[[' .. u.projectColon .. 'Special:CentralAuth/' .. u.username .. '|central&nbsp;auth]]'
return makeWikilink(
end
snippets.interwiki,
-1,
'Log/move/' .. snippets.username,
message('display-moves')
)
end
 
local function makeDeletedContribsLinklinkFunctions.l(snippets)
-- Logs
return '[[' .. u.projectColon .. 'Special:DeletedContributions/' .. u.username .. '|deleted&nbsp;contribs]]'
return makeWikilink(
end
snippets.interwiki,
-1,
'Log/' .. snippets.username,
message('display-logs')
)
end
 
local function makeEmailLinklinkFunctions.ae(snippets)
-- Automated edits (and non-automated contributions).
return '[[' .. u.projectColon .. 'Special:Emailuser/' .. u.username .. '|email]]'
return makeUrlLink(
end
{
host = 'xtools.wmflabs.org',
path = '/autoedits/',
query = {
username = snippets.username,
project = snippets.toolLang .. '.' .. snippets.projectLong .. '.org'
}
},
message('display-autoedits')
)
end
 
local function makeEditSummariesLinklinkFunctions.bl(snippets)
-- Block log
return '[http://toolserver.org/~tparis/editsummary/index.php?name=' .. u.usernameHtml .. '&lang=en&wiki=wikipedia edit summaries]'
return makeFullUrlLink(
end
snippets.interwiki,
-1,
'Log/block',
{page = 'User:' .. snippets.username},
message('display-blocklog')
)
end
 
local function makeDeletionsLinklinkFunctions.bls(snippets)
-- Blocks
return '[[' .. u.projectColon .. 'Special:Log/delete/' .. u.username .. '|deletions]]'
return makeWikilink(
end
snippets.interwiki,
-1,
'Log/block/' .. snippets.username,
message('display-blocks')
)
end
 
local function makeListUserLinklinkFunctions.bu(snippets)
-- Block user
local url = mw.uri.fullUrl('Special:ListUsers', 'limit=1&username=' .. u.usernameHtml)
return makeWikilink(
return '[' .. tostring(url) .. ' list&nbsp;user]'
snippets.interwiki,
end
-1,
'Block/' .. snippets.username,
message('display-blockuser')
)
end
 
local function makeSulLinklinkFunctions.ca(snippets)
-- Central auth
return '[[sulutil:' .. u.username .. '|global&nbsp;contribs]]'
return makeWikilink(
end
snippets.interwiki,
-1,
'CentralAuth/' .. snippets.username,
message('display-centralauth')
)
end
 
local function makeTargetLogsLinklinkFunctions.dc(snippets)
-- Deleted contribs
local url = mw.uri.fullUrl('Special:Log', 'page=User:' .. u.usernameHtml)
return makeWikilink(
return '[' .. tostring(url) .. ' target&nbsp;logs]'
snippets.interwiki,
end
-1,
'DeletedContributions/' .. snippets.username,
message('display-deletedcontributions')
)
end
 
local function makeEditFilterLogLinklinkFunctions.e(snippets)
-- Email
local url = mw.uri.fullUrl('Special:AbuseLog', 'wpSearchUser=' .. u.usernameHtml)
return makeWikilink(
return '[' .. tostring(url) .. ' edit&nbsp;filter&nbsp;log]'
snippets.interwiki,
-1,
'EmailUser/' .. snippets.username,
message('display-email')
)
end
 
function linkFunctions.es(snippets)
-- Edit summaries
return makeUrlLink(
{
host = 'xtools.wmflabs.org',
path = '/editsummary/',
query = {
username = snippets.username,
project = snippets.toolLang .. '.' .. snippets.projectLong .. '.org'
}
},
message('display-editsummaries')
)
end
 
function linkFunctions.del(snippets)
-- Deletions
return makeWikilink(
snippets.interwiki,
-1,
'Log/delete/' .. snippets.username,
message('display-deletions')
)
end
 
function linkFunctions.lu(snippets)
-- List user
return makeFullUrlLink(
snippets.interwiki,
-1,
'ListUsers',
{limit = 1, username = snippets.username},
message('display-listuser')
)
end
 
function linkFunctions.sul(snippets)
-- SUL
return makeWikilink(
nil,
nil,
'sulutil:' .. snippets.username,
message('display-sul')
)
end
 
function linkFunctions.tl(snippets)
-- Target logs
return makeFullUrlLink(
snippets.interwiki,
-1,
'Log',
{page = mw.site.namespaces[2].name .. ':' .. snippets.username},
message('display-targetlogs')
)
end
 
function linkFunctions.efl(snippets)
-- Edit filter log
return makeFullUrlLink(
snippets.interwiki,
-1,
'AbuseLog',
{wpSearchUser = snippets.username},
message('display-abuselog')
)
end
 
function linkFunctions.pr(snippets)
-- Protections
return makeWikilink(
snippets.interwiki,
-1,
'Log/protect/' .. snippets.username,
message('display-protections')
)
end
 
function linkFunctions.rl(snippets)
-- User rights
return makeWikilink(
snippets.interwiki,
-1,
'Log/rights/' .. snippets.username,
message('display-rights')
)
end
 
function linkFunctions.ren(snippets)
-- Renames
return makeWikilink(
snippets.interwiki,
-1,
'Log/renameuser/' .. snippets.username,
message('display-renames')
)
end
 
function linkFunctions.rfa(snippets)
-- Requests for adminship
return makeWikilink(
nil,
-1,
'PrefixIndex/' .. message('page-rfa') .. '/' .. snippets.username,
message('display-rfa')
)
end
 
function linkFunctions.api(snippets)
-- API user data
return makeUrlLink(
{
host = snippets.fullDomain,
path = '/w/api.php',
query = {
action = 'query',
list = 'users',
usprop = 'groups|editcount',
ususers = snippets.username
}
},
message('display-api')
)
end
 
function linkFunctions.up(snippets)
-- Uploads
return makeWikilink(
snippets.interwiki,
-1,
'ListFiles/' .. snippets.username,
message('display-uploads')
)
end
----------------------------------------------------------------------------
-- End of link functions
----------------------------------------------------------------------------
 
-- Define the metatable that memoizes the link functions, and fetches link
-- functions from [[Module:UserLinks/extra]] if necessary.
 
-- Lazily initialise the extraLinkFunctions table. We only want to load
-- [[Module:UserLinks/extra]] as necessary, so it has a low transclusion
-- count.
local extraLinkFunctions
 
-- Define functions for shared code in the metatable.
local function validateCode(code)
-- Checks whether code is a valid link code - i.e. checks that it is a
-- string and that it is not the blank string. Returns the code if
-- the check passes, and nil if not.
if type(code) == 'string' and code ~= '' then
return code
else
return nil
end
end
 
local function getExtraLinkFunctions()
-- Loads the table of extra link functions from the /extra module.
-- If there is a problem with loading it, return false. We use the
-- distinction between false and nil to record whether we have already
-- tried to load it.
if extraLinkFunctions ~= nil then
return extraLinkFunctions
end
if mExtra == nil then
-- If loading the module fails, maybeLoadModule returns false.
-- Here we use the distinction between false and nil to record
-- whether we have already tried to load the /extra module.
mExtra = maybeLoadModule('Module:UserLinks/extra')
end
if type(mExtra) == 'table'
and type(mExtra.linkFunctions) == 'table'
then
extraLinkFunctions = mExtra.linkFunctions
else
extraLinkFunctions = false
end
return extraLinkFunctions
end
 
local function memoizeExtraLink(code, func)
local success, link = pcall(func, snippets)
if success and type(link) == 'string' then
links[code] = link
return link
end
return nil
end
 
-- Define the metatable.
setmetatable(links, {
__index = function (t, key)
local code = validateCode(key)
if not code then
raiseError(
message('error-malformedlinkcode'),
message('error-malformedlinkcode-section')
)
end
local linkFunction = linkFunctions[code]
local link
if linkFunction then
link = linkFunction(snippets)
links[code] = link
else
extraLinkFunctions = getExtraLinkFunctions()
if extraLinkFunctions then
local extraLinkFunction = extraLinkFunctions[code]
if type(extraLinkFunction) == 'function' then
link = memoizeExtraLink(code, extraLinkFunction)
end
end
end
if link then
return link
else
raiseError(
message('error-invalidlinkcode', code),
message('error-invalidlinkcode-section')
)
end
end,
__pairs = function ()
extraLinkFunctions = getExtraLinkFunctions()
if extraLinkFunctions then
for code, func in pairs(extraLinkFunctions) do
if validateCode(code) and type(func) == 'function' then
memoizeExtraLink(code, func)
end
end
end
-- Allow built-in functions to overwrite extra functions.
for code, func in pairs(linkFunctions) do
local link = func(snippets)
links[code] = link
end
return function (t, key)
return next(links, key)
end
end
})
return links
end
 
--------------------------------------------------------------------------------
local function makeProtectionsLink()
-- User data snippets
return '[[' .. u.projectColon .. 'Special:Log/protect/' .. u.username .. '|protections]]'
--------------------------------------------------------------------------------
 
function p.getSnippets(args)
--[=[
-- This function gets user data snippets from the arguments, and from
-- [[Module:InterwikiTable]]. The data is loaded as necessary and memoized
-- in the snippets table for performance.
--
-- Snippets default to the blank string, '', so they can be used in
-- concatenation operations without coders having to worry about raising
-- errors. Because of this, the local functions snippetExists and
-- getSnippet have been written to aid people writing new snippets. These
-- functions treat the blank string as false. It is not necessary to return
-- the blank string from a snippet function, as nil and false values are
-- automatically converted into the blank string by the metatable.
--
-- If you add a new snippet, please document it at
-- [[Module:UserLinks#Adding new links]].
--]=]
local snippets, snippetFunctions = {}, {}
setmetatable(snippets, {
__index = function (t, key)
local snippetFunction = snippetFunctions[key]
if snippetFunction then
snippets[key] = snippetFunction() or ''
return snippets[key]
else
raiseError(
message('error-nosnippet', key),
message('error-nosnippet-section')
)
end
end
})
 
-- Define helper functions for writting the snippet functions.
local function snippetExists(key)
-- We have set the metatable up to make snippets default to '', so we
-- don't have to test for false or nil.
return snippets[key] ~= ''
end
 
local function getSnippet(key)
local ret = snippets[key]
if ret == '' then
return nil
else
return ret
end
end
 
-- Start snippet functions.
 
function snippetFunctions.username()
-- The username.
local username = args.user or args.User
return username or raiseError(
message('error-nousername'),
message('error-nousername-section')
)
end
 
function snippetFunctions.usernameHtml()
-- The username html-encoded. Spaces are encoded as pluses.
return mw.uri.encode(snippets.username)
end
 
function snippetFunctions.project()
-- The project name.
-- Also does the work for snippetFunctions.interwikiTableKey, and adds
-- the project value to snippets.lang if it is a valid language code.
local project = args.Project or args.project
if not project then
return nil
end
local projectValidated, interwikiTableKey = p.validateProjectCode(project)
if not projectValidated then
if mw.language.isKnownLanguageTag(project) then
if not snippetExists('lang') then
snippets.lang = project
end
else
raiseError(
message('error-invalidproject', project),
message('error-invalidproject-section')
)
end
end
snippets.interwikiTableKey = interwikiTableKey
return project
end
 
function snippetFunctions.interwikiTableKey()
-- The key for the project in Module:InterwikiTable.
-- Relies on snippetFunctions.project to do the real work.
local temp = snippets.project -- required; puts key in snippets table
return rawget(snippets, 'interwikiTableKey')
end
 
function snippetFunctions.toolProject()
-- The short project code for use with toolserver or labs. It is always
-- present, even if the "project" argument is absent. The default value
-- is the "snippet-project-default" message.
local project = getSnippet('project')
if not project then
return message('snippet-project-default')
else
return project
end
end
 
function snippetFunctions.projectLong()
-- The long form of the project name, e.g. "wikipedia" or "wikibooks".
local key = getSnippet('interwikiTableKey')
if not key then
return message('snippet-projectlong-default')
end
interwikiTable = interwikiTable or mw.loadData('Module:InterwikiTable')
local prefixes = interwikiTable[key].iw_prefix
-- Using prefixes[2] is a bit of a hack, but should find the long name
-- most of the time.
return prefixes[2] or prefixes[1]
end
 
function snippetFunctions.lang()
-- The language code.
local lang = args.lang or args.Lang
if not lang then
return nil
end
if mw.language.isKnownLanguageTag(lang) then
return lang
else
raiseError(
message('error-invalidlanguage', lang),
message('error-invalidlanguage-section')
)
end
end
 
function snippetFunctions.toolLang()
-- The language code for use with toolserver or labs tools. It is always
-- present, even if the "lang" argument is absent. The default value is
-- the "snippet-lang-default" message.
return getSnippet('lang') or message('snippet-lang-default')
end
 
function snippetFunctions.interwiki()
-- The interwiki prefix, consisting of the project and language values,
-- separated by colons, e.g. ":wikt:es:".
local project = getSnippet('project')
local lang = getSnippet('lang')
if not project and not lang then
return nil
end
local ret = {}
ret[#ret + 1] = project
ret[#ret + 1] = lang
return table.concat(ret, ':')
end
 
function snippetFunctions.fullDomain()
-- The full domain name of the site, e.g. www.mediawiki.org,
-- en.wikpedia.org, or ja.wikibooks.org.
local fullDomain
local lang = getSnippet('toolLang')
local key = getSnippet('interwikiTableKey')
if key then
interwikiTable = interwikiTable or mw.loadData('Module:InterwikiTable')
local domain = interwikiTable[key].domain
local takesLangPrefix = interwikiTable[key].takes_lang_prefix
if takesLangPrefix then
fullDomain = lang .. '.' .. domain
else
fullDomain = domain
end
else
fullDomain = lang .. '.wikipedia.org'
end
return fullDomain
end
 
-- End snippet functions. If you add a new snippet function, please
-- document it at [[Module:UserLinks#Adding new links]].
 
return snippets
end
 
function p.validateProjectCode(s)
-- Validates a project code, by seeing whether it is present in
-- [[Module:InterwikiTable]]. If it is present, returns the code and the
-- InterwikiTable key for the corresponding site. If not present,
-- returns nil for both.
interwikiTable = interwikiTable or mw.loadData('Module:InterwikiTable')
for key, t in pairs(interwikiTable) do
for i, prefix in ipairs(t.iw_prefix) do
if s == prefix then
return s, key
end
end
end
return nil, nil
end
 
--------------------------------------------------------------------------------
local function makeRightsLink()
-- Main functions
return '[[' .. u.projectColon .. 'Special:Log/rights/' .. u.username .. '|rights]]'
--------------------------------------------------------------------------------
 
local function makeInvokeFunction(funcName)
-- Makes a function that can be accessed from #invoke. This is only required
-- for functions that need to access arguments.
return function (frame)
mArguments = require('Module:Arguments')
local args = mArguments.getArgs(frame)
return p[funcName](args)
end
end
 
p.main = makeInvokeFunction('_main')
local function makeRenamesLink()
 
return '[[' .. u.projectColon .. 'Special:Log/renameuser/' .. u.username .. '|renames]]'
function p._main(args)
-- The main function. This is the one called from [[Template:User-multi]],
-- via p.main.
local options = p.getOptions(args)
local snippets = p.getSnippets(args)
local codes = p.getCodes(args)
local links = p.getLinks(snippets)
-- Overload the built-in Lua error function to generate wikitext errors
-- meant for end users to see. This makes things harder to debug when
-- real errors occur, but it is the only realistic way to show wikitext
-- errors and and still have sane code when using metatables, etc.
local success, result = pcall(p.export, codes, links, options)
if success then
return result
else
return makeWikitextError(result, options.isDemo)
end
end
 
local function makeRfaLinkp.getOptions(args)
-- Gets the options from the args table, so that we don't have to pass
return '[[Special:PrefixIndex/Wikipedia:Requests for adminship/' .. u.username .. '|RfA]]'
-- around the whole args table all the time.
local options = {}
options.isDemo = yesno(args.demo) or false
options.toolbarStyle = yesno(args.small) and 'font-size: 90%;' or nil
options.sup = yesno(args.sup, true)
options.separator = args.separator
options.span = args.span
return options
end
 
local function getLinkp.getCodes(linktypeargs)
-- Gets the link codes from the arguments. The codes aren't validated
local linktypes = {
-- at this point.
t = makeTalkLink,
mTableTools = maybeLoadModule('Module:TableTools')
c = makeContribsLink,
local codes
ct = makeCountLink,
if mTableTools then
m = makeMovesLink,
codes = mTableTools.compressSparseArray(args)
l = makeLogsLink,
else
bl = makeBlockLogLink,
codes = {}
bls = makeBlocksLink,
for i, code in ipairs(args) do
bu = makeBlockUserLink,
codes[i] = code
ca = makeCentralAuthLink,
end
dc = makeDeletedContribsLink,
end
e = makeEmailLink,
return codes
es = makeEditSummariesLink,
del = makeDeletionsLink,
lu = makeListUserLink,
sul = makeSulLink,
tl = makeTargetLogsLink,
efl = makeEditFilterLogLink,
pr = makeProtectionsLink,
rl = makeRightsLink,
ren = makeRenamesLink,
rfa = makeRfaLink
}
if not linktypes[linktype] then
return err('"' .. linktype .. '" is not a valid link code', 'UserLinks transclusions with invalid link types')
end
return linktypes[linktype]()
end
 
local function makeToolbarp.export(argscodes, links, options)
-- Make the user link.
local targs = {}
local numArgsExistuserLink = falselinks.u
 
for k, v in pairs(args) do
-- If we weren't passed any link codes, just return the user link.
if type(k) == 'number' then
if #codes < 1 then
numArgsExist = true
return userLink
targs[k] = getLink(v)
end
 
end
-- Make the toolbar.
targs.style = args.small and 'font-size: 90%;'
mToolbar = require('Module:Toolbar')
targs.separator = args.separator or 'dot'
local toolbarArgs = {}
for i, code in ipairs(codes) do
if numArgsExist == false then
local link = links[code]
return -- Don't return a toolbar if no numeric arguments exist.
toolbarArgs[#toolbarArgs + 1] = link
else
end
return ToolbarBuilder.main(targs)
toolbarArgs.style = options.toolbarStyle
end
toolbarArgs.separator = options.separator or 'dot'
toolbarArgs.span = options.span
local toolbar = mToolbar.main(toolbarArgs)
 
-- Apply the sup option.
if options.sup then
toolbar = '<sup>' .. toolbar .. '</sup>'
end
-- If we are transcluding, add a non-breaking space, but if we are substing
-- just use a normal space
local space = mw.isSubsting() and ' ' or '&nbsp;'
return userLink .. space .. toolbar
end
 
--------------------------------------------------------------------------------
local function generateUserDataStrings(args)
-- Single link function
-- Username helper strings.
--------------------------------------------------------------------------------
u.username = args.user or args.User
 
u.usernameHtml = mw.uri.encode(u.username) -- Html-encoded username. Spaces are encoded as pluses.
p.single = makeInvokeFunction('_single')
-- Project helper strings.
 
u.project = args.Project
function p._single(args)
u.projectColon = (u.project and (':' .. args.Project .. ':')) or '' -- Project value plus colons, for escaping interwiki links.
-- Fetches a single link from the link table.
u.project = u.project or '' -- Control for nil values of args.Project.
local options = p.getOptions(args)
local snippets = p.getSnippets(args)
local links = p.getLinks(snippets)
local code = args[1]
local success, link = pcall(p.exportSingle, links, code)
if success then
return link
else
return makeWikitextError(link, options.isDemo)
end
end
 
local function getSingleLinkp.exportSingle(argslinks, code)
-- If any errors occur, they will probably occur here. This function
local linktype = args[1]
-- exists purely so that all the errors that will occur in p._single can
if not linktype then
-- be handled using a single pcall.
return err('no link type specified', 'UserLinks transclusions with invalid link types')
if not code then
end
raiseError(
return getLink(linktype)
message('error-nolinkcode'),
message('error-nolinkcode-section')
)
end
return links[code]
end
 
--------------------------------------------------------------------------------
local function getLinks(args)
-- Link table
-- Build the template output.
--------------------------------------------------------------------------------
local result = makeToolbar(args) -- Get the toolbar contents.
if result then
if args.sup then
result = '<sup>' .. result .. '</sup>'
end
result = '&nbsp;' .. result
else
result = '' -- If there are no links specified, don't return the toolbar at all.
end
result = '<span>' .. makeUserLink() .. result .. '</span>'
return result
end
 
local function makeWrapperp.linktable(func)
-- Returns a wikitext table of link codes, with an example link for each
return function (frame)
-- one. This function doesn't take any arguments, so it can be accessed
-- If called via #invoke, use the args passed into the invoking template.
-- directly from wiki pages without using makeInvokeFunction.
-- Otherwise, for testing purposes, assume args are being passed directly in.
local args = {user = 'Example'}
local origArgs
local snippets = p.getSnippets(args)
if frame == mw.getCurrentFrame() then
local links = p.getLinks(snippets)
origArgs = frame:getParent().args
for k, v in pairs(frame.args) do
origArgs = frame.args
break
end
else
origArgs = frame
end
-- Strip whitespace, and treat blank arguments as nil.
-- 'user', 'User', and 'separator' have different behaviour depending on
-- whether they are blank or nil, so keep them as they are.
local args = {}
for k, v in pairs(origArgs) do
v = mw.text.trim(v)
if v ~= '' or k == 'user' or k == 'User' or k == 'separator' then
args[k] = v
end
end
 
-- Assemble the codes and links in order
-- If the username is absent or blank, return an error and a tracking category.
local firstCodes = {'u', 't', 'c'}
if args.user == '' or (not args.user and (not args.User or args.User == '')) then
local firstLinks, firstCodesKeys = {}, {}
return err('no username detected', 'UserLinks transclusions without usernames')
for i, code in ipairs(firstCodes) do
end
firstCodesKeys[code] = true
-- Generate the user data strings.
firstLinks[#firstLinks + 1] = {code, links[code]}
generateUserDataStrings(args)
end
local secondLinks = {}
return func(args)
for code, link in pairs(links) do
end
if not firstCodesKeys[code] then
end
secondLinks[#secondLinks + 1] = {code, link}
end
end
table.sort(secondLinks, function(t1, t2)
return t1[1] < t2[1]
end)
local links = {}
for i, t in ipairs(firstLinks) do
links[#links + 1] = t
end
for i, t in ipairs(secondLinks) do
links[#links + 1] = t
end
 
-- Output the code table in table format
local ret = {}
ret[#ret + 1] = '{| class="wikitable plainlinks sortable"'
ret[#ret + 1] = '|-'
ret[#ret + 1] = '! ' .. message('linktable-codeheader')
ret[#ret + 1] = '! ' .. message('linktable-previewheader')
for i, t in ipairs(links) do
local code = t[1]
local link = t[2]
ret[#ret + 1] = '|-'
ret[#ret + 1] = "| '''" .. code .. "'''"
ret[#ret + 1] = '| ' .. link
end
ret[#ret + 1] = '|}'
return table.concat(ret, '\n')
end
 
return {p
main = makeWrapper(getLinks),
single = makeWrapper(getSingleLink)
}
Retrieved from "https://crocwiki.com/wiki/Special:MobileDiff/18070...18107"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information

Navigation menu