Module:Class/sandbox

 -- This module implements [[Template:Class]], [[Template:Class/icon]] and
 -- [[Template:Class/colour]].

 localmArguments-- lazily loaded
 localdefinitions=mw.loadJsonData('Module:Class/sandbox/definition.json')

 localp={}

 --------------------------------------------------------------------------------
 -- Local configuration and messages
 --------------------------------------------------------------------------------

 localcfg={
 defaultCode='DEFAULT',
 classPrefix='assess-',
 globalClass='assess',
 defaultClassSuffix='default',
 unboldClassSuffix='unbold',
 catRootFormat='%s %s',
 catTopicFormat='%s %s %s',
 catBasicFormat='%s %s',
 categoryFormat='[[:Category:%s|%s]]',
 templateLocation='Template:Class',
 iconTemplateLocation='Template:Class/icon',
 colourTemplateLocation='Template:Class/colour',
 stylesLocation='Module:Class/styles.css',
 baseColourPath={'colour','base'},
 iconPath={"icon","file"},
 iconDefaultPath={"icon","default"},
 iconAttribPath={"icon","requiresAttribution"},
 fullLabelPath={"labels","full"},
 shortLabelPath={"labels","short"},
 categoryRootPath={"categoryRoot"},
 tooltipPath={"labels","tooltip"},
 articlePath={"article"},
 yes="yes",
 no="no",
 articles="articles",
 pages="pages",
 argumentNames={
 class="class",
 style="style"
 },
 getOptions={
 --First item is localized argument name, second is case-sensitivity
 bold={"bold",false},
 header={"header",false},
 image={"image",false},
 rowspan={"rowspan",false},
 fullcategory={"fullcategory",true},
 category={"category",true},
 topic={"topic",true}
 }
 }

 --------------------------------------------------------------------------------
 -- Argument helper functions
 --------------------------------------------------------------------------------

 localfunctiongetRawArgs(frame,wrapper)
 --Retrieves the arguments from the frame
 mArguments=mArgumentsorrequire('Module:Arguments')
 returnmArguments.getArgs(frame,{
 wrappers=wrapper,
 trim=false,
 removeBlanks=false
 })
 end

 localfunctionmakeInvokeFunction(func,wrapper)
 --Wraps a general function into an invokable version
 returnfunction(frame)
 localargs=getRawArgs(frame,wrapper)
 returnfunc(args)
 end
 end

 --------------------------------------------------------------------------------
 -- String helper functions
 --------------------------------------------------------------------------------

 localfunctiontrim(str)
 --Trims strings, passes through non-strings without modification
 return(type(str)=='string')andmw.text.trim(str)orstr
 end

 localfunctionnormalizeValue(val)
 --Normalizes strings, particularly class codes
 iftype(val)=='string'thenval=trim(val):lower()end
 ifval==''thenval=nilend
 returnval
 end

 localfunctionucfirst(str)
 --Capitalizes the first character of a string
 returnmw.ustring.upper(mw.ustring.sub(str,1,1))..mw.ustring.sub(str,2)
 end

 --------------------------------------------------------------------------------
 -- Definition helper functions
 --------------------------------------------------------------------------------

 localfunctiongetDefinition(code)
 --Retrieves the definition and canonical class code for a given code.
 --Returns two values: the definition object and the canonical class code
 --string.
 localcanonicalCode=normalizeValue(code)
 ifcode==cfg.defaultCodethencanonicalCode=codeend
 localclass=definitions[canonicalCode]
 whileclassandclass.aliasdo
 canonicalCode=class.alias
 class=definitions[class.alias]
 end
 ifnotclassthen
 returnnil,nil
 end
 returnclass,canonicalCode
 end

 localfunctiongetDefault()
 --Shortcut function for retrieving the default definition
 returngetDefinition(cfg.defaultCode)end

 localfunctiongetProperty(class,default,map)
 --Retrieves a given property from a string given a class definition, a
 --default class definition, and a map for the path to traverse through the
 --class object. The map should be a sequential table of string property
 --names, e.g. {"colour", "base"} would retrieve someClass.colour.base
 localprop,dProp=class,default
 fork,vinipairs(map)do
 prop=((type(prop)=='table')ornil)andprop[v]
 dProp=((type(dProp)=='table')ornil)anddProp[v]
 end
 ifprop==nilthenprop=dPropend
 returnprop
 end

 --------------------------------------------------------------------------------
 -- Color functions
 --------------------------------------------------------------------------------

 functionp._colour(code)
 --Retrieves the base colour for a given code
 returngetProperty(getDefinition(code),getDefault(),cfg.baseColourPath)
 end

 functionp.colour(frame)
 --Retrieves the base colour for a given code; is invokable
 localargs=getRawArgs(frame,cfg.colourTemplateLocation)
 -- Nowiki tags prevent output beginning with "#" from triggering bug 14974.
 returnframe:extensionTag('nowiki',p._colour(args[1]))
 end

 --------------------------------------------------------------------------------
 -- Icon functions
 --------------------------------------------------------------------------------

 functionp._icon(args)
 --Retrieves an icon image and formats it as wikitext
 localclass=getDefinition(args[cfg.argumentNames.class]orargs[1])
 localdefault=getDefault()
 localfile=getProperty(class,default,cfg.iconPath)
 locallabel=
 getProperty(class,default,cfg.tooltipPath)or
 ucfirst(getProperty(class,default,cfg.fullLabelPath))
 localattrib=getProperty(class,default,cfg.iconAttribPath)
 localsize=args.sizeor'16px'
 localspan=mw.html.create('span')

 span
 :cssText(args[cfg.argumentNames.style])
 :attr('title',label)
 :wikitext(
 string.format(
 '[[File:%s|%s|'..size..'%s|class=noviewer|alt=]]',
 file,
 label,
 attriband''or'|link='
 )
 )
 returntostring(span)
 end

 p.icon=makeInvokeFunction(p._icon,cfg.iconTemplateLocation)
 --Invokable version of p._icon

 --------------------------------------------------------------------------------
 -- Class functions
 --------------------------------------------------------------------------------

 functionp._class(args)
 --Parses its arguments into a table cell with an optional icon, a name
 --linked to an appropriate category, and appropriate colour styling
 localclassDef,classCode=getDefinition(args[cfg.argumentNames.class]orargs[1])
 localdefault=getDefault()
 localiconDefault=getProperty(classDef,default,cfg.iconDefaultPath)
 localshortLabel=getProperty(classDef,default,cfg.shortLabelPath)
 localcategoryRoot=getProperty(classDef,default,cfg.categoryRootPath)
 localarticle=getProperty(classDef,false,cfg.articlePath)
 localpagetype=articleandcfg.articlesorcfg.pages
 --o is short for "options", go for "get options". Bool true → case-sensitive
 localo,go={},cfg.getOptions
 fork,vinpairs(go)do
 o[k]=v[2]andtrim(args[v[1]])ornormalizeValue(args[v[1]])
 end

 localcell=mw.html.create(o.headerand'th'or'td')
 --image=yes forces icon, image=no disables it, otherwise checks default
 localicon=iconDefaultand(o.image~=cfg.no)or(o.image==cfg.yes)
 icon=iconandp.icon(args)..' 'or''

 localcategory
 ifo.fullcategorythen
 category=o.fullcategory
 elseifo.categorythen
 category=cfg.catRootFormat:format(categoryRoot,o.category)
 elseifo.topicthen
 category=cfg.catTopicFormat:format(categoryRoot,o.topic,pagetype)
 else
 category=cfg.catBasicFormat:format(categoryRoot,pagetype)
 end
 localtext=string.format(cfg.categoryFormat,category,shortLabel)
 cell
 :addClass(cfg.globalClass)
 :addClass(
 o.bold==cfg.noandcfg.classPrefix..cfg.unboldClassSuffixornil
 )
 :addClass(cfg.classPrefix..(classCodeorcfg.defaultClassSuffix))
 :attr('rowspan',tonumber(o.rowspan))
 :wikitext(mw.getCurrentFrame():extensionTag{name='templatestyles',args={src=cfg.stylesLocation}},icon,text)

 returntostring(cell)
 end

 p.class=makeInvokeFunction(p._class,cfg.templateLocation)
 --Invokable version of p._class

 returnp