Module:UserLinks/sandbox2

local ToolbarBuilder = require('Module:Toolbar')

local interwikiTable = mw.loadData("Module:InterwikiTable")

local u = {} -- Table for user-data helper strings.

local trackingCategories = {} -- Table for storing the tracking categories.

local demo

-- Define a custom error message for this module.

local function err(msg, section)

local help

if section then

help = ' (help)'

else

help = ''

end

local cat

if demo == 'yes' then

cat = ''

else

cat = 'Category:UserLinks transclusions with errors'

end

return 'User-multi error: ' .. msg

.. help .. '.' .. cat

end

----------------------------------------------------------------------------------------------

-- To add more link types, write a function that produces an individual link, and put --

-- it at the bottom of the list below. Then, add a link code for your function to the --

-- "linktypes" table. Try and make the code three letters or less. There are a number --

-- of helper strings available for writing the functions: --

-- --

-- u.username The plain username. If the username is not present then the --

-- module returns an error. --

-- u.usernameHtml The username html-encoded. Spaces are encoded with plus signs. --

-- u.project The project name. Nil if not specified. --

-- u.lang The language code. Nil if not specified. --

-- u.interwiki The interwiki prefix, consisting of the project and language --

-- values, separated by colons, e.g. ":wikt:es:". If no project --

-- or language values are found, this is the blank string, "". --

-- u.projectCode If a valid project is specified, this is the code for that --

-- project in Module:InterwikiTable. Otherwise this is nil. --

-- u.projectLong The long project name, e.g. "wikipedia" or "wikibooks". If --

-- not specified the default is "wikipedia". --

-- u.toolLang The language code for use with toolserver or labs tools. The --

-- default is "en". --

-- --

-- If you want more helper strings, you can define them in the generateUserDataStrings --

-- function below. --

----------------------------------------------------------------------------------------------

-- LINK FUNCTIONS START --

----------------------------------------------------------------------------------------------

local function makeUserLink()

return '' .. u.username .. ''

end

local function makeTalkLink()

return 'talk'

end

local function makeContribsLink()

return 'contribs'

end

local function makeCountLink()

return '[https://tools.wmflabs.org/supercount/index.php?user=' .. u.usernameHtml

.. '&project=' .. u.toolLang .. '.' .. u.projectLong

.. ' count]'

end

local function makeMovesLink()

return 'page moves'

end

local function makeLogsLink()

return 'logs'

end

local function makeBlockLogLink()

local url = mw.uri.fullUrl(u.interwiki .. 'Special:Log/block', 'page=User:' .. u.usernameHtml)

return '[' .. tostring(url) .. ' block log]'

end

local function makeBlocksLink()

return 'blocks'

end

local function makeBlockUserLink()

return 'block user'

end

local function makeCentralAuthLink()

return 'central auth'

end

local function makeDeletedContribsLink()

return 'deleted contribs'

end

local function makeEmailLink()

return 'email'

end

local function makeEditSummariesLink()

return '[https://tools.wmflabs.org/xtools/editsummary/index.php?name=' .. u.usernameHtml

.. '&lang=' .. u.toolLang

.. '&wiki=' .. u.projectLong

.. ' edit summaries]'

end

local function makeDeletionsLink()

return 'deletions'

end

local function makeListUserLink()

local url = mw.uri.fullUrl(u.interwiki .. 'Special:ListUsers', 'limit=1&username=' .. u.usernameHtml)

return '[' .. tostring(url) .. ' list user]'

end

local function makeSulLink()

return 'global contribs'

end

local function makeTargetLogsLink()

local url = mw.uri.fullUrl(u.interwiki .. 'Special:Log', 'page=User:' .. u.usernameHtml)

return '[' .. tostring(url) .. ' target logs]'

end

local function makeEditFilterLogLink()

local url = mw.uri.fullUrl(u.interwiki .. 'Special:AbuseLog', 'wpSearchUser=' .. u.usernameHtml)

return '[' .. tostring(url) .. ' edit filter log]'

end

local function makeProtectionsLink()

return 'protections'

end

local function makeRightsLink()

return 'rights'

end

local function makeRenamesLink()

return 'renames'

end

local function makeRfaLink()

if u.project or u.lang then

table.insert( trackingCategories, 'Category:UserLinks transclusions with unresolvable interwiki links' )

end

return 'RfA'

end

local function makeApiLink()

