Wikipedia

Module:Navbox/sandbox: Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
add a note in case someone wants to hack on this in the mean time and is inclined to sync things from the main module first............
Tag: Reverted
sandbox config
 
(87 intermediate revisions by 10 users not shown)
Line 1:
require('strict')
--[[
The changes removing titlegroup are safe to sync but I'm waiting for the
CSS removal from Common.css (Jan 3) to take effect before rolling out. That way
we can maybe avoid many confused users.
]]
 
local p = {}
local navbarcfg = requiremw.loadData('Module:NavbarNavbox/configuration/sandbox')._navbar
local cfginArray = mw.loadDatarequire('"Module:Navbox/configuration'TableTools").inArray
local getArgs -- lazily initialized
local hiding_templatestyles = {}
local args
local format = string.format
 
-- global passthrough variables
local function striped(wikitext, border)
local passthrough = {
-- Return wikitext with markers replaced for odd/even striping.
[cfg.arg.above]=true,[cfg.arg.aboveclass]=true,[cfg.arg.abovestyle]=true,
-- Child (subgroup) navboxes are flagged with a category that is removed
[cfg.arg.basestyle]=true,
-- by parent navboxes. The result is that the category shows all pages
[cfg.arg.below]=true,[cfg.arg.belowclass]=true,[cfg.arg.belowstyle]=true,
-- where a child navbox is not contained in a parent navbox.
[cfg.arg.bodyclass]=true,
local orphanCat = cfg.category.orphan
[cfg.arg.groupclass]=true,
if border == cfg.keyword.border_subgroup and args[cfg.arg.orphan] ~= cfg.keyword.orphan_yes then
[cfg.arg.image]=true,[cfg.arg.imageclass]=true,[cfg.arg.imagestyle]=true,
-- No change; striping occurs in outermost navbox.
[cfg.arg.imageleft]=true,[cfg.arg.imageleftstyle]=true,
return wikitext .. orphanCat
[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
local andnum = function(s, n) return string.format(cfg.arg[s .. '_and_num'], n) end
local isblank = function(v) return (v or '') == '' end
 
local function concatstrings(s)
local r = table.concat(s, '')
if r:match('^%s*$') then return nil end
return r
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
local first, second = cfg.class.navbox_odd_part, cfg.class.navbox_even_part
return r
if args[cfg.arg.evenodd] then
end
if args[cfg.arg.evenodd] == cfg.keyword.evenodd_swap then
 
first, second = second, first
local function getSubgroup(args, listnum, listText, prefix)
else
local subArgs = {
first = args[cfg.arg.evenodd]
[cfg.arg.border] = cfg.keyword.border_subgroup,
second = first
[cfg.arg.navbar] = cfg.keyword.navbar_plain,
end
argHash = 0
end
}
local changer
local hasSubArgs = false
if first == second then
local subgroups_and_num = prefix and {prefix} or cfg.arg.subgroups_and_num
changer = first
for k, v in pairs(args) do
else
k = tostring(k)
local index = 0
for _, w in ipairs(subgroups_and_num) do
changer = function (code)
w = string.format(w, listnum) .. "_"
if code == '0' then
if (#k > #w) and (k:sub(1, #w) == w) then
-- Current occurrence is for a group before a nested table.
subArgs[k:sub(#w + 1)] = v
-- Set it to first as a valid although pointless class.
hasSubArgs = true
-- The next occurrence will be the first row after a title
subArgs.argHash = subArgs.argHash + (v and #v or 0)
-- 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
return hasSubArgs and p._navbox(subArgs) or listText
local regex = orphanCat:gsub('([%[%]])', '%%%1')
return (wikitext:gsub(regex, ''):gsub(cfg.marker.regex, changer)) -- () omits gsub count
end
 
-- Main functions
local function processItem(item, nowrapitems)
function p._navbox(args)
if item:sub(1, 2) == '{|' then
if args.type == cfg.keyword.with_collapsible_groups then
-- Applying nowrap to lines in a table does not make sense.
return p._withCollapsibleGroups(args)
-- Add newlines to compensate for trim of x in |parm=x in a template.
elseif args.type == cfg.keyword.with_columns then
return '\n' .. item ..'\n'
return p._withColumns(args)
end
 
if nowrapitems == cfg.keyword.nowrapitems_yes then
local function striped(wikitext, border)
local lines = {}
-- Return wikitext with markers replaced for odd/even striping.
for line in (item .. '\n'):gmatch('([^\n]*)\n') do
-- Child (subgroup) navboxes are flagged with a category that is removed
local prefix, content = line:match('^([*:;#]+)%s*(.*)')
-- by parent navboxes. The result is that the category shows all pages
if prefix and not content:match(cfg.pattern.nowrap) then
-- where a child navbox is not contained in a parent navbox.
line = format(cfg.nowrap_item, prefix, content)
local orphanCat = cfg.category.orphan
if border == cfg.keyword.border_subgroup and args[cfg.arg.orphan] ~= cfg.keyword.orphan_yes then
-- No change; striping occurs in outermost navbox.
return wikitext .. orphanCat
end
local first, second = cfg.class.navbox_odd_part, cfg.class.navbox_even_part
if args[cfg.arg.evenodd] then
if args[cfg.arg.evenodd] == cfg.keyword.evenodd_swap then
first, second = second, first
else
first = args[cfg.arg.evenodd]
second = first
end
table.insert(lines, line)
end
local changer
item = table.concat(lines, '\n')
if first == second then
changer = first
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
 
if item:match('^[*:;#]') then
local function processItem(item, nowrapitems)
return '\n' .. item ..'\n'
if item:sub(1, 2) == '{|' then
-- Applying nowrap to lines in a table does not make sense.
-- Add newlines to compensate for trim of x in |parm=x in a template.
return '\n' .. item .. '\n'
end
if nowrapitems == cfg.keyword.nowrapitems_yes then
local lines = {}
for line in (item .. '\n'):gmatch('([^\n]*)\n') do
local prefix, content = line:match('^([*:;#]+)%s*(.*)')
if prefix and not content:match(cfg.pattern.nowrap) then
line = string.format(cfg.nowrap_item, prefix, content)
end
table.insert(lines, line)
end
item = table.concat(lines, '\n')
end
if item:match('^[*:;#]') then
return '\n' .. item .. '\n'
end
return item
end
return item
end
 
local function has_navbar()
-- we will want this later when we want to add tstyles for hlist/plainlist
return args[cfg.arg.navbar] ~= cfg.keyword.navbar_off
local function has_navbar()
return and args[cfg.arg.navbar] ~= cfg.keyword.navbar_offnavbar_plain
and (
and args[cfg.arg.navbar] ~= cfg.keyword.navbar_plain
args[cfg.arg.name]
and (
or mw.getCurrentFrame():getParent():getTitle():gsub(cfg.pattern.sandbox, '')
args[cfg.arg.name]
~= cfg.pattern.navbox
or mw.getCurrentFrame():getParent():getTitle():gsub(cfg.pattern.sandbox, '')
)
~= cfg.pattern.navbox
end
)
end
 
-- extract text color from css, which is the only permitted inline CSS for the navbar
local function renderNavBar(titleCell)
local function extract_color(css_str)
if has_navbar() then
-- return nil because navbar takes its argument into mw.html which handles
titleCell:wikitext(navbar{
-- nil gracefully, removing the associated style attribute
[cfg.navbar.name] = args[cfg.arg.name],
return mw.ustring.match(';' .. css_str .. ';', '.*;%s*([Cc][Oo][Ll][Oo][Rr]%s*:%s*.-)%s*;') or nil
[cfg.navbar.mini] = 1,
[cfg.navbar.fontstyle] = (args[cfg.arg.basestyle] or '') .. ';' ..
(args[cfg.arg.titlestyle] or '') ..
';background:none transparent;border:none;box-shadow:none;padding:0;'
})
end
 
local function renderNavBar(titleCell)
end
if has_navbar() then
local navbar = require('Module:Navbar')._navbar
titleCell:wikitext(navbar{
[cfg.navbar.name] = args[cfg.arg.name],
[cfg.navbar.mini] = 1,
[cfg.navbar.fontstyle] = extract_color(
(args[cfg.arg.basestyle] or '') .. ';' .. (args[cfg.arg.titlestyle] or '')
)
})
end
 
end
local function renderTitleRow(tbl)
if not args[cfg.arg.title] then return end
 
local titleRow =function renderTitleRow(tbl:tag('tr')
if not args[cfg.arg.title] then return end
 
local titleCelltitleRow = titleRowtbl:tag('th'):attr('scope', 'coltr')
 
local titleCell = titleRow:tag('th'):attr('scope', 'col')
local titleColspan = 2
if args[cfg.arg.imageleft] then titleColspan = titleColspan + 1 end
if args[cfg.arg.image] then titleColspan = titleColspan + 1 end
 
local titleColspan = 2
titleCell
:cssText(if args[cfg.arg.basestyleimageleft]) then titleColspan = titleColspan + 1 end
:cssText(if args[cfg.arg.titlestyleimage]) then titleColspan = titleColspan + 1 end
:addClass(cfg.class.navbox_title)
:attr('colspan', titleColspan)
 
renderNavBar( titleCell)
:cssText(args[cfg.arg.basestyle])
:cssText(args[cfg.arg.titlestyle])
:addClass(cfg.class.navbox_title)
:attr('colspan', titleColspan)
 
renderNavBar(titleCell)
:tag('div')
-- id for aria-labelledby attribute
:attr('id', mw.uri.anchorEncode(args[cfg.arg.title]))
:addClass(args[cfg.arg.titleclass])
:css('font-size', '114%')
:css('margin', '0 4em')
:wikitext(processItem(args[cfg.arg.title]))
end
 
titleCell
local function getAboveBelowColspan()
local ret = 2
if args[cfg.arg.imageleft] then ret = ret + 1 end
if args[cfg.arg.image] then ret = ret + 1 end
return ret
end
 
local function renderAboveRow(tbl)
if not args[cfg.arg.above] then return end
 
tbl:tag('tr')
:tag('td')
:addClass(cfg.class.navbox_abovebelow)
:addClass(args[cfg.arg.aboveclass])
:cssText(args[cfg.arg.basestyle])
:cssText(args[cfg.arg.abovestyle])
:attr('colspan', getAboveBelowColspan())
:tag('div')
-- id for aria-labelledby attribute, if no title
:attr('id', args[cfg.arg.title] and nil or mw.uri.anchorEncode(args[cfg.arg.abovetitle]) .. args.argHash)
:wikitextaddClass(processItem(args[cfg.arg.above], args[cfg.arg.nowrapitemstitleclass]))
:css('font-size', '114%')
end
:css('margin', '0 4em')
:wikitext(processItem(args[cfg.arg.title]))
end
 
local function renderBelowRowgetAboveBelowColspan(tbl)
local ret = 2
if not args[cfg.arg.below] then return end
if args[cfg.arg.imageleft] then ret = ret + 1 end
if args[cfg.arg.image] then ret = ret + 1 end
return ret
end
 
local function renderAboveRow(tbl)
tbl:tag('tr')
if not args[cfg.arg.above] then return end
:tag('td')
 
:addClass(cfg.class.navbox_abovebelow)
tbl:tag('tr')
:addClass(args[cfg.arg.belowclass])
:tag('td')
:cssText(args[cfg.arg.basestyle])
:cssTextaddClass(args[cfg.argclass.belowstyle]navbox_abovebelow)
:addClass(args[cfg.arg.aboveclass])
:attr('colspan', getAboveBelowColspan())
:cssText(args[cfg.arg.basestyle])
:tag('div')
:wikitextcssText(processItem(args[cfg.arg.below], args[cfg.arg.nowrapitemsabovestyle]))
:attr('colspan', getAboveBelowColspan())
end
:tag('div')
-- id for aria-labelledby attribute, if no title
:attr('id', (not args[cfg.arg.title]) and
(mw.uri.anchorEncode(args[cfg.arg.above]) .. args.argHash)
or nil)
:wikitext(processItem(args[cfg.arg.above], args[cfg.arg.nowrapitems]))
end
 
local function renderListRowrenderBelowRow(tbl, index, listnum, listnums_size)
if not args[cfg.arg.below] then return end
local row = tbl:tag('tr')
 
tbl:tag('tr')
if index == 1 and args[cfg.arg.imageleft] then
row
:tag('td')
:addClass(cfg.class.noviewernavbox_abovebelow)
:addClass(args[cfg.classarg.navbox_imagebelowclass])
:addClasscssText(args[cfg.arg.imageclassbasestyle])
:cssText(args[cfg.arg.belowstyle])
:css('width', '1px') -- Minimize width
:cssattr('paddingcolspan', '0 2px 0 0'getAboveBelowColspan())
:cssText(args[cfg.arg.imageleftstyle])
:attr('rowspan', listnums_size)
:tag('div')
:wikitext(processItem(args[cfg.arg.imageleftbelow], args[cfg.arg.nowrapitems]))
end
 
local group_and_numfunction = formatrenderListRow(cfg.arg.group_and_numtbl, index, listnum, listnums_size)
local row = tbl:tag('tr')
local groupstyle_and_num = format(cfg.arg.groupstyle_and_num, listnum)
 
if args[group_and_num] then
if index == 1 and args[cfg.arg.imageleft] then
local groupCell = row:tag('th')
row
:tag('td')
:addClass(cfg.class.noviewer)
:addClass(cfg.class.navbox_image)
:addClass(args[cfg.arg.imageclass])
:css('width', '0px') -- 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)
local groupstyle_and_num = andnum('groupstyle', listnum)
if args[group_and_num] then
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
 
-- 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('idscope', mw.uri.anchorEncode(args[cfg.arg.group1])'row')
:addClass(cfg.class.navbox_group)
:addClass(args[cfg.arg.groupclass])
:cssText(args[cfg.arg.basestyle])
-- If groupwidth not specified, minimize width
:css('width', args[cfg.arg.groupwidth] or '1%')
 
groupCell
:cssText(args[cfg.arg.groupstyle])
:cssText(args[groupstyle_and_num])
:wikitext(args[group_and_num])
end
 
local listCell = row:tag('td')
groupCell
:attr('scope', 'row')
:addClass(cfg.class.navbox_group)
:addClass(args[cfg.arg.groupclass])
:cssText(args[cfg.arg.basestyle])
-- If groupwidth not specified, minimize width
:css('width', args[cfg.arg.groupwidth] or '1%')
 
if args[group_and_num] then
groupCell
listCell
:cssText(args[cfg.arg.groupstyle])
:addClass(cfg.class.navbox_list_with_group)
:cssText(args[groupstyle_and_num])
else
:wikitext(args[group_and_num])
listCell:attr('colspan', 2)
end
end
 
if not args[cfg.arg.groupwidth] then
local listCell = row:tag('td')
listCell:css('width', '100%')
end
 
local rowstyle -- usually nil so cssText(rowstyle) usually adds nothing
if args[group_and_num] then
if index % 2 == 1 then
listCell
rowstyle = args[cfg.arg.oddstyle]
:addClass(cfg.class.navbox_list_with_group)
else
rowstyle = args[cfg.arg.evenstyle]
listCell:attr('colspan', 2)
end
 
local list_and_num = andnum('list', listnum)
if not args[cfg.arg.groupwidth] then
local listText = inArray(cfg.keyword.subgroups, args[list_and_num])
listCell:css('width', '100%')
and getSubgroup(args, listnum, args[list_and_num]) or args[list_and_num]
end
 
local oddEven = cfg.marker.oddeven
local rowstyle -- usually nil so cssText(rowstyle) usually adds nothing
if indexlistText:sub(1, % 212) == 1'</div><table' then
-- Assume list text is for a subgroup navbox so no automatic striping for this row.
rowstyle = args[cfg.arg.oddstyle]
oddEven = listText:find(cfg.pattern.navbox_title) and cfg.marker.restart or cfg.class.navbox_odd_part
else
end
rowstyle = args[cfg.arg.evenstyle]
end
 
local list_and_numliststyle_and_num = formatandnum(cfg.arg.list_and_num'liststyle', listnum)
local listclass_and_num = andnum('listclass', listnum)
local listText = args[list_and_num]
listCell
local oddEven = cfg.marker.oddeven
:css('padding', '0')
if listText:sub(1, 12) == '</div><table' then
:cssText(args[cfg.arg.liststyle])
-- Assume list text is for a subgroup navbox so no automatic striping for this row.
:cssText(rowstyle)
oddEven = listText:find(cfg.pattern.navbox_title) and cfg.marker.restart or cfg.class.navbox_odd_part
: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', '0px') -- 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 liststyle_and_num = format(cfg.arg.liststyle_and_num, listnum)
local patterns = {
local listclass_and_num = format(cfg.arg.listclass_and_num, listnum)
'^' .. htmlclass .. '$',
listCell
'%s' .. htmlclass .. '$',
:css('padding', '0')
'^' .. htmlclass .. '%s',
:cssText(args[cfg.arg.liststyle])
'%s' .. htmlclass .. '%s'
: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]))
 
for arg, _ in pairs(args) do
if index == 1 and args[cfg.arg.image] then
if type(arg) == 'string' and mw.ustring.find(arg, cfg.pattern.class) then
row
for _, pattern in ipairs(patterns) do
:tag('td')
if mw.ustring.find(args[arg] or '', pattern) then
:addClass(cfg.class.noviewer)
return true
:addClass(cfg.class.navbox_image)
end
:addClass(args[cfg.arg.imageclass])
end
:css('width', '1px') -- Minimize width
end
:css('padding', '0 0 0 2px')
end
:cssText(args[cfg.arg.imagestyle])
return false
:attr('rowspan', listnums_size)
:tag('div')
:wikitext(processItem(args[cfg.arg.image]))
end
end
 
-- there are a lot of list classes in the wild, so we add their TemplateStyles
-- uses this now to make the needHlistCategory correct
local function add_list_styles()
-- to use later for when we add list styles via navbox
local frame = mw.getCurrentFrame()
local function has_list_class(htmlclass)
local function add_list_templatestyles(htmlclass, templatestyles)
local class_args = { -- rough order of probability of use
if has_list_class(htmlclass) then
cfg.arg.bodyclass, cfg.arg.listclass, cfg.arg.aboveclass,
return frame:extensionTag{
cfg.arg.belowclass, cfg.arg.titleclass, cfg.arg.navboxclass,
name = 'templatestyles', args = { src = templatestyles }
cfg.arg.groupclass, cfg.arg.imageclass
}
}
else
local patterns = {
return ''
'^' .. htmlclass .. '$',
'%s' .. htmlclass .. '$',
'^' .. htmlclass .. '%s',
'%s' .. htmlclass .. '%s'
}
for _, arg in ipairs(class_args) do
for _, pattern in ipairs(patterns) do
if mw.ustring.find(args[arg] or '', pattern) then
return true
end
end
end
return false
end
 
local hlist_styles = add_list_templatestyles('hlist', cfg.hlist_templatestyles)
local function needsHorizontalLists(border)
local plainlist_styles = add_list_templatestyles('plainlist', cfg.plainlist_templatestyles)
if border == cfg.keyword.border_subgroup or args[cfg.arg.tracking] == cfg.keyword.tracking_no then
 
return false
-- 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
return not has_list_class(cfg.pattern.hlist) and not has_list_class(cfg.pattern.plainlist)
end
 
local function hasBackgroundColorsneedsHorizontalLists(border)
if border == cfg.keyword.border_subgroup or args[cfg.arg.tracking] == cfg.keyword.tracking_no then
for _, key in ipairs({cfg.arg.titlestyle, cfg.arg.groupstyle,
return false
cfg.arg.basestyle, cfg.arg.abovestyle, cfg.arg.belowstyle}) do
if tostring(args[key]):find('background', 1, true) then
return true
end
return not has_list_class(cfg.pattern.hlist) and not has_list_class(cfg.pattern.plainlist)
end
return false
end
 
local function hasBordershasBackgroundColors()
for _, key in ipairs({cfg.arg.groupstyletitlestyle, cfg.arg.basestylegroupstyle,
cfg.arg.basestyle, cfg.arg.abovestyle, cfg.arg.belowstyle}) do
if tostring(args[key]):find('borderbackground', 1, true) then
return true
end
end
return false
end
return false
end
 
local function isIllegiblehasBorders()
for _, key in ipairs({cfg.arg.groupstyle, cfg.arg.basestyle,
local styleratio = require('Module:Color contrast')._styleratio
cfg.arg.abovestyle, cfg.arg.belowstyle}) do
for key, style in pairs(args) do
if tostring(args[key]):matchfind(cfg.pattern.style'border', 1, true) then
if styleratio{mw.text.unstripNoWiki(style)} < 4.5 then
return true
end
end
return false
end
return false
end
 
local function getTrackingCategoriesisIllegible(border)
local styleratio = require('Module:Color contrast')._styleratio
local cats = {}
for key, style in pairs(args) do
if needsHorizontalLists(border) then table.insert(cats, cfg.category.horizontal_lists) end
if tostring(key):match(cfg.pattern.style) then
if hasBackgroundColors() then table.insert(cats, cfg.category.background_colors) end
if styleratio{mw.text.unstripNoWiki(style)} < 4.5 then
if isIllegible() then table.insert(cats, cfg.category.illegible) end
return true
if hasBorders() then table.insert(cats, cfg.category.borders) end
end
return cats
end
end
 
return false
local function renderTrackingCategories(builder, border)
end
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
 
forlocal _,function cat in ipairs(getTrackingCategories(border)) do
local cats = {}
builder:wikitext('[[Category:' .. cat .. ']]')
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
end
 
local function renderMainTablerenderTrackingCategories(borderbuilder, listnumsborder)
local tbltitle = mw.htmltitle.creategetCurrentTitle('table')
if title.namespace ~= 10 then return end -- not in template space
:addClass(cfg.class.nowraplinks)
local subpage = title.subpageText
:addClass(args[cfg.arg.bodyclass])
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
local state = args[cfg.arg.state]
builder:wikitext('[[Category:' .. cat .. ']]')
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
 
local function renderMainTable(border, listnums)
tbl:css('border-spacing', 0)
local tbl = mw.html.create('table')
if border == cfg.keyword.border_subgroup or border == cfg.keyword.border_none then
:addClass(cfg.class.nowraplinks)
tbl
:addClass(args[cfg.classarg.navbox_subgroupbodyclass])
: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])
 
local state = args[cfg.arg.state]
renderTitleRow(tbl)
if args[cfg.arg.title] and state ~= cfg.keyword.state_plain and state ~= cfg.keyword.state_off then
renderAboveRow(tbl)
if state == cfg.keyword.state_collapsed then
local listnums_size = #listnums
state = cfg.class.collapsed
for i, listnum in ipairs(listnums) do
end
renderListRow(tbl, i, listnum, listnums_size)
tbl
end
:addClass(cfg.class.collapsible)
renderBelowRow(tbl)
:addClass(state or cfg.class.autocollapse)
end
 
tbl:css('border-spacing', 0)
return tbl
if border == cfg.keyword.border_subgroup or border == cfg.keyword.border_none then
end
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)
local function add_navbox_styles()
renderAboveRow(tbl)
local frame = mw.getCurrentFrame()
local listnums_size = #listnums
-- This is a lambda so that it doesn't need the frame as a parameter
for i, listnum in ipairs(listnums) do
local function add_user_styles(templatestyles)
renderListRow(tbl, i, listnum, listnums_size)
if templatestyles and templatestyles ~= '' then
return frame:extensionTag{
name = 'templatestyles', args = { src = templatestyles }
}
end
renderBelowRow(tbl)
return ''
 
return tbl
end
 
local function add_navbox_styles(hiding_templatestyles)
-- get templatestyles. load base from config so that Lua only needs to do
local frame = mw.getCurrentFrame()
-- the work once of parser tag expansion
-- This is a lambda so that it doesn't need the frame as a parameter
local base_templatestyles = cfg.templatestyles
local templatestyles =function add_user_styles(args[cfg.arg.templatestyles])
if not isblank(templatestyles) then
local child_templatestyles = add_user_styles(args[cfg.arg.child_templatestyles])
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 'navbox-styles' div exists for two reasons:
-- 1. To wrap the styles to work aroundonce T200206of moreparser elegantly.tag Insteadexpansion
local base_templatestyles = cfg.templatestyles
-- of combinatorial rules, this ends up being linear number of CSS rules.
local templatestyles = add_user_styles(args[cfg.arg.templatestyles])
-- 2. To allow MobileFrontend to rip the styles out with 'nomobile' such that
local child_templatestyles = add_user_styles(args[cfg.arg.child_templatestyles])
-- they are not dumped into the mobile view.
 
return mw.html.create('div')
-- The 'navbox-styles' div exists to wrap the styles to work around T200206
:addClass(cfg.class.navbox_styles)
-- more elegantly. Instead of combinatorial rules, this ends up being linear
:addClass(cfg.class.nomobile)
-- number of CSS rules.
:wikitext(base_templatestyles .. templatestyles .. child_templatestyles)
return mw.html.create('div')
:done()
:addClass(cfg.class.navbox_styles)
end
: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
 
function p._navbox(navboxArgs)
args = navboxArgs
local listnums = {}
 
Line 430 ⟶ 546:
if type(k) == 'string' then
local listnum = k:match(cfg.pattern.listnum)
if listnum thenand table.insertargs[andnum(listnums'list', tonumber(listnum))] endthen
table.insert(listnums, tonumber(listnum))
end
end
end
Line 447 ⟶ 565:
 
if border == cfg.keyword.border_none then
res:node(add_navbox_styles(hiding_templatestyles))
local nav = res:tag('div')
:attr('role', 'navigation')
Line 458 ⟶ 576:
mw.uri.anchorEncode(
args[cfg.arg.title] or args[cfg.arg.above] or args[cfg.arg.group1]
) .. args.argHash
)
else
Line 473 ⟶ 591:
:wikitext('<div>')
else
res:node(add_navbox_styles(hiding_templatestyles))
local nav = res:tag('div')
:attr('role', 'navigation')
Line 480 ⟶ 598:
:cssText(args[cfg.arg.bodystyle])
:cssText(args[cfg.arg.style])
:css('padding', '3px0px')
:node(tbl)
-- aria-labelledby title, otherwise above, otherwise lone group
Line 487 ⟶ 605:
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
Line 498 ⟶ 618:
end
return striped(tostring(res), border)
end --p._navbox
end
 
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
 
function p.navbox(frame)
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
 
p[cfg.keyword.with_collapsible_groups] = function (frame)
-- Read the arguments in the order they'll be output in, to make references
return p.navbox(frame, 'with_collapsible_groups')
-- number in the right order.
end
local _
_ = args[cfg.arg.title]
_ = args[cfg.arg.above]
-- 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[format(cfg.arg.group_and_num, i)]
_ = args[format(cfg.arg.list_and_num, i)]
end
_ = args[cfg.arg.below]
 
p[cfg.keyword.with_columns] = function (frame)
return p._navbox(args)
return p.navbox(frame, 'with_columns')
end
 
Retrieved from "https://en.wikipedia.org/wiki/Module:Navbox/sandbox"