Module:alternative forms: difference between revisions
Jump to navigation
Jump to search
Content deleted Content added
delete now-unused categorize() method; handled in Module:documentation |
fix support for references in {{alt}} items |
||
(16 intermediate revisions by 2 users not shown) | |||
Line 1: | Line 1: | ||
local export = {} |
local export = {} |
||
local m_links = require("Module:links") |
|||
local m_languages = require("Module:languages") |
|||
local put_module = "Module:parse utilities" |
|||
local |
local labels_module = "Module:labels" |
||
local links_module = "Module:links" |
|||
local parameter_utilities_module = "Module:parameter utilities" |
|||
-- See if the language's dialectal data module has a label corresponding to the dialect argument. |
|||
local parameters_module = "Module:parameters" |
|||
function export.getLabel(dialect, dialect_data) |
|||
local parse_utilities_module = "Module:parse utilities" |
|||
local data = dialect_data[dialect] or ( dialect_data.labels and dialect_data.labels[dialect] ) |
|||
local pron_qualifier_module = "Module:pron qualifier" |
|||
local alias_of = ( dialect_data.aliases and dialect_data.aliases[dialect] ) |
|||
if not data then |
|||
if alias_of then |
|||
data = dialect_data[alias_of] or ( dialect_data.labels and dialect_data.labels[alias_of] ) |
|||
end |
|||
end |
|||
if data then |
|||
local display = data.display or dialect |
|||
if data.appendix then |
|||
dialect = '[[Appendix:' .. data.appendix .. '|' .. display .. ']]' |
|||
else |
|||
local target = data.link |
|||
dialect = target and '[[w:'.. target .. '|' .. display .. ']]' or display |
|||
end |
|||
end |
|||
return dialect |
|||
end |
|||
function export.make_dialects(raw, lang) |
|||
local dialect_page = 'Module:'.. lang:getCode() ..':Dialects' |
|||
local dialect_info |
|||
if raw[1] then |
|||
dialect_info = mw.title.new(dialect_page).exists and mw.loadData(dialect_page) or false |
|||
end |
|||
local dialects = {} |
|||
for _, dialect in ipairs(raw) do |
|||
table.insert(dialects, dialect_info and export.getLabel(dialect, dialect_info) or dialect) |
|||
end |
|||
return dialects |
|||
end |
|||
local function track(page) |
local function track(page) |
||
Line 47: | Line 12: | ||
end |
end |
||
-- Per-param modifiers, which can be specified either as separate parameters (e.g. t2=, pos3=) or as inline modifiers |
|||
-- <t:...>, <pos:...>, etc. The key is the name fo the parameter (e.g. "t", "pos") and the value is a table with |
|||
-- elements as follows: |
|||
-- * `extra_specs`: An optional table of extra key-value pairs to add to the spec used for parsing the parameter |
|||
-- when specified as a separate parameter (e.g. {type = "boolean"} for a Boolean parameter, or |
|||
-- {alias_of = "t"} for the "gloss" parameter, which is aliased to "t"), on top of the default, which |
|||
-- is {list = true, allow_holes = true}. |
|||
-- * `convert`: An optional function to convert the raw argument into the form passed to [[Module:links]]. |
|||
-- This function takes two parameters: (1) `arg` (the raw argument); (2) `parse_err` (a function used to |
|||
-- throw an error in case of a parse error). |
|||
-- * `item_dest`: The name of the key used when storing the parameter's value into the processed `term` or `termobj` |
|||
-- object. Normally the same as the parameter's name. Different in the case of "t", where we store the |
|||
-- gloss in "gloss", and "g", where we store the genders in "genders". |
|||
local param_mods = { |
local param_mods = { |
||
alt = {}, |
|||
t = { |
t = { |
||
-- [[Module:links]] expects the gloss in "gloss". |
|||
-- We need to store the t1=/t2= param and the <t:...> inline modifier into the "gloss" key of the parsed term, |
|||
-- because that is what [[Module:links]] expects. |
|||
item_dest = "gloss", |
item_dest = "gloss", |
||
}, |
}, |
||
gloss = { |
gloss = { |
||
alias_of = "t", |
|||
-- The `extra_specs` handles the fact that "gloss" is an alias of "t". |
|||
extra_specs = {alias_of = "t"}, |
|||
}, |
}, |
||
tr = {}, |
tr = {}, |
||
ts = {}, |
ts = {}, |
||
g = { |
g = { |
||
-- [[Module:links]] expects the genders in "genders". |
|||
-- We need to store the g1=/g2= param and the <g:...> inline modifier into the "genders" key of the parsed term, |
|||
-- because that is what [[Module:links]] expects. |
|||
item_dest = "genders", |
item_dest = "genders", |
||
sublist = true, |
|||
convert = function(arg, parse_err) |
|||
return rsplit(arg, ",") |
|||
end, |
|||
}, |
}, |
||
pos = {}, |
|||
lit = {}, |
|||
id = {}, |
id = {}, |
||
alt = {}, |
|||
q = {}, |
|||
qq = {}, |
|||
lit = {}, |
|||
pos = {}, |
|||
sc = { |
sc = { |
||
separate_no_index = true, |
|||
-- sc1=, sc2=, ... are different from sc=; the former apply to individual arguments while the latter applies to |
|||
type = "script", |
|||
-- all arguments. To handle this in separate parameters, we need to set the key in the `params` object passed to |
|||
-- [[Module:parameters]] to something else (in this case "partsc") and set `list = "sc"` and |
|||
-- `require_index = true` in the value of the `params` object. This causes [[Module:parameters]] to fetch |
|||
-- parameters named sc1=, sc2= etc. but store them into "partsc", while sc= is stored into "sc". |
|||
param_key = "partsc", |
|||
require_index = true, |
|||
extra_specs = {list = "sc"}, |
|||
convert = function(arg, parse_err) |
|||
return require("Module:scripts").getByCode(arg, parse_err) |
|||
end, |
|||
}, |
}, |
||
} |
} |
||
--[==[ |
|||
local function get_valid_prefixes() |
|||
Main function for displaying alternative forms. Extracted out from the template-callable function so this can be |
|||
local valid_prefixes = {} |
|||
called by other modules (in particular, [[Module:descendants tree]]). `show_labels_after_terms` no longer has any |
|||
for param_mod, _ in pairs(param_mods) do |
|||
meaning. `allow_self_link` causes terms the same as the pagename to be shown normally; otherwise they are displayed |
|||
table.insert(valid_prefixes, param_mod) |
|||
unlinked. |
|||
end |
|||
]==] |
|||
table.sort(valid_prefixes) |
|||
function export.display_alternative_forms(parent_args, pagename, show_labels_after_terms, allow_self_link) |
|||
return valid_prefixes |
|||
end |
|||
-- Main function for displaying alternative forms. Extracted out from the template-callable function so this can be |
|||
-- called by other modules (in particular, [[Module:descendants tree]]). `show_dialect_tags_after_terms` (used by |
|||
-- [[Module:descendants tree]]) causes dialect tags to be placed in brackets after each term rather than at the end |
|||
-- using an em-dash. `allow_self_link` causes terms the same as the pagename to be shown normally; otherwise they are |
|||
-- displayed unlinked. |
|||
function export.display_alternative_forms(parent_args, pagename, show_dialect_tags_after_terms, allow_self_link) |
|||
local list_with_holes = { list = true, allow_holes = true } |
|||
local params = { |
local params = { |
||
[1] = { |
[1] = {required = true, type = "language", etym_lang = true, default = "en"}, |
||
[2] = |
[2] = {list = true, allow_holes = true}, |
||
["sc"] = {}, |
|||
} |
} |
||
local m_param_utils = require(parameter_utilities_module) |
|||
-- Add parameters for each term modifier. |
|||
m_param_utils.augment_param_mods_with_pron_qualifiers(param_mods, { |
|||
for param_mod, param_mod_spec in pairs(param_mods) do |
|||
{param = "q", separate_no_index = false}, |
|||
local param_key = param_mod_spec.param_key or param_mod |
|||
{param = "l", separate_no_index = false, require_index = true}, |
|||
if not param_mod_spec.extra_specs then |
|||
"ref", |
|||
params[param_key] = list_with_holes |
|||
}) |
|||
else |
|||
m_param_utils.augment_params_with_modifiers(params, param_mods) |
|||
local param_spec = mw.clone(list_with_holes) |
|||
for k, v in pairs(param_mod_spec.extra_specs) do |
|||
param_spec[k] = v |
|||
end |
|||
if param_mod_spec.require_index then |
|||
param_spec.require_index = true |
|||
end |
|||
params[param_key] = param_spec |
|||
end |
|||
end |
|||
local args = require("Module:parameters").process(parent_args, params) |
local args = require("Module:parameters").process(parent_args, params) |
||
local lang = m_languages.getByCode(args[1], 1) |
|||
local sc = args["sc"] and require("Module:scripts").getByCode(args["sc"], "sc") or nil |
|||
local |
local lang = args[1] |
||
local items = {} |
|||
local items = m_param_utils.process_list_arguments { |
|||
-- Find the maximum index among any of the list parameters. |
|||
args = args, |
|||
local maxmaxindex = 0 |
|||
param_mods = param_mods, |
|||
for k, v in pairs(args) do |
|||
termarg = 2, |
|||
if type(v) == "table" and v.maxindex and v.maxindex > maxmaxindex then |
|||
parse_lang_prefix = true, |
|||
maxmaxindex = v.maxindex |
|||
track_module = "alter", |
|||
end |
|||
lang = lang, |
|||
end |
|||
sc = args.sc.default, |
|||
stop_when = function(data) |
|||
return not data.any_param_at_index |
|||
end, |
|||
} |
|||
if |
if not items[1] then |
||
error("No items found!") |
|||
error("Either a positional parameter, alt parameter, id parameter, tr parameter, or ts parameter is required.") |
|||
end |
end |
||
local raw_labels = {} |
|||
-- Is set to true if there is a term (entry link, alt text, transliteration, transcription) at the previous index. |
|||
local prev = false |
|||
local use_semicolon = false |
|||
local put |
|||
-- Extract the labels and make sure none are blank or omitted. |
|||
local termno = 0 |
|||
local last_item_index = items[#items].orig_index |
|||
for i = 1, maxmaxindex do |
|||
if last_item_index < args[2].maxindex then |
|||
-- If the previous term parameter was empty and we're not on the first term parameter, |
|||
for i = last_item_index + 2, args[2].maxindex do |
|||
-- this term parameter and any others contain dialect or other labels. |
|||
if |
if not args[2][i] then |
||
-- Indices in i start at 1 but parameters start at 2 to add 1 to shown index. |
|||
rawDialects = {unpack(args[2], i, maxmaxindex)} |
|||
error("Missing/blank item not allowed in [[Template:alt]] labels, but saw such an item in parameter " |
|||
break |
|||
.. (i + 1)) |
|||
end |
|||
table.insert(raw_labels, args[2][i]) |
|||
end |
end |
||
end |
|||
-- Make sure there aren't property parameters after the last item (i.e. corresponding to labels). |
|||
local term = args[2][i] |
|||
for k, v in pairs(args) do |
|||
-- Look for named list parameters. We check: |
|||
if term ~= ";" then |
|||
-- (1) key is a string (excludes the term param, which is a number); |
|||
termno = termno + 1 |
|||
-- (2) value is a table, i.e. a list; |
|||
-- (3) v.maxindex is set (i.e. allow_holes was used); |
|||
-- Compute whether any of the separate indexed params exist for this index. |
|||
-- (4) v.maxindex is past the index of the last term. |
|||
local any_param_at_index = term ~= nil |
|||
if type(k) == "string" and type(v) == "table" and v.maxindex and v.maxindex > last_item_index then |
|||
for k, v in pairs(args) do |
|||
local set_values = {} |
|||
-- Look for named list parameters. We check: |
|||
for i = last_item_index + 1, v.maxindex do |
|||
-- (1) key is a string (excludes 2=, a numbered rather than named list param, because it needs to |
|||
if v[i] then |
|||
-- be indexed using `i` instead of `termno`); |
|||
table.insert(set_values, i) |
|||
-- (2) value is a table (1= and sc= are converted into strings or nil rather than lists); |
|||
-- (3) the value has an entry at index `termno` (the current logical index). |
|||
if type(k) == "string" and type(v) == "table" and v[termno] then |
|||
any_param_at_index = true |
|||
-- Tracking for use of any specific indexed parameter. FIXME: Do we still need this? |
|||
-- FIXME: If we don't need it, remove the call to track() below, add `break` below, and wrap |
|||
-- the `for` loop in `if not any_param_at_index then` for efficiency purposes. |
|||
-- break |
|||
-- [[Special:WhatLinksHere/Template:tracking/alter/alt]] |
|||
-- [[Special:WhatLinksHere/Template:tracking/alter/id]] |
|||
-- [[Special:WhatLinksHere/Template:tracking/alter/tr]] |
|||
-- [etc.] |
|||
track(k) |
|||
end |
end |
||
end |
end |
||
error(("Extraneous values for %s= (set at position%s %s)"):format(k, #set_values > 1 and "s" or "", |
|||
table.concat(set_values, ","))) |
|||
end |
|||
end |
|||
if not allow_self_link then |
|||
-- If any of the params used for formatting this term is present, create a term and add it to the list. |
|||
-- If the to-be-linked term is the same as the pagename, display it unlinked. |
|||
if any_param_at_index then |
|||
for _, item in ipairs(items) do |
|||
-- Initialize the `termobj` object passed to full_link() in [[Module:links]]. |
|||
if not item.term and (lang:makeEntryName(item.term)) == pagename then |
|||
local termobj = { |
|||
track("term is pagename") |
|||
joiner = i > 1 and (args[2][i - 1] == ";" and "; " or ", ") or "", |
|||
item.alt = item.alt or item.term |
|||
lang = lang, |
|||
item.term = nil |
|||
term = term, |
|||
} |
|||
-- Parse all the term-specific parameters and store in `termobj`. |
|||
for param_mod, param_mod_spec in pairs(param_mods) do |
|||
local dest = param_mod_spec.item_dest or param_mod |
|||
local param_key = param_mod_spec.param_key or param_mod |
|||
local arg = args[param_key] and args[param_key][termno] |
|||
if arg then |
|||
if param_mod_spec.convert then |
|||
local function parse_err(msg, stack_frames_to_ignore) |
|||
error(("%s: %s%s=%s"):format(msg, param_mod, |
|||
(termno > 1 or param_mod_spec.require_index) and termno or "", arg), |
|||
stack_frames_to_ignore |
|||
) |
|||
end |
|||
arg = param_mod_spec.convert(arg, parse_err) |
|||
end |
|||
termobj[dest] = arg |
|||
end |
|||
end |
|||
-- Check for inline modifier, e.g. מרים<tr:Miryem>. But exclude HTML entry with <span ...>, <i ...>, |
|||
-- <br/> or similar in it, caused by wrapping an argument in {{l|...}}, {{af|...}} or similar. |
|||
-- Basically, all tags of the sort we parse here should consist of a less-than sign, plus letters, plus |
|||
-- a colon, e.g. <tr:...>, so if we see a tag on the outer level that isn't in this format, we don't |
|||
-- try to parse it. The restriction to the outer level is to allow generated HTML inside of e.g. |
|||
-- qualifier tags, such as foo<q:similar to {{m|fr|bar}}>. |
|||
if term and term:find("<") and not term:find("^[^<]*<[a-z]*[^a-z:]") then |
|||
local function generate_obj(term) |
|||
termobj.term = term ~= "" and term or nil |
|||
return termobj |
|||
end |
|||
require(put_module).parse_inline_modifiers(term, { |
|||
-- Add 1 because first term index starts at 2. |
|||
paramname = i + 1, |
|||
param_mods = param_mods, |
|||
generate_obj = generate_obj, |
|||
}) |
|||
end |
|||
-- If the displayed term (from .term or .alt) has an embedded comma, use a semicolon to join the terms. |
|||
local term_text = termobj.term or termobj.alt |
|||
if not use_semicolon and term_text then |
|||
if term_text:find(",", 1, true) then |
|||
use_semicolon = true |
|||
end |
|||
end |
|||
-- If the to-be-linked term is the same as the pagename, display it unlinked. |
|||
if not allow_self_link and termobj.term and (lang:makeEntryName(termobj.term)) == pagename then |
|||
track("term is pagename") |
|||
termobj.alt = termobj.alt or termobj.term |
|||
termobj.term = nil |
|||
end |
|||
table.insert(items, termobj) |
|||
prev = true |
|||
else |
|||
if math.max(args.alt.maxindex, args.id.maxindex, args.tr.maxindex, args.ts.maxindex) >= termno then |
|||
track("too few terms") |
|||
end |
|||
prev = false |
|||
end |
end |
||
end |
end |
||
end |
end |
||
local labels |
|||
-- The template must have either items or dialect labels. |
|||
if #raw_labels > 0 then |
|||
if items[1] == nil and rawDialects[1] == nil then error("No terms found!") end |
|||
labels = require(labels_module).process_raw_labels { labels = raw_labels, lang = lang, nocat = true } |
|||
end |
|||
local parts = {} |
|||
-- If any term had an embedded comma, override all joiners to be semicolons. |
|||
local function ins(part) |
|||
if use_semicolon then |
|||
table.insert(parts, part) |
|||
for i, item in ipairs(items) do |
|||
if i > 1 then |
|||
item.joiner = "; " |
|||
end |
|||
end |
|||
end |
end |
||
-- Construct the final output. |
|||
local dialects = export.make_dialects(rawDialects, lang) |
|||
-- |
-- First the items, including separators, left and right regular qualifiers and left and right per-item labels. |
||
for _, item in ipairs(items) do |
|||
-- is given) dialect tags. |
|||
ins(item.separator) |
|||
for i, item in ipairs(items) do |
|||
local text = require(links_module).full_link(item, nil, allow_self_link) |
|||
if item.q and item.q[1] or item.qq and item.qq[1] or item.l and item.l[1] or item.ll and item.ll[1] |
|||
-- Temporarily turn this off till we can fix it correctly. |
|||
or item.refs and item.refs[1] then |
|||
if false then -- show_dialect_tags_after_terms and #dialects > 0 then |
|||
text = require(pron_qualifier_module).format_qualifiers { |
|||
items[i] = items[i] .. " " .. require("Module:qualifier").format_qualifier(dialects, "[", "]") |
|||
lang = item.lang, |
|||
text = text, |
|||
q = item.q, |
|||
qq = item.qq, |
|||
l = item.l, |
|||
ll = item.ll, |
|||
refs = item.refs, |
|||
} |
|||
end |
end |
||
ins(text) |
|||
end |
end |
||
-- |
-- If there are labels, construct them now and append to final output. |
||
if |
if labels then |
||
if lang:hasTranslit() then |
|||
-- If there are dialect or similar tags, construct them now and append to final output. |
|||
ins(" — " .. require(labels_module).format_processed_labels { |
|||
if #dialects > 0 then |
|||
labels = labels, lang = lang |
|||
local dialect_label |
|||
}) |
|||
if lang:hasTranslit() then |
|||
else |
|||
dialect_label = " — ''" .. table.concat(dialects, ", ") .. "''" |
|||
ins(" " .. require(labels_module).format_processed_labels { |
|||
else |
|||
labels = labels, lang = lang, open = "(", close = ")" |
|||
}) |
|||
-- Fixes the problem of '' being added to '' at the end of last dialect parameter |
|||
dialect_label = mw.ustring.gsub(dialect_label, "''''", "") |
|||
table.insert(items, dialect_label) |
|||
end |
end |
||
end |
end |
||
return table.concat( |
return table.concat(parts) |
||
end |
end |
||
--[==[ |
|||
-- Template-callable function for displaying alternative forms. |
|||
Template-callable function for displaying alternative forms. |
|||
]==] |
|||
function export.create(frame) |
function export.create(frame) |
||
local parent_args = frame:getParent().args |
local parent_args = frame:getParent().args |
Revision as of 19:16, 16 June 2024
- The following documentation is located at Module:alternative forms/documentation. [edit]
- Useful links: subpage list • links • transclusions • testcases • sandbox (diff)
This module is called by {{alter}}
, the template that is used in Alternative forms sections to link the alternative forms of a term and to show which dialect or spelling system they belong to.
The dialect labels used after an empty parameter are now the same as those used by {{lb}}
, and can be found in the labels data modules, e.g. Module:labels/data/lang/en for English and Module:labels/data/lang/grc for Ancient Greek.
Testcases
- ὑμεῖς (humeîs)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- (using aliases of labels)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- items with commas
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- term param missing
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
- Lua error at line 52: attempt to call field 'augment_param_mods_with_pron_qualifiers' (a nil value)
See also
- Module:descendants tree, which retrieves alternative forms for
{{desc}}
and{{desctree}}
local export = {}
local labels_module = "Module:labels"
local links_module = "Module:links"
local parameter_utilities_module = "Module:parameter utilities"
local parameters_module = "Module:parameters"
local parse_utilities_module = "Module:parse utilities"
local pron_qualifier_module = "Module:pron qualifier"
local function track(page)
require("Module:debug/track")("alter/" .. page)
end
local param_mods = {
alt = {},
t = {
-- [[Module:links]] expects the gloss in "gloss".
item_dest = "gloss",
},
gloss = {
alias_of = "t",
},
tr = {},
ts = {},
g = {
-- [[Module:links]] expects the genders in "genders".
item_dest = "genders",
sublist = true,
},
pos = {},
lit = {},
id = {},
sc = {
separate_no_index = true,
type = "script",
},
}
--[==[
Main function for displaying alternative forms. Extracted out from the template-callable function so this can be
called by other modules (in particular, [[Module:descendants tree]]). `show_labels_after_terms` no longer has any
meaning. `allow_self_link` causes terms the same as the pagename to be shown normally; otherwise they are displayed
unlinked.
]==]
function export.display_alternative_forms(parent_args, pagename, show_labels_after_terms, allow_self_link)
local params = {
[1] = {required = true, type = "language", etym_lang = true, default = "en"},
[2] = {list = true, allow_holes = true},
}
local m_param_utils = require(parameter_utilities_module)
m_param_utils.augment_param_mods_with_pron_qualifiers(param_mods, {
{param = "q", separate_no_index = false},
{param = "l", separate_no_index = false, require_index = true},
"ref",
})
m_param_utils.augment_params_with_modifiers(params, param_mods)
local args = require("Module:parameters").process(parent_args, params)
local lang = args[1]
local items = m_param_utils.process_list_arguments {
args = args,
param_mods = param_mods,
termarg = 2,
parse_lang_prefix = true,
track_module = "alter",
lang = lang,
sc = args.sc.default,
stop_when = function(data)
return not data.any_param_at_index
end,
}
if not items[1] then
error("No items found!")
end
local raw_labels = {}
-- Extract the labels and make sure none are blank or omitted.
local last_item_index = items[#items].orig_index
if last_item_index < args[2].maxindex then
for i = last_item_index + 2, args[2].maxindex do
if not args[2][i] then
-- Indices in i start at 1 but parameters start at 2 to add 1 to shown index.
error("Missing/blank item not allowed in [[Template:alt]] labels, but saw such an item in parameter "
.. (i + 1))
end
table.insert(raw_labels, args[2][i])
end
end
-- Make sure there aren't property parameters after the last item (i.e. corresponding to labels).
for k, v in pairs(args) do
-- Look for named list parameters. We check:
-- (1) key is a string (excludes the term param, which is a number);
-- (2) value is a table, i.e. a list;
-- (3) v.maxindex is set (i.e. allow_holes was used);
-- (4) v.maxindex is past the index of the last term.
if type(k) == "string" and type(v) == "table" and v.maxindex and v.maxindex > last_item_index then
local set_values = {}
for i = last_item_index + 1, v.maxindex do
if v[i] then
table.insert(set_values, i)
end
end
error(("Extraneous values for %s= (set at position%s %s)"):format(k, #set_values > 1 and "s" or "",
table.concat(set_values, ",")))
end
end
if not allow_self_link then
-- If the to-be-linked term is the same as the pagename, display it unlinked.
for _, item in ipairs(items) do
if not item.term and (lang:makeEntryName(item.term)) == pagename then
track("term is pagename")
item.alt = item.alt or item.term
item.term = nil
end
end
end
local labels
if #raw_labels > 0 then
labels = require(labels_module).process_raw_labels { labels = raw_labels, lang = lang, nocat = true }
end
local parts = {}
local function ins(part)
table.insert(parts, part)
end
-- Construct the final output.
-- First the items, including separators, left and right regular qualifiers and left and right per-item labels.
for _, item in ipairs(items) do
ins(item.separator)
local text = require(links_module).full_link(item, nil, allow_self_link)
if item.q and item.q[1] or item.qq and item.qq[1] or item.l and item.l[1] or item.ll and item.ll[1]
or item.refs and item.refs[1] then
text = require(pron_qualifier_module).format_qualifiers {
lang = item.lang,
text = text,
q = item.q,
qq = item.qq,
l = item.l,
ll = item.ll,
refs = item.refs,
}
end
ins(text)
end
-- If there are labels, construct them now and append to final output.
if labels then
if lang:hasTranslit() then
ins(" — " .. require(labels_module).format_processed_labels {
labels = labels, lang = lang
})
else
ins(" " .. require(labels_module).format_processed_labels {
labels = labels, lang = lang, open = "(", close = ")"
})
end
end
return table.concat(parts)
end
--[==[
Template-callable function for displaying alternative forms.
]==]
function export.create(frame)
local parent_args = frame:getParent().args
local title = mw.title.getCurrentTitle()
local PAGENAME = title.text
return export.display_alternative_forms(parent_args, title)
end
return export