Linguifex

Module:etymology/templates: Difference between revisions

Created page with "local export = {} local m_languages = require("Module:languages") local m_etymology = require("Module:etymology") local rsplit = mw.text.split local rsubn = mw.ustring.gsub..."
 
No edit summary
 
(17 intermediate revisions by the same user not shown)
Line 1: Line 1:
local export = {}
local export = {}


local m_languages = require("Module:languages")
local require_when_needed = require("Module:require when needed")
local m_etymology = require("Module:etymology")


local rsplit = mw.text.split
local concat = table.concat
local rsubn = mw.ustring.gsub
local format_categories = require_when_needed("Module:utilities", "format_categories")
local insert = table.insert
local process_params = require_when_needed("Module:parameters", "process")
local trim = mw.text.trim
local lower = mw.ustring.lower
local dump = mw.dumpObject


-- version of rsubn() that discards all but the first return value
local etymology_module = "Module:etymology"
local function rsub(term, foo, bar)
local etymology_specialized_module = "Module:etymology/specialized"
local retval = rsubn(term, foo, bar)
local parameter_utilities_module = "Module:parameter utilities"
return retval
end


local function fetch_lang(lang, parameter)
-- For testing
return m_languages.getByCode(lang) or m_languages.err(lang, parameter)
local force_cat = false
end


local allowed_conjs = {"and", "or", ",", "/", "~", ";"}


local function fetch_source(code, disallow_family)
local function parse_etym_args(parent_args, base_params, has_dest_lang)
local source =
local m_param_utils = require(parameter_utilities_module)
m_languages.getByCode(code)
local param_mods = m_param_utils.construct_param_mods {
or require("Module:etymology languages").getByCode(code)
{group = {"link", "q", "l", "ref"}},
or not disallow_family and require("Module:families").getByCode(code)
}
if source then
return source
else
error("The language" .. (not disallow_family and ", family" or "") .. " or etymology language code \"" .. code .. "\" is not valid.")
end
end
 


