Module:GHS phrases

 --------------------------------------------------------------------------------
 -- Module:GHS phrases
 -- 
 -- main: reads GHS parameters (arguments like "H301", "P401")
 --		and returns for each (listtype='abbr'):
 --		phraseID visible; formal phrase text as <abbr title="...">
 -- setID	= "H" or "P"
 -- phraseID = e.g. "H201", "P231+P234"
 -- phrase text read from array tables in [[Module:GHS phrases/data]]
 --
 -- Implements: [[Template:GHS phrases]]
 -- Helppage: [[Template:GHS phrases]]
 -- Error category: [[Category:GHS errors]], [[Category:GHS warnings]] (mainspace pages only)
 --
 -- Also: 
 -- listAll(), numberOfPhrases(), listOmitRules(),
 -- listtype, omit
 --------------------------------------------------------------------------------
 require('strict')
 localr={}-- "r" for return, so no confusion with setID P
 localGHSdata=mw.loadData('Module:GHS phrases/data')
 localgetArgs=require('Module:Arguments').getArgs
 localtTools=require('Module:TableTools')
 localyesno=require('Module:Yesno')
 localtArgName={}-- named parameters (setid, omit, listtype)
 localtMessagesToShow={}-- the tail: Preview, Categories

 --------------------------------------------------------------------------------
 -- wlHelpPage
 --
 -- Formats page as [[Helppage#Section|Label]]
 -- by default, sLabel == sSection
 --------------------------------------------------------------------------------
 localfunctionwlHelpPage(sSection,sLabel)
 localsHelpPage='Template:GHS phrases'

 ifsLabel==nilthensLabel=sSectionend

 if(sLabelor'')==''then
 sLabel=''
 else
 sLabel='|'..sLabel
 end
 if(sSectionor'')==''then
 sSection=''
 else
 sSection='#'..sSection
 end
 return'[['..sHelpPage..sSection..sLabel..']]'
 end

 --------------------------------------------------------------------------------
 -- addErrorCategory
 --
 -- Formats as [[Category:GHS errors|catsort]]
 -- or '' when in other namespace.
 -- sCatsort option using: H, P, _
 --------------------------------------------------------------------------------
 localfunctionaddErrorCategory(sCatsort)
 localpagetype=require('Module:Pagetype').main

 localwlErrCat
 ifpagetype()=='article'then-- mainspace only
 ifsCatsort==nilthensCatsort=tArgName['setID']end

 ifsCatsort==''then
 wlErrCat='[[Category:GHS errors]]'
 else
 wlErrCat='[[Category:GHS errors|'..sCatsort..']]'
 end
 else
 return''
 end

 table.insert(tMessagesToShow,wlErrCat)
 return
 end

 --------------------------------------------------------------------------------
 -- addWarningCategory
 --
 -- Formats as [[Category:GHS warnings|catsort]]
 -- mainspace only, or '' when in other namespace.
 -- sCatsort option using: H, P, U, ?, D, O
 --------------------------------------------------------------------------------
 localfunctionaddWarningCategory(sCatsort)
 localpagetype=require('Module:Pagetype').main
 ifsCatsort==nilthensCatsort=tArgName['setID']end

 localwlWarnCat
 ifpagetype()=='article'then-- mainspace only
 ifsCatsort==''then
 wlWarnCat='[[Category:GHS warnings]]'
 else
 wlWarnCat='[[Category:GHS warnings|'..sCatsort..']]'
 end
 else
 return
 end

 table.insert(tMessagesToShow,wlWarnCat)
 return
 end

 --------------------------------------------------------------------------------
 -- addPreviewMsg
 --------------------------------------------------------------------------------
 localfunctionaddPreviewMsg(sMsg)
 localpreviewWarn=require('Module:If preview')._warning
 table.insert(tMessagesToShow,previewWarn({sMsg}))
 return
 end

 --------------------------------------------------------------------------------
 -- showPreviewMsg
 --
 -- show table tMessagesToShow
 -- preview-messages and errorcat
 -- all namespaces
 --------------------------------------------------------------------------------
 localfunctionshowPreviewMsg()
 iftTools.size(tMessagesToShow)>0then
 returntable.concat(tMessagesToShow,'')
 else
 return''
 end
 end

 --------------------------------------------------------------------------------
 -- applyRemoveDuplicates
 --
 -- returns edited table, with double Codes removed
 -- adds warning with codes.
 -- base table tArgs is walked through by a iwalker that reads a singel code,
 -- then a ikiller checks the upward part of the same table to delete all copies
 -- ikiller starts at end of table, walks towards iwalker; then tArgs is compressed
 -- iwalker steps 1 up in the freshly compressed table
 -- Used: iArgs is sorted, and order stays same. compress does not change that.
 --------------------------------------------------------------------------------
 localfunctionapplyRemoveDuplicates(tArgs)
 localiR,iK-- iR = reader, iK = killer
 localhit=false

 iR=1
 whileiR<#tArgsdo
 iK=#tArgs-- will be counting downwards
 whileiK>iRdo
 iftArgs[iK]==tArgs[iR]then
 hit=true
 addPreviewMsg('Duplicate removed: '..tArgs[iR])
 table.remove(tArgs,iK)
 tTools.compressSparseArray(tArgs)
 end
 iK=iK-1
 end
 tTools.compressSparseArray(tArgs)
 iR=iR+1
 end

 ifhitthen
 addWarningCategory('D')
 end
 returntArgs
 end

 --------------------------------------------------------------------------------
 -- applyOmitRules
 --
 -- returns edited table, with Omit phraseID's removed
 -- Omit rule is per GHS 11th rev. ed. (2025)
 --------------------------------------------------------------------------------
 localfunctionapplyOmitRules(tArgs)
 localtRules=GHSdata['tOmitRules']
 localhit=false

 forkeep,omitinpairs(tRules)do
 iftTools.inArray(tArgs,omit)then
 iftTools.inArray(tArgs,keep)then
 hit=true
 fori,kinpairs(tArgs)do
 ifk==omitthen
 table.remove(tArgs,i)
 end
 end
 addPreviewMsg(wlHelpPage('Omit Rules')..': keep '..keep..', omit '..omit)
 end
 end
 end
 ifhitthen
 tTools.compressSparseArray(tArgs)
 addWarningCategory('O')
 end
 returntArgs
 end

 --------------------------------------------------------------------------------
 -- label H-phrases or P-phrases
 --------------------------------------------------------------------------------
 localfunctionPHlabel()
 iftArgName['setID']=='GHS'then
 return'GHS phrases'
 else
 returntArgName['setID']..'-phrases'
 end
 end

 --------------------------------------------------------------------------------
 -- inMono
 --
 -- Use mono font-family (from: Template:Mono)
 --------------------------------------------------------------------------------
 localfunctioninMono(s)
 ifs==nilthens=''end
 return'<span class="monospaced" style="font-family: monospace;">'..s..'</span>'
 end

 --------------------------------------------------------------------------------
 -- wlInlineTag
 --
 -- Returns <sup>[?]</sup> with wikilink to [[helppage#section|errormessage]]
 --------------------------------------------------------------------------------
 localfunctionwlInlineTag(phraseID)
 localsMsg
 sMsg='<sup><span class="noprint Inline-Template">&#91;<i>'
 ..wlHelpPage(PHlabel(),'<span title="'
 ..PHlabel()..': '
 ..phraseID
 ..' not found'
 ..'">?</span>')
 ..'</i>&#93;</span></sup>'
 returnsMsg
 end

 --------------------------------------------------------------------------------
 -- errorPhraseIDnotFound
 --
 -- Returns single value when error (not found in list):
 -- plain value + inline warning [?] (linked) + error cat (mainsp) + preview warning
 --------------------------------------------------------------------------------
 localfunctionerrorPhraseIDnotFound(phraseID)
 ifphraseID==nilthenphraseID=''end

 localinlineTag=wlInlineTag(phraseID)
 localpreviewMsg=wlHelpPage(PHlabel())..': \"'..phraseID..'\" not found'
 addPreviewMsg(previewMsg)
 addErrorCategory()

 returnphraseID..inlineTag
 end

 --------------------------------------------------------------------------------
 -- errorHPsetIDnotFound
 --
 -- setID H or P could not be found
 --------------------------------------------------------------------------------
 localfunctionerrorHPsetIDnotFound()
 localsMsg
 sMsg=wlHelpPage('',PHlabel())
 ..': "H" or "P" set id not found'
 ..' (please use form like "|H200" or "|P300+P301")'
 addPreviewMsg(sMsg)
 addErrorCategory('?')
 returnshowPreviewMsg()
 end

 --------------------------------------------------------------------------------
 -- errorHPsetIDmissing
 --
 -- parameter |setid= to be used
 --------------------------------------------------------------------------------
 localfunctionerrorHPsetIDmissing()
 localsMsg
 sMsg=wlHelpPage('',PHlabel())
 ..': "H" or "P" set id not found,'
 ..' please use |setid=... (H or P)'
 addPreviewMsg(sMsg)
 return
 end

 --------------------------------------------------------------------------------
 -- formatPhraseAbbr
 --
 -- format phraseID and text, for abbr-form (infobox list form)
 --------------------------------------------------------------------------------
 localfunctionformatPhraseAbbr(phraseID,sPhrase)
 return'<abbr class="abbr" title=" '..phraseID..': '..sPhrase..'">'
 ..phraseID
 ..'</abbr>'
 end

 --------------------------------------------------------------------------------
 -- formatPhraseInline
 --
 -- format phraseID and text, for inline form (in sentence)
 -- adds "quotes"
 --------------------------------------------------------------------------------
 localfunctionformatPhraseInline(phraseID,sPhrase)
 returninMono(phraseID)..': \"'..sPhrase..'\"'
 end

 --------------------------------------------------------------------------------
 -- formatPhraseList
 --
 -- as inline, but no "quotes" added.
 --------------------------------------------------------------------------------
 localfunctionformatPhraseList(phraseID,sPhrase)
 returninMono(phraseID)..': '..sPhrase
 end

 --------------------------------------------------------------------------------
 -- getSetID
 --
 -- Determines setID (expected either 'H' or 'P')
 -- First route is: read |setid=
 -- When |setid= is not set, 
 --		it looks for a first parameter that has an H of P prefix (in |P201|P202|...)
 --		when not found, 'GHS' is retured
 -- In one call, P and H numbers can *not* be mixed
 --		so "|H201|P202|" will cause error "P202 not found" (... in H-list)
 --------------------------------------------------------------------------------
 localfunctiongetSetID(tArgs)
 localsetIDfound='GHS'
 localparamsetID=tArgs['setid']ornil

 if(paramsetID~=nil)and(paramsetID=='P'orparamsetID=='H')then
 setIDfound=paramsetID
 else
 localinitial
 fori,vinipairs(tArgs)do
 initial=mw.ustring.match(v,'^[PH]')
 ifinitial~=nilthen
 setIDfound=initial
 break
 end
 end
 end
 returnsetIDfound
 end

 --------------------------------------------------------------------------------
 -- getListType
 --
 -- Checks list format, including those from Module:List
 --------------------------------------------------------------------------------
 localfunctiongetListType(tArgs)
 locallistTypes={
 ['abbr']=true,
 ['bulleted']=true,
 ['unbulleted']=true,
 ['horizontal']=true,
 ['ordered']=true,
 ['horizontal_ordered']=true,
 ['horizontal ordered']=true,
 ['inline']=true
 }
 localsListType=tArgs['listtype']or'abbr'

 ifsListType==''orsListType=='abbr'then
 return'abbr'
 elseiflistTypes[sListType]==truethen
 ifsListType=='horizontal ordered'then
 sListType='horizontal_ordered'
 end
 returnsListType
 else
 sListType='abbr'
 end
 returnsListType
 end

 --------------------------------------------------------------------------------
 -- getDoOmitRules
 --------------------------------------------------------------------------------
 localfunctiongetDoOmitRules(tArgs)
 localb=yesno(tArgs['omit'],true)

 ifb==nilthenb=trueend

 returnyesno(b,true)
 end

 --------------------------------------------------------------------------------
 -- getMinMax
 --------------------------------------------------------------------------------
 localfunctiongetMinMax(targs,key)
 localminmax=targs[key]
 ifminmaxthen
 minmax=mw.ustring.gsub(minmax,'^[PH]','')
 minmax=tonumber(minmax)
 end
 returnminmax
 end

 --------------------------------------------------------------------------------
 -- prepareArgs
 --
 -- First: determine setID (from |setID= OR from prefixes in parameters)
 -- Then: clean up & format phrase IDs (=unnamed parameters)
 --		remove bad characters, create H/P pattern "H201", "P310+P302"
 -- straight array, no nil's, sorted
 --------------------------------------------------------------------------------
 localfunctionprepareArgs(tArgs)

 tArgName['setID']=getSetID(tArgs)
 tArgName['listtype']=getListType(tArgs)
 tArgName['omit']=getDoOmitRules(tArgs)
 tArgName['min']=getMinMax(tArgs,'min')or0
 tArgName['max']=getMinMax(tArgs,'max')or9999

 tArgs=tTools.compressSparseArray(tArgs)-- removes all named args
 ifstring.len(tArgName['setID'])==1and#tArgs>0then
 fori,vinipairs(tArgs)do
 v=mw.text.decode(v)
 v=mw.ustring.gsub(v,'[^%d%+A-Za-z]','')
 v=mw.ustring.gsub(v,'^(%d)',tArgName['setID']..'%1')
 v=mw.ustring.gsub(v,'%+(%d)','+'..tArgName['setID']..'%1')
 tArgs[i]=v
 end
 table.sort(tArgs)
 end
 returntArgs
 end

 --------------------------------------------------------------------------------
 -- listAll
 --
 -- Returns wikitable rows for each phrase id.
 -- requires |setID=P/H
 -- returns full list, all phrases, for a setID
 -- 2-columns wikitable, sorted, sortable, anchor like "H201" for each
 --------------------------------------------------------------------------------
 functionr.listAll(frame)
 localnewArgs=getArgs(frame)
 localtL={}

 prepareArgs(newArgs)

 localtRead
 iftArgName['setID']=='H'ortArgName['setID']=='P'then
 tRead=GHSdata[tArgName['setID']..'phrases']
 else
 errorHPsetIDmissing()
 returnshowPreviewMsg()
 end

 -- Intermediate table t2 to maintain order; read from original table (/data)
 localt2={}
 localiPh
 forsinpairs(tRead)do
 iftArgName.min==0andtArgName.max==9999then
 table.insert(t2,s)
 else
 iPh=tonumber(mw.ustring.match(s,'[PH](%d%d%d)'))
 ifiPhandiPh>=tArgName.minandiPh<=tArgName.maxthen
 table.insert(t2,s)
 end
 end
 end
 table.sort(t2)

 localsTR,v,sAnchor
 -- i = array index, s = phraseID, v = phrase text
 fori,sinipairs(t2)do
 v=tRead[s]
 sAnchor='<span class="anchor" id="'..s..'"></span>'
 sTR='|- '..sAnchor..'\n| datasortvalue="'..i..'" | <span style="font-family: monospace;">'..s..'</span> || '..v
 table.insert(tL,sTR)
 end

 returntable.concat(tL,'\n')
 end

 --------------------------------------------------------------------------------
 -- numberOfPhrases
 --
 -- Documentation
 -- requires |setID=H/P
 -- Returns number of phrases, in format
 --	"GHS H-phrases (123)"
 --------------------------------------------------------------------------------
 functionr.numberOfPhrases(frame)
 localnewArgs=getArgs(frame)

 prepareArgs(newArgs)

 localiT
 iftArgName['setID']=='H'ortArgName['setID']=='P'then
 localtRead=GHSdata[tArgName['setID']..'phrases']

 iftArgName.min==0andtArgName.max==9999then
 iT=tTools.size(tRead)
 else
 localiPh
 iT=0
 forsinpairs(tRead)do
 iPh=tonumber(mw.ustring.match(s,'[PH](%d%d%d)'))
 ifiPhandiPh>=tArgName.minandiPh<=tArgName.maxthen
 iT=iT+1
 end
 end
 end
 else
 errorHPsetIDmissing()
 returnshowPreviewMsg()
 end

 return'GHS '..PHlabel()..' <span style="font-weight: normal;">('..tostring(iT)..')</span>'
 end

 --------------------------------------------------------------------------------
 -- listOmitRules
 --
 -- self-documentation
 --------------------------------------------------------------------------------
 functionr.listOmitRules()
 localtRules=GHSdata['tOmitRules']
 localtL={}
 locals

 s=wlHelpPage('Omit Rules')
 ..': when the <i>keep</i> ID is present, do not show the <i>omit</i> ID phrase'
 table.insert(tL,s)
 forkeep,omitinpairs(tRules)do
 s='&bull; keep '..inMono(keep)..', omit '..inMono(omit)
 table.insert(tL,s)
 end
 returntable.concat(tL,'<br/>')
 end

 --------------------------------------------------------------------------------
 -- _main
 --
 -- processes setID (H, P) and phrase codes
 --		error:	setID not P, H
 --				code not found
 -- cannot mix H and P phrases
 -- reads phrases from /data H or P phrases tables
 -- formats phrase (abbreviation, abbr-title, phraseID)
 --------------------------------------------------------------------------------
 functionr._main(tArgs)

 tArgs=prepareArgs(tArgs)

 if#tArgs==0then
 returnshowPreviewMsg()-- no content
 elseiftArgName['setID']=='GHS'then
 returnerrorHPsetIDnotFound()
 end

 tArgs=applyRemoveDuplicates(tArgs)
 iftArgName['omit']then
 tArgs=applyOmitRules(tArgs)
 end

 localformatterF
 iftArgName['listtype']=='abbr'then
 formatterF=formatPhraseAbbr
 elseiftArgName['listtype']=='inline'then
 formatterF=formatPhraseInline
 else--- Module:List options
 formatterF=formatPhraseList
 end

 localtReadD
 iftArgName['setID']=='H'ortArgName['setID']=='P'then
 tReadD=GHSdata[tArgName['setID']..'phrases']
 else
 returnshowPreviewMsg()
 end

 localsPhrase
 localtR={}
 fori,vinipairs(tArgs)do
 sPhrase=tReadD[v]
 ifsPhrase==nilthen
 table.insert(tR,errorPhraseIDnotFound(tostring(v)))
 else
 table.insert(tR,formatterF(v,sPhrase))
 end
 end

 iftArgName['listtype']=='abbr'then
 returntable.concat(tR,', ')..showPreviewMsg()
 elseiftArgName['listtype']=='inline'then
 returntable.concat(tR,', ')..showPreviewMsg()
 else
 localmList=require('Module:List')
 returnmList[tArgName['listtype']](tR)..showPreviewMsg()
 end
 end

 --------------------------------------------------------------------------------
 -- main
 --
 -- handles template input frame, then calls generic _main() function
 -- To be invoked from {{template}}
 --------------------------------------------------------------------------------
 functionr.main(frame)
 localnewArgs=getArgs(frame)
 returnr._main(newArgs)
 end


 returnr