Module:pollasena-roots: Difference between revisions

← Older edit Newer edit →

@@ Line 111: / Line 111: @@
 end
-local function parse_args(parent_args, dest_code, ancestor_codes)
+local function parse_args(parent_args, ancestor_specs)
-	local param_mods = m_param_utils.construct_param_mods({{group = {"link", "q", "l"}}})
+	local param_mods = m_param_utils.construct_param_mods({
-	local dest_lang = m_lang.getByCode(dest_code)
+		{ group = {"link", "q", "l"} },
-	local etymologies = {}
+	})
-	-- Parse all terms once
+	local parsed = {}
-	local parsed = m_param_utils.parse_term_with_inline_modifiers_and_separate_params({
+	local common = {
-		params = {},  -- generic, handled per ancestor below
+		nocat = parent_args.nocat,
-		param_mods = param_mods,
+		nocap = parent_args.nocap,
-		raw_args = parent_args,
+	}
-		termarg = 1,
-	})
-	local all_terms = parsed.terms
-	-- Loop through ancestors in order
+	for i, spec in ipairs(ancestor_specs) do
-	for i, ancestor in ipairs(ancestor_codes) do
+		local lang = m_lang.getByCode(spec.code)
-		local code = ancestor.code
+		local params = {
-		local options = ancestor.options or {}
+			[1] = {
-		local ancestor_lang = m_lang.getByCode(code)
+				required = not spec.optional,
+				list = spec.roots and "term",
+				allow_holes = spec.roots or nil,
+			},
+		}
-		-- Select the correct term(s) for this ancestor
+		local terms_obj = m_param_utils.parse_term_with_inline_modifiers_and_separate_params({
-		local terms = {}
+			params = params,
-		if i == 1 then
+			param_mods = param_mods,
-			-- first ancestor takes the first term
+			raw_args = { [1] = parent_args[i] }, -- map positional arg i -> local [1]
-			if all_terms[1] then terms = { all_terms[1] } end
+			termarg = 1,
-		else
+			lang = lang,
-			-- subsequent ancestors take remaining terms
+			sc = "sc.default",
-			for j = i, #all_terms do
+		})
-				table.insert(terms, all_terms[j])
-			end
-		end
-		-- Ensure at least one term exists
+		local terms = terms_obj.terms
 		if not terms[1] then
-			terms[1] = { lang = ancestor_lang }
+			terms[1] = { lang = lang } -- allow empty optional term if desired
 		end
-		-- Generate etymology step
+		parsed[i] = {
-		local etymology = m_etym.format_derived({
+			lang = lang,
-			lang = dest_lang,
-			sources = { ancestor_lang },
 			terms = terms,
-			nocat = parent_args.nocat,
+		}
-			template_name = "derived",
-		})
-		table.insert(etymologies, etymology)
 	end
-	return etymologies
+	return parsed, common
 end
--- Concatenate multiple etymology steps into a readable string
+local function concat_etymologies(parsed, opts, dest_lang)
-local function concat_etymologies(parent_args, etymologies)
+	local chunks = {}
-	local capital = parent_args.nocap and "f" or "F"
-	return capital .. "rom " .. table.concat(etymologies, ", from ") .. "."
+	for _, item in ipairs(parsed) do
+		if item.terms and item.terms[1] then
+			table.insert(chunks, m_etym.format_derived({
+				lang = dest_lang,
+				sources = { item.lang },
+				terms = item.terms,
+				nocat = opts.nocat,
+				template_name = "der",
+			}))
+		end
+	end
+	local capital = opts.nocap and "f" or "F"
+	local text = capital .. "rom " .. table.concat(chunks, ", from ")
+	return text .. "."
 end
 function export.qsc(frame)
 	local parent_args = frame:getParent().args
+	local dest_lang = m_lang.getByCode("qsc")
-	local ancestor_codes = {
+	local ancestor_specs = {
-		{ code = "sekh", options = { default = "asʰilavən" } },
+		{ code = "sekh", optional = false },
-		{ code = "wasc", options = { optional = true, roots = true, default = "asł-ila" } },
+		{ code = "wasc", optional = true, roots = true },
 	}
-	local etymologies = parse_args(parent_args, "qsc", ancestor_codes)
+	local parsed, opts = parse_args(parent_args, ancestor_specs)
-	return concat_etymologies(parent_args, etymologies)
+	return concat_etymologies(parsed, opts, dest_lang)
 end