|
|
(2 intermediate revisions by 2 users not shown) |
Line 11: |
Line 11: |
| local checkTypeForNamedArg = libraryUtil.checkTypeForNamedArg | | local checkTypeForNamedArg = libraryUtil.checkTypeForNamedArg |
| local mArguments -- lazily initialise [[Module:Arguments]] | | local mArguments -- lazily initialise [[Module:Arguments]] |
| | local mError -- lazily initialise [[Module:Error]] |
| local yesno -- lazily initialise [[Module:Yesno]] | | local yesno -- lazily initialise [[Module:Yesno]] |
|
| |
|
Line 29: |
Line 30: |
| -- Removes the initial colon from a string, if present. | | -- Removes the initial colon from a string, if present. |
| return s:match('^:?(.*)') | | return s:match('^:?(.*)') |
| end
| |
|
| |
| local function italicize(s)
| |
| -- Italicize a string.
| |
| return '<i>' .. s .. '</i>'
| |
| end | | end |
|
| |
|
| local function maybeItalicize(s, shouldItalicize) | | local function maybeItalicize(s, shouldItalicize) |
| -- italicize s if s is a string and the shouldItalicize parameter is true. | | -- Italicize s if s is a string and the shouldItalicize parameter is true. |
| if s and shouldItalicize then | | if s and shouldItalicize then |
| return italicize(s) | | return '<i>' .. s .. '</i>' |
| else | | else |
| return s | | return s |
Line 82: |
Line 78: |
| section = section, | | section = section, |
| display = display, | | display = display, |
| | } |
| | end |
| | |
| | local function formatDisplay(parsed, options) |
| | -- Formats a display string based on a parsed link table (matching the |
| | -- output of parseLink) and an options table (matching the input options for |
| | -- _formatLink). |
| | local page = maybeItalicize(parsed.page, options.italicizePage) |
| | local section = maybeItalicize(parsed.section, options.italicizeSection) |
| | if (not section) then |
| | return page |
| | elseif (not page) then |
| | return mw.ustring.format('§ %s', section) |
| | else |
| | return mw.ustring.format('%s § %s', page, section) |
| | end |
| | end |
| | |
| | local function missingArgError(target) |
| | mError = require('Module:Error') |
| | return mError.error{message = |
| | 'Error: no link or target specified! ([[' .. target .. '#Errors|help]])' |
| } | | } |
| end | | end |
Line 93: |
Line 111: |
| yesno = require('Module:Yesno') | | yesno = require('Module:Yesno') |
| local args = getArgs(frame) | | local args = getArgs(frame) |
| local link = args[1] | | local link = args[1] or args.link |
| if not link then | | local target = args[3] or args.target |
| return | | if not (link or target) then |
| '<strong class="error">'..
| | return missingArgError('Template:Format link') |
| 'Error: no link specified ([[Template:Format link#Errors|help]]).'..
| |
| '</strong>'
| |
| end | | end |
| | |
| return p._formatLink{ | | return p._formatLink{ |
| link = link, | | link = link, |
| display = args[2], | | display = args[2] or args.display, |
| | target = target, |
| italicizePage = yesno(args.italicizepage), | | italicizePage = yesno(args.italicizepage), |
| italicizeSection = yesno(args.italicizesection), | | italicizeSection = yesno(args.italicizesection), |
Line 112: |
Line 130: |
| -- The formatLink export function, for use in modules. | | -- The formatLink export function, for use in modules. |
| checkType('_formatLink', 1, options, 'table') | | checkType('_formatLink', 1, options, 'table') |
| checkTypeForNamedArg('_formatLink', 'link', options.link, 'string', false) | | local function check(key, expectedType) --for brevity |
| checkTypeForNamedArg( | | checkTypeForNamedArg( |
| '_formatLink',
| | '_formatLink', key, options[key], expectedType or 'string', true |
| 'display',
| | ) |
| options.display,
| | end |
| 'string',
| | check('link') |
| true
| | check('display') |
| )
| | check('target') |
| checkTypeForNamedArg( | | check('italicizePage', 'boolean') |
| '_formatLink',
| | check('italicizeSection', 'boolean') |
| 'italicizePage',
| | check('categorizeMissing') |
| options.italicizePage,
| | |
| 'boolean',
| | -- Normalize link and target and check that at least one is present |
| true
| | if options.link == '' then options.link = nil end |
| )
| | if options.target == '' then options.target = nil end |
| checkTypeForNamedArg( | | if not (options.link or options.target) then |
| '_formatLink',
| | return missingArgError('Module:Format link') |
| 'italicizeSection',
| | end |
| options.italicizeSection,
| |
| 'boolean',
| |
| true
| |
| ) | |
| checkTypeForNamedArg( | |
| '_formatLink',
| |
| 'categorizeMissing',
| |
| options.categorizeMissing,
| |
| 'string', | |
| true
| |
| ) | |
|
| |
|
| local parsed = parseLink(options.link) | | local parsed = parseLink(options.link) |
Line 147: |
Line 154: |
| local category = '' | | local category = '' |
|
| |
|
| --Test if page exists if a diagnostic category is specified | | -- Find the display text |
| | if not display then display = formatDisplay(parsed, options) end |
| | |
| | -- Handle the target option if present |
| | if options.target then |
| | local parsedTarget = parseLink(options.target) |
| | parsed.link = parsedTarget.link |
| | parsed.page = parsedTarget.page |
| | end |
| | |
| | -- Test if page exists if a diagnostic category is specified |
| if catMissing and (mw.ustring.len(catMissing) > 0) then | | if catMissing and (mw.ustring.len(catMissing) > 0) then |
| local title = nil | | local title = nil |
| if parsed.page then title = mw.title.new(parsed.page) end | | if parsed.page then title = mw.title.new(parsed.page) end |
| if title and (not title.isExternal) and (not title.exists) then | | if title and (not title.isExternal) then |
| category = mw.ustring.format('[[Category:%s]]', catMissing)
| | local success, exists = pcall(function() return title.exists end) |
| | if success and not exists then |
| | category = mw.ustring.format('[[Category:%s]]', catMissing) |
| | end |
| end | | end |
| end | | end |
| | | |
| -- Deal with the case where we don't have to pipe the link | | -- Format the result as a link |
| if not display and not parsed.section and not options.italicizePage then | | if parsed.link == display then |
| return mw.ustring.format('[[:%s]]%s', parsed.link, category) | | return mw.ustring.format('[[:%s]]%s', parsed.link, category) |
| | else |
| | return mw.ustring.format('[[:%s|%s]]%s', parsed.link, display, category) |
| end | | end |
|
| |
| -- Find the display text for piped links
| |
| if not display then
| |
| local page = maybeItalicize(parsed.page, options.italicizePage)
| |
| local section = maybeItalicize(parsed.section, options.italicizeSection)
| |
| if not page then
| |
| display = mw.ustring.format('§ %s', section)
| |
| elseif section then
| |
| display = mw.ustring.format('%s § %s', page, section)
| |
| else
| |
| display = page
| |
| end
| |
| end
| |
|
| |
| return mw.ustring.format('[[:%s|%s]]%s', parsed.link, display, category)
| |
| end | | end |
|
| |
|