Module:Track gauge/autodocument
 | This module depends on the following other modules: |
 | This module uses TemplateStyles: |
This module documents the Track gauge/data data page of {{Track gauge}}. Its main product is Template:Track gauge/doc/input options.
Gauges
[edit]documentGauge
Can list in complete tableform one, multiple or all gauges listed in the /data page. Gauges defined in both metric and imperial are grouped into one row.
Per gauge size a link to the category:Articles that mentions this gauge ... is added.
#invoke functions
[edit]checkData documentGauge catContent catMentions createCatMentions documentGaugeSizeFromTitle catSortFromTitle
Parameters
[edit]|1= alias |1<!--???-->= (datafile for checkData) |n=all (list) |docfrom= |docto= |doctitle= |docstate= |docstats= |displaynotfound= |docsortlabel= |docreturnargs=
Parser limits (expensive functions)
[edit]Module:Track gauge/autodocument uses expensive function calls (especially the documentGauge listing). The wiki parser only allows 500 such calls in one page. As of July 2014, this number is almost reached in (~475 in Template:Track gauge/doc/input options). When, after adding new entries to /data or /extra, the number is reached, a "Script error" will show.
Best practice is to prevent this error: adding content category name to the /data, even if they have default name pattern or do not exist:
["contentcat"] = "5 ft 3 in gauge railways",
-- or
["contentcat"] = "",
This way, these category pages are not checked for existence.
See also
[edit]
-- This module documents the track gauges
-- as defined in [[module:Track gauge/data]].
-- General note: "id" is the size-id (in mm). With this id, definitions can vary (mm, ft/in, name)
-- Alias (the normalised input value) is the primary search term
local p = {}
local getArgs = require('Module:Arguments').getArgs
local modMath = require('Module:Math')
local modTrackGauge = require('Module:Track gauge') -- /andbox here
local dataPageName = 'Module:Track gauge/data' -- /sandbox here
local gaugeDataAll = nil
local tableTools = require('Module:tableTools')
-- global counters (to keep between the id-row building calls)
local ttlSizeClassCount = {}
local ttlAliasCount = 0
local ttlEntries = 0
local ttlUnitCount = {}
local ttlAltNameCount = 0
local ttlAltName = {}
local ttlLinkCount = 0
local ttlContentCatsCount = 0
local ttlMentioningCatsCount = 0
local ttlMentioningPageCount = 0
local ttlListedRange = {}
-----------------------------------------------------------------------------------
-- prepareArgs -- Arguments coming from an #invoke or from a module
-----------------------------------------------------------------------------------
local function prepareArgs(frame)
local origArgs = getArgs(frame)
-- Trim whitespace, make lower-case and remove blank arguments for all arguments
-- searchAlias is the cleaned value of [1]. [1] is kept as rawInput for error message
local args = {}
args['searchAlias'] = ''
args['rawInput'] = origArgs[1] or ''
for k, v in pairs(origArgs) do
if tonumber(k) == nil then
-- Named argument
if k == 'docsortlabel' then -- not in TG
args[k] = v
else
args[k] = mw.ustring.lower(v)
end
else
-- Unnamed argument, alias to be searched
args[k] = modTrackGauge.normaliseAliasInput(v)
if k == 1 then
args['searchAlias'] = args[1]
end
end
end
return args
end
-----------------------------------------------------------------------------------
-- formatUnitPlaintext
-- Pattern '00016.5 mm' for table.sort and catsort.
-----------------------------------------------------------------------------------
local function formatUnitPlaintext(tgEntry, unit, fmtZeroPadding, toFracChar)
-- Returns plaintext (ASCII) only. No css.
if tgEntry == nil then
return ''
end
if (unit or tgEntry.def) == 'imp' then
-- imperial
local ft = ''
local inch = ''
local frac = ''
if tgEntry.ft then
ft = tgEntry.ft .. ' ft'
end
if tgEntry.num then
frac = ' ' .. tgEntry.num .. '/' .. tgEntry.den
if toFracChar then
-- as used in contentCat pagenames
if frac == ' 1/8' then frac = '⅛'
elseif frac == ' 1/4' then frac = '¼'
elseif frac == ' 3/8' then frac = '⅜'
elseif frac == ' 1/2' then frac = '½'
elseif frac == ' 3/4' then frac = '¾'
elseif frac == ' 7/8' then frac = '⅞'
else
frac = frac .. ' (error: fraction character missing in module:Track gauge)'
end
end
if tgEntry['in'] then
frac = ' ' .. tgEntry['in'] .. frac .. ' in'
else
frac = ' ' .. frac .. ' in'
end
else
if tgEntry['in'] then
inch = ' ' .. tgEntry['in'] .. ' in'
end
end
return mw.text.trim(ft .. inch .. frac)
else
-- metric (mm)
if fmtZeroPadding == nil or tonumber(fmtZeroPadding) <= 0 then
return tgEntry.id .. ' mm'
else
return string.rep('0', fmtZeroPadding - math.floor(math.log10(tonumber(tgEntry.id))) - 1)
.. tgEntry.id .. ' mm'
end
end
end
-----------------------------------------------------------------------------------
-- document data-sort-value
-----------------------------------------------------------------------------------
local function documentdatasortvalue(tgEntry)
local s = formatUnitPlaintext(tgEntry, 'met', 5)
return tostring(mw.html.create():tag('span'):attr('data-sort-value', s))
end
-----------------------------------------------------------------------------------
-- catSortFromTitle
-- Currently finds "600 mm" when at end of title, then returns "0600 mm" (for catSort).
-- Blank when not found. Used for cat:mentions category page.
-----------------------------------------------------------------------------------
function p.catSortFromTitle()
local title = mw.title.getCurrentTitle()
local catSort = string.match(title.text, '%s(%d+%.?%d*)%smm$') or ''
if catSort ~= '' then
catSort = string.rep('0', 4 - math.floor(math.log10(tonumber(catSort))) - 1)
.. catSort .. ' mm'
end
if catSort == '' then
return '*'
else
return catSort
end
end
-----------------------------------------------------------------------------------
-- documentGaugeClass
-----------------------------------------------------------------------------------
local function documentGaugeClass(tgEntry, countMentionings)
local size = tonumber(tgEntry.id or 0)
local j
if size > 1435 then
j = 5
elseif size == 1435 then
j = 4
elseif size > 500 then
j = 3
elseif size >= 100 then
j = 2
elseif size > 0 then
j = 1
else
j = 6
end
ttlSizeClassCount[j][2] = ttlSizeClassCount[j][2] +1
ttlSizeClassCount[j][4] = ttlSizeClassCount[j][4] + (countMentionings or 0)
return '<span data-sort-value="' .. j .. '">' .. ttlSizeClassCount[j][1] .. '</span>' --(20190920: linter closing span added)
end
-----------------------------------------------------------------------------------
-- anchor -- Anchor text *here* is: <span id="1000 mm">; anchor *there* should be: #1000 mm.
-----------------------------------------------------------------------------------
local function anchor(tgEntry, unit, herethere)
if tgEntry == nil then
return ''
end
unit = unit or tgEntry.def1
local anch = formatUnitPlaintext(tgEntry, unit, 0)
if herethere == 'there' then -- Untested, April 2014
anch = '#' .. anch
else
anch = mw.html.create():tag('span'):attr('id', anch)
end
return tostring(anch)
end
-----------------------------------------------------------------------------------
-- noWrap -- Add span tags to prevent a string from wrapping.
-----------------------------------------------------------------------------------
local function noWrap(s)
return mw.ustring.format('<span class="nowrap">%s</span>', s)
end
-----------------------------------------------------------------------------------
-- frac -- A slimmed-down version of the {{frac}} template (a single nowrap to be added with the unit)
-----------------------------------------------------------------------------------
local function frac(whole, num, den)
local templatestyles = mw.getCurrentFrame():extensionTag{
name = 'templatestyles', args = { src = 'Fraction/styles.css' }
}
return mw.ustring.format(
'%s<span class="frac" role="math">%s<span class="num">%s</span>⁄<span class="den">%s</span></span>',
templatestyles,
whole and (whole .. '<span class="sr-only">+</span>') or '',
num,
den
)
end
-----------------------------------------------------------------------------------
-- debugReturnArgs
-----------------------------------------------------------------------------------
function p.debugReturnArgs(frame)
local args = prepareArgs(frame)
local retArgs = {}
for k, a in pairs(args) do
table.insert(retArgs, k .. '=' .. a)
end
return 'Args: ' .. table.concat(retArgs, '; ')
end
-----------------------------------------------------------------------------------
-- checkData -- Public. Performs various checks on the /data subpage.
-- not maintained since ca. 2015
-----------------------------------------------------------------------------------
function p.checkData(frame)
--To be allowed: entry.link empty; then use entry.name.
local dataPage = frame and frame.args and frame.args[1] or dataPageName
local data = mw.loadData(dataPage)
local exists, dupes, dupeSort, ret = {}, {}, {}, {}
-- Check for duplicate aliases.
for ti, t in ipairs(data) do
for ai, alias in ipairs(t.aliases or {}) do
if not exists[alias] then
exists[alias] = { ti, ai }
else
if not dupes[alias] then
dupes[alias] = { exists[alias] }
end
table.insert(dupes[alias], { ti, ai })
end
end
end
for alias in pairs(dupes) do
table.insert(dupeSort, alias)
end
table.sort(dupeSort)
for i1, alias in ipairs(dupeSort) do
local positions = {}
for i2, aliasKeys in ipairs(dupes[alias]) do
local position = mw.ustring.format('gauge %d, alias %d (gauge id: <code>%s</code>)', aliasKeys[1], aliasKeys[2], data[aliasKeys[1]].id or '')
table.insert(positions, position)
end
local aliasText = mw.ustring.format('Duplicate aliases "%s" detected at the following positions: %s.', alias, mw.text.listToText(positions, '; '))
table.insert(ret, aliasText)
end
-- Check for numerators without denominators.
for ti, t in ipairs(data) do
local num = t.num
local den = t.den
if num and not den then
table.insert(ret, mw.ustring.format('Numerator "%s" with no denominator detected at gauge %d (id: <code>%s</code>).', num, ti, t.id or ''))
elseif den and not num then
table.insert(ret, mw.ustring.format('Denominator "%s" with no numerator detected at gauge %d (id: <code>%s</code>).', den, ti, t.id or ''))
end
end
-- Check for gauges with no imperial or no metric measurements.
for ti, t in ipairs(data) do
if not (t.ft or t['in'] or t.num or t.den) then
table.insert(ret, mw.ustring.format('No imperial measurements found for gauge %d (id: <code>%s</code>).', ti, t.id or ''))
end
if not (t.m or t.mm) then
table.insert(ret, mw.ustring.format('No metric measurements found for gauge %d (id: <code>%s</code>).', ti, t.id or ''))
end
end
-- Check for non-numeric measurements.
local measurements = { 'ft', 'in', 'num', 'den', 'm', 'mm' }
for ti, t in ipairs(data) do
for mi, measurement in ipairs(measurements) do
local measurementVal = t[measurement]
if measurementVal and not tonumber(measurementVal) then
table.insert(ret, mw.ustring.format('Non-numeric <code>%s</code> measurement ("%s") found for gauge %d (id: <code>%s</code>).', measurement, measurementVal, ti, t.id or ''))
end
end
end
-- Check for gauges with no id.
for ti, t in ipairs(data) do
if not t.id then
local aliases = {}
for i, alias in ipairs(t.aliases) do
table.insert(aliases, mw.ustring.format('<code>%s</code>', alias))
end
aliases = mw.ustring.format(' (aliases: %s)', mw.text.listToText(aliases))
table.insert(ret, mw.ustring.format('No id found for track gauge %d%s.', ti, aliases or ''))
end
end
-- Check for gauges with no aliases.
for ti, t in ipairs(data) do
if type(t.aliases) ~= 'table' then
table.insert(ret, mw.ustring.format('No aliases found for gauge %d (id: <code>%s</code>).', ti, t.id or ''))
else
local isAlias = false
for ai, alias in ipairs(t.aliases) do
isAlias = true
break
end
if not isAlias then
table.insert(ret, mw.ustring.format('No aliases found for gauge %d (id: <code>%s</code>).', ti, t.id or ''))
end
end
end
-- Check for named gauges with no links and gauges with links but no names.
-- 20140520: no link? could be acceptable. Code falls back to the unlinked name (in test now).
if false then -- skipped 2014-05-25
for ti, t in ipairs(data) do
if t.name and not t.link then
table.insert(ret, mw.ustring.format('No link found for the named gauge "%s" at position %d (id: <code>%s</code>).', t.name, ti, t.id or ''))
elseif t.link and not t.name then
table.insert(ret, mw.ustring.format('No name found for the gauge with link "%s" at position %d (id: <code>%s</code>).', t.link, ti, t.id or ''))
end
end
end
-- Check for invalid def1 values.
for ti, t in ipairs(data) do
local def = t.def1
if def ~= 'imp' and def ~= 'met' then
table.insert(ret, mw.ustring.format('Invalid def1 value "%s" found for gauge %d (id: <code>%s</code>).', def or '', ti, t.id or ''))
end
end
-- Check for unwanted whitespace.
for ti, t in ipairs(data) do
for tkey, tval in pairs(t) do
if tkey == 'aliases' and type(tval) == 'table' then
for ai, alias in ipairs(tval) do
if mw.ustring.find(alias, '%s') then
table.insert(ret, mw.ustring.format('Unwanted whitespace detected in gauge %d alias %d ("%s", gauge id: <code>%s</code>).', ti, ai, alias, t.id or ''))
end
end
elseif tkey == 'name' or tkey == 'link' or tkey == 'pagename' or tkey == 'contentcat' then
if tval ~= mw.text.trim(tval) then
table.insert(ret, mw.ustring.format('Unwanted whitespace detected in <code>%s</code> field of gauge %d ("%s", gauge id: <code>%s</code>).', tkey, ti, tval, t.id or ''))
end
elseif mw.ustring.find(tval, '%s') then
table.insert(ret, mw.ustring.format('Unwanted whitespace detected in <code>%s</code> field of gauge %d ("%s", gauge id: <code>%s</code>).', tkey, ti, tval, t.id or ''))
end
end
end
-- Added April 2014: alias should not double with another id (imp and mm not ambiguous)
local self_id = ''
local self_def = ''
for ti, t in ipairs(data) do
self_id = t.id
self_def = t.def1
for iC, aliasCheck in ipairs(t.aliases) do
if tonumber(aliasCheck) ~= nil then
if self_id ~= aliasCheck then
for iTwo, tTwo in ipairs(data) do
if aliasCheck == tTwo.id then
table.insert(ret,
mw.ustring.format('Input alias %s (%s) from <code>id=%s mm</code> ambiguous with gauge id=<code>%s mm</code> (%s)'
, aliasCheck, self_def, self_id, tTwo.id, tTwo.def1)
)
end
end
end
end
end
end
-- Return any errors found.
for i, msg in ipairs(ret) do
ret[i] = mw.ustring.format('<span class="error">%s</span>', msg)
end
if #ret > 0 then
return mw.ustring.format('Found the following errors in %s:\n* %s', dataPage, table.concat(ret, '\n* '))
else
return mw.ustring.format('No errors found in %s.', dataPage)
end
end
-----------------------------------------------------------------------------------
-- catContent -- content category for the gauge
-----------------------------------------------------------------------------------
function p.catContent(frame)
-- catContent (content category for this alias)
-- can be hardcoded in the data, or build by size (pattern)
local args = prepareArgs(frame)
local tgEntry = modTrackGauge.getTrackGaugeEntry(args.searchAlias)
if tgEntry == nil then
return args['displaynotfound'] or 'No gauge entry found for ' .. (args[1] or '""')
end
local catTitle
local label
local catC
local docsortlabel = ''
if args.docsortlabel ~= nil then
docsortlabel = '|' .. args.docsortlabel
end
if tgEntry.contentcat == '' then
catC = ''
elseif tgEntry.contentcat ~= nil then
catC = '[[:Category:' .. tgEntry.contentcat .. docsortlabel .. ']]'
else -- no name given, try default name:
local catCsuffix = ' gauge railways'
if tgEntry.def1 == 'met' then
label = formatUnitPlaintext(tgEntry, 'met')
catTitle = mw.title.makeTitle(14, label .. catCsuffix)
if catTitle.exists then
catC = '[[:' .. catTitle.fullText .. docsortlabel .. ']]'
end
elseif tgEntry.def1 == 'imp' then
label = formatUnitPlaintext(tgEntry, 'imp', nil, true)
catTitle = mw.title.makeTitle(14, label .. catCsuffix)
if catTitle.exists then
catC = '[[:' .. catTitle.fullText .. docsortlabel .. ']]'
end
end
end
return catC
end
-----------------------------------------------------------------------------------
-- catMentions -- maintenance only
-----------------------------------------------------------------------------------
function p.catMentions(frame)
local args = prepareArgs(frame)
local tgEntry = modTrackGauge.getTrackGaugeEntry(args.searchAlias)
if tgEntry == nil then
return args['displaynotfound'] or 'No gauge entry found for ' .. (args[1] or '""')
end
local catM = modTrackGauge.catMentions(tgEntry, args.docsortlabel, 'show')
return catM
end
-----------------------------------------------------------------------------------
-- fromInputToId -- Used cleaned Alias as searchkey
-----------------------------------------------------------------------------------
local function fromInputToId(searchAlias)
gaugeDataAll = mw.loadData(dataPageName)
for i, tgEntry in ipairs(gaugeDataAll) do
for j, alias in ipairs(tgEntry.aliases) do
if alias == searchAlias then
return tgEntry.id
end
end
end
-- Next search: by id (autodocument only, not in main RG)
if tonumber(searchAlias) ~= nil then
for i, tgEntry in ipairs(gaugeDataAll) do
if tgEntry.id == searchAlias then
return tgEntry.id
end
end
end
end
-----------------------------------------------------------------------------------
-- documentInchCount -- Number of inches in decimals.
-----------------------------------------------------------------------------------
local function documentInchCount(tgEntry)
local inches = 0
if tgEntry['num'] ~= nil then
inches = modMath._round(tonumber((tgEntry['num'] or 0) / (tgEntry['den'] or 1)), 4)
end
inches = tostring((tonumber(tgEntry['ft'] or 0) * 12)
+ tonumber(tgEntry['in'] or 0) + inches)
return inches
end
-----------------------------------------------------------------------------------
-- documentInchToMm -- Not used lately
-----------------------------------------------------------------------------------
local function documentInchToMm(inchCount)
return tonumber(inchCount or 0) * 25.4
end
-----------------------------------------------------------------------------------
-- documentGaugeSizeFromTitle -- Currently finds "1620 mm" when at end of title,
-- then returns "1620". Blank when not found.
-----------------------------------------------------------------------------------
function p.documentGaugeSizeFromTitle()
local title = mw.title.getCurrentTitle()
return string.match(title.text, '%s(%d+%.?%d*)%smm$') or ''
end
-----------------------------------------------------------------------------------
-- documentBuildTgList -- The table of id's to fill the table
-----------------------------------------------------------------------------------
function documentBuildTgList(args)
-- Build series from the list. idFrom and idTo are numerical
local tgList = {}
local idFrom = -1
local idTo = -1
for i, v in ipairs(args) do
if v == 'all' then
idFrom = -math.huge
idTo = math.huge
break
end
end
if args.docfrom ~= nil then
idFrom = tonumber(fromInputToId(args.docfrom)
or mw.ustring.gsub(args.docfrom, 'mm', ''))
idTo = math.huge
end
if args.docto ~= nil then
idTo = tonumber(fromInputToId(args.docto)
or mw.ustring.gsub(args.docto, 'mm', ''))
end
if idTo > 0 then -- Some subset is requested from the whole data set
if idFrom > idTo then
local dummy = idFrom
idFrom = idTo
idTo = dummy
end
for i, tgEntry in ipairs(gaugeDataAll) do
if (tonumber(tgEntry.id) >= idFrom) and (tonumber(tgEntry.id) <= idTo) then
table.insert(tgList, tonumber(tgEntry.id))
end
end
tgList = tableTools.removeDuplicates(tgList)
table.sort(tgList)
if #tgList > 1 then
ttlListedRange[1] = tgList[1] .. ' mm – ' .. tgList[#tgList] .. ' mm '
end
end
-- Individual entries can be mentioned in args (all unnamed = numbered params)
-- Need a straight table.to keep sequence right
local id
local argsAliasesIn = tableTools.compressSparseArray(args)
for i, argsAlias in ipairs(argsAliasesIn) do
id = fromInputToId(argsAlias)
if id ~= nil then
table.insert(tgList, i, tonumber(id))
table.insert(ttlListedRange, i, id .. ' mm; ')
end
end
ttlListedRange = tableTools.compressSparseArray(ttlListedRange)
ttlListedRange = tableTools.removeDuplicates(ttlListedRange)
tgList = tableTools.compressSparseArray(tgList)
tgList = tableTools.removeDuplicates(tgList)
return tgList
end
-----------------------------------------------------------------------------------
-- documentPostListStats -- build footer table, after list only
-----------------------------------------------------------------------------------
local function documentPostListStats(countTgList)
-- Report data counters
-- Data
local retFoot = {}
table.insert(retFoot, '\n*Sources')
table.insert(retFoot, ':Data pages: [[:' .. dataPageName .. ']]')
table.insert(retFoot, '*Data')
table.insert(retFoot, ':Listed: ' .. table.concat(ttlListedRange, '') .. ' (' .. countTgList .. ' rows)')
table.insert(retFoot, ":'''Entries''' (defined gauges, per unit): " .. ttlEntries)
table.insert(retFoot, ":'''Gauges''' (defined gauges, per size): " .. countTgList)
for i, stat in ipairs (ttlUnitCount) do
table.insert(retFoot, ':' .. stat[2] .. ': ' .. stat[1])
end
table.insert(retFoot, ':Aliases (input options): ' .. ttlAliasCount)
table.insert(retFoot, ':Named definitions (as output link; ' .. ttlAltNameCount .. '): ' .. table.concat(ttlAltName, '; '))
table.insert(retFoot, ':Entries with an article link: ' .. ttlLinkCount)
-- TODO table.insert(retFoot, '*Named gauges (named input)') -- todo
-- Categories (content, maintenance)
table.insert(retFoot, '*Categories')
table.insert(retFoot, ':Content categories: ' .. ttlContentCatsCount)
-- Size classes (narrow, broad, ..)
table.insert(retFoot, '*Size classes')
for i, stat in ipairs (ttlSizeClassCount) do
if stat[2] ~= 0 then
table.insert(retFoot, ':' .. stat[2] .. ' ' .. stat[3] .. ' (' .. stat[4] .. ' mentionings)')
end
end
local anchor = tostring(mw.html.create():tag('span'):attr('id', 'Statistics'))
-- help:using colors. Hue=190 (blue)
local statTable = anchor .. '\n{| class="wikitable collapsible collapsed" style="background:#e6fbff; font-size:85%; width:100%;"'
.. '\n|-'
.. '\n! style="background:#ceecf2; width:100%;" | Track gauge data statistics'
.. '\n|-'
.. '\n|' .. table.concat(retFoot, '\n')
.. '\n|}'
return statTable
end
-----------------------------------------------------------------------------------
-- documentHeader
-----------------------------------------------------------------------------------
local function documentHeader(numberOfEntries, docTitle, docState)
local docBgHeader = '#cef2e0' -- Green. See [[template:documentation]]
-- Header row 1 (title)
local pagetitle = mw.title.getCurrentTitle()
urlPurgePage = pagetitle:fullUrl({action = 'purge'})
urlPurgePage = '<span class="plainlinks purgelink nourlexpansion" title="Purge this page (update countings)">[' .. urlPurgePage .. ' (purge)]</span>'
if docTitle == '' then
docTitle = 'Track gauges' -- (' .. dataPageName .. ')' -- optional, sandbox here
end
docTitle = docTitle .. ' ' .. urlPurgePage
if docState == '' then
docState = 'uncollapsed'
end
-- Header row 2 (sort buttons, blank cells)
local sortColHeaders = ''
local sortClass = ''
if (numberOfEntries or 0) > 1 then
sortClass = 'sortable'
local sortCell = '! style="background:' .. docBgHeader .. ';"'
-- todo: 10 cols with bg color
sortColHeaders = '\n|- style="background:' .. docBgHeader .. '; line-height:90%;"'
.. '\n! || || || || || || || '
end
-- Header row 3 (column headers)
local catMparent = modTrackGauge.catMentions(nil, 'Mentionings', 'show')
--10 columns:
local tableStyle = 'style="text-align:right; width:100%; font-size:85%;" '
local retHdr = {}
table.insert(retHdr, '\n{| class="wikitable collapsible ' .. docState .. ' ' .. sortClass .. '" ' .. tableStyle)
table.insert(retHdr, '|-')
table.insert(retHdr, '! colspan=10 style="background:' .. docBgHeader .. ';" | ' .. docTitle)
table.insert(retHdr, '|-')
table.insert(retHdr, '! style="background:' .. docBgHeader .. ';" | Gauge<br>(mm)')
table.insert(retHdr, '! style="background:' .. docBgHeader .. ';" | Gauge<br>(ft, in)')
table.insert(retHdr, '! style="background:' .. docBgHeader .. ';" | Alt<br>name')
table.insert(retHdr, '! style="background:' .. docBgHeader .. ';" | Gauge<br>(inch)')
table.insert(retHdr, '! style="background:' .. docBgHeader .. ';" | Def<br>unit')
table.insert(retHdr, '! style="background:' .. docBgHeader .. '; width:8em;" | Aliases<br>(input options)')
table.insert(retHdr, '! style="background:' .. docBgHeader .. ';" | Class<br> ')
table.insert(retHdr, '! style="background:' .. docBgHeader .. '; min-width:5em;" | Source<br>article')
return table.concat(retHdr, '\n') .. sortColHeaders
end
-----------------------------------------------------------------------------------
-- documentFooter
-----------------------------------------------------------------------------------
local function documentFooter()
return {'\n|}'}
end
-----------------------------------------------------------------------------------
-- documentFromIdToEntrySet -- from fromIdToEntrySet
-- From one id, make the set with all one-two-three-more entries (met, inp, variants)
-----------------------------------------------------------------------------------
local function documentFromIdToEntrySet(id, searchedAlias)
local docBgColor = '#e6fff2' -- Green. See header bg color
local rowSplit = '<div style="border-top:1px solid #ccc; height:1px;"></div>'
-- From the size-id, build the set of existing entries (met, imp, and variants)
local entry = {}
local defType = 0
-- data
for i, tgEntry in ipairs(gaugeDataAll) do
if id == tgEntry.id then
if tgEntry.def1 == 'met' and entry[1] == nil then
entry[1] = tgEntry
defType = defType + 1
elseif tgEntry.def1 == 'imp' and entry[2] == nil then
entry[2] = tgEntry
defType = defType + 2
else
entry[3 + tableTools.size(entry)] = tgEntry
end
end
end
entry = tableTools.compressSparseArray(entry)
-- Entry set is now complete & clean
-- Result: the entry table with entries present in /data,
-- in sequence if present (1. met, 2. imp, any extra)
-- (to build into a single row, maybe with split cells)
--Build cell elements, then string row together.
local inchCount = documentInchCount(entry[1])
local datasortvalue = documentdatasortvalue(entry[1], 'met', 5)
local aliasList = {}
local tempEntryAltName = {}
local entryAltName = {}
local hasAltName = false
for i, e in ipairs(entry) do
local alis = {}
for j, v in ipairs(e.aliases) do
if tonumber(v) == nil then -- (plain numbers are not shown)
table.insert(alis, tostring(v))
end
end
for j, v in ipairs(alis) do
if string.match(v, '^%d') == nil then -- textual so to italic.
alis[j] = tostring(mw.html.create():tag('span'):wikitext(v):css('font-style', 'italic'))
end
end
table.insert (aliasList, table.concat(alis, '; '))
ttlAliasCount = ttlAliasCount + #alis
-- process Alt name links
if e.name or '' ~= '' then
tempEntryAltName[i] = tostring(mw.html.create():tag('span'):wikitext(e.link):css('font-weight', 'bold'))
table.insert(ttlAltName, e.id .. ': ' .. e.link)
ttlAltNameCount = ttlAltNameCount + 1
hasAltName = true
end
end
if hasAltName then
local text
for i, v in ipairs(entry) do
table.insert(entryAltName, i, tempEntryAltName[i] or ' ')
end
end
local def = {} -- Definition unit code: 'met' or 'imp'
local defText = {}
for i, v in ipairs (entry) do
table.insert(def, v.def1)
if v.def1 == 'imp' then
table.insert(defText, 'imp')
ttlUnitCount[2][1] = ttlUnitCount[2][1] + 1
elseif v.def1 == 'met' then
table.insert(defText, 'met')
ttlUnitCount[1][1] = ttlUnitCount[1][1] + 1
end
end
if #entry >= 2 then
if #entry == 2 and entry[1].def1 ~= entry[2].def1 then -- Regular pair: def in met and in imp
ttlUnitCount[3][1] = ttlUnitCount[3][1] + 1
else -- More than 2, or a double unit definition
ttlUnitCount[4][1] = ttlUnitCount[4][1] .. ' ' .. id .. ' mm (' .. #entry ..');'
end
end
-- mm; ft in -- Measurement (number & unit; met and imp; anchor to here)
local measure = {}
local unitanchor = { '', '' }
measure[1] = modTrackGauge.formatMet(entry[1])
measure[2] = modTrackGauge.formatImp(entry[1]) -- both met and imp from entry[1]
if modMath._mod(defType, 2) == 1 then
measure[1] = tostring(mw.html.create():tag('span'):wikitext(measure[1]):css('font-weight', 'bold'))
unitanchor[1] = anchor(entry[1], 'met')
end
if defType >= 2 then
measure[2] = tostring(mw.html.create():tag('span'):wikitext(measure[2]):css('font-weight', 'bold'))
unitanchor[2] = anchor(entry[1], 'imp')
end
-- Linked article
local linkArticle = {}
for i, e in ipairs(entry) do
table.insert(linkArticle, e.pagename)
end
ttlLinkCount = ttlLinkCount + #linkArticle
local eq
if #linkArticle >= 2 then
eq = true
for i, v in ipairs(linkArticle) do
if v ~= linkArticle[1] then
eq = false
break
end
end
if eq == true then
for i, v in ipairs(linkArticle) do
if i > 1 then
linkArticle[i] = nil
end
end
end
end
for i, lp in ipairs(linkArticle) do
local fmtLp = ''
fmtLp = '[[' .. lp .. ']]'
linkArticle[i] = tostring(mw.html.create():tag('span'):css('text-align', 'left'):wikitext(fmtLp))
end
-- catContent (content category for this alias). note: function p.catContent is a reduced code of this.
-- can be hardcoded in the data, or build by size (pattern)
local catContent = {}
local catTitle
local label
local skipCheck = false
for i, e in ipairs(entry) do
if e.contentcat == '' then
-- no cat; option to prevent expensive calls
skipCheck = true
elseif e.contentcat ~= nil then
label = string.match(e.contentcat, '([%S]*)') or 'nomatch'
table.insert(catContent,
'[[:Category:' .. e.contentcat .. '|cat:' .. label .. ' ...]]')
end
end
if #catContent >= 2 then
eq = true
for i, v in ipairs(catContent) do
if v ~= catContent[1] then
eq = false
break
end
end
if eq == true then
for i, v in ipairs(catContent) do
if i > 1 then
catContent[i] = nil
end
end
end
end
if #catContent == 0 and not skipCheck then
local catCsuffix = ' gauge railways'
if modMath._mod(defType, 2) == 1 then
label = formatUnitPlaintext(entry[1], 'met')
catTitle = mw.title.makeTitle(14, label .. catCsuffix)
if catTitle.exists then
table.insert(catContent,
'[[:' .. catTitle.fullText .. '|cat:' .. noWrap(label) .. ']]')
end
end
if defType >= 2 then
label = formatUnitPlaintext(entry[1], 'imp', nil, true)
catTitle = mw.title.makeTitle(14, label .. catCsuffix)
if catTitle.exists then
table.insert(catContent, '[[:' ..catTitle.fullText .. '|cat:' .. noWrap(label) .. ']]')
end
end
end
ttlContentCatsCount = ttlContentCatsCount + #catContent
-- Mentions category
local catMentions = modTrackGauge.catMentions(entry[1], "cat:mnt", 'show')
local catCount = mw.site.stats.pagesInCategory(
modTrackGauge.catMentions(entry[1], nil, 'pagename'), pages)
ttlMentioningCatsCount = ttlMentioningCatsCount + 1 -- Exists
ttlMentioningPageCount = ttlMentioningPageCount + catCount
-- class: Counter SizeClass (narrow, broad, ...)
local rgSizeClass = documentGaugeClass(entry[1], catCount)
ttlEntries = ttlEntries + #entry
sortCount = mw.text.truncate('00000' .. tostring(catCount), -5, '')
sortCount = '<span data-sort-value="' .. sortCount .. '">'
catCount = sortCount .. catCount .. ' P' .. '</span>' --(20190920: linter closing span added)
-- Compose the size-id row with all cell values (10 columns)
local row = {}
table.insert(row, datasortvalue .. unitanchor[1] .. measure[1])
table.insert(row, datasortvalue .. unitanchor[2] .. measure[2])
table.insert(row, table.concat(entryAltName, rowSplit))
table.insert(row, datasortvalue .. inchCount)
table.insert(row, table.concat(defText, rowSplit))
table.insert(row, table.concat(aliasList, rowSplit))
table.insert(row, rgSizeClass)
table.insert(row, table.concat(linkArticle, rowSplit))
return '\n|- style="background:' .. docBgColor .. '; border-top:2px solid #aaa;" |'
.. '\n|'
.. table.concat(row, ' || ')
end
-----------------------------------------------------------------------------------
-- documentGauge -- Selfdocument gauge data (one, multiple, range, all)
-----------------------------------------------------------------------------------
function p.documentGauge(frame)
local args = prepareArgs(frame)
gaugeDataAll = mw.loadData(dataPageName)
-- Init glolbal counters by table:
ttlUnitCount =
{
[1] = {0, 'Entries defined metric'},
[2] = {0, 'Entries defined imperial'},
[3] = {0, 'Gauge sizes defined both metric and imperial'},
[4] = {'', 'Gauge sizes with multiple entries in one unit'}
}
ttlSizeClassCount =
{
[1] = {'scaled', 0, 'scaled or model gauges', 0},
[2] = {'min', 0, 'minimum gauges', 0},
[3] = {'narrow', 0, 'narrow gauges', 0},
[4] = {'s.g.', 0, 'standard gauge', 0},
[5] = {'broad', 0, 'broad gauges', 0},
[6] = {'unk', 0, 'unknown', 0}
}
local tgList = documentBuildTgList(args)
-- Now loop through the prepared tgList[id] and add rows to result le
-- One row contains all available entries for the id (met, imp, a third variant)
local rowTGid = {}
for i, numId in ipairs(tgList) do
table.insert(rowTGid, documentFromIdToEntrySet(tostring(numId)))
end
-- Return args
local retArgs = ''
if args.docreturnargs == 'on' then
retArgs = '\n' .. p.debugReturnArgs(frame)
end
-- Build statistics footer
local retStats = ''
if args.docstats == 'on' then
retStats = documentPostListStats(#tgList)
end
-- Build up
return documentHeader(#tgList, args.doctitle or '', args.docstate or '')
.. table.concat(rowTGid, '')
.. table.concat(documentFooter(), '')
.. retStats
.. retArgs
end
--------------------------------------------------------
-- doc
--------------------------------------------------------
function p.docFracAliases(frame)
local args = prepareArgs(frame)
gaugeDataAll = mw.loadData(dataPageName)
local tgList = documentBuildTgList(args)
local ttlHitCount =0
local rowIMP = {}
local fracAlias =''
for i, id in ipairs(tgList) do
for j, tgEntry in pairs(gaugeDataAll) do
if nil and tostring(id) == '53.975' and tostring(id) == tgEntry.id then
fracAlias = anchor(tgEntry, 'imp', 'there')
fracAlias = mw.ustring.lower(mw.ustring.gsub(fracAlias, '[%s%,%#]', ''))
table.insert(rowIMP, fracAlias .. '||' .. i .. '||' .. id ..
'||' .. modTrackGauge.formatImp(tgEntry) .. ' || plus ' .. tgEntry.num)
end
if tostring(id) == tgEntry.id and tgEntry.def1 == 'imp' and tgEntry.num ~= nil then
if tgEntry.ft ~= nil then
ttlHitCount = ttlHitCount + 1
fracAlias = anchor(tgEntry, 'imp', 'there')
fracAlias = mw.ustring.lower(mw.ustring.gsub(fracAlias, '[%s%,%#]', ''))
fracAlias = mw.ustring.gsub(fracAlias, '⁄', '/')
table.insert(rowIMP, fracAlias .. '||' .. i .. '||' .. id ..
'||' .. modTrackGauge.formatImp(tgEntry))
fracAlias = tostring((tonumber((tgEntry.ft) or 0) * 12) + tonumber(tgEntry["in"] or 0)) .. tgEntry.num .. '/' .. tgEntry.den .. 'in'
table.insert(rowIMP, fracAlias .. '||' .. i .. '||' .. id ..
'||' .. modTrackGauge.formatImp(tgEntry))
end
end
end
end
-- return '\n|' .. ttlHitCount .. ' hits. ' .. #rowIMP
return '\n\n|-\n\n|' .. table.concat(rowIMP, '\n\n|-\n\n|')
end
return p