Module:Format link

 --------------------------------------------------------------------------------
 -- Format link
 --
 -- Makes a wikilink from the given link and display values. Links are escaped
 -- with colons if necessary, and links to sections are detected and displayed
 -- with " § " as a separator rather than the standard MediaWiki "#". Used in
 -- the {{format link}} template.
 --------------------------------------------------------------------------------
 locallibraryUtil=require('libraryUtil')
 localcheckType=libraryUtil.checkType
 localcheckTypeForNamedArg=libraryUtil.checkTypeForNamedArg
 localmArguments-- lazily initialise [[Module:Arguments]]
 localmError-- lazily initialise [[Module:Error]]
 localyesno-- lazily initialise [[Module:Yesno]]

 localp={}

 --------------------------------------------------------------------------------
 -- Helper functions
 --------------------------------------------------------------------------------

 localfunctiongetArgs(frame)
 -- Fetches the arguments from the parent frame. Whitespace is trimmed and
 -- blanks are removed.
 mArguments=require('Module:Arguments')
 returnmArguments.getArgs(frame,{parentOnly=true})
 end

 localfunctionremoveInitialColon(s)
 -- Removes the initial colon from a string, if present.
 returns:match('^:?(.*)')
 end

 localfunctionmaybeItalicize(s,shouldItalicize)
 -- Italicize s if s is a string and the shouldItalicize parameter is true.
 ifsandshouldItalicizethen
 return'<i>'..s..'</i>'
 else
 returns
 end
 end

 localfunctionparseLink(link)
 -- Parse a link and return a table with the link's components.
 -- These components are:
 -- - link: the link, stripped of any initial colon (always present)
 -- - page: the page name (always present)
 -- - section: the page name (may be nil)
 -- - display: the display text, if manually entered after a pipe (may be nil)
 link=removeInitialColon(link)

 -- Find whether a faux display value has been added with the {{!}} magic
 -- word.
 localprePipe,display=link:match('^(.-)|(.*)$')
 link=prePipeorlink

 -- Find the page, if it exists.
 -- For links like [[#Bar]], the page will be nil.
 localpreHash,postHash=link:match('^(.-)#(.*)$')
 localpage
 ifnotpreHashthen
 -- We have a link like [[Foo]].
 page=link
 elseifpreHash~=''then
 -- We have a link like [[Foo#Bar]].
 page=preHash
 end

 -- Find the section, if it exists.
 localsection
 ifpostHashandpostHash~=''then
 section=postHash
 end

 return{
 link=link,
 page=page,
 section=section,
 display=display,
 }
 end

 localfunctionformatDisplay(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).
 localpage=maybeItalicize(parsed.page,options.italicizePage)
 localsection=maybeItalicize(parsed.section,options.italicizeSection)
 if(notsection)then
 returnpage
 elseif(notpage)then
 returnmw.ustring.format('§&nbsp;%s',section)
 else
 returnmw.ustring.format('%s §&nbsp;%s',page,section)
 end
 end

 localfunctionmissingArgError(target)
 mError=require('Module:Error')
 returnmError.error{message=
 'Error: no link or target specified! ([['..target..'#Errors|help]])'
 }
 end

 --------------------------------------------------------------------------------
 -- Main functions
 --------------------------------------------------------------------------------

 functionp.formatLink(frame)
 -- The formatLink export function, for use in templates.
 yesno=require('Module:Yesno')
 localargs=getArgs(frame)
 locallink=args[1]orargs.link
 localtarget=args[3]orargs.target
 ifnot(linkortarget)then
 returnmissingArgError('Template:Format link')
 end

 returnp._formatLink{
 link=link,
 display=args[2]orargs.display,
 target=target,
 italicizePage=yesno(args.italicizepage),
 italicizeSection=yesno(args.italicizesection),
 categorizeMissing=args.categorizemissing
 }
 end

 functionp._formatLink(options)
 -- The formatLink export function, for use in modules.
 checkType('_formatLink',1,options,'table')
 localfunctioncheck(key,expectedType)--for brevity
 checkTypeForNamedArg(
 '_formatLink',key,options[key],expectedTypeor'string',true
 )
 end
 check('link')
 check('display')
 check('target')
 check('italicizePage','boolean')
 check('italicizeSection','boolean')
 check('categorizeMissing')

 -- Normalize link and target and check that at least one is present
 ifoptions.link==''thenoptions.link=nilend
 ifoptions.target==''thenoptions.target=nilend
 ifnot(options.linkoroptions.target)then
 returnmissingArgError('Module:Format link')
 end

 localparsed=parseLink(options.link)
 localdisplay=options.displayorparsed.display
 localcatMissing=options.categorizeMissing
 localcategory=''

 -- Find the display text
 ifnotdisplaythendisplay=formatDisplay(parsed,options)end

 -- Handle the target option if present
 ifoptions.targetthen
 localparsedTarget=parseLink(options.target)
 parsed.link=parsedTarget.link
 parsed.page=parsedTarget.page
 end

 -- Test if page exists if a diagnostic category is specified
 ifcatMissingand(mw.ustring.len(catMissing)>0)then
 localtitle=nil
 ifparsed.pagethentitle=mw.title.new(parsed.page)end
 iftitleand(nottitle.isExternal)then
 localsuccess,exists=pcall(function()returntitle.existsend)
 ifsuccessandnotexiststhen
 category=mw.ustring.format('[[Category:%s]]',catMissing)
 end
 end
 end

 -- Format the result as a link
 ifparsed.link==displaythen
 returnmw.ustring.format('[[:%s]]%s',parsed.link,category)
 else
 returnmw.ustring.format('[[:%s|%s]]%s',parsed.link,display,category)
 end
 end

 --------------------------------------------------------------------------------
 -- Derived convenience functions
 --------------------------------------------------------------------------------

 functionp.formatPages(options,pages)
 -- Formats an array of pages using formatLink and the given options table,
 -- and returns it as an array. Nil values are not allowed.
 localret={}
 fori,pageinipairs(pages)do
 ret[i]=p._formatLink{
 link=page,
 categorizeMissing=options.categorizeMissing,
 italicizePage=options.italicizePage,
 italicizeSection=options.italicizeSection
 }
 end
 returnret
 end

 returnp