local function fetch_script(sc)
local sourcearg, termarg
if sc then
if has_dest_lang then
return require("Module:scripts").getByCode(sc) or error("The script code \"" .. sc .. "\" is not valid.")
sourcearg, termarg = 2, 3
else
else
return nil
sourcearg, termarg = 1, 2
end
end
end
local terms, args = m_param_utils.parse_term_with_inline_modifiers_and_separate_params {
 
params = base_params,
 
param_mods = param_mods,
function export.etyl(frame)
raw_args = parent_args,
local params = {
termarg = termarg,
[1] = {required = true, default = "und"},
track_module = "etymology",
[2] = {},
lang = function(args)
["sort"] = {},
return args[sourcearg][#args[sourcearg]]
end,
sc = "sc",
-- Don't do this, doesn't seem to make sense.
-- parse_lang_prefix = true,
make_separate_g_into_list = true,
splitchar = ",",
subitem_param_handling = "last",
}
}
-- If term param 3= is empty, there will be no terms in terms.terms. To facilitate further code and for
local args = require("Module:parameters").process(frame:getParent().args, params)
-- compatibility,, insert one. It will display as <small>[Term?]</small>.
if not terms.terms[1] then
local source = fetch_source(args[1])
terms.terms[1] = {
local lang = args[2]
lang = args[sourcearg][#args[sourcearg]],
local sort_key = args["sort"]
sc = args.sc,
}
-- Empty language means English, but "-" means no language. Yes, confusing...
if not lang then
lang = "en"
elseif lang == "-" then
lang = nil
end
end
if lang then
 
lang = fetch_lang(lang, 2)
return terms.terms, args
end
if lang and (lang:getCode() == "la" or lang:getCode() == "nl") then
require("Module:debug").track("etyl/" .. lang:getCode())
require("Module:debug").track("etyl/" .. lang:getCode() .. "/" .. source:getCode())
end
return m_etymology.format_etyl(lang, source, sort_key)
end
end




function export.cognate(frame)
function export.parse_2_lang_args(parent_args, has_text, no_family)
local args = frame:getParent().args
local boolean = {type = "boolean"}
if args.gloss then
require("Module:debug").track("cognate/gloss param")
end
local params = {
local params = {
[1] = {required = true, default = "und"},
[1] = {
[2] = {},
required = true,
[3] = {alias_of = "alt"},
type = "language",
[4] = {alias_of = "t"},
default = "und"
},
["alt"] = {},
[2] = {
["g"] = {list = true},
required = true,
["id"] = {},
sublist = true,
["lit"] = {},
type = "language",
["pos"] = {},
family = not no_family,
["t"] = {},
default = "und"
["gloss"] = {alias_of = "t"},
["tr"] = {},
["ts"] = {},
["sc"] = {},
["sort"] = {},
}
args = require("Module:parameters").process(args, params)
local source = fetch_source(args[1])
local sc = fetch_script(args["sc"])
 
return m_etymology.format_cognate(
{
lang = source,
sc = sc,
term = args[2],
alt = args["alt"],
id = args["id"],
genders = args["g"],
tr = args["tr"],
ts = args["ts"],
gloss = args["t"],
pos = args["pos"],
lit = args["lit"]
},
},
args["sort"])
[3] = true,
end
 
 
function export.noncognate(frame)
return export.cognate(frame)
end
 
local function parse_2_lang_args(frame, has_text, no_family)
local params = {
[1] = {required = true, default = "und"},
[2] = {required = true, default = "und"},
[3] = {},
[4] = {alias_of = "alt"},
[4] = {alias_of = "alt"},
[5] = {alias_of = "t"},
[5] = {alias_of = "t"},
["alt"] = {},
["g"] = {list = true},
["gloss"] = {alias_of = "t"},
["id"] = {},
["lit"] = {},
["pos"] = {},
["t"] = {},
["tr"] = {},
["ts"] = {},
["sc"] = {},


["nocat"] = {type = "boolean"},
["senseid"] = true,
["sort"] = {},
["nocat"] = boolean,
["sort"] = true,
["sourceconj"] = true,
["conj"] = {set = allowed_conjs, default = ","},
}
}
if has_text then
if has_text then
params["notext"] = {type = "boolean"}
params["notext"] = boolean
params["nocap"] = {type = "boolean"}
params["nocap"] = boolean
end
end


local args = require("Module:parameters").process(frame:getParent().args, params)
return parse_etym_args(parent_args, params, "has dest lang")
local lang = fetch_lang(args[1], 1)
local source = fetch_source(args[2], no_family)
local sc = fetch_script(args["sc"])
 
return args, lang, {
lang = source,
sc = sc,
term = args[3],
alt = args["alt"],
id = args["id"],
genders = args["g"],
tr = args["tr"],
ts = args["ts"],
gloss = args["t"],
pos = args["pos"],
lit = args["lit"]
}
end
end


function export.derived(frame)
local args, lang, term = parse_2_lang_args(frame)
return m_etymology.format_derived(lang, term, args["sort"], args["nocat"], "derived")
end


function export.inherited(frame)
-- Implementation of deprecated {{etyl}}. Provided to make histories more legible.
local args, lang, term = parse_2_lang_args(frame, nil, "no family")
function export.etyl(frame)
return m_etymology.format_inherited(lang, term, args["sort"], args["nocat"])
local params = {
end
[1] = {required = true, type = "language", default = "und"},
 
[2] = {type = "language", default = "en"},
function export.borrowed(frame)
["sort"] = {},
local args, lang, term = parse_2_lang_args(frame)
}
return m_etymology.format_borrowed(lang, term, args["sort"],
-- Empty language means English, but "-" means no language. Yes, confusing...
false, true, args["nocat"], "plain")
local args = frame:getParent().args
end
if args[2] and trim(args[2]) == "-" then
 
params[2] = nil
function export.learned_borrowing(frame)
args = process_params({
if frame:getParent().args.gloss then
[1] = args[1],
require("Module:debug").track("learned_borrowing/gloss param")
["sort"] = args.sort
}, params)
else
args = process_params(args, params)
end
end
 
return require(etymology_module).format_source {
local args, lang, term = parse_2_lang_args(frame, "has text")
lang = args[2],
return m_etymology.format_borrowed(lang, term, args["sort"],
source = args[1],
args["nocap"], args["notext"], args["nocat"], "learned")
sort_key = args.sort,
force_cat = force_cat,
}
end
end


function export.semi_learned_borrowing(frame)
if frame:getParent().args.gloss then
require("Module:debug").track("semi_learned_borrowing/gloss param")
end


local args, lang, term = parse_2_lang_args(frame, "has text")
-- Implementation of {{derived}}/{{der}}.
return m_etymology.format_borrowed(lang, term, args["sort"],
function export.derived(frame)
args["nocap"], args["notext"], args["nocat"], "semi-learned")
local parent_args = frame:getParent().args
local terms, args = export.parse_2_lang_args(parent_args)
return require(etymology_module).format_derived {
lang = args[1],
sources = args[2],
terms = terms,
sort_key = args.sort,
nocat = args.nocat,
sourceconj = args.sourceconj,
conj = args.conj,
template_name = "derived",
force_cat = force_cat,
}
end
end


function export.orthographic_borrowing(frame)
-- Implementation of {{borrowed}}/{{bor}}.
if frame:getParent().args.gloss then
function export.borrowed(frame)
require("Module:debug").track("orthographic_borrowing/gloss param")
local parent_args = frame:getParent().args
end
local terms, args = export.parse_2_lang_args(parent_args)
 
return require(etymology_module).format_borrowed {
local args, lang, term = parse_2_lang_args(frame, "has text")
lang = args[1],
return m_etymology.format_borrowed(lang, term, args["sort"],
sources = args[2],
args["nocap"], args["notext"], args["nocat"], "orthographic")
terms = terms,
sort_key = args.sort,
nocat = args.nocat,
sourceconj = args.sourceconj,
conj = args.conj,
force_cat = force_cat,
}
end
end


function export.unadapted_borrowing(frame)
function export.inherited(frame)
if frame:getParent().args.gloss then
local parent_args = frame:getParent().args
require("Module:debug").track("unadapted_borrowing/gloss param")
local terms, args = export.parse_2_lang_args(parent_args)
local sources = args[2]
if sources[2] then
-- Because this doesn't really make sense.
error("[[Template:inherited]] doesn't support multiple comma-separated sources")
end
end
 
return require(etymology_module).format_inherited {
local args, lang, term = parse_2_lang_args(frame, "has text")
lang = args[1],
return m_etymology.format_borrowed(lang, term, args["sort"],
terms = terms,
args["nocap"], args["notext"], args["nocat"], "unadapted")
sort_key = args.sort,
nocat = args.nocat,
conj = args.conj,
force_cat = force_cat,
}
end
end


function export.calque(frame)
function export.cognate(frame)
local args = frame:getParent().args
local params = {
[1] = {
-- More informative error message.
required = true,
if args["etyl lang"] or args["etyl term"] or args["etyl t"] or args["etyl tr"] then
sublist = true,
error("{{[[Template:calque|calque]]}} no longer supports parameters beginning with etyl. " ..
type = "language",
"The parameters supported are similar to those used by " ..
family = true,
"{{[[Template:der|der]]}}, {{[[Template:inh|inh]]}}, " ..
default = "und"
"{{[[Template:bor|bor]]}}. See [[Template:calque/documentation]] for more.")
},
end
[2] = true,
[3] = {alias_of = "alt"},
local args, lang, term = parse_2_lang_args(frame, "has text")
[4] = {alias_of = "t"},
return m_etymology.calque(lang, term, args["sort"],
sourceconj = true,
args["nocap"], args["notext"], args["nocat"])
["conj"] = {set = allowed_conjs, default = ","},
end
sort = true,
}


function export.partial_calque(frame)
local parent_args = frame:getParent().args
if frame:getParent().args.gloss then
local terms, args = parse_etym_args(parent_args, params, false)
require("Module:debug").track("partial_calque/gloss param")
end


local args, lang, term = parse_2_lang_args(frame, "has text")
return require(etymology_module).format_cognate {
return m_etymology.partial_calque(lang, term, args["sort"],
sources = args[1],
args["nocap"], args["notext"], args["nocat"])
terms = terms,
sort_key = args.sort,
sourceconj = args.sourceconj,
conj = args.conj,
force_cat = force_cat,
}
end
end


function export.semantic_loan(frame)
function export.noncognate(frame)
local args, lang, term = parse_2_lang_args(frame, "has text")
return export.cognate(frame)
return m_etymology.semantic_loan(lang, term, args["sort"],
args["nocap"], args["notext"], args["nocat"])
end
end


function export.psm(frame)
-- Supports various specialized types of borrowings, according to `frame.args.bortype`:
local args, lang, term = parse_2_lang_args(frame, "has text")
--  "learned" = {{lbor}}/{{learned borrowing}}
return m_etymology.phono_semantic_matching(lang, term, args["sort"],
--  "semi-learned" = {{slbor}}/{{semi-learned borrowing}}
args["nocap"], args["notext"], args["nocat"])
--  "orthographic" = {{obor}}/{{orthographic borrowing}}
--  "unadapted" = {{ubor}}/{{unadapted borrowing}}
--  "calque" = {{cal}}/{{calque}}
--  "partial-calque" = {{pcal}}/{{partial calque}}
--  "semantic-loan" = {{sl}}/{{semantic loan}}
--  "transliteration" = {{translit}}/{{transliteration}}
--  "phono-semantic-matching" = {{psm}}/{{phono-semantic matching}}
function export.specialized_borrowing(frame)
local parent_args = frame:getParent().args
local terms, args = export.parse_2_lang_args(parent_args, "has text")
local m_etymology_specialized = require(etymology_specialized_module)
return m_etymology_specialized.specialized_borrowing {
bortype = frame.args.bortype,
lang = args[1],
sources = args[2],
terms = terms,
sort_key = args.sort,
nocap = args.nocap,
notext = args.notext,
nocat = args.nocat,
sourceconj = args.sourceconj,
conj = args.conj,
senseid = args.senseid,
force_cat = force_cat,
}
end
end


local function qualifier(content)
if content then
return table.concat{
'<span class="ib-brac qualifier-brac">(</span>',
'<span class="ib-content qualifier-content">',
content,
'</span>',
'<span class="ib-brac qualifier-brac">)</span>'
}
end
end


local function desc_or_desc_tree(frame, desc_tree)
-- Implementation of miscellaneous templates such as {{abbrev}}, {{back-formation}}, {{clipping}}, {{ellipsis}},
local params
-- {{rebracketing}} and {{reduplication}} that have a single associated term.
if desc_tree then
function export.misc_variant(frame)
params = {
local iparams = {
[1] = {required = true, default = "gem-pro"},
["ignore-params"] = true,
[2] = {required = true, default = "*fuhsaz"},
text = {required = true},
["notext"] = { type = "boolean" },
oftext = true,
["noalts"] = { type = "boolean" },
cat = {list = true}, -- allow and compress holes
["noparent"] = { type = "boolean" },
conj = true,
}
}
else
params = {
[1] = { required = true },
[2] = {},
["alts"] = { type = "boolean" }
}
end
 
for k, v in pairs({
[3] = {},
[4] = { alias_of = "gloss" },
["g"] = {list = true},
["gloss"] = {},
["id"] = {},
["lit"] = {},
["pos"] = {},
["t"] = { alias_of = "gloss" },
["tr"] = {},
["ts"] = {},
["sc"] = {},
["bor"] = { type = "boolean" },
["lbor"] = { type = "boolean" },
["slb"] = { type = "boolean" },
["der"] = { type = "boolean" },
["clq"] = { type = "boolean" },
["cal"] = { alias_of = "clq" },
["calq"] = { alias_of = "clq" },
["calque"] = { alias_of = "clq" },
["pclq"] = { type = "boolean" },
["sml"] = { type = "boolean" },
["unc"] = { type = "boolean" },
["sclb"] = { type = "boolean" },
["nolb"] = { type = "boolean" },
["q"] = {},
["sandbox"] = { type = "boolean" },
}) do
params[k] = v
end
 
local namespace = mw.title.getCurrentTitle().nsText
 
local args
if frame.args[1] then
args = require("Module:parameters").process(frame.args, params)
else
args = require("Module:parameters").process(frame:getParent().args, params)
end
 
if args.sandbox then
if namespace == "" or namespace == "Reconstruction" then
error('The sandbox module, Module:descendants tree/sandbox, should not be used in entries.')
end
end
local lang = args[1]
local term = args[2]
local alt = args[3]
local gloss = args["gloss"]
local tr = args["tr"]
local ts = args["ts"]
local sc = args["sc"]
local id = args["id"]
if namespace == "Template" then
if not ( sc or lang ) then
sc = "Latn"
end
if not lang then
lang = "en"
end
if not term then
term = "word"
end
end
lang = m_languages.getByCode(lang)
or require("Module:etymology languages").getByCode(lang)
or m_languages.err(lang, 1)
local entryLang = m_etymology.getNonEtymological(lang)
if not desc_tree and entryLang:getType() == "family" then
error("Cannot use language family code in [[Template:desc]].")
end
if lang:getCode() ~= entryLang:getCode() then
-- [[Special:WhatLinksHere/Template:tracking/descendant/etymological]]
require("Module:debug").track("descendant/etymological")
require("Module:debug").track("descendant/etymological/" .. lang:getCode())
end
if sc then
sc = require("Module:scripts").getByCode(sc) or error("The script code \"" .. sc .. "\" is not valid.")
end
local languageName = lang:getCanonicalName()
languageName = mw.ustring.gsub(languageName, "^Proto%-", "")
 
local link = ""
if term ~= "-" then
link = require("Module:links").full_link(
{
lang = entryLang,
sc = sc,
term = term,
alt = alt,
id = id,
tr = tr,
ts = ts,
genders = args["g"],
gloss = gloss,
pos = args["pos"],
lit = args["lit"],
},
nil,
true)
elseif ts or gloss or #args["g"] > 0 then
-- [[Special:WhatLinksHere/Template:tracking/descendant/no term]]
require "Module:debug".track("descendant/no term")
link = require("Module:links").full_link(
{
lang = entryLang,
sc = sc,
ts = ts,
gloss = gloss,
genders = args["g"],
},
nil,
true)
link = link
:gsub("<small>%[Term%?%]</small> ", "")
:gsub("<small>%[Term%?%]</small>&nbsp;", "")
:gsub("%[%[Category:[^%[%]]+ term requests%]%]", "")
else -- display no link at all
-- [[Special:WhatLinksHere/Template:tracking/descendant/no term or annotations]]
require "Module:debug".track("descendant/no term or annotations")
end
local function add_tooltip(text, tooltip)
return '<span class="desc-arr" title="' .. tooltip .. '">' .. text .. '</span>'
end
local label, arrow, descendants, alts, semi_learned, calque, partial_calque, semantic_loan, qual
if args["sclb"] then
if sc then
label = sc:getCanonicalName()
else
label = require("Module:scripts").findBestScript(term, lang):getCanonicalName()
end
else
label = languageName
end
if args["bor"] then
arrow = add_tooltip("→", "borrowed")
elseif args["lbor"] then
arrow = add_tooltip("→", "learned borrowed")
elseif args["slb"] then
arrow = add_tooltip("→", "semi-learned borrowing")
elseif args["clq"] then
arrow = add_tooltip("→", "calque")
elseif args["pclq"] then
arrow = add_tooltip("→", "partial calque")
elseif args["sml"] then
arrow = add_tooltip("→", "semantic loan")
elseif args["unc"] and not args["der"] then
arrow = add_tooltip(">", "inherited")
else
arrow = ""
end
-- allow der=1 in conjunction with bor=1 to indicate e.g. English "pars recta"
-- derived and borrowed from Latin "pars".
if args["der"] then
arrow = arrow .. add_tooltip("⇒", "reshaped by analogy or addition of morphemes")
end
if args["unc"]then
arrow = arrow .. add_tooltip("?", "uncertain")
end
 
local m_desctree
if desc_tree or args["alts"] then
if args.sandbox or require("Module:yesno")(frame.args.sandbox, false) then
m_desctree = require("Module:descendants tree/sandbox")
else
m_desctree = require("Module:descendants tree")
end
end
 
if desc_tree then
descendants = m_desctree.getDescendants(entryLang, term, id)
end
if desc_tree and not args["noalts"] or not desc_tree and args["alts"] then
-- [[Special:WhatLinksHere/Template:tracking/desc/alts]]
require("Module:debug").track("desc/alts")
alts = m_desctree.getAlternativeForms(entryLang, term, id)
end
if args["lbor"] then
learned = " " .. qualifier("learned")
else
learned = ""
end
if args["slb"] then
semi_learned = " " .. qualifier("semi-learned")
else
semi_learned = ""
end
if args["clq"] then
calque = " " .. qualifier("calque")
else
calque = ""
end
if args["pclq"] then
partial_calque = " " .. qualifier("partial calque")
else
partial_calque = ""
end
 
if args["sml"] then
semantic_loan = " " .. qualifier("semantic loan")
else
semantic_loan = ""
end
if args["q"] then
qual = " " .. require("Module:qualifier").format_qualifier(args["q"])
else
qual = ""
end


if args["noparent"] then
local iargs = process_params(frame.args, iparams)
return descendants
end
if arrow and arrow ~= "" then
arrow = arrow .. " "
end
local linktext = table.concat{link, alts or "", learned, semi_learned, calque,
partial_calque, semantic_loan, qual, descendants or ""}
if args["notext"] then
return linktext
elseif args["nolb"] then
return arrow .. linktext
else
return table.concat{arrow, label, ":", linktext ~= "" and " " or "", linktext}
end
end
function export.descendant(frame)
return desc_or_desc_tree(frame, false) .. require("Module:TemplateStyles")("Module:etymology/style.css")
end


function export.descendants_tree(frame)
local boolean = {type = "boolean"}
return desc_or_desc_tree(frame, true)
end


-- Implementation of miscellaneous templates such as {{back-formation}}, {{clipping}},
-- {{ellipsis}}, {{rebracketing}}, and {{reduplication}} that have a single
-- associated term.
function export.misc_variant(frame)
local params = {
local params = {
[1] = {required = true, default = "und"},
[1] = {required = true, type = "language", default = "und"},
[2] = {},
[2] = true,
[3] = {alias_of = "alt"},
[3] = {alias_of = "alt"},
[4] = {alias_of = "t"},
[4] = {alias_of = "t"},
 
["alt"] = {},
nocap = boolean, -- should be processed in the template itself
["gloss"] = {alias_of = "t"},
notext = boolean,
["g"] = {list = true},
nocat = boolean,
["id"] = {},
conj = {set = allowed_conjs},
["lit"] = {},
sort = true,
["pos"] = {},
["t"] = {},
["tr"] = {},
["ts"] = {},
["sc"] = {},
["nocap"] = {type = "boolean"}, -- should be processed in the template itself
["notext"] = {type = "boolean"},
["nocat"] = {type = "boolean"},
["sort"] = {},
}
}
 
-- |ignore-params= parameter to module invocation specifies
-- |ignore-params= parameter to module invocation specifies
-- additional parameter names to allow  in template invocation, separated by
-- additional parameter names to allow  in template invocation, separated by
-- commas. They must consist of ASCII letters or numbers or hyphens.
-- commas. They must consist of ASCII letters or numbers or hyphens.
local ignore_params = frame.args["ignore-params"]
local ignore_params = iargs["ignore-params"]
if ignore_params then
if ignore_params then
ignore_params = mw.text.trim(ignore_params)
ignore_params = trim(ignore_params)
if not ignore_params:match "^[%w%-,]+$" then
if not ignore_params:match("^[%w%-,]+$") then
error("Invalid characters in |ignore-params=: " .. ignore_params:gsub("[%w%-,]+", ""))
error("Invalid characters in |ignore-params=: " .. ignore_params:gsub("[%w%-,]+", ""))
end
end
for param in ignore_params:gmatch "[%w%-]+" do
for param in ignore_params:gmatch("[%w%-]+") do
if params[param] then
if params[param] then
error("Duplicate param |" .. param
error("Duplicate param |" .. param
.. " in |ignore-params=: already specified in params")
.. " in |ignore-params=: already specified in params")
end
end
params[param] = {}
params[param] = true
end
end
end
end
local args = require("Module:parameters").process(frame:getParent().args, params)
local lang = fetch_lang(args[1], 1)
local sc = fetch_script(args["sc"])


local parts = {}
local m_param_utils = require(parameter_utilities_module)
if not args["notext"] then
local param_mods = m_param_utils.construct_param_mods {
table.insert(parts, frame.args["text"])
{group = {"link", "q", "l", "ref"}},
end
}
if args[2] or args["alt"] then
if not args["notext"] then
table.insert(parts, " ")
table.insert(parts, frame.args["oftext"] or "of")
table.insert(parts, " ")
end
table.insert(parts, require("Module:links").full_link(
{
lang = lang,
sc = sc,
term = args[2],
alt = args["alt"],
id = args["id"],
tr = args["tr"],
ts = args["ts"],
genders = args["g"],
gloss = args["t"],
pos = args["pos"],
lit = args["lit"],
},
"term",
true))
end
-- Allow |cat=, |cat2=, |cat3=, etc. They must be sequential. If |cat=
-- is not defined, |cat2= will not be checked. Empty categories are ignored.
local categories = {}
if not args["nocat"] and frame.args["cat"] then
local cat_number
while true do
local cat = frame.args["cat" .. (cat_number or "")]
if not cat then break end
cat = mw.text.trim(cat)
if cat ~= "" then
table.insert(categories, lang:getCanonicalName() .. " " .. cat)
end
cat_number = (cat_number or 1) + 1
end
end
if #categories > 0 then
table.insert(
parts,
require("Module:utilities").format_categories(categories, lang, args["sort"]))
end


return table.concat(parts)
local parent_args = frame:getParent().args
end


local terms, args = m_param_utils.parse_term_with_inline_modifiers_and_separate_params {
params = params,
param_mods = param_mods,
raw_args = parent_args,
termarg = 2,
track_module = "etymology",
-- Don't set lang here as we want to know whether there was a lang prefix or not.
sc = "sc",
parse_lang_prefix = true,
allow_multiple_lang_prefixes = true,
make_separate_g_into_list = true,
splitchar = ",",
subitem_param_handling = "last",
}


local function get_parsed_part(template, lang, args, terms, i)
return require(etymology_module).format_misc_variant {
local term = terms[i]
lang = args[1],
local alt = args["alt"][i]
notext = args.notext,
local id = args["id"][i]
text = iargs.text,
local sc = fetch_script(args["sc"][i])
oftext = iargs.oftext,
 
terms = terms.terms,
local tr = args["tr"][i]
sort_key = args.sort,
local ts = args["ts"][i]
conj = args.conj or iargs.conj or "and",
local gloss = args["t"][i]
nocat = args.nocat,
local pos = args["pos"][i]
cats = iargs.cat,
local lit = args["lit"][i]
force_cat = force_cat,
local g = args["g"][i]
}
 
if not (term or alt or tr or ts) then
require("Module:debug").track(template .. "/no term or alt or tr")
return nil
else
return require("Module:links").full_link(
{ term = term, alt = alt, id = id, lang = lang, sc = sc, tr = tr,
ts = ts, gloss = gloss, pos = pos, lit = lit,
genders = g and rsplit(g, ",") or {}
}, "term", true)
end
end
end




local function get_parsed_parts(template, lang, args, terms)
-- Implementation of miscellaneous templates such as {{doublet}} that can take multiple terms. Doesn't handle {{blend}}
local parts = {}
-- or {{univerbation}}, which display + signs between elements and use compound_like in [[Module:affix/templates]].
 
function export.misc_variant_multiple_terms(frame)
-- Find the maximum index among any of the list parameters.
local iparams = {
local maxmaxindex = 0
text = {required = true},
for k, v in pairs(args) do
oftext = true,
if type(v) == "table" and v.maxindex and v.maxindex > maxmaxindex then
cat = {list = true}, -- allow and compress holes
maxmaxindex = v.maxindex
conj = true,
end
}
end


for index = 1, maxmaxindex do
local iargs = process_params(frame.args, iparams)
table.insert(parts, get_parsed_part(template, lang, args, terms, index))
end
return parts
end


local boolean = {type = "boolean"}


-- Implementation of miscellaneous templates such as {{doublet}} that can take
-- multiple terms. Doesn't handle {{blend}} or {{univerbation}}, which display
-- + signs between elements and use compound_like in [[Module:compound/templates]].
function export.misc_variant_multiple_terms(frame)
local params = {
local params = {
[1] = {required = true, default = "und"},
[1] = {required = true, type = "language", template_default = "und"},
[2] = {list = true, allow_holes = true},
[2] = {list = true, allow_holes = true},
nocap = boolean, -- should be processed in the template itself
notext = boolean,
nocat = boolean,
conj = {set = allowed_conjs},
sort = true,
}
    local m_param_utils = require(parameter_utilities_module)
local param_mods = m_param_utils.construct_param_mods {
-- We want to require an index for all params.
{default = true, require_index = true},
{group = {"link", "q", "l", "ref"}},
}


["t"] = {list = true, allow_holes = true, require_index = true},
local parent_args = frame:getParent().args
["gloss"] = {list = true, allow_holes = true, require_index = true, alias_of = "t"},
 
["tr"] = {list = true, allow_holes = true, require_index = true},
local terms, args = m_param_utils.parse_list_with_inline_modifiers_and_separate_params {
["ts"] = {list = true, allow_holes = true, require_index = true},
params = params,
["g"] = {list = true, allow_holes = true, require_index = true},
param_mods = param_mods,
["id"] = {list = true, allow_holes = true, require_index = true},
raw_args = parent_args,
["alt"] = {list = true, allow_holes = true, require_index = true},
termarg = 2,
["lit"] = {list = true, allow_holes = true, require_index = true},
parse_lang_prefix = true,
["pos"] = {list = true, allow_holes = true, require_index = true},
allow_multiple_lang_prefixes = true,
["sc"] = {list = true, allow_holes = true, require_index = true},
track_module = "etymology-templates-doublet",
disallow_custom_separators = true,
-- For compatibility, we need to not skip completely unspecified items. It is common, for example, to do
-- {{suffix|lang||foo}} to generate "+ -foo".
dont_skip_items = true,
-- Don't set lang here as we want to know whether there was a lang prefix or not.
sc = "sc.default",
}


["nocap"] = {type = "boolean"}, -- should be processed in the template itself
return require(etymology_module).format_misc_variant {
["notext"] = {type = "boolean"},
lang = args[1],
["nocat"] = {type = "boolean"},
notext = args.notext,
["sort"] = {},
text = iargs.text,
oftext = iargs.oftext,
terms = terms,
sort_key = args.sort,
conj = args.conj or iargs.conj or "and",
nocat = args.nocat,
cats = iargs.cat,
force_cat = force_cat,
}
}
end


local args = require("Module:parameters").process(frame:getParent().args, params)
-- Implementation of miscellaneous templates such as {{unknown}} that have no associated terms.
do
local lang = fetch_lang(args[1], 1)
local function get_args(frame)
local boolean = {type = "boolean"}
local params = {
[1] = {required = true, type = "language", default = "und"},


local parts = {}
["title"] = true,
if not args["notext"] then
["nocap"] = boolean, -- should be processed in the template itself
table.insert(parts, frame.args["text"])
["notext"] = boolean,
end
["nocat"] = boolean,
if #args[2] > 0 or #args["alt"] > 0 then
["sort"] = true,
if not args["notext"] then
}
table.insert(parts, " ")
if frame.args.title2_alias then
table.insert(parts, frame.args["oftext"] or "of")
params[2] = {alias_of = "title"}
table.insert(parts, " ")
end
end
local formatted_terms = get_parsed_parts(mw.ustring.lower(
return process_params(frame:getParent().args, params)
-- Remove link and convert uppercase to lowercase to get an
-- approximation of the original template name.
rsub(rsub(frame.args["text"], "^%[%[.*|", ""), "%]%]$", "")),
lang, args, args[2])
table.insert(parts, require("Module:table").serialCommaJoin(formatted_terms))
end
if not args["nocat"] and frame.args["cat"] then
local categories = {}
table.insert(categories, lang:getCanonicalName() .. " " .. frame.args["cat"])
table.insert(parts, require("Module:utilities").format_categories(categories, lang, args["sort"]))
end
end


return table.concat(parts)
function export.misc_variant_no_term(frame)
end
local args = get_args(frame)


return require(etymology_module).format_misc_variant_no_term {
lang = args[1],
notext = args.notext,
title = args.title or frame.args.text,
nocat = args.nocat,
cat = frame.args.cat,
sort_key = args.sort,
force_cat = force_cat,
}
end


-- Implementation of miscellaneous templates such as {{unknown}} that have no
-- This function works similarly to misc_variant_no_term(), but with some automatic linking to the glossary in
-- associated terms.
-- `title`.
function export.misc_variant_no_term(frame)
function export.onomatopoeia(frame)
local params = {
local args = get_args(frame)
[1] = {required = true, default = "und"},


["title"] = {},
local title = args.title
["nocap"] = {type = "boolean"}, -- should be processed in the template itself
if title and (lower(title) == "imitative" or lower(title) == "imitation") then
["notext"] = {type = "boolean"},
title = "[[wikt:Appendix:Glossary#imitative|" .. title .. "]]"
["nocat"] = {type = "boolean"},
end
["sort"] = {},
}


if frame.args["title2_alias"] then
return require(etymology_module).format_misc_variant_no_term {
params[2] = {alias_of = "title"}
lang = args[1],
notext = args.notext,
title = title or frame.args.text,
nocat = args.nocat,
cat = frame.args.cat,
sort_key = args.sort,
force_cat = force_cat,
}
end
end
local args = require("Module:parameters").process(frame:getParent().args, params)
local lang = fetch_lang(args[1], 1)
local parts = {}
if not args["notext"] then
table.insert(parts, args["title"] or frame.args["text"])
end
if not args["nocat"] and frame.args["cat"] then
local categories = {}
table.insert(categories, lang:getCanonicalName() .. " " .. frame.args["cat"])
table.insert(parts, require("Module:utilities").format_categories(categories, lang, args["sort"]))
end
return table.concat(parts)
end
end


return export
return export
Retrieved from "https://linguifex.com/wiki/Module:etymology/templates"