Module:Navbox: Difference between revisions

From Test Wiki
← Older edit
Content deleted Content added
edge cases
m 1 revision imported
 
(76 intermediate revisions by 27 users not shown)
Line 1: Line 1:
require('strict')
--
-- This module will implement {{Navbox}}
--
local p = {}
local p = {}
local cfg = mw.loadData('Module:Navbox/configuration')
local HtmlBuilder = require('Module:HtmlBuilder')
local inArray = require("Module:TableTools").inArray
local getArgs -- lazily initialized
local hiding_templatestyles = {}


-- global passthrough variables
local args
local frame
local passthrough = {
[cfg.arg.above]=true,[cfg.arg.aboveclass]=true,[cfg.arg.abovestyle]=true,
local tableRowAdded = false
[cfg.arg.basestyle]=true,
local border
[cfg.arg.below]=true,[cfg.arg.belowclass]=true,[cfg.arg.belowstyle]=true,
local listnums = {}
[cfg.arg.bodyclass]=true,
[cfg.arg.groupclass]=true,
function trim(s)
[cfg.arg.image]=true,[cfg.arg.imageclass]=true,[cfg.arg.imagestyle]=true,
return (mw.ustring.gsub(s, "^%s*(.-)%s*$", "%1"))
[cfg.arg.imageleft]=true,[cfg.arg.imageleftstyle]=true,
end
[cfg.arg.listclass]=true,
[cfg.arg.name]=true,
[cfg.arg.navbar]=true,
[cfg.arg.state]=true,
[cfg.arg.title]=true,[cfg.arg.titleclass]=true,[cfg.arg.titlestyle]=true,
argHash=true
}


-- helper functions
function addTableRow(tbl)
local andnum = function(s, n) return string.format(cfg.arg[s .. '_and_num'], n) end
-- If any other rows have already been added, then we add a 2px gutter row.
local isblank = function(v) return (v or '') == '' end
if tableRowAdded then

tbl
local function concatstrings(s)
.tag('tr')
.css('height', '2px')
local r = table.concat(s, '')
if r:match('^%s*$') then return nil end
.tag('td')
return r
end
tableRowAdded = true
return tbl.tag('tr')
end
end


local function concatstyles(s)
local r = ''
for _, v in ipairs(s) do
v = mw.text.trim(v, "%s;")
if not isblank(v) then r = r .. v .. ';' end
end
if isblank(r) then return nil end
return r
end


