Module:Archive list

 -- This module implements {{archive list}} in Lua, and adds a few
 -- new features.

 -- Process a numeric argument to make sure it is a positive
 -- integer.
 localfunctionprocessNumArg(num)
 ifnumthen
 num=tonumber(num)
 iftype(num)=='number'then
 num=math.floor(num)
 ifnum>=0then
 returnnum
 end
 end
 end
 returnnil
 end

 -- Checks whether a page exists, going through pcall
 -- in case we are over the expensive function limit.
 localfunctioncheckPageExists(title)
 ifnottitlethen
 error('No title passed to checkArchiveExists',2)
 end
 localnoError,titleObject=pcall(mw.title.new,title)
 ifnotnoErrorthen
 -- If we are over the expensive function limit then assume
 -- that the page doesn't exist.
 returnfalse
 else
 iftitleObjectthen
 returntitleObject.exists
 else
 returnfalse-- Return false if given a bad title.
 end
 end
 end

 -- Checks every nth archive to see if it exists, and returns the
 -- number of the first archive that doesn't exist. It is
 -- necessary to do this in batches because each check is an
 -- expensive function call, and we want to avoid making too many
 -- of them so as not to go over the expensive function limit.
 localfunctioncheckArchives(prefix,n,start)
 locali=start
 localexists=true
 whileexistsdo
 exists=checkPageExists(prefix..tostring(i))
 ifexiststhen
 i=i+n
 end
 end
 returni
 end

 -- Return the biggest archive number, using checkArchives()
 -- and starting in intervals of 1000. This should get us a
 -- maximum of 500,000 possible archives before we hit the
 -- expensive function limit.
 localfunctiongetBiggestArchiveNum(prefix,start,max)
 -- Return the value for max if it is specified.
 max=processNumArg(max)
 ifmaxthen
 returnmax
 end

 -- Otherwise, detect the largest archive number.
 start=startor1
 localcheck1000=checkArchives(prefix,1000,start)
 ifcheck1000==startthen
 return0-- Return 0 if no archives were found.
 end
 localcheck200=checkArchives(prefix,200,check1000-1000)
 localcheck50=checkArchives(prefix,50,check200-200)
 localcheck10=checkArchives(prefix,10,check50-50)
 localcheck1=checkArchives(prefix,1,check10-10)
 -- check1 is the first page that doesn't exist, so we want to
 -- subtract it by one to find the biggest existing archive.
 returncheck1-1
 end

 -- Get the archive link prefix (the title of the archive pages
 -- minus the number).
 localfunctiongetPrefix(root,prefix,prefixSpace)
 localret=rootormw.title.getCurrentTitle().prefixedText
 ret=ret..'/'
 ifprefixthen
 ret=ret..prefix
 ifprefixSpace=='yes'then
 ret=ret..' '
 end
 else
 ret=ret..'Archive '
 end
 returnret
 end

 -- Get the number of archives to put on one line. Set to
 -- math.huge if there should be no line breaks.
 localfunctiongetLineNum(links,nobr,isLong)
 locallinksToNum=tonumber(links)
 locallineNum
 ifnobr=='yes'or(linksandnotlinksToNum)then
 lineNum=math.huge
 -- If links is a number, process it. Negative values and expressions
 -- such as links=8/2 produced some interesting values with the old
 -- template, but we will ignore those for simplicity.
 elseiftype(linksToNum)=='number'andlinksToNum>=0then
 -- The old template rounded down decimals to the nearest integer.
 lineNum=math.floor(linksToNum)
 iflineNum==0then
 -- In the old template, values of links between 0 and 0.999
 -- suppressed line breaks.
 lineNum=math.huge
 end
 else
 ifisLong==truethen
 lineNum=3-- Default to 3 links on long
 else
 lineNum=10-- Default to 10 on short
 end
 end
 returnlineNum
 end

 -- Gets the prefix to put before the archive links.
 localfunctiongetLinkPrefix(prefix,space,isLong)
 -- Get the link prefix.
 localret=''
 ifisLong==truethen---- Default of old template for long is 'Archive '
 iftype(prefix)=='string'then
 ifprefix=='none'then-- 'none' overrides to empty prefix
 ret=''
 else
 ret=prefix
 ifspace=='yes'then
 ret=ret..' '
 end
 end
 else
 ret='Archive '
 end
 else--type is not long
 iftype(prefix)=='string'then
 ret=prefix
 ifspace=='yes'then
 ret=ret..' '
 end
 end
 end
 returnret
 end

 -- Get the number to start listing archives from.
 localfunctiongetStart(start)
 start=processNumArg(start)
 ifstartthen
 returnstart
 else
 return1
 end
 end

 -- Get whether to leave a blank cell in the first row and column 
 -- If links start at 1, and lineNum is a round number, this aligns the first 
 -- column to start on a multiple of lineNum, which may be a nice round number 
 localfunctiongetLeaveFirstCellBlank(leaveFirstCellBlank)
 returnleaveFirstCellBlank=='yes'
 orleaveFirstCellBlank=='y'
 orleaveFirstCellBlank==1
 end

 -- Process the separator parameter.
 localfunctiongetSeparator(sep)
 ifsepandtype(sep)=='string'then
 ifsep=='dot'
 orsep=='pipe'
 orsep=='comma'
 orsep=='tpt-languages'then
 returnmw.message.new(sep..'-separator'):plain()
 else
 returnsep
 end
 else
 returnnil
 end
 end

 -- Generates the list of archive links. glargs.max must be either zero (for
 -- no archives) or a positive integer value.
 localfunctiongenerateLinks(glargs)
 iftype(glargs)~='table'ornotglargs.maxornotglargs.prefixthen
 error('insufficient arguments passed to generateLinks',2)
 end
 -- If there are no archives yet, return a message and a
 -- link to create Archive one.
 ifglargs.max==0then
 ifglargs.isLong==truethen
 glargs.max=1-- One archive redlink is displayed for Long format
 else-- Short error and a creat link is displayed for short
 return'no archives yet ([['..glargs.prefix..'1|create]])'
 end
 end
 -- Return an html error if the start number is greater than the 
 -- maximum number.
 localstart=glargs.startor1
 ifstart>glargs.maxthen
 return'<span class="error">Start value "'
 ..tostring(start)
 ..'" is greater than the most recent archive number "'
 ..tostring(glargs.max)
 ..'".</span>'
 end
 locallinkPrefix=glargs.linkPrefixor''
 locallineNum=glargs.lineNumor10
 localsep=''-- Long default separator is cell elements, short is ', '
 locallineSep=''-- Long default linebreak is row elements short is '\n'
 ifglargs.isLong==truethen
 sep=glargs.sepor''
 sep=sep..'</td><td>'
 lineSep=glargs.lineSepor''
 lineSep=lineSep..'</td></tr><tr><td>'
 else
 sep=glargs.sepormw.message.new('comma-separator'):plain()
 lineSep=glargs.lineSepor'<br />'
 end
 -- Generate the archive links.
 locallineCounter=1-- The counter to see whether we need a line break or not.
 localret={}-- A table containing the strings to be returned.
 ifglargs.isLong==truethen--Long version is a table
 table.insert(ret,"<table style=\"width: 100%; padding: 0px; text-align: center; background-color: transparent;\"><tr><td>")
 end
 ifglargs.leaveFirstCellBlankthen
 -- An empty first cell aligns the first column on multiples of lineNum 
 table.insert(ret,sep)
 lineCounter=lineCounter+1
 end
 forarchiveNum=start,glargs.maxdo
 locallink=mw.ustring.format(
 '[[%s%d|%s%d]]',
 glargs.prefix,archiveNum,linkPrefix,archiveNum
 )
 table.insert(ret,link)
 -- If we don't need a new line, output a comma. We don't need
 -- a comma after the last link. 
 iflineCounter<lineNumandarchiveNum<glargs.maxthen
 table.insert(ret,sep)
 lineCounter=lineCounter+1
 -- Output new lines if needed. We don't need a new line after
 -- the last link.
 elseiflineCounter>=lineNumandarchiveNum<glargs.maxthen
 table.insert(ret,lineSep)
 lineCounter=1
 end
 end
 ifglargs.isLong==truethen--Long version is a table
 table.insert(ret,"</td></tr></table>")
 end
 returntable.concat(ret)
 end

 -- Determine if format should be long
 localfunctionfindFormType(auto)
 ifauto==nilorauto==''then
 returnfalse
 elseifauto=='long'then
 returntrue
 else
 returnfalse
 end
 end

 -- Get the archive data and pass it to generateLinks().
 localfunction_main(args)
 localisLong=findFormType(args.auto)
 localprefix=getPrefix(args.root,args.prefix,args.prefixspace)
 locallineNum=getLineNum(args.links,args.nobr,isLong)
 locallinkPrefix=getLinkPrefix(args.linkprefix,args.linkprefixspace,isLong)
 localstart=getStart(args.start)
 localmax=getBiggestArchiveNum(prefix,start,args.max)
 localsep=getSeparator(args.sep)
 locallineSep=getSeparator(args.linesep)
 localleaveFirstCellBlank=getLeaveFirstCellBlank(args.leavefirstcellblank)
 localglargs={
 start=start,
 max=max,
 prefix=prefix,
 linkPrefix=linkPrefix,
 isLong=isLong,
 sep=sep,
 lineNum=lineNum,
 lineSep=lineSep,
 leaveFirstCellBlank=leaveFirstCellBlank
 }
 returngenerateLinks(glargs)
 end

 -- A wrapper function to make getBiggestArchiveNum() available from
 -- #invoke.
 localfunction_count(args)
 localprefix=getPrefix(args.root,args.prefix,args.prefixspace)
 localarchiveMax=getBiggestArchiveNum(prefix)
 returnarchiveMax
 end

 functionmakeWrapper(func)
 returnfunction(frame)
 -- If we are being called from #invoke, get the args from #invoke
 -- if they exist, or else get the arguments passed to the parent
 -- frame. Otherwise, assume the arguments are being passed directly
 -- in from another module or from the debug console.
 localorigArgs
 ifframe==mw.getCurrentFrame()then
 origArgs=frame:getParent().args
 fork,vinpairs(frame.args)do
 origArgs=frame.args
 break
 end
 else
 origArgs=frame
 end

 -- Ignore blank values for parameters other than "links",
 -- which functions differently depending on whether it is
 -- blank or absent.
 localargs={}
 fork,vinpairs(origArgs)do
 ifk=='links'orv~=''then
 args[k]=v
 end
 end

 returnfunc(args)
 end
 end

 return{
 main=makeWrapper(_main),
 count=makeWrapper(_count)
 }