|
|
Zeile 6: |
Zeile 6: |
|
| |
|
| local mHatnote = require('Module:Hatnote') | | local mHatnote = require('Module:Hatnote') |
| | local mHatList = require('Module:Hatnote list') |
| | local mArguments --lazily initialize |
| local libraryUtil = require('libraryUtil') | | local libraryUtil = require('libraryUtil') |
| local checkType = libraryUtil.checkType | | local checkType = libraryUtil.checkType |
Zeile 22: |
Zeile 24: |
|
| |
|
| function p.redirect(frame) | | function p.redirect(frame) |
| -- Get the args table and work out the maximum arg key. | | mArguments = require('Module:Arguments') |
| local origArgs = frame:getParent().args
| | local args = mArguments.getArgs(frame, {parentOnly=true}) |
| local args = {} | | --Get number of redirects |
| local maxArg = 0 | | local numRedirects = tonumber(frame.args[1]) or 1 |
| for k, v in pairs(origArgs) do | | -- Create the options table. |
| if type(k) == 'number' and k > maxArg then
| | local options = {} |
| maxArg = k
| | options.selfref = args.selfref |
| end
| | return p._redirect(args, numRedirects, options) |
| v = v:match('^%s*(.-)%s*$') -- Trim whitespace
| | end |
| if v ~= '' then
| |
| args[k] = v
| |
| end
| |
| end
| |
|
| |
|
| --Get table of redirects | | function p._redirect(args, numRedirects, options, currentTitle, redirectTitle, targetTitle) |
| local numRedirects = tonumber(frame.args[1]) or 1 | | -- Validate the input. Don't bother checking currentTitle, redirectTitle or |
| | -- targetTitle, as they are only used in testing. |
| | checkType('_redirect', 1, args, 'table') |
| | checkType('_redirect', 2, numRedirects, 'number', true) |
| | numRedirects = numRedirects or 1 |
| | checkType('_redirect', 3, options, 'table', true) |
| | options = options or {} |
| | currentTitle = currentTitle or mw.title.getCurrentTitle() |
| | -- Get the table of redirects |
| local redirect = {} | | local redirect = {} |
| for i = 1, numRedirects do | | for i = 1, numRedirects do |
Zeile 50: |
Zeile 56: |
| redirect[i] = args[i] | | redirect[i] = args[i] |
| end | | end |
|
| |
|
| |
| -- Create the data table.
| |
| local data = {}
| |
| local iArg = numRedirects - 1
| |
| local iData = 1
| |
| repeat
| |
| iArg = iArg + 2
| |
| local useTable = data[iData] or {}
| |
| local pages = useTable.pages or {}
| |
| local use = args[iArg]
| |
| local page = args[iArg + 1]
| |
| local nextUse = args[iArg + 2]
| |
| --Tracking for and-gaps
| |
| if (page == nil) and (nextUse == 'and' or use == 'and') then
| |
| --It's an "unusual cat". Get it? :P
| |
| local cheshire = '[[Category:Hatnote templates using unusual parameters]]'
| |
| if use ~= nil and use ~= 'and' then
| |
| use = use .. cheshire
| |
| elseif useTable.use ~= nil then
| |
| useTable.use = useTable.use .. cheshire
| |
| else
| |
| --Previous tracking suggests this won't change behaviour in
| |
| --practice, for any extant uses, but it does change behaviour in
| |
| --theory.
| |
| use = 'other uses' .. cheshire
| |
| end
| |
| end
| |
| pages[#pages + 1] = page
| |
| useTable.pages = pages
| |
| if use ~= 'and' then
| |
| useTable.use = use
| |
| end
| |
| data[iData] = useTable
| |
| if nextUse ~= 'and' then
| |
| iData = iData + 1
| |
| end
| |
| until iArg >= maxArg - 1
| |
|
| |
| -- Create the options table.
| |
| local options = {}
| |
| options.selfref = args.selfref
| |
|
| |
| return p._redirect(redirect, data, options)
| |
| end
| |
|
| |
| local function formatUseTable(useTable, isFirst, redirect)
| |
| -- Formats one use table. Use tables are the tables inside the data array.
| |
| -- Each one corresponds to one use. (A use might be the word "cats" in the
| |
| -- phrase "For cats, see [[Felines]]".)
| |
| -- Returns a string, or nil if no use was specified.
| |
| -- The isFirst parameter is legacy, but partly maintained for its effect of
| |
| -- cancelling empty use items.
| |
| useTable = useTable or {}
| |
| local use
| |
| if not (useTable.use or isFirst) then
| |
| if (not isFirst) and useTable.pages and #useTable.pages ~= 0 then
| |
| return '[[Category:Hatnote templates using unusual parameters]]'
| |
| else
| |
| return nil
| |
| end
| |
| end
| |
| use = useTable.use or 'other uses'
| |
| local pages = useTable.pages or {}
| |
| redirect = redirect[1] or error(
| |
| 'no redirect was supplied',
| |
| 2
| |
| )
| |
| pages[1] = pages[1] or redirect .. ' (disambiguation)'
| |
| pages = mHatnote.formatPages(unpack(pages))
| |
| pages = mw.text.listToText(pages)
| |
| return string.format(
| |
| 'For %s, see %s.',
| |
| use,
| |
| pages
| |
| )
| |
| end
| |
|
| |
| function p._redirect(redirect, data, options, currentTitle, redirectTitle, targetTitle)
| |
| -- Validate the input. Don't bother checking currentTitle, redirectTitle or
| |
| -- targetTitle, as they are only used in testing.
| |
| checkTypeMulti('_redirect', 1, redirect, {'string', 'table'})
| |
| -- String type can stay valid until extant use-cases are checked-for and
| |
| -- updated, but we'll coerce them to table for now
| |
| if type(redirect) == 'string' then redirect = {redirect} end
| |
| checkType('_redirect', 2, data, 'table', true)
| |
| checkType('_redirect', 3, options, 'table', true)
| |
| data = data or {}
| |
| options = options or {}
| |
| currentTitle = currentTitle or mw.title.getCurrentTitle()
| |
|
| |
| -- Generate the text. | | -- Generate the text. |
| local text = {}
| |
| local formattedRedirect = {} | | local formattedRedirect = {} |
| for k,v in pairs(redirect) do | | for k,v in pairs(redirect) do |
| formattedRedirect[k] = '"' .. v .. '"' | | formattedRedirect[k] = '"' .. v .. '"' |
| end | | end |
| text[#text + 1] = mw.text.listToText(formattedRedirect) .. ' ' .. (#redirect == 1 and 'redirects' or 'redirect') .. ' here.' | | local text = { |
| text[#text + 1] = formatUseTable(data[1] or {}, true, redirect)
| | mHatList.andList(formattedRedirect) .. ' ' .. (#redirect == 1 and 'redirects' or 'redirect') .. ' here.', |
| if data[1] and data[1].use then
| | mHatList._forSee(args, #redirect + 1, {title = redirect[1]}) |
| for i = 2, #data do
| | } |
| text[#text + 1] = formatUseTable(data[i] or {}, false, redirect)
| |
| end
| |
| end | |
| text = table.concat(text, ' ') | | text = table.concat(text, ' ') |
| | | -- Functionality for adding categories |
| local categoryTable = {} | | local categoryTable = {} |
| --add categories to a table by index, so we don't get duplicates
| |
| function addCategory(cat) | | function addCategory(cat) |
| if cat and cat ~= '' then | | if cat and cat ~= '' then |
| | -- Add by index to avoid duplicates |
| categoryTable[string.format('[[Category:%s]]', cat)] = true | | categoryTable[string.format('[[Category:%s]]', cat)] = true |
| end | | end |
| end | | end |
| | | --Generate tracking categories |
| local mhOptions = {} | | local mhOptions = {} |
| for k,v in pairs(redirect) do | | for k,v in pairs(redirect) do |
| -- Generate the tracking category.
| |
| -- We don't need a tracking category if the template invocation has been | | -- We don't need a tracking category if the template invocation has been |
| -- copied directly from the docs, or if we aren't in main- or category-space. | | -- copied directly from the docs, or if we aren't in main- or category-space. |