Modul:Sports table/auto
Qiyofa
-- Builds standings from match results for |auto_generate_standings=yes.
-- Reads match cells, calculates records, ranks teams, and writes the results
-- back for Module:Sports table. See the documentation for criteria.
require('strict')
local pa = {}
local yesno = require('Module:Yesno')
-- Fields in each statistics record.
local FIELDS = {'pld', 'w', 'otw', 'd', 'otl', 'l', 'gf', 'ga',
'hpld', 'hw', 'hotw', 'hd', 'hotl', 'hl', 'hgf', 'hga',
'apld', 'aw', 'aotw', 'ad', 'aotl', 'al', 'agf', 'aga'}
-- |result_AAA_BBB= values that mark an overtime result; SO (shootout) is an alias.
local OT_RESULTS = {OT = true, SO = true}
-- Score separators normalized to hyphens before matching.
local DASHES = {'–', '—', '−', '‒', '―', '‐', '‑'}
local DASH = '%-+'
-- Limit displayed errors for badly broken tables.
local MAX_ERRORS = 25
-- Limit recursive tiebreak processing.
local MAX_RECURSION = 25
--------------------------------------------------------------------------------
-- Helpers
--------------------------------------------------------------------------------
local function trim(s)
return mw.text.trim(tostring(s or ''))
end
local function add_error(errors, msg)
if #errors < MAX_ERRORS then
errors[#errors + 1] = msg
elseif #errors == MAX_ERRORS then
errors[#errors + 1] = 'further problems were found but are not listed'
end
end
--------------------------------------------------------------------------------
-- Match-cell parsing
--------------------------------------------------------------------------------
-- Remove common markup from a match cell before parsing its score.
local function clean_cell(raw)
local s = tostring(raw or '')
-- Strip reference markers.
s = s:gsub('\127[^\127]*\127', '')
-- Remove superscripts; retain other tag contents.
s = s:gsub('<[Ss][Uu][Pp].->.-</[Ss][Uu][Pp]>', '')
s = s:gsub('</?%w+[^<>]*>', '')
-- Keep wikilink display text.
s = s:gsub('%[%[[^%[%]|]*|([^%[%]|]*)%]%]', '%1')
s = s:gsub('%[%[([^%[%]|]*)%]%]', '%1')
-- Keep external-link display text.
s = s:gsub('%[%S+%s+([^%[%]]*)%]', '%1')
-- Normalize entities.
s = s:gsub('&[Nn][Dd][Aa][Ss][Hh];', '-')
s = s:gsub('&[Mm][Dd][Aa][Ss][Hh];', '-')
s = s:gsub('−', '-')
s = s:gsub(' ', ' ')
-- Normalize dash characters.
for _, d in ipairs(DASHES) do
s = s:gsub(d, '-')
end
return trim(s)
end
-- Returns scores and whether an unparseable value resembles a score.
local function parse_score(raw)
local s = clean_cell(raw)
if s == '' or s:lower() == 'null' then
return nil, nil, false
end
local h, a = s:match('^([%d%.]+)%s*' .. DASH .. '%s*([%d%.]+)')
h, a = tonumber(h or ''), tonumber(a or '')
if h and a then
return h, a, false
end
-- Flag score-like but unparseable values.
local looks = s:match('[%d%.]+%s*' .. DASH .. '%s*[%d%.]+') ~= nil
return nil, nil, looks
end
-- Split match parameter suffixes, preferring known codes with underscores.
local function split_pair(rest, codes)
local cands = {}
local i = rest:find('_', 1, true)
while i do
local h, a = rest:sub(1, i - 1), rest:sub(i + 1)
if h ~= '' and a ~= '' then
cands[#cands + 1] = {h, a}
end
i = rest:find('_', i + 1, true)
end
if #cands == 0 then return nil end
for _, c in ipairs(cands) do
if codes[c[1]] and codes[c[2]] then return c[1], c[2] end
end
for _, c in ipairs(cands) do
if codes[c[1]] then return c[1], c[2] end
end
for _, c in ipairs(cands) do
if codes[c[2]] then return c[1], c[2] end
end
return cands[#cands][1], cands[#cands][2]
end
-- Return match parameters in a stable order.
local function match_keys(Args)
local keys = {}
for k, v in pairs(Args) do
if type(k) == 'string' and v ~= nil then
-- Check neutral matches first.
local num, rest = k:match('^matchn(%d*)_(.+)$')
local neutral = true
if not rest then
num, rest = k:match('^match(%d*)_(.+)$')
neutral = false
end
if rest and not rest:match('_note$') then
keys[#keys + 1] = {key = k, rest = rest, neutral = neutral,
num = tonumber(num) or 1, numbered = (num ~= '')}
end
end
end
table.sort(keys, function(x, y) return x.key < y.key end)
return keys
end
--------------------------------------------------------------------------------
-- Team list
--------------------------------------------------------------------------------
-- Convert a team name to plain text for sorting and link anchors.
-- Keep this in sync with clean_team_name in Module:Sports results.
local function replace_link(m)
local pipe_pos = m:find('|')
if pipe_pos then
return m:sub(pipe_pos + 1, -3) -- text after the '|'
else
return m:sub(3, -3) -- text between the brackets
end
end
local function plain_name(str, default)
if str and str ~= '' then
str = str:gsub('<sup.->.-</sup>', '')
str = str:gsub('</?%w+[^>]*>', '')
str = str:gsub('\127%\'"`UNIQ.-QINU`"%\'\127', '')
str = str:gsub('%[%[[Ff]ile:[^%]]+%]%]', '')
str = str:gsub('%[%[[Ii]mage:[^%]]+%]%]', '')
str = str:gsub('%[%[.-%]%]', replace_link)
str = str:gsub('%s* %s*', '')
str = str:gsub("'''+", '')
str = str:gsub("''", '')
str = str:match('^%s*(.-)%s*$') -- trim
return (str ~= '' and str) or default
end
return default
end
local function name_sorter(Args)
local key = {}
local function keyof(c)
if key[c] == nil then
key[c] = string.lower(plain_name(Args['name_' .. c], c))
end
return key[c]
end
return function(x, y)
local kx, ky = keyof(x), keyof(y)
if kx == ky then return x < y end
return kx < ky
end
end
-- Read outside opponents, which are excluded from the standings and matches.
function pa.external(Args)
local ext = {}
for _, c in ipairs(mw.text.split(trim(Args['external_teams'] or ''), '%s*[;,]%s*')) do
if c ~= '' then ext[c] = true end
end
return ext
end
-- Read withdrawn teams: kept in the standings (pinned at the bottom, in the
-- order given) but left out of the results grid entirely. Returns a lookup
-- set and the ordered list.
function pa.withdrawn(Args)
local set, order = {}, {}
for _, c in ipairs(mw.text.split(trim(Args['withdrawn_teams'] or ''), '%s*[;,]%s*')) do
if c ~= '' and not set[c] then
set[c] = true
order[#order + 1] = c
end
end
return set, order
end
-- Build the roster from names and matches, excluding outside opponents.
-- The code set retains outsiders to split match names with underscores.
function pa.roster(Args)
local codes, list = {}, {}
local ext = pa.external(Args)
for k, _ in pairs(Args) do
if type(k) == 'string' then
local c = k:match('^name_(.+)$') or k:match('^schedule_(.+)$')
if c and c ~= '' then codes[c] = true end
end
end
for _, mk in ipairs(match_keys(Args)) do
local h, a = split_pair(mk.rest, codes)
if h then
codes[h] = true
codes[a] = true
end
end
for c in pairs(codes) do
if not ext[c] then list[#list + 1] = c end
end
table.sort(list, name_sorter(Args))
return list, codes
end
-- Warn about likely mistyped team codes without rejecting valid sparse input.
local function check_orphans(Args, teams, errors)
local n_named = 0
local unnamed = {}
for _, c in ipairs(teams) do
if Args['name_' .. c] ~= nil then
n_named = n_named + 1
else
unnamed[#unnamed + 1] = c
end
end
-- Unnamed codes are suspicious only when other teams have names.
if n_named > 0 and #unnamed > 0 then
add_error(errors, 'unnamed teams = ' .. table.concat(unnamed, ', ')
.. ' (found in a match parameter but given no |name_TTT=)')
end
end
-- Base order: |default_order= first, then remaining codes alphabetically.
function pa.base_order(Args, teams, codes, errors)
local order, seen = {}, {}
local raw = Args['default_order']
if raw and trim(raw) ~= '' then
for _, tname in ipairs(mw.text.split(raw, '%s*[;,]%s*')) do
tname = trim(tname)
if tname ~= '' then
if not codes[tname] then
add_error(errors, 'the team "' .. tname .. '" given in |default_order= is not in the table')
elseif seen[tname] then
add_error(errors, 'the team "' .. tname .. '" is given more than once in |default_order=')
else
seen[tname] = true
order[#order + 1] = tname
end
end
end
end
-- teams is already sorted alphabetically.
for _, c in ipairs(teams) do
if not seen[c] then order[#order + 1] = c end
end
return order
end
--------------------------------------------------------------------------------
-- Statistics
--------------------------------------------------------------------------------
local function new_stats()
local st = {}
for _, f in ipairs(FIELDS) do st[f] = 0 end
return st
end
-- Neutral matches affect overall records, not home/away records.
-- side is 'home', 'away', or 'neutral'. ot marks an overtime result, counted as
-- an overtime win/loss instead of a win/loss; a drawn score stays a draw.
local function add_result(st, gf, ga, side, ot)
st.pld = st.pld + 1
st.gf = st.gf + gf
st.ga = st.ga + ga
local w, otw, d, otl, l = 0, 0, 0, 0, 0
if gf > ga then
if ot then otw = 1 else w = 1 end
elseif gf < ga then
if ot then otl = 1 else l = 1 end
else
d = 1
end
st.w, st.otw, st.d, st.otl, st.l = st.w + w, st.otw + otw, st.d + d, st.otl + otl, st.l + l
if side == 'home' then
st.hpld = st.hpld + 1
st.hgf = st.hgf + gf
st.hga = st.hga + ga
st.hw, st.hotw, st.hd, st.hotl, st.hl =
st.hw + w, st.hotw + otw, st.hd + d, st.hotl + otl, st.hl + l
elseif side == 'away' then
st.apld = st.apld + 1
st.agf = st.agf + gf
st.aga = st.aga + ga
st.aw, st.aotw, st.ad, st.aotl, st.al =
st.aw + w, st.aotw + otw, st.ad + d, st.aotl + otl, st.al + l
end
end
-- Build played matches; the first code is the home team. With read_ot,
-- |result_AAA_BBB=OT (or SO) marks the match as decided in overtime.
function pa.matches(Args, codes, errors, read_ot)
local out = {}
local legs = tonumber(Args['legs']) or 1
local fmt = string.lower(trim(Args['matches_format']))
local schedule = (fmt == 'schedule' or fmt == 'series' or fmt == 'series_split')
-- Neutral matches cannot appear in a results grid.
local sm = string.lower(trim(Args['show_matches']))
local shows_grid = (fmt == '' or fmt == 'grid')
and sm ~= '' and sm ~= 'no' and sm ~= 'n' and sm ~= 'false' and sm ~= 'f'
and sm ~= 'off' and sm ~= '0'
local seen = {}
local ext = pa.external(Args)
for _, mk in ipairs(match_keys(Args)) do
local h, a = split_pair(mk.rest, codes)
local hs, as, broken = parse_score(Args[mk.key])
-- Skip matches against listed outside opponents.
local outside = h and (ext[h] or ext[a]) and true or false
-- Count only matches shown by grid mode; schedules number freely.
local displayed = true
if not schedule and not mk.neutral then
displayed = (legs == 1) and not mk.numbered or (mk.numbered and mk.num <= legs)
end
-- Neutral fixtures are unordered.
local pair_id
if mk.neutral and h then
local x, y = h, a
if y < x then x, y = y, x end
pair_id = 'n' .. mk.num .. '|' .. x .. '|' .. y
else
pair_id = mk.num .. '|' .. tostring(h) .. '|' .. tostring(a)
end
if not h then
add_error(errors, 'could not read two team codes from |' .. mk.key .. '=')
elseif outside then
-- Outside fixture.
elseif h == a then
add_error(errors, '|' .. mk.key .. '= is a match of a team against itself')
elseif seen[pair_id] then
-- Catch reversed duplicate neutral fixtures.
add_error(errors, '|' .. mk.key .. '= repeats a match already given by |' .. seen[pair_id]
.. '=' .. (mk.neutral and ' (a neutral match is the same match either way round)' or ''))
elseif not displayed then
add_error(errors, '|' .. mk.key .. '= is not shown in the results grid with |legs='
.. legs .. ', so it has not been counted; use |'
.. ((legs == 1) and ('match_' .. mk.rest) or ('match<1-' .. legs .. '>_' .. mk.rest)) .. '=')
elseif broken then
add_error(errors, 'could not read the score in |' .. mk.key .. '=' .. trim(Args[mk.key]))
else
if mk.neutral and shows_grid then
add_error(errors, '|' .. mk.key .. '= is a neutral-venue match, which the results grid '
.. 'cannot show; it has still been counted in the standings')
end
seen[pair_id] = mk.key
if hs then
local ot = false
if read_ot then
-- match_h_a -> result_h_a, matchn2_h_a -> resultn2_h_a
local rkey = mk.key:gsub('^match', 'result')
ot = OT_RESULTS[trim(Args[rkey])] or false
end
out[#out + 1] = {home = h, away = a, hs = hs, as = as, neutral = mk.neutral, ot = ot}
end
end
end
return out
end
-- Build statistics for these teams only (used for head-to-head criteria).
local function build_stats(matches, teams)
local st = {}
for _, c in ipairs(teams) do st[c] = new_stats() end
for _, m in ipairs(matches) do
if st[m.home] and st[m.away] then
add_result(st[m.home], m.hs, m.as, m.neutral and 'neutral' or 'home', m.ot)
add_result(st[m.away], m.as, m.hs, m.neutral and 'neutral' or 'away', m.ot)
end
end
return st
end
-- Aggregate opponents' full-season records, counting repeat meetings twice.
local function opp_stats(code, matches, full, adj)
local agg = new_stats()
local aadj = {pts = 0, gf = 0, ga = 0}
for _, m in ipairs(matches) do
local opp
if m.home == code then
opp = m.away
elseif m.away == code then
opp = m.home
end
if opp and full[opp] then
for _, f in ipairs(FIELDS) do
agg[f] = agg[f] + full[opp][f]
end
local a = adj[opp]
if a then
aadj.pts = aadj.pts + (a.pts or 0)
aadj.gf = aadj.gf + (a.gf or 0)
aadj.ga = aadj.ga + (a.ga or 0)
end
end
end
return agg, aadj
end
--------------------------------------------------------------------------------
-- Criteria
--------------------------------------------------------------------------------
-- Criterion identifiers; each also accepts a h2h_ or opp_ scope prefix, and
-- (independently) a h or a side prefix (e.g. hpts, agd, h2h_hpts, opp_agpm).
local METRICS = {
pts = true, gd = true, gf = true, ga = true,
w = true, otw = true, d = true, otl = true, l = true,
gr = true, gp = true, ap = true, pp = true, gpm = true,
wp = true, perc = true, ppg = true,
}
local SIDES = {h = true, a = true}
-- Split a criterion id into its scope (full/h2h/opp), side (''/h/a), and
-- underlying metric. A bare metric name is always preferred over reading its
-- first letter as a side prefix (so e.g. "ap" is the against-percentage
-- metric, not the away "p" metric, since "p" is not a metric on its own).
local function id_parts(id)
local scope, rest = 'full', id
if id:sub(1, 4) == 'h2h_' then
scope, rest = 'h2h', id:sub(5)
elseif id:sub(1, 4) == 'opp_' then
scope, rest = 'opp', id:sub(5)
end
if METRICS[rest] then
return scope, '', rest
end
local prefix, remainder = rest:sub(1, 1), rest:sub(2)
if SIDES[prefix] and METRICS[remainder] then
return scope, prefix, remainder
end
return scope, '', rest
end
local function valid_id(id)
local _, _, base = id_parts(id)
return METRICS[base] and true or false
end
-- Pick out the home, away, or overall view of a statistics record.
local function side_view(st, side)
if side == 'h' then
return {pld = st.hpld, w = st.hw, otw = st.hotw, d = st.hd, otl = st.hotl, l = st.hl,
gf = st.hgf, ga = st.hga}
elseif side == 'a' then
return {pld = st.apld, w = st.aw, otw = st.aotw, d = st.ad, otl = st.aotl, l = st.al,
gf = st.agf, ga = st.aga}
end
return st
end
-- Return a criterion value; undefined values sort last. adj is {pts=, gf=,
-- ga=}, from |adjust_points_TTT=/|startpoints_TTT=/|adjust_gf_TTT=/
-- |adjust_ga_TTT=; gf/ga adjustments feed every goal-based metric below
-- (including the points formula's goalpoints term), the same way pts' own
-- adjustment feeds pts.
local function value_of(base, opts, st, adj)
adj = adj or {}
local gf = st.gf + (adj.gf or 0)
local ga = st.ga + (adj.ga or 0)
local pts = opts.winpoints * st.w + opts.otwinpoints * st.otw + opts.drawpoints * st.d
+ opts.otlosspoints * st.otl + opts.losspoints * st.l + opts.goalpoints * gf + (adj.pts or 0)
if base == 'pts' then return pts end
if base == 'gd' then return gf - ga end
if base == 'gf' then return gf end
if base == 'ga' then return ga end
if base == 'w' then return st.w end
if base == 'otw' then return st.otw end
if base == 'd' then return st.d end
if base == 'otl' then return st.otl end
if base == 'l' then return st.l end
-- A clean sheet is infinite; 0–0 is undefined.
if base == 'gr' or base == 'gp' then
if ga ~= 0 then
return (base == 'gr') and (gf / ga) or (100 * gf / ga)
end
return (gf > 0) and math.huge or nil
end
if base == 'ap' then
if gf ~= 0 then return 100 * ga / gf end
return (ga > 0) and math.huge or nil
end
if base == 'pp' then
return ((gf + ga) > 0) and (100 * gf / (gf + ga)) or nil
end
if base == 'gpm' then return (st.pld > 0) and (gf / st.pld) or nil end
if base == 'wp' then return (st.pld > 0) and (100 * (st.w + st.otw) / st.pld) or nil end
if base == 'perc' then
if opts.ot then
-- Same as the OT styles' PCT: points over the most a team could earn.
return (st.pld > 0 and opts.winpoints > 0) and (pts / (opts.winpoints * st.pld)) or nil
end
return (st.pld > 0) and ((2 * st.w + st.d + (adj.pts or 0)) / (2 * st.pld)) or nil
end
if base == 'ppg' then return (st.pld > 0) and (pts / st.pld) or nil end
return nil
end
-- Parse ranking criteria, recursive groups, ascending order, and final-only rules.
local function parse_criteria(str, errors)
str = tostring(str or '')
str = str:gsub('−', '-'):gsub('−', '-')
local items = {}
local stack = {items}
local cur = items
local buf = ''
local final, seen_period = false, false
local function flush()
local tok = trim(buf)
buf = ''
if tok == '' then return end
local desc = true
if tok:sub(1, 1) == '-' then
desc = false
tok = tok:sub(2)
end
local id = (trim(tok):lower():gsub('%s+', '_'))
if id == '' then return end
if not valid_id(id) then
add_error(errors, 'unknown ranking criterion "' .. id ..
'" in |ranking_criteria=')
return
end
cur[#cur + 1] = {kind = 'crit', id = id, desc = desc, final_only = final}
end
for i = 1, #str do
local ch = str:sub(i, i)
if ch == '(' then
flush()
local g = {kind = 'group', items = {}, final_only = final}
cur[#cur + 1] = g
stack[#stack + 1] = g.items
cur = g.items
elseif ch == ')' then
flush()
if #stack > 1 then
table.remove(stack)
cur = stack[#stack]
else
add_error(errors, 'unmatched ")" in |ranking_criteria=')
end
elseif ch == ',' or ch == ';' then
flush()
elseif ch == '.' then
flush()
if #stack == 1 and not seen_period then
seen_period = true
final = true
end
else
buf = buf .. ch
end
end
flush()
if #stack > 1 then
add_error(errors, 'unmatched "(" in |ranking_criteria=')
end
-- Remove empty groups.
local function prune(list)
local out = {}
for _, it in ipairs(list) do
if it.kind == 'group' then
it.items = prune(it.items)
if #it.items > 0 then out[#out + 1] = it end
else
out[#out + 1] = it
end
end
return out
end
return prune(items)
end
--------------------------------------------------------------------------------
-- Ranking
--------------------------------------------------------------------------------
-- Evaluate one criterion for a tied group.
local function evaluate(crit, bucket, ctx)
local scope, side, base = id_parts(crit.id)
local vals = {}
if scope == 'h2h' then
-- Rebuild the mini-table for the tied teams.
local sub = build_stats(ctx.matches, bucket)
for _, c in ipairs(bucket) do
vals[c] = value_of(base, ctx.opts, side_view(sub[c], side), nil)
end
elseif scope == 'opp' then
for _, c in ipairs(bucket) do
local agg, aadj = opp_stats(c, ctx.matches, ctx.full, ctx.adj)
-- A home/away split of the opponents' aggregate has no adjustment to prorate.
vals[c] = value_of(base, ctx.opts, side_view(agg, side), (side == '') and aadj or nil)
end
else
for _, c in ipairs(bucket) do
-- Adjustments are season-wide, not tied to venue, so they only
-- apply to the overall (non-home/away-split) criteria.
vals[c] = value_of(base, ctx.opts, side_view(ctx.full[c], side), (side == '') and ctx.adj[c] or nil)
end
end
return vals
end
--------------------------------------------------------------------------------
-- Head-to-head completeness (|h2h_after_complete=)
--------------------------------------------------------------------------------
-- One match slot: present with a readable score, or explicitly 'null'.
local function slot_ok(Args, key)
local raw = Args[key]
if raw == nil then return false end
local s = clean_cell(raw)
if s == '' then return false end
if s:lower() == 'null' then return true end
local hs = parse_score(raw)
return hs ~= nil
end
local function directional_key(h, a, n)
if n == 1 then return 'match_' .. h .. '_' .. a end
return 'match' .. n .. '_' .. h .. '_' .. a
end
local function neutral_key(x, y, n)
if n == 1 then return 'matchn_' .. x .. '_' .. y end
return 'matchn' .. n .. '_' .. x .. '_' .. y
end
-- Whether x and y have completed every leg against each other. Every leg is
-- expected in both directions (home and away); a leg explicitly marked
-- 'null' does not block completeness. Pairs with no directional fixtures at
-- all (an all-neutral competition) instead need one recorded neutral meeting
-- per leg, in either team's order.
local function h2h_pair_complete(Args, x, y, legs)
local has_directional = false
for n = 1, legs do
if Args[directional_key(x, y, n)] ~= nil or Args[directional_key(y, x, n)] ~= nil then
has_directional = true
break
end
end
if has_directional then
for n = 1, legs do
if not slot_ok(Args, directional_key(x, y, n)) or not slot_ok(Args, directional_key(y, x, n)) then
return false
end
end
return true
end
local nx, ny = x, y
if ny < nx then nx, ny = ny, nx end
for n = 1, legs do
if not (slot_ok(Args, neutral_key(nx, ny, n)) or slot_ok(Args, neutral_key(ny, nx, n))) then
return false
end
end
return true
end
-- Whether every pair within a tied bucket has completed its head-to-head fixtures.
local function bucket_h2h_complete(Args, bucket, legs)
for i = 1, #bucket do
for j = i + 1, #bucket do
if not h2h_pair_complete(Args, bucket[i], bucket[j], legs) then
return false
end
end
end
return true
end
-- Split tied teams by a criterion, retaining base order for equal values.
local function split_by(bucket, vals, desc, rank)
local sorted = {}
for _, c in ipairs(bucket) do sorted[#sorted + 1] = c end
table.sort(sorted, function(x, y)
local vx, vy = vals[x], vals[y]
if vx == nil and vy == nil then return rank[x] < rank[y] end
if vx == nil then return false end
if vy == nil then return true end
if vx == vy then return rank[x] < rank[y] end
if desc then return vx > vy end
return vx < vy
end)
local out, cur, prev = {}, nil, nil
for _, c in ipairs(sorted) do
local v = vals[c]
if cur == nil or v ~= prev then
cur = {c}
out[#out + 1] = cur
else
cur[#cur + 1] = c
end
prev = v
end
return out
end
local apply_items, apply_group
-- Reapply grouped criteria to smaller unresolved ties.
function apply_group(bucket, group, ctx, depth, frozen)
depth = (depth or 0) + 1
local res = apply_items({bucket}, group.items, ctx, frozen)
if depth >= MAX_RECURSION then return res end
local out = {}
for _, b in ipairs(res) do
if #b > 1 and #b < #bucket and not frozen[b] then
for _, nb in ipairs(apply_group(b, group, ctx, depth, frozen)) do
out[#out + 1] = nb
end
else
out[#out + 1] = b
end
end
return out
end
function apply_items(buckets, items, ctx, frozen)
frozen = frozen or {}
for _, item in ipairs(items) do
if item.final_only and not ctx.complete then
-- Final-only criteria require |update=complete.
break
end
local nextb = {}
for _, b in ipairs(buckets) do
if #b <= 1 or frozen[b] then
nextb[#nextb + 1] = b
else
local res
local scope = (item.kind == 'crit') and select(1, id_parts(item.id)) or nil
if scope == 'h2h' and ctx.h2h_gate and not bucket_h2h_complete(ctx.Args, b, ctx.legs) then
-- Not every tied team has played every other tied team yet.
res = {b}
if ctx.h2h_freeze then
-- Stop ranking this group altogether, not just this
-- criterion: it stays tied until the mini-league completes.
frozen[b] = true
end
-- Otherwise (the default), just skip this head-to-head
-- criterion for this group and continue with the next one.
elseif item.kind == 'group' then
res = apply_group(b, item, ctx, nil, frozen)
else
res = split_by(b, evaluate(item, b, ctx), item.desc, ctx.rank)
end
for _, nb in ipairs(res) do nextb[#nextb + 1] = nb end
end
end
buckets = nextb
end
return buckets
end
--------------------------------------------------------------------------------
-- Options and write-back
--------------------------------------------------------------------------------
-- write_ot uses the OT styles' points (win 3, overtime win 2, draw or overtime
-- loss 1, loss 0), which do not depend on |show_draw=.
local function read_opts(Args, write_ot)
local goalpoints = Args['goalpoints'] and (tonumber(Args['goalpoints']) or 1) or 0
if write_ot then
return {
ot = true,
winpoints = tonumber(Args['winpoints']) or 3,
otwinpoints = tonumber(Args['OTwinpoints']) or 2,
drawpoints = tonumber(Args['drawpoints']) or 1,
otlosspoints = tonumber(Args['OTlosspoints']) or 1,
losspoints = tonumber(Args['losspoints']) or 0,
goalpoints = goalpoints,
}
end
local show_draw = yesno(Args['show_draw'] or 'yes')
return {
winpoints = tonumber(Args['winpoints']) or (show_draw and 3 or 2),
otwinpoints = 0,
drawpoints = tonumber(Args['drawpoints']) or (show_draw and 1 or 0),
otlosspoints = 0,
losspoints = tonumber(Args['losspoints']) or (show_draw and 0 or 1),
goalpoints = goalpoints,
}
end
local function read_adjustments(Args, teams)
local adj = {}
for _, c in ipairs(teams) do
adj[c] = {
pts = (tonumber(Args['adjust_points_' .. c]) or 0) + (tonumber(Args['startpoints_' .. c]) or 0),
gf = tonumber(Args['adjust_gf_' .. c]) or 0,
ga = tonumber(Args['adjust_ga_' .. c]) or 0,
}
end
return adj
end
-- Warn about manual parameters that automatic generation ignores or overwrites.
local function check_ignored(Args, teams, errors, write_ha, write_ot)
local overwritten, n_over, first = {}, 0, nil
local rounds = {}
local fields = {'win', 'pf', 'pa', 'matches'}
if write_ot then
fields[#fields + 1] = 'OTwin'
fields[#fields + 1] = 'OTloss'
end
if write_ha then
for _, f in ipairs({'hwin', 'hdraw', 'hloss', 'hgf', 'hga', 'awin', 'adraw', 'aloss', 'agf', 'aga'}) do
fields[#fields + 1] = f
end
else
for _, f in ipairs({'draw', 'loss', 'gf', 'ga'}) do
fields[#fields + 1] = f
end
end
for _, c in ipairs(teams) do
local hit = false
for _, f in ipairs(fields) do
if Args[f .. '_' .. c] ~= nil then
overwritten[f] = true
hit = true
end
end
if hit then
n_over = n_over + 1
first = first or c
end
if tonumber(Args['rw_' .. c]) then rounds[#rounds + 1] = c end
end
if n_over > 0 then
local names = {}
for f in pairs(overwritten) do names[#names + 1] = '|' .. f .. '_TTT=' end
table.sort(names)
add_error(errors, 'values given in ' .. table.concat(names, ', ') .. ' are ignored when '
.. '|auto_generate_standings= is set (found for ' .. first
.. (n_over > 1 and (' and ' .. (n_over - 1) .. ' other team(s)') or '')
.. '); they are calculated from the match results and can be removed')
end
if #rounds > 0 then
add_error(errors, '|rw_TTT= is added to the points column by the style but is not used when ranking, '
.. 'so the table may not be in points order (found for ' .. table.concat(rounds, ', ')
.. '); rounds won are not supported by |auto_generate_standings=')
end
end
-- write_ha writes HA-style split fields (hwin_TTT, awin_TTT, etc.) only.
-- WDLHA/WLHA do not use plain fields, which argcheck would flag as unknown.
local function write_stats(Args, teams, full, write_ha, write_ot)
for _, c in ipairs(teams) do
local st = full[c]
Args['win_' .. c] = tostring(st.w)
if write_ot then
Args['OTwin_' .. c] = tostring(st.otw)
Args['OTloss_' .. c] = tostring(st.otl)
end
if write_ha then
Args['hwin_' .. c] = tostring(st.hw)
Args['hdraw_' .. c] = tostring(st.hd)
Args['hloss_' .. c] = tostring(st.hl)
Args['hgf_' .. c] = tostring(st.hgf)
Args['hga_' .. c] = tostring(st.hga)
Args['awin_' .. c] = tostring(st.aw)
Args['adraw_' .. c] = tostring(st.ad)
Args['aloss_' .. c] = tostring(st.al)
Args['agf_' .. c] = tostring(st.agf)
Args['aga_' .. c] = tostring(st.aga)
else
Args['draw_' .. c] = tostring(st.d)
Args['loss_' .. c] = tostring(st.l)
Args['gf_' .. c] = tostring(st.gf)
Args['ga_' .. c] = tostring(st.ga)
end
end
end
--------------------------------------------------------------------------------
-- Table rows
--------------------------------------------------------------------------------
-- Read manual ordering; |team_order= overrides |teamN= at any position both give.
-- Withdrawn teams are always placed at the bottom separately, so any
-- |teamN=/|team_order= entry naming one is ignored here.
local function read_pins(Args, top_pos, errors, withdrawn)
withdrawn = withdrawn or {}
local pins, order_full = {}, false
local from_teamN = {}
-- |teamN= gives an absolute table position, so a withdrawn entry cannot
-- just be dropped in place -- that would leave a gap and later positions
-- would fail range/displacement checks. Instead, delete it and shift
-- every later |teamN= down by one, exactly as if that slot never
-- existed; positions unrelated to any withdrawn team keep their number.
do
local raw = {}
for k, v in pairs(Args) do
if type(k) == 'string' and v and trim(v) ~= '' then
local num = k:match('^team(%d+)$')
if num then
raw[#raw + 1] = {num = tonumber(num), tname = trim(v)}
end
end
end
table.sort(raw, function(a, b) return a.num < b.num end)
local shift = 0
for _, entry in ipairs(raw) do
if withdrawn[entry.tname] then
shift = shift + 1
else
local pos = entry.num - shift
pins[pos] = entry.tname
from_teamN[pos] = entry.tname
end
end
end
local to = Args['team_order']
if to and trim(to) ~= '' then
order_full = true
local offset = (tonumber(Args['team_order_start']) or top_pos) - 1
local overridden = {}
local k = 0
for _, tname in ipairs(mw.text.split(to, '%s*[;,]%s*')) do
if tname ~= '' and not withdrawn[tname] then
k = k + 1
local pos = k + offset
if from_teamN[pos] and from_teamN[pos] ~= tname then
overridden[#overridden + 1] = pos
end
pins[pos] = tname
end
end
if errors and #overridden > 0 then
table.sort(overridden)
add_error(errors, '|team_order= and |team' .. table.concat(overridden, '=, |team') .. '= are both set; '
.. '|team_order= takes precedence, so the |teamN= value(s) at position(s) '
.. table.concat(overridden, ', ') .. ' have been ignored')
end
end
return pins, order_full
end
local function clear_team_args(Args)
local keys = {}
for k, _ in pairs(Args) do
if type(k) == 'string' and k:match('^team%d+$') then keys[#keys + 1] = k end
end
for _, k in ipairs(keys) do Args[k] = nil end
Args['team_order'] = nil
Args['team_order_start'] = nil
end
-- Place ranked teams, applying manual ordering unless disabled.
local function place(Args, buckets, top_pos, errors, ignore_manual, withdrawn)
local auto, auto_index, shared, group_of = {}, {}, {}, {}
local n, gid = 0, 0
for _, b in ipairs(buckets) do
gid = gid + 1
local pos = top_pos + n
for _, c in ipairs(b) do
n = n + 1
auto[n] = c
auto_index[c] = top_pos + n - 1
shared[c] = pos
if #b > 1 then group_of[c] = gid end
end
end
local pins, order_full = {}, false
if not ignore_manual then
pins, order_full = read_pins(Args, top_pos, errors, withdrawn)
end
-- A valid manual order must fill every vacated slot.
local pinned_at, ok, count = {}, true, 0
-- Keep messages in a stable order.
local pin_slots = {}
for pos in pairs(pins) do pin_slots[#pin_slots + 1] = pos end
table.sort(pin_slots)
for _, pos in ipairs(pin_slots) do
local tname = pins[pos]
count = count + 1
if not auto_index[tname] then
ok = false
add_error(errors, 'the team "' .. tname .. '" given in the manual order is not in the table')
elseif pinned_at[tname] then
ok = false
add_error(errors, 'the team "' .. tname .. '" is given more than once in the manual order')
else
pinned_at[tname] = pos
end
if pos < top_pos or pos > (top_pos + n - 1) then
ok = false
add_error(errors, 'position ' .. pos .. ' in the manual order is outside the table')
end
end
if ok then
for _, slot in ipairs(pin_slots) do
local tname = pins[slot]
local pos = pinned_at[tname]
if tname and pins[auto_index[tname]] == nil then
ok = false
add_error(errors, 'the manual order is incomplete: "' .. tname .. '" has been moved from position '
.. auto_index[tname] .. ' to position ' .. pos .. ', but nothing has been given for position '
.. auto_index[tname] .. '. Every team displaced by a |teamN= must itself be given a position, '
.. 'otherwise the order cannot be resolved. The order before the manual changes has been used instead')
end
end
end
local final, manual = {}, false
if count > 0 and ok then
manual = true
for pos, tname in pairs(pins) do final[pos] = tname end
local rest = {}
for i = 1, n do
if not pinned_at[auto[i]] then rest[#rest + 1] = auto[i] end
end
local j = 1
for i = top_pos, top_pos + n - 1 do
if not final[i] then
final[i] = rest[j]
j = j + 1
end
end
else
for i = 1, n do final[top_pos + i - 1] = auto[i] end
end
-- Manual ordering breaks tied-position groups it touches.
local broken = {}
if manual then
if order_full then
for g = 1, gid do broken[g] = true end
else
for tname, _ in pairs(pinned_at) do
if group_of[tname] then broken[group_of[tname]] = true end
end
end
end
-- Number every row if tied positions are disabled.
local show_tied = yesno(Args['show_tied_positions'] or 'yes')
clear_team_args(Args)
for i = top_pos, top_pos + n - 1 do
local c = final[i]
Args['team' .. i] = c
local shown = i
if show_tied and group_of[c] and not broken[group_of[c]] then shown = shared[c] end
-- Preserve editor-set positions.
if Args['pos_' .. c] == nil and shown ~= i then
Args['pos_' .. c] = tostring(shown)
end
end
-- Prevent stale |teamN= values from adding rows.
if not tonumber(Args['lowest_pos']) then
Args['lowest_pos'] = tostring(top_pos + n - 1)
end
return n
end
--------------------------------------------------------------------------------
-- Entry points
--------------------------------------------------------------------------------
-- Build standings and return any errors. write_ha additionally computes and
-- writes the home/away split fields a HA-style table needs to render.
function pa.generate(Args, top_pos, write_ha, write_ot)
local errors = {}
top_pos = top_pos or 1
local teams, codes = pa.roster(Args)
if #teams == 0 then
add_error(errors, 'no teams were found: |auto_generate_standings= needs |name_TTT= or |match_TTT_SSS= parameters')
return errors
end
check_orphans(Args, teams, errors)
local withdrawn, withdrawn_order = pa.withdrawn(Args)
for _, c in ipairs(withdrawn_order) do
if not codes[c] then
add_error(errors, 'the team "' .. c .. '" given in |withdrawn_teams= is not in the table')
end
end
local matches = pa.matches(Args, codes, errors, write_ot)
local opts = read_opts(Args, write_ot)
local adj = read_adjustments(Args, teams)
local full = build_stats(matches, teams)
check_ignored(Args, teams, errors, write_ha, write_ot)
write_stats(Args, teams, full, write_ha, write_ot)
local crit_str = Args['ranking_criteria']
if not crit_str or trim(crit_str) == '' then crit_str = 'pts, gd, gf' end
local items = parse_criteria(crit_str, errors)
-- Withdrawn teams do not compete for ranked positions; they are appended
-- below, in the order given, after the ranked teams are placed.
local start = {}
local rank = {}
for i, c in ipairs(pa.base_order(Args, teams, codes, errors)) do
if not withdrawn[c] then
start[#start + 1] = c
rank[c] = i
end
end
local legs = tonumber(Args['legs']) or 1
-- |h2h_after_complete=freeze leaves teams tied after an incomplete
-- head-to-head criterion; other positive values skip it and continue.
local h2h_raw = trim(Args['h2h_after_complete'] or '')
local h2h_freeze = (string.lower(h2h_raw) == 'freeze')
local h2h_gate = h2h_freeze or (yesno(h2h_raw) and true or false)
if h2h_gate then
local fmt = string.lower(trim(Args['matches_format']))
if fmt == 'schedule' or fmt == 'series' or fmt == 'series_split' then
add_error(errors, '|h2h_after_complete= has no effect with |matches_format=' .. fmt
.. ', because that fixture list is not necessarily a full round-robin; the head-to-head '
.. 'criteria have been applied immediately instead')
h2h_gate = false
h2h_freeze = false
end
end
local ctx = {
matches = matches,
full = full,
adj = adj,
opts = opts,
rank = rank,
complete = (trim(Args['update']):lower() == 'complete'),
Args = Args,
legs = legs,
h2h_gate = h2h_gate,
h2h_freeze = h2h_freeze,
}
local buckets = apply_items({start}, items, ctx)
local n = place(Args, buckets, top_pos, errors, nil, withdrawn)
-- Withdrawn teams are appended after place() has fully resolved the
-- ranked teams.
local next_pos = top_pos + n
for _, c in ipairs(withdrawn_order) do
if codes[c] then
Args['team' .. next_pos] = c
next_pos = next_pos + 1
end
end
return errors
end
-- Place teams in base order for |show_matches=only.
function pa.order_only(Args, top_pos, ignore_manual)
local errors = {}
top_pos = top_pos or 1
local teams, codes = pa.roster(Args)
if #teams == 0 then
add_error(errors, 'no teams were found: |auto_generate_standings= needs |name_TTT= or |match_TTT_SSS= parameters')
return errors
end
check_orphans(Args, teams, errors)
local withdrawn, withdrawn_order = pa.withdrawn(Args)
for _, c in ipairs(withdrawn_order) do
if not codes[c] then
add_error(errors, 'the team "' .. c .. '" given in |withdrawn_teams= is not in the table')
end
end
local buckets = {}
for _, c in ipairs(pa.base_order(Args, teams, codes, errors)) do
if not withdrawn[c] then
buckets[#buckets + 1] = {c}
end
end
place(Args, buckets, top_pos, errors, ignore_manual, withdrawn)
return errors
end
return pa