Module:pollasena-roots

The following documentation is located at Module:pollasena-roots/doc.^[edit]

Useful links: subpage list • links • transclusions • testcases • sandbox

This module implemented inherited templates for Pollasena languages: {{qsc-inh}}, {{sekh-inh}}, {{gwax-wasc}}, {{soky-inh}}. It was generalized to also include other non-Pollasena languages: {{guim-inh}}.

---

local m_put = require("Module:parse utilities")
local m_families = require("Module:families")
local m_lang = require("Module:languages")
local m_param = require("Module:parameters")
local m_param_utils = require("Module:parameter utilities")
local m_param_utils = require("Module:parameter utilities")
local m_utils = require("Module:utilities")
local m_etym = require("Module:etymology")
local m_etym_specialized = require("Module:etymology/specialized")
local m_links = require("Module:links")
local m_table = require("Module:table")

local gsub = mw.ustring.gsub
local match = mw.ustring.match

local export = {}

local wasc_suffixes = m_table.listToSet {
	"-ati", "-cosc", "-e", "-ekan", "-i", "-ila", "-kan",
	"-la", "-osc", "-otl", "-que", "-scati", "-si", "-tl",
}

local function get_single_args(args, index)
	local single = {}
	for k, v in pairs(args) do
		if type(v) == "table" and v.maxindex then
			if v[index] ~= nil then
				single[k] = v[index]
			end
		else
			single[k] = v
		end
	end
	return single
end

function export.parse_args(parent_args, dest_code, ancestor_codes, extra_params)
	local param_mods = m_param_utils.construct_param_mods({{group = {"link", "q", "l"}}})
	
	local params = extra_params or {}
	params.nocap = {type = "boolean"} -- no capital letter
	params.nocat = {type = "boolean"} -- no categories
	params.p = {} -- borrowing process
	
	local termarg_index
	if parent_args.borrowing then
		termarg_index = 2
		params[1] = {
			type = "language",
			required = true,
		}
	else
		termarg_index = 1
	end
	
	for _, ancestor in ipairs(ancestor_codes) do
		local lang_options = ancestor.options or {}
		
		if lang_options.roots then
			params[termarg_index] = {
				required = not lang_options.optional,
				list = true,
			}
			params["c"] = {
				list = true,
				allow_holes = true,
			}
		else
			params[termarg_index] = {
				required = not lang_options.optional,
			}
			
			if lang_options.annotated then
				params["parts"] = {
					sublist = true,
				}	
			end
		end
		
		termarg_index = termarg_index + 1
	end
	
	m_param_utils.augment_params_with_modifiers(params, param_mods)
	
	local args = m_param.process(parent_args, params)

	local dest_lang = m_lang.getByCode(dest_code)
	local etymologies = {}
	
	termarg_index = parent_args.borrowing and 2 or 1
	local cats = {}
	for _, ancestor in ipairs(ancestor_codes) do
		local code = ancestor.code
		local lang_options = ancestor.options or {}
		local ancestor_lang = m_lang.getByCode(code)
		
		local raw_val = parent_args[termarg_index] or parent_args[tostring(termarg_index)]
		if lang_options.optional and (raw_val == nil or raw_val == "") then
			termarg_index = termarg_index + 1
		else
			local terms
			local separator = ""
			
			if lang_options.roots then
				local items = m_param_utils.parse_list_with_inline_modifiers_and_separate_params({
					processed_args = args,
					param_mods = param_mods,
					termarg = termarg_index,
					lang = ancestor_lang,
				})
				
				terms = {}
				local root_index = 1
				local last_term = ""
				for _, item in ipairs(items) do
					if item.alt and not match(item.alt, "^%*") and ancestor_lang:hasType("reconstructed") then
						item.alt = "*" .. item.alt
					end
					
					if item.term == "-" or item.term == "+" then
						separator = item.term
					elseif item.term then
						if root_index > 1 and match(last_term, "%-$") then -- no asterisk after hyphen
							if not item.alt then
								item.alt = item.term:gsub("^%*", "")
							else
								item.alt = item.alt:gsub("^%*", "")
							end
						end
						table.insert(terms, item)
						
						local cat_term = args.c[root_index] or item.term
						cat_term = "*" .. gsub(cat_term, "^*+", "") -- ensure only one asterisk
						local user_provided_cat_term = cat_term
						
						if code == "wasc" then -- Wascotl root and suffix handling
							local suffix = match(cat_term, "^*[%w']+(%-[%w']+)$")
							
							if wasc_suffixes[suffix] then
								cat_term = gsub(cat_term, suffix, "-")
							end
							
							if args.c[root_index] and user_provided_cat_term == cat_term then
								require("Module:debug").track("redundant and obsolete c")
							end
						end
						
						table.insert(cats, dest_lang:getCanonicalName() .. " terms derived from the " .. ancestor_lang:getCanonicalName() .. " root " .. cat_term)
						
						root_index = root_index + 1
					end
					
					last_term = item.term
				end
				
				if not terms[1] then
					terms[1] = { lang = ancestor_lang }
				end
				
				
			else
				local single_args = get_single_args(args, termarg_index)
				local parsed = m_param_utils.parse_term_with_inline_modifiers_and_separate_params({
					processed_args = single_args,
					param_mods = param_mods,
					termarg = termarg_index,
					lang = ancestor_lang,
				})

				terms = parsed.terms or {}
				if not terms[1] then
					if parsed.term then
						terms[1] = parsed
					else
						terms[1] = { lang = ancestor_lang }
					end
				end
			end
			
			local etymology
			if lang_options.borrowed then
				etymology = m_etym_specialized.specialized_borrowing{
					bortype = args.p or "b",
					lang = dest_lang,
					sources = {ancestor_lang},
					terms = terms,
					sort_key = args.sort,
					nocat = args.nocat,
					conj = lang_options.roots and separator or nil,
					nocap = args.mid or args.old or args.nocap,
				}
			else
				etymology = m_etym.format_inherited{
					lang = dest_lang,
					terms = terms,
					sort_key = args.sort,
					nocat = args.nocat,
					conj = lang_options.roots and separator or nil,
				}
				etymology = "from " .. etymology
			end
			
			if lang_options.annotated and args.parts then
				local referrals = {}
				for _, part in ipairs(args.parts) do
					local referral = m_links.full_link({
						lang = ancestor_lang,
						term = part,
					}, "term")
					
					table.insert(referrals, referral)
				end
				
				
				etymology = etymology .. " (see " .. m_table.serialCommaJoin(referrals) .. ")"
			end
			
			table.insert(etymologies, etymology)
			termarg_index = termarg_index + 1
		end
	end
	
	local categories = m_utils.format_categories(cats, dest_lang)
	
	return etymologies, args, parent_args.nocat and "" or categories
end

return export