local function getSubgroup(args, listnum, listText, prefix)
--
local subArgs = {
-- Title row
[cfg.arg.border] = cfg.keyword.border_subgroup,
--
[cfg.arg.navbar] = cfg.keyword.navbar_plain,
function renderTitleRow(tbl)
argHash = 0
if not args.title then return end
}
local titleRow = addTableRow(tbl)
local hasSubArgs = false
local subgroups_and_num = prefix and {prefix} or cfg.arg.subgroups_and_num
if args.titlegroup then
for k, v in pairs(args) do
k = tostring(k)
titleRow
for _, w in ipairs(subgroups_and_num) do
.tag('th')
w = string.format(w, listnum) .. "_"
.attr('scope', 'row')
if (#k > #w) and (k:sub(1, #w) == w) then
.addClass('navbox-group')
subArgs[k:sub(#w + 1)] = v
.addClass(args.titlegroupclass)
hasSubArgs = true
.cssText(args.basestyle)
subArgs.argHash = subArgs.argHash + (v and #v or 0)
.cssText(args.groupstyle)
end
.cssText(args.titlegroupstyle)
end
.wikitext(args.titlegroup)
end
end
return hasSubArgs and p._navbox(subArgs) or listText
local titleCell = titleRow.tag('th').attr('scope', 'col')
if args.titlegroup then
titleCell
.css('border-left', '2px solid #fdfdfd')
.css('width', '100%')
end
local titleColspan = 2
if args.imageleft then titleColspan = titleColspan + 1 end
if args.image then titleColspan = titleColspan + 1 end
if args.titlegroup then titleColspan = titleColspan - 1 end
titleCell
.cssText(args.basestyle)
.cssText(args.titlestyle)
.addClass('navbox-title')
.attr('colspan', titleColspan)
renderNavBar(titleCell)
titleCell
.tag('div')
.addClass(args.titleclass)
.css('font-size', '110%')
.newline()
.wikitext(args.title)
end
end


-- Main functions
function p._navbox(args)
if args.type == cfg.keyword.with_collapsible_groups then
return p._withCollapsibleGroups(args)
elseif args.type == cfg.keyword.with_columns then
return p._withColumns(args)
end


function formNavBar( div, args )
local function striped(wikitext, border)
-- Return wikitext with markers replaced for odd/even striping.
local class = 'noprint plainlinks hlist navbar';
-- Child (subgroup) navboxes are flagged with a category that is removed
local title;
-- by parent navboxes. The result is that the category shows all pages
args[1] = trim( args[1] or '' );
-- where a child navbox is not contained in a parent navbox.
local orphanCat = cfg.category.orphan
if args[1] == '' then
if border == cfg.keyword.border_subgroup and args[cfg.arg.orphan] ~= cfg.keyword.orphan_yes then
title = mw.title.new( '' );
-- No change; striping occurs in outermost navbox.
elseif args[1]:sub(1,1) == ':' then
return wikitext .. orphanCat
title = mw.title.new( args[1]:sub(2) );
end
else
local first, second = cfg.class.navbox_odd_part, cfg.class.navbox_even_part
title = mw.title.new( 'Template:' .. args[1] );
if args[cfg.arg.evenodd] then
end
if args[cfg.arg.evenodd] == cfg.keyword.evenodd_swap then
first, second = second, first
local mainpage, talkpage, editurl;
else
mainpage = title.fullText;
first = args[cfg.arg.evenodd]
talkpage = title.talkPageTitle;
second = first
talkpage = talkpage.fullText or '';
end
editurl = title:fullUrl( 'action=edit' );
end
local changer
if args.mini ~= nil then
if first == second then
class = class .. ' mini';
changer = first
end
else
local index = 0
changer = function (code)
if code == '0' then
-- Current occurrence is for a group before a nested table.
-- Set it to first as a valid although pointless class.
-- The next occurrence will be the first row after a title
-- in a subgroup and will also be first.
index = 0
return first
end
index = index + 1
return index % 2 == 1 and first or second
end
end
local regex = orphanCat:gsub('([%[%]])', '%%%1')
return (wikitext:gsub(regex, ''):gsub(cfg.marker.regex, changer)) -- () omits gsub count
end


local function processItem(item, nowrapitems)
div
if item:sub(1, 2) == '{|' then
.addClass( class )
-- Applying nowrap to lines in a table does not make sense.
.cssText( args.style or '' )
-- Add newlines to compensate for trim of x in |parm=x in a template.
return '\n' .. item .. '\n'
if args.mini == nil and args.plain == nil then
end
div.tag( 'span' )
if nowrapitems == cfg.keyword.nowrapitems_yes then
.css( 'word-spacing', 0 )
local lines = {}
.cssText( args.fontstyle or '' )
for line in (item .. '\n'):gmatch('([^\n]*)\n') do
.wikitext( args.text or 'This box:' );
local prefix, content = line:match('^([*:;#]+)%s*(.*)')
end
if prefix and not content:match(cfg.pattern.nowrap) then
line = string.format(cfg.nowrap_item, prefix, content)
if args.brackets ~= nil then
end
div.wikitext(' ');
table.insert(lines, line)
div.tag('span')
end
.css('margin-right', '-0.125em')
item = table.concat(lines, '\n')
.cssText( args.fontstyle or '' )
end
.wikitext( '[' )
if item:match('^[*:;#]') then
.newline();
return '\n' .. item .. '\n'
end
end
return item
local ul = div.tag('ul');
end
local inner
if args.mini ~= nil then
inner = 'v';
else
inner = 'view';
end
ul.tag( 'li' )
.addClass( 'nv-view' )
.wikitext( '[[' .. mainpage .. '|' )
.tag( 'span ' )
.attr( 'title', 'View this template' )
.cssText( args.fontstyle or '' )
.wikitext( inner )
.done()
.wikitext( ']]' );


local function has_navbar()
if args.mini ~= nil then
return args[cfg.arg.navbar] ~= cfg.keyword.navbar_off
inner = 't';
and args[cfg.arg.navbar] ~= cfg.keyword.navbar_plain
else
and (
inner = 'talk';
args[cfg.arg.name]
end
or mw.getCurrentFrame():getParent():getTitle():gsub(cfg.pattern.sandbox, '')
~= cfg.pattern.navbox
ul.tag( 'li' )
)
.addClass( 'nv-talk' )
end
.wikitext( '[[' .. talkpage .. '|' )
.tag( 'span ' )
.attr( 'title', 'Discuss this template' )
.cssText( args.fontstyle or '' )
.wikitext( inner )
.done()
.wikitext( ']]' );


-- extract text color from css, which is the only permitted inline CSS for the navbar
if args.mini ~= nil then
local function extract_color(css_str)
inner = 'e';
-- return nil because navbar takes its argument into mw.html which handles
else
-- nil gracefully, removing the associated style attribute
inner = 'edit';
return mw.ustring.match(';' .. css_str .. ';', '.*;%s*([Cc][Oo][Ll][Oo][Rr]%s*:%s*.-)%s*;') or nil
end
end
ul.tag( 'li' )
.addClass( 'nv-edit' )
.wikitext( '[' .. editurl .. ' ' )
.tag( 'span ' )
.attr( 'title', 'Edit this template' )
.cssText( args.fontstyle or '' )
.wikitext( inner )
.done()
.wikitext( ']' );


local function renderNavBar(titleCell)
if args.brackets ~= nil then
if has_navbar() then
div.tag('span')
local navbar = require('Module:Navbar')._navbar
.css('margin-left', '-0.125em')
titleCell:wikitext(navbar{
.cssText( args.fontstyle or '' )
[cfg.navbar.name] = args[cfg.arg.name],
.wikitext( ']' )
[cfg.navbar.mini] = 1,
.newline();
[cfg.navbar.fontstyle] = extract_color(
end
(args[cfg.arg.basestyle] or '') .. ';' .. (args[cfg.arg.titlestyle] or '')
)
})
end


end
return div;
end
function renderNavBar(titleCell)
-- Depending on the presence of the navbar and/or show/hide link, we may need to add a spacer div on the left
-- or right to keep the title centered.
local spacerSide = nil


local function renderTitleRow(tbl)
if args.navbar == 'off' then
if not args[cfg.arg.title] then return end
-- No navbar, and client wants no spacer, i.e. wants the title to be shifted to the left. If there's
-- also no show/hide link, then we need a spacer on the right to achieve the left shift.
if args.state == 'plain' then spacerSide = 'right' end
elseif args.navbar == 'plain' or args.navbar == 'off' or (not args.name and (border == 'subgroup' or border == 'child' or border == 'none')) then
-- No navbar. Need a spacer on the left to balance out the width of the show/hide link.
if args.state ~= 'plain' then spacerSide = 'left' end
else
-- Will render navbar (or error message). If there's no show/hide link, need a spacer on the right
-- to balance out the width of the navbar.
if args.state == 'plain' then spacerSide = 'right' end


local titleRow = tbl:tag('tr')
if args.name then
local div = HtmlBuilder.create('div');
local args = {
args.name,
mini = 1,
fontstyle = (args.basestyle or '') .. ';' .. (args.titlestyle or '') .. ';background:none transparent;border:none;'
};
div = formNavBar( div, args );
titleCell.node( div )
else
titleCell
.tag('span')
.addClass('error')
.css('float', 'left')
.css('white-space', 'nowrap')
.wikitext('Error: No name provided')
end
end
-- Render the spacer div.
if spacerSide then
titleCell
.tag('span')
.css('float', spacerSide)
.css('width', '6em')
.wikitext(' ')
end
end


local titleCell = titleRow:tag('th'):attr('scope', 'col')


local titleColspan = 2
--
if args[cfg.arg.imageleft] then titleColspan = titleColspan + 1 end
-- Above/Below rows
if args[cfg.arg.image] then titleColspan = titleColspan + 1 end
--
function renderAboveRow(tbl)
if not args.above then return end
addTableRow(tbl)
.tag('td')
.addClass('navbox-abovebelow')
.addClass(args.aboveclass)
.cssText(args.basestyle)
.cssText(args.abovestyle)
.attr('colspan', getAboveBelowColspan())
.tag('div')
.newline()
.wikitext(args.above)
end


titleCell
function renderBelowRow(tbl)
:cssText(args[cfg.arg.basestyle])
if not args.below then return end
:cssText(args[cfg.arg.titlestyle])
:addClass(cfg.class.navbox_title)
addTableRow(tbl)
:attr('colspan', titleColspan)
.tag('td')
.addClass('navbox-abovebelow')
.addClass(args.belowclass)
.cssText(args.basestyle)
.cssText(args.belowstyle)
.attr('colspan', getAboveBelowColspan())
.tag('div')
.newline()
.wikitext(args.below)
end


renderNavBar(titleCell)
function getAboveBelowColspan()
local ret = 2
if args.imageleft then ret = ret + 1 end
if args.image then ret = ret + 1 end
return ret
end
--
-- List rows
--
function renderListRow(tbl, listnum)
local row = addTableRow(tbl)
if listnum == 1 and args.imageleft then
row
.tag('td')
.addClass('navbox-image')
.addClass(args.imageclass)
.css('width', '0%')
.css('padding', '0px 2px 0px 0px')
.cssText(args.imageleftstyle)
.attr('rowspan', 2 * #listnums - 1)
.tag('div')
.newline()
.wikitext(args.imageleft)
end
if args['group' .. listnum] then
local groupCell = row.tag('th')
groupCell
.attr('scope', 'row')
.addClass('navbox-group')
.addClass(args.groupclass)
.cssText(args.basestyle)
if args.groupwidth then
groupCell.css('width', args.groupwidth)
end
groupCell
.cssText(args.groupstyle)
.cssText(args['group' .. listnum .. 'style'])
.wikitext(args['group' .. listnum])
end
local listCell = row.tag('td')


titleCell
if args['group' .. listnum] then
:tag('div')
listCell
-- id for aria-labelledby attribute
.css('text-align', 'left')
:attr('id', mw.uri.anchorEncode(args[cfg.arg.title]) .. args.argHash)
.css('border-left-width', '2px')
:addClass(args[cfg.arg.titleclass])
.css('border-left-style', 'solid')
:css('font-size', '114%')
else
:css('margin', '0 4em')
listCell.attr('colspan', 2)
:wikitext(processItem(args[cfg.arg.title]))
end
end
if not args.groupwidth then
listCell.css('width', '100%')
end
local isOdd = (listnum % 2) == 1
local rowstyle = args.evenstyle
if isOdd then rowstyle = args.oddstyle end
local evenOdd
if args.evenodd == 'swap' then
if isOdd then evenOdd = 'even' else evenOdd = 'odd' end
else
if isOdd then evenOdd = args.evenodd or 'odd' else evenOdd = args.evenodd or 'even' end
end
listCell
.css('padding', '0px')
.cssText(args.liststyle)
.cssText(rowstyle)
.cssText(args['list' .. listnum .. 'style'])
.addClass('navbox-list')
.addClass('navbox-' .. evenOdd)
.addClass(args.listclass)
.tag('div')
.css('padding', (listnum == 1 and args.list1padding) or args.listpadding or '0em 0.25em')
.newline()
.wikitext(args['list' .. listnum])


local function getAboveBelowColspan()
if listnum == 1 and args.image then
local ret = 2
row
if args[cfg.arg.imageleft] then ret = ret + 1 end
.tag('td')
if args[cfg.arg.image] then ret = ret + 1 end
.addClass('navbox-image')
return ret
.addClass(args.imageclass)
end
.css('width', '0%')
.css('padding', '0px 0px 0px 2px')
.cssText(args.imagestyle)
.attr('rowspan', 2 * #listnums - 1)
.tag('div')
.newline()
.wikitext(args.image)
end
end


local function renderAboveRow(tbl)
if not args[cfg.arg.above] then return end


tbl:tag('tr')
--
:tag('td')
-- Tracking categories
:addClass(cfg.class.navbox_abovebelow)
--
:addClass(args[cfg.arg.aboveclass])
function renderTrackingCategories(builder)
:cssText(args[cfg.arg.basestyle])
local frame = mw.getCurrentFrame()
:cssText(args[cfg.arg.abovestyle])
:attr('colspan', getAboveBelowColspan())
if not frame then return end
:tag('div')
-- id for aria-labelledby attribute, if no title
local s = frame:preprocess('{{#ifeq:{{NAMESPACE}}|{{ns:10}}|1|0}}{{SUBPAGENAME}}')
:attr('id', (not args[cfg.arg.title]) and
if mw.ustring.sub(s, 1, 1) == '0' then return end -- not in template space
(mw.uri.anchorEncode(args[cfg.arg.above]) .. args.argHash)
local subpage = mw.ustring.lower(mw.ustring.sub(s, 2))
or nil)
if subpage == 'doc' or subpage == 'sandbox' or subpage == 'testcases' then return end
:wikitext(processItem(args[cfg.arg.above], args[cfg.arg.nowrapitems]))
end
for i, cat in ipairs(getTrackingCategories()) do
builder.wikitext('[[Category:' .. cat .. ']]')
end
end


function getTrackingCategories()
local function renderBelowRow(tbl)
if not args[cfg.arg.below] then return end
local cats = {}
if needsHorizontalLists() then table.insert(cats, 'Navigational boxes without horizontal lists') end
if hasCustomListSpacing() then table.insert(cats, 'Navigational boxes with custom list spacing') end
if hasBackgroundColors() then table.insert(cats, 'Navboxes using background colours') end
return cats
end


tbl:tag('tr')
function needsHorizontalLists()
:tag('td')
if border == 'child' or border == 'subgroup' or args.tracking == 'no' then return false end
:addClass(cfg.class.navbox_abovebelow)
:addClass(args[cfg.arg.belowclass])
local listClasses = {'plainlist', 'hlist', 'hlist hnum', 'hlist vcard', 'vcard hlist'}
:cssText(args[cfg.arg.basestyle])
for i, cls in ipairs(listClasses) do
:cssText(args[cfg.arg.belowstyle])
if args.listclass == cls or args.bodyclass == cls then
:attr('colspan', getAboveBelowColspan())
return false
:tag('div')
end
:wikitext(processItem(args[cfg.arg.below], args[cfg.arg.nowrapitems]))
end
end


local function renderListRow(tbl, index, listnum, listnums_size)
return true
local row = tbl:tag('tr')
end


if index == 1 and args[cfg.arg.imageleft] then
function hasCustomListSpacing()
row
return args.liststyle == 'padding: 0.25em 0; line-height: 1.3em;' or
:tag('td')
args.liststyle == 'padding:0.25em 0; line-height:1.4em; width:auto;' or
:addClass(cfg.class.noviewer)
args.liststyle == 'padding:0.4em 0; line-height:1.4em;'
:addClass(cfg.class.navbox_image)
end
:addClass(args[cfg.arg.imageclass])
:css('width', '1px') -- Minimize width
:css('padding', '0 2px 0 0')
:cssText(args[cfg.arg.imageleftstyle])
:attr('rowspan', listnums_size)
:tag('div')
:wikitext(processItem(args[cfg.arg.imageleft]))
end


local group_and_num = andnum('group', listnum)
function hasBackgroundColors()
local groupstyle_and_num = andnum('groupstyle', listnum)
return args.titlestyle or args.groupstyle
if args[group_and_num] then
end
local groupCell = row:tag('th')


-- id for aria-labelledby attribute, if lone group with no title or above
if listnum == 1 and not (args[cfg.arg.title] or args[cfg.arg.above] or args[cfg.arg.group2]) then
groupCell
:attr('id', mw.uri.anchorEncode(args[cfg.arg.group1]) .. args.argHash)
end


groupCell
--
:attr('scope', 'row')
-- Main navbox tables
:addClass(cfg.class.navbox_group)
--
:addClass(args[cfg.arg.groupclass])
function renderMainTable()
:cssText(args[cfg.arg.basestyle])
local tbl = HtmlBuilder.create('table')
-- If groupwidth not specified, minimize width
.attr('cellspacing', 0)
:css('width', args[cfg.arg.groupwidth] or '1%')
.addClass('nowraplinks')
.addClass(args.bodyclass)
if args.title and (args.state ~= 'plain' and args.state ~= 'off') then
tbl
.addClass('collapsible')
.addClass(args.state or 'autocollapse')
end
tbl.css('border-spacing', 0)
if border == 'subgroup' or border == 'child' or border == 'none' then
tbl
.addClass('navbox-subgroup')
.cssText(args.bodystyle)
.cssText(args.style)
else -- regular navobx - bodystyle and style will be applied to the wrapper table
tbl
.addClass('navbox-inner')
.css('background', 'transparent')
.css('color', 'inherit')
end
tbl.cssText(args.innerstyle)
renderTitleRow(tbl)
renderAboveRow(tbl)
for i, listnum in ipairs(listnums) do
renderListRow(tbl, listnum)
end
renderBelowRow(tbl)
return tbl
end


groupCell
function p._navbox(navboxArgs)
:cssText(args[cfg.arg.groupstyle])
args = navboxArgs
:cssText(args[groupstyle_and_num])
:wikitext(args[group_and_num])
for k, v in pairs(args) do
end
local listnum = ('' .. k):match('^list(%d+)$')
if listnum then table.insert(listnums, tonumber(listnum)) end
end
table.sort(listnums)
border = trim(args.border or args[1] or '')


local listCell = row:tag('td')
-- render the main body of the navbox
local tbl = renderMainTable()


if args[group_and_num] then
-- render the appropriate wrapper around the navbox, depending on the border param
listCell
local res = HtmlBuilder.create()
:addClass(cfg.class.navbox_list_with_group)
if border == 'none' then
else
res.node(tbl)
listCell:attr('colspan', 2)
elseif border == 'subgroup' or border == 'child' then
end
-- We assume that this navbox is being rendered in a list cell of a parent navbox, and is

-- therefore inside a div with padding:0em 0.25em. We start with a </div> to avoid the
if not args[cfg.arg.groupwidth] then
-- padding being applied, and at the end add a <div> to balance out the parent's </div>
listCell:css('width', '100%')
res
end
.tag('/div', {unclosed = true})

.done()
local rowstyle -- usually nil so cssText(rowstyle) usually adds nothing
.node(tbl)
if index % 2 == 1 then
.tag('div', {unclosed = true})
rowstyle = args[cfg.arg.oddstyle]
else
else
res
rowstyle = args[cfg.arg.evenstyle]
.tag('table')
end
.attr('cellspacing', 0)

.addClass('navbox')
local list_and_num = andnum('list', listnum)
.css('border-spacing', 0)
local listText = inArray(cfg.keyword.subgroups, args[list_and_num])
.cssText(args.bodystyle)
and getSubgroup(args, listnum, args[list_and_num]) or args[list_and_num]
.cssText(args.style)

.tag('tr')
local oddEven = cfg.marker.oddeven
.tag('td')
if listText:sub(1, 12) == '</div><table' then
.css('padding', '2px')
-- Assume list text is for a subgroup navbox so no automatic striping for this row.
.node(tbl)
oddEven = listText:find(cfg.pattern.navbox_title) and cfg.marker.restart or cfg.class.navbox_odd_part
end
end

renderTrackingCategories(res)
local liststyle_and_num = andnum('liststyle', listnum)
local listclass_and_num = andnum('listclass', listnum)
return tostring(res)
listCell
:css('padding', '0')
:cssText(args[cfg.arg.liststyle])
:cssText(rowstyle)
:cssText(args[liststyle_and_num])
:addClass(cfg.class.navbox_list)
:addClass(cfg.class.navbox_part .. oddEven)
:addClass(args[cfg.arg.listclass])
:addClass(args[listclass_and_num])
:tag('div')
:css('padding',
(index == 1 and args[cfg.arg.list1padding]) or args[cfg.arg.listpadding] or '0 0.25em'
)
:wikitext(processItem(listText, args[cfg.arg.nowrapitems]))

if index == 1 and args[cfg.arg.image] then
row
:tag('td')
:addClass(cfg.class.noviewer)
:addClass(cfg.class.navbox_image)
:addClass(args[cfg.arg.imageclass])
:css('width', '1px') -- Minimize width
:css('padding', '0 0 0 2px')
:cssText(args[cfg.arg.imagestyle])
:attr('rowspan', listnums_size)
:tag('div')
:wikitext(processItem(args[cfg.arg.image]))
end
end

local function has_list_class(htmlclass)
local patterns = {
'^' .. htmlclass .. '$',
'%s' .. htmlclass .. '$',
'^' .. htmlclass .. '%s',
'%s' .. htmlclass .. '%s'
}

for arg, _ in pairs(args) do
if type(arg) == 'string' and mw.ustring.find(arg, cfg.pattern.class) then
for _, pattern in ipairs(patterns) do
if mw.ustring.find(args[arg] or '', pattern) then
return true
end
end
end
end
return false
end

-- there are a lot of list classes in the wild, so we add their TemplateStyles
local function add_list_styles()
local frame = mw.getCurrentFrame()
local function add_list_templatestyles(htmlclass, templatestyles)
if has_list_class(htmlclass) then
return frame:extensionTag{
name = 'templatestyles', args = { src = templatestyles }
}
else
return ''
end
end

local hlist_styles = add_list_templatestyles('hlist', cfg.hlist_templatestyles)
local plainlist_styles = add_list_templatestyles('plainlist', cfg.plainlist_templatestyles)

-- a second workaround for [[phab:T303378]]
-- when that issue is fixed, we can actually use has_navbar not to emit the
-- tag here if we want
if has_navbar() and hlist_styles == '' then
hlist_styles = frame:extensionTag{
name = 'templatestyles', args = { src = cfg.hlist_templatestyles }
}
end

-- hlist -> plainlist is best-effort to preserve old Common.css ordering.
-- this ordering is not a guarantee because most navboxes will emit only
-- one of these classes [hlist_note]
return hlist_styles .. plainlist_styles
end

local function needsHorizontalLists(border)
if border == cfg.keyword.border_subgroup or args[cfg.arg.tracking] == cfg.keyword.tracking_no then
return false
end
return not has_list_class(cfg.pattern.hlist) and not has_list_class(cfg.pattern.plainlist)
end

local function hasBackgroundColors()
for _, key in ipairs({cfg.arg.titlestyle, cfg.arg.groupstyle,
cfg.arg.basestyle, cfg.arg.abovestyle, cfg.arg.belowstyle}) do
if tostring(args[key]):find('background', 1, true) then
return true
end
end
return false
end

local function hasBorders()
for _, key in ipairs({cfg.arg.groupstyle, cfg.arg.basestyle,
cfg.arg.abovestyle, cfg.arg.belowstyle}) do
if tostring(args[key]):find('border', 1, true) then
return true
end
end
return false
end

local function isIllegible()
local styleratio = require('Module:Color contrast')._styleratio
for key, style in pairs(args) do
if tostring(key):match(cfg.pattern.style) then
if styleratio{mw.text.unstripNoWiki(style)} < 4.5 then
return true
end
end
end
return false
end

local function getTrackingCategories(border)
local cats = {}
if needsHorizontalLists(border) then table.insert(cats, cfg.category.horizontal_lists) end
if hasBackgroundColors() then table.insert(cats, cfg.category.background_colors) end
if isIllegible() then table.insert(cats, cfg.category.illegible) end
if hasBorders() then table.insert(cats, cfg.category.borders) end
return cats
end

local function renderTrackingCategories(builder, border)
local title = mw.title.getCurrentTitle()
if title.namespace ~= 10 then return end -- not in template space
local subpage = title.subpageText
if subpage == cfg.keyword.subpage_doc or subpage == cfg.keyword.subpage_sandbox
or subpage == cfg.keyword.subpage_testcases then return end

for _, cat in ipairs(getTrackingCategories(border)) do
builder:wikitext('[[Category:' .. cat .. ']]')
end
end

local function renderMainTable(border, listnums)
local tbl = mw.html.create('table')
:addClass(cfg.class.nowraplinks)
:addClass(args[cfg.arg.bodyclass])

local state = args[cfg.arg.state]
if args[cfg.arg.title] and state ~= cfg.keyword.state_plain and state ~= cfg.keyword.state_off then
if state == cfg.keyword.state_collapsed then
state = cfg.class.collapsed
end
tbl
:addClass(cfg.class.collapsible)
:addClass(state or cfg.class.autocollapse)
end

tbl:css('border-spacing', 0)
if border == cfg.keyword.border_subgroup or border == cfg.keyword.border_none then
tbl
:addClass(cfg.class.navbox_subgroup)
:cssText(args[cfg.arg.bodystyle])
:cssText(args[cfg.arg.style])
else -- regular navbox - bodystyle and style will be applied to the wrapper table
tbl
:addClass(cfg.class.navbox_inner)
:css('background', 'transparent')
:css('color', 'inherit')
end
tbl:cssText(args[cfg.arg.innerstyle])

renderTitleRow(tbl)
renderAboveRow(tbl)
local listnums_size = #listnums
for i, listnum in ipairs(listnums) do
renderListRow(tbl, i, listnum, listnums_size)
end
renderBelowRow(tbl)

return tbl
end

local function add_navbox_styles(hiding_templatestyles)
local frame = mw.getCurrentFrame()
-- This is a lambda so that it doesn't need the frame as a parameter
local function add_user_styles(templatestyles)
if not isblank(templatestyles) then
return frame:extensionTag{
name = 'templatestyles', args = { src = templatestyles }
}
end
return ''
end

-- get templatestyles. load base from config so that Lua only needs to do
-- the work once of parser tag expansion
local base_templatestyles = cfg.templatestyles
local templatestyles = add_user_styles(args[cfg.arg.templatestyles])
local child_templatestyles = add_user_styles(args[cfg.arg.child_templatestyles])

-- The 'navbox-styles' div exists to wrap the styles to work around T200206
-- more elegantly. Instead of combinatorial rules, this ends up being linear
-- number of CSS rules.
return mw.html.create('div')
:addClass(cfg.class.navbox_styles)
:wikitext(
add_list_styles() .. -- see [hlist_note] applied to 'before base_templatestyles'
base_templatestyles ..
templatestyles ..
child_templatestyles ..
table.concat(hiding_templatestyles)
)
:done()
end

-- work around [[phab:T303378]]
-- for each arg: find all the templatestyles strip markers, insert them into a
-- table. then remove all templatestyles markers from the arg
local strip_marker_pattern = '(\127[^\127]*UNIQ%-%-templatestyles%-%x+%-QINU[^\127]*\127)'
local argHash = 0
for k, arg in pairs(args) do
if type(arg) == 'string' then
for marker in string.gfind(arg, strip_marker_pattern) do
table.insert(hiding_templatestyles, marker)
end
argHash = argHash + #arg
args[k] = string.gsub(arg, strip_marker_pattern, '')
end
end
if not args.argHash then args.argHash = argHash end

local listnums = {}

for k, _ in pairs(args) do
if type(k) == 'string' then
local listnum = k:match(cfg.pattern.listnum)
if listnum and args[andnum('list', tonumber(listnum))] then
table.insert(listnums, tonumber(listnum))
end
end
end
table.sort(listnums)

local border = mw.text.trim(args[cfg.arg.border] or args[1] or '')
if border == cfg.keyword.border_child then
border = cfg.keyword.border_subgroup
end

-- render the main body of the navbox
local tbl = renderMainTable(border, listnums)

local res = mw.html.create()
-- render the appropriate wrapper for the navbox, based on the border param

if border == cfg.keyword.border_none then
res:node(add_navbox_styles(hiding_templatestyles))
local nav = res:tag('div')
:attr('role', 'navigation')
:node(tbl)
-- aria-labelledby title, otherwise above, otherwise lone group
if args[cfg.arg.title] or args[cfg.arg.above] or (args[cfg.arg.group1]
and not args[cfg.arg.group2]) then
nav:attr(
'aria-labelledby',
mw.uri.anchorEncode(
args[cfg.arg.title] or args[cfg.arg.above] or args[cfg.arg.group1]
) .. args.argHash
)
else
nav:attr('aria-label', cfg.aria_label)
end
elseif border == cfg.keyword.border_subgroup then
-- We assume that this navbox is being rendered in a list cell of a
-- parent navbox, and is therefore inside a div with padding:0em 0.25em.
-- We start with a </div> to avoid the padding being applied, and at the
-- end add a <div> to balance out the parent's </div>
res
:wikitext('</div>')
:node(tbl)
:wikitext('<div>')
else
res:node(add_navbox_styles(hiding_templatestyles))
local nav = res:tag('div')
:attr('role', 'navigation')
:addClass(cfg.class.navbox)
:addClass(args[cfg.arg.navboxclass])
:cssText(args[cfg.arg.bodystyle])
:cssText(args[cfg.arg.style])
:css('padding', '3px')
:node(tbl)
-- aria-labelledby title, otherwise above, otherwise lone group
if args[cfg.arg.title] or args[cfg.arg.above]
or (args[cfg.arg.group1] and not args[cfg.arg.group2]) then
nav:attr(
'aria-labelledby',
mw.uri.anchorEncode(
args[cfg.arg.title] or args[cfg.arg.above] or args[cfg.arg.group1]
) .. args.argHash
)
else
nav:attr('aria-label', cfg.aria_label .. args.argHash)
end
end

if (args[cfg.arg.nocat] or cfg.keyword.nocat_false):lower() == cfg.keyword.nocat_false then
renderTrackingCategories(res, border)
end
return striped(tostring(res), border)
end --p._navbox

function p._withCollapsibleGroups(pargs)
-- table for args passed to navbox
local targs = {}

-- process args
local passthroughLocal = {
[cfg.arg.bodystyle] = true,
[cfg.arg.border] = true,
[cfg.arg.style] = true,
}
for k,v in pairs(pargs) do
if k and type(k) == 'string' then
if passthrough[k] or passthroughLocal[k] then
targs[k] = v
elseif (k:match(cfg.pattern.num)) then
local n = k:match(cfg.pattern.num)
local list_and_num = andnum('list', n)
if ((k:match(cfg.pattern.listnum) or k:match(cfg.pattern.contentnum))
and targs[list_and_num] == nil
and pargs[andnum('group', n)] == nil
and pargs[andnum('sect', n)] == nil
and pargs[andnum('section', n)] == nil) then
targs[list_and_num] = concatstrings({
pargs[list_and_num] or '',
pargs[andnum('content', n)] or ''
})
if (targs[list_and_num] and inArray(cfg.keyword.subgroups, targs[list_and_num])) then
targs[list_and_num] = getSubgroup(pargs, n, targs[list_and_num])
end
elseif ((k:match(cfg.pattern.groupnum) or k:match(cfg.pattern.sectnum) or k:match(cfg.pattern.sectionnum))
and targs[list_and_num] == nil) then
local titlestyle = concatstyles({
pargs[cfg.arg.groupstyle] or '',
pargs[cfg.arg.secttitlestyle] or '',
pargs[andnum('groupstyle', n)] or '',
pargs[andnum('sectiontitlestyle', n)] or ''
})
local liststyle = concatstyles({
pargs[cfg.arg.liststyle] or '',
pargs[cfg.arg.contentstyle] or '',
pargs[andnum('liststyle', n)] or '',
pargs[andnum('contentstyle', n)] or ''
})
local title = concatstrings({
pargs[andnum('group', n)] or '',
pargs[andnum('sect', n)] or '',
pargs[andnum('section', n)] or ''
})
local list = concatstrings({
pargs[list_and_num] or '',
pargs[andnum('content', n)] or ''
})
if list and inArray(cfg.keyword.subgroups, list) then
list = getSubgroup(pargs, n, list)
end
local abbr_and_num = andnum('abbr', n)
local state = (pargs[abbr_and_num] and pargs[abbr_and_num] == pargs[cfg.arg.selected])
and cfg.keyword.state_uncollapsed
or (pargs[andnum('state', n)] or cfg.keyword.state_collapsed)
targs[list_and_num] =p._navbox({
cfg.keyword.border_child,
[cfg.arg.navbar] = cfg.keyword.navbar_plain,
[cfg.arg.state] = state,
[cfg.arg.basestyle] = pargs[cfg.arg.basestyle],
[cfg.arg.title] = title,
[cfg.arg.titlestyle] = titlestyle,
[andnum('list', 1)] = list,
[cfg.arg.liststyle] = liststyle,
[cfg.arg.listclass] = pargs[andnum('listclass', n)],
[cfg.arg.image] = pargs[andnum('image', n)],
[cfg.arg.imageleft] = pargs[andnum('imageleft', n)],
[cfg.arg.listpadding] = pargs[cfg.arg.listpadding],
argHash = pargs.argHash
})
end
end
end
end
-- ordering of style and bodystyle
targs[cfg.arg.style] = concatstyles({targs[cfg.arg.style] or '', targs[cfg.arg.bodystyle] or ''})
targs[cfg.arg.bodystyle] = nil

-- child or subgroup
if targs[cfg.arg.border] == nil then targs[cfg.arg.border] = pargs[1] end

return p._navbox(targs)
end --p._withCollapsibleGroups

function p._withColumns(pargs)
-- table for args passed to navbox
local targs = {}

-- tables of column numbers
local colheadernums = {}
local colnums = {}
local colfooternums = {}

-- process args
local passthroughLocal = {
[cfg.arg.evenstyle]=true,
[cfg.arg.groupstyle]=true,
[cfg.arg.liststyle]=true,
[cfg.arg.oddstyle]=true,
[cfg.arg.state]=true,
}
for k,v in pairs(pargs) do
if passthrough[k] or passthroughLocal[k] then
targs[k] = v
elseif type(k) == 'string' then
if k:match(cfg.pattern.listnum) then
local n = k:match(cfg.pattern.listnum)
targs[andnum('liststyle', n + 2)] = pargs[andnum('liststyle', n)]
targs[andnum('group', n + 2)] = pargs[andnum('group', n)]
targs[andnum('groupstyle', n + 2)] = pargs[andnum('groupstyle', n)]
if v and inArray(cfg.keyword.subgroups, v) then
targs[andnum('list', n + 2)] = getSubgroup(pargs, n, v)
else
targs[andnum('list', n + 2)] = v
end
elseif (k:match(cfg.pattern.colheadernum) and v ~= '') then
table.insert(colheadernums, tonumber(k:match(cfg.pattern.colheadernum)))
elseif (k:match(cfg.pattern.colnum) and v ~= '') then
table.insert(colnums, tonumber(k:match(cfg.pattern.colnum)))
elseif (k:match(cfg.pattern.colfooternum) and v ~= '') then
table.insert(colfooternums, tonumber(k:match(cfg.pattern.colfooternum)))
end
end
end
table.sort(colheadernums)
table.sort(colnums)
table.sort(colfooternums)

-- HTML table for list1
local coltable = mw.html.create( 'table' ):addClass('navbox-columns-table')
local row, col

local tablestyle = ( (#colheadernums > 0) or (not isblank(pargs[cfg.arg.fullwidth])) )
and 'width:100%'
or 'width:auto; margin-left:auto; margin-right:auto'

coltable:cssText(concatstyles({
'border-spacing: 0px; text-align:left',
tablestyle,
pargs[cfg.arg.coltablestyle] or ''
}))

--- Header row ---
if (#colheadernums > 0) then
row = coltable:tag('tr')
for k, n in ipairs(colheadernums) do
col = row:tag('td'):addClass('navbox-abovebelow')
col:cssText(concatstyles({
(k > 1) and 'border-left:2px solid #fdfdfd' or '',
'font-weight:bold',
pargs[cfg.arg.colheaderstyle] or '',
pargs[andnum('colheaderstyle', n)] or ''
}))
col:attr('colspan', tonumber(pargs[andnum('colheadercolspan', n)]))
col:wikitext(pargs[andnum('colheader', n)])
end
end

--- Main columns ---
row = coltable:tag('tr'):css('vertical-align', 'top')
for k, n in ipairs(colnums) do
if k == 1 and isblank(pargs[andnum('colheader', 1)])
and isblank(pargs[andnum('colfooter', 1)])
and isblank(pargs[cfg.arg.fullwidth]) then
local nopad = inArray(
{'off', '0', '0em', '0px'},
mw.ustring.gsub(pargs[cfg.arg.padding] or '', '[;%%]', ''))
if not nopad then
row:tag('td'):wikitext('&nbsp;&nbsp;&nbsp;')
:css('width', (pargs[cfg.arg.padding] or '5em'))
end
end
col = row:tag('td'):addClass('navbox-list')
col:cssText(concatstyles({
(k > 1) and 'border-left:2px solid #fdfdfd' or '',
'padding:0px',
pargs[cfg.arg.colstyle] or '',
((n%2 == 0) and pargs[cfg.arg.evencolstyle] or pargs[cfg.arg.oddcolstyle]) or '',
pargs[andnum('colstyle', n)] or '',
'width:' .. (pargs[andnum('colwidth', n)] or pargs[cfg.arg.colwidth] or '10em')
}))
local wt = pargs[andnum('col', n)]
if wt and inArray(cfg.keyword.subgroups, wt) then
wt = getSubgroup(pargs, n, wt, cfg.arg.col_and_num)
end
col:tag('div'):newline():wikitext(wt):newline()
end

--- Footer row ---
if (#colfooternums > 0) then
row = coltable:tag('tr')
for k, n in ipairs(colfooternums) do
col = row:tag('td'):addClass('navbox-abovebelow')
col:cssText(concatstyles({
(k > 1) and 'border-left:2px solid #fdfdfd' or '',
'font-weight:bold',
pargs[cfg.arg.colfooterstyle] or '',
pargs[andnum('colfooterstyle', n)] or ''
}))
col:attr('colspan', tonumber(pargs[andnum('colfootercolspan', n)]))
col:wikitext(pargs[andnum('colfooter', n)])
end
end

-- assign table to list1
targs[andnum('list', 1)] = tostring(coltable)
if isblank(pargs[andnum('colheader', 1)])
and isblank(pargs[andnum('col', 1)])
and isblank(pargs[andnum('colfooter', 1)]) then
targs[andnum('list', 1)] = targs[andnum('list', 1)] ..
cfg.category.without_first_col
end

-- Other parameters
targs[cfg.arg.border] = pargs[cfg.arg.border] or pargs[1]
targs[cfg.arg.evenodd] = (not isblank(pargs[cfg.arg.evenodd])) and pargs[cfg.arg.evenodd] or nil
targs[cfg.arg.list1padding] = '0px'
targs[andnum('liststyle', 1)] = 'background:transparent;color:inherit;'
targs[cfg.arg.style] = concatstyles({pargs[cfg.arg.style], pargs[cfg.arg.bodystyle]})
targs[cfg.arg.tracking] = 'no'
return p._navbox(targs)
end --p._withColumns

-- Template entry points
function p.navbox (frame, boxtype)
local function readArgs(args, prefix)
-- Read the arguments in the order they'll be output in, to make references
-- number in the right order.
local _ = 0
_ = _ + (args[prefix .. cfg.arg.title] and #args[prefix .. cfg.arg.title] or 0)
_ = _ + (args[prefix .. cfg.arg.above] and #args[prefix .. cfg.arg.above] or 0)
-- Limit this to 20 as covering 'most' cases (that's a SWAG) and because
-- iterator approach won't work here
for i = 1, 20 do
_ = _ + (args[prefix .. andnum('group', i)] and #args[prefix .. andnum('group', i)] or 0)
if inArray(cfg.keyword.subgroups, args[prefix .. andnum('list', i)]) then
for _, v in ipairs(cfg.arg.subgroups_and_num) do
readArgs(args, prefix .. string.format(v, i) .. "_")
end
readArgs(args, prefix .. andnum('col', i) .. "_")
end
end
_ = _ + (args[prefix .. cfg.arg.below] and #args[prefix .. cfg.arg.below] or 0)
return _
end

if not getArgs then
getArgs = require('Module:Arguments').getArgs
end
local args = getArgs(frame, {wrappers = {cfg.pattern[boxtype or 'navbox']}})
args.argHash = readArgs(args, "")
args.type = args.type or cfg.keyword[boxtype]
return p['_navbox'](args)
end
end

p[cfg.keyword.with_collapsible_groups] = function (frame)
function p.navbox(frame)
return p.navbox(frame, 'with_collapsible_groups')
-- ParserFunctions considers the empty string to be false, so to preserve the previous
-- behavior of {{navbox}}, change any empty arguments to nil, so Lua will consider
-- them false too.
local args = {}
for k, v in pairs(frame:getParent().args) do
if v ~= '' then
args[k] = v
end
end
return p._navbox(args)
end
end

p[cfg.keyword.with_columns] = function (frame)
function p.navbar(frame)
return p.navbox(frame, 'with_columns')
-- ParserFunctions considers the empty string to be false, so to preserve the previous
-- behavior of {{navbox}}, change any empty arguments to nil, so Lua will consider
-- them false too.
local args = {}
for k, v in pairs(frame:getParent().args) do
if v ~= '' then
args[k] = v
end
end
local div = HtmlBuilder.create('div')
return tostring( formNavBar( div, args ) )
end
end

return p
return p
Retrieved from "https://testwiki.wiki/wiki/Module:Navbox"