-- Find the full domain, as the API can't be accessed through the interwiki system.

local fulldomain

local lang = u.lang or 'en'

if u.projectCode then

local domain = interwikiTable[u.projectCode].domain

local takesLangPrefix = interwikiTable[u.projectCode].takes_lang_prefix

if not takesLangPrefix then

fulldomain = domain

else

fulldomain = lang .. '.' .. domain

end

else

fulldomain = lang .. '.wikipedia.org'

end

-- Return the API link

return '[https://' .. fulldomain .. '/w/api.php?action=query&list=users&usprop=editcount&ususers=' .. u.usernameHtml .. ' api]'

end

local function makeUploadsLink()

return 'uploads'

end

----------------------------------------------------------------------------------------------

-- LINK FUNCTIONS END --

-- To enable new link functions, add the code to the "linktypes" table directly below. --

----------------------------------------------------------------------------------------------

local linktypes = {

{'t' , makeTalkLink},

{'c' , makeContribsLink},

{'ct' , makeCountLink},

{'m' , makeMovesLink},

{'l' , makeLogsLink},

{'bl' , makeBlockLogLink},

{'bls' , makeBlocksLink},

{'bu' , makeBlockUserLink},

{'ca' , makeCentralAuthLink},

{'dc' , makeDeletedContribsLink},

{'e' , makeEmailLink},

{'es' , makeEditSummariesLink},

{'del' , makeDeletionsLink},

{'lu' , makeListUserLink},

{'sul' , makeSulLink},

{'tl' , makeTargetLogsLink},

{'efl' , makeEditFilterLogLink},

{'pr' , makeProtectionsLink},

{'rl' , makeRightsLink},

{'ren' , makeRenamesLink},

{'rfa' , makeRfaLink},

{'api' , makeApiLink},

{'up' , makeUploadsLink}

}

local function getLink(linktype)

local linkNumber

for i, value in ipairs(linktypes) do

if value[1] == linktype then

linkNumber = i

break

end

if not linkNumber then

return err('"' .. linktype .. '" is not a valid link code', 'Not a valid link code')

end

local result = linktypes[linkNumber][2]()

if type(result) ~= 'string' then

return err(

'the function for code "' .. linktype .. '" did not return a string value',

'Function did not return a string value'

)

end

return result

end

local function makeToolbar(args)

local targs = {}

local numArgsExist = false

for k, v in pairs(args) do

if type(k) == 'number' then

numArgsExist = true

targs[k] = getLink(v)

end

targs.style = args.small and 'font-size: 90%;'

targs.separator = args.separator or 'dot'

if numArgsExist == false then

return nil -- Don't return a toolbar if no numeric arguments exist.

else

return ToolbarBuilder.main(targs)

end

-- This function finds whether a string is a valid interwiki project prefix.

-- If the string is valid, the function outputs two values: true, and the site code

-- used in Module:InterwikiTable. If the string is valid, the function outputs

-- false and nil.

local function isKnownProject(prefix)

for projectCode, projectVal in pairs(interwikiTable) do

for _, iwCode in ipairs(projectVal.iw_prefix) do

if iwCode == prefix then

return true, projectCode

end

return false, nil

end

local function generateUserDataStrings(args)

-- If the username is absent or blank, return an error and a tracking category.

if args.user == or (not args.user and (not args.User or args.User == )) then

return err('no username detected', 'No username detected')

else

u.username = args.user or args.User

end

-- Get other basic user data strings.

u.project = args.Project or args.project

u.lang = args.lang or args.Lang

if u.lang then

if mw.language.isKnownLanguageTag(u.lang) then

table.insert(trackingCategories, 'Category:UserLinks transclusions with language parameters')

else

return err('"' .. u.lang .. '" is not a valid language code', 'Not a valid language code')

end

-- Process the project value if it is present.

if u.project then

table.insert( trackingCategories, 'Category:UserLinks transclusions with project parameters' )

-- If u.project is a known project, we only need to get the project code. If the project

-- isn't known, first check whether it is a valid language code, and if not then see if it's

-- an interwiki code separated by colons, e.g. "wikt:es".

local uprojectIsKnownProject, uprojectProjectCode = isKnownProject(u.project)

if uprojectIsKnownProject then

u.projectCode = uprojectProjectCode

else

if mw.language.isKnownLanguageTag(u.project) then

u.lang = u.project

u.project = nil

else

local pref1, pref2 = mw.ustring.match( u.project, '^(%w+):(%w+)$' )

if pref1 and pref2 then

local pref1IsKnownProject, pref1ProjectCode = isKnownProject(pref1)

local pref2IsKnownProject, pref2ProjectCode = isKnownProject(pref2)

if pref1IsKnownProject

and mw.language.isKnownLanguageTag(pref2)

and interwikiTable[pref1ProjectCode].takes_lang_prefix then

u.project = pref1

u.lang = pref2

u.projectCode = pref1ProjectCode

table.insert(

trackingCategories,

'Category:UserLinks transclusions with project parameters containing language codes'

)

elseif pref2IsKnownProject

and mw.language.isKnownLanguageTag(pref1)

and interwikiTable[pref2ProjectCode].takes_lang_prefix then

u.project = pref2

u.lang = pref1

u.projectCode = pref2ProjectCode

table.insert(

trackingCategories,

'Category:UserLinks transclusions with project parameters containing language codes'

)

else

return err(

'"' .. u.project .. '" is not a valid interwiki prefix',

'Not a valid interwiki prefix'

)

end

else

return err(

'"' .. u.project .. '" is not a valid interwiki prefix',

'Not a valid interwiki prefix'

)

end

-- Generate the interwiki prefix. This includes colons.

if u.project or u.lang then

u.interwiki = ''

if u.project then

u.interwiki = u.interwiki .. ':' .. u.project

end

if u.lang then

u.interwiki = u.interwiki .. ':' .. u.lang

end

u.interwiki = u.interwiki .. ':'

else

u.interwiki = ''

end

-- Generate the other helper strings.

u.usernameHtml = mw.uri.encode(u.username) -- Html-encoded username. Spaces are encoded as pluses.

if u.project then

local prefixes = interwikiTable[u.projectCode].iw_prefix

u.projectLong = prefixes[2] or prefixes[1] -- A bit of a hack, but should find the long prefix name most of the time.

else

u.projectLong = 'wikipedia'

end

u.toolLang = u.lang or 'en' -- set the default language for tools on the toolserver or labs.

end

local function generateTrackingCategories()

if demo == 'yes' then

return ''

else

return table.concat(trackingCategories)

end

-- This function generates a table of all available link types, with their previews.

-- It is used in the module documentation.

local function getLinkTable(args)

demo = args.demo -- Set the demo variable.

-- Generate the user data strings and return any errors.

local dataStringError = generateUserDataStrings(args)

if dataStringError then

return dataStringError

end

-- Build a table of all of the links.

local result = '

.. '\n

for i, value in ipairs(linktypes) do

local code = value[1]

result = result .. "\n

end

result = result .. '\n

Code	Preview
" .. code .. "	" .. getLink(code) .. '

return result

end

local function getSingleLink(args)

demo = args.demo -- Set the demo variable.

-- Generate the user data strings and return any errors.

local dataStringError = generateUserDataStrings(args)

if dataStringError then

return dataStringError

end

local linktype = args[1]

if not linktype then

return err('no link type specified')

end

local result = getLink(linktype)

result = result .. generateTrackingCategories()

return result

end

local function getLinks(args)

demo = args.demo -- Set the demo variable.

-- Generate the user data strings and return any errors.

local dataStringError = generateUserDataStrings(args)

if dataStringError then

return dataStringError

end

-- Build the template output.

local result = makeToolbar(args) -- Get the toolbar contents.

if result then

if args.sup then

result = '^{' .. result .. '}'

end

result = ' ' .. result

else

result = '' -- If there are no links specified, don't return the toolbar at all.

end

result = '' .. makeUserLink() .. result .. ''

result = result .. generateTrackingCategories()

return result

end

local function getExampleLinks(args)

-- This function enables example output without having to specify any

-- parameters to #invoke.

args.demo = 'yes'

args.user = 'Example'

args.User = nil

return getLinks(args)

end

local function makeWrapper(func)

return function (frame)

-- If called via #invoke, use the args passed into the invoking template.

-- Otherwise, for testing purposes, assume args are being passed directly in.

local origArgs

if frame == mw.getCurrentFrame() then

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

return func(args)

end

return {

main = makeWrapper(getLinks),

single = makeWrapper(getSingleLink),

linktable = makeWrapper(getLinkTable),

example = makeWrapper(getExampleLinks)

}