Module:User:Benwing2/it-inflections

local export = {}

--[=[

Authorship: Ben Wing

This module implements, which automatically generates the appropriate inflections of a non-lemma verb form given the form and the conjugation spec for the verb (which is usually just the infinitive; see and ). ]=]

local m_table = require("Module:table") local m_form_of = require("Module:form of") local m_it_verb = require("Module:User:Benwing2/it-verb")

local lang = require("Module:languages").getByCode("it")

local rmatch = mw.ustring.match local rfind = mw.ustring.find local rsplit = mw.text.split local usub = mw.ustring.sub

local function track(page) require("Module:debug/track")("it-inflections/" .. page) return true end

local function extract_link_targets(text) text = text:gsub("%[%[([^|%]]-)|[^|%]]-%]%]", "%1") text = text:gsub("%[%[", "") text = text:gsub("%]%]", "")

return text end

local function generate_inflection_of(tags, lemma) local has_multiple_tag_sets = #tags > 1

tags = table.concat(tags, "|;|") tags = rsplit(tags, "|")

local lemma_obj = { lang = lang, term = lemma, }

if has_multiple_tag_sets then tags = require("Module:accel").combine_tag_sets_into_multipart(tags, lang) end local categories = m_form_of.fetch_lang_categories(lang, tags, lemma_obj, "verb") local cat_text = #categories > 0 and require("Module:utilities").format_categories(categories, lang) or "" return m_form_of.tagged_inflections({		tags = tags, lemmas = {lemma_obj}, lemma_face = "term",	}) .. cat_text end

function export.verb_form_of(frame) local parent_args = frame:getParent.args local params = { [1] = {required = true, default = def or "mettere"}, ["noheadword"] = {type = "boolean"}, -- FIXME: ignored for now ["pagename"] = {}, -- for testing }

local args = require("Module:parameters").process(parent_args, params) local alternant_multiword_spec = m_it_verb.do_generate_forms(args, "it-inflections") local non_lemma_form = alternant_multiword_spec.verb_form_of_form

local lemmas = {} if not alternant_multiword_spec.forms.inf then error("Internal error: No infinitive?") end for _, formobj in ipairs(alternant_multiword_spec.forms.inf) do		m_table.insertIfNot(lemmas, extract_link_targets(formobj.form)) end

-- FIXME: Consider supporting multiple lemmas. local lemma = lemmas[1]

local tags = {} local function loop_over_verb_slots(verb_slots) for _, slot_accel in ipairs(verb_slots) do			local slot, accel = unpack(slot_accel) local forms = alternant_multiword_spec.forms[slot] if forms then for _, formobj in ipairs(forms) do					local form = extract_link_targets(formobj.form) if non_lemma_form == form then m_table.insertIfNot(tags, accel) end end end end end loop_over_verb_slots(m_it_verb.all_verb_slots) if #tags > 0 then return generate_inflection_of(tags, lemma) end

-- If we don't find any matches, we try again, looking for non-reflexive forms of reflexive-only verbs. if not alternant_multiword_spec.props.is_non_reflexive and not lemma:find(" ") then local refl_forms_to_tags = {} -- Only basic verb forms (not combined forms) have non-reflexive parts generated. for _, slot_accel in ipairs(alternant_multiword_spec.verb_slots_basic) do			local slot, accel = unpack(slot_accel) local part_forms = alternant_multiword_spec.forms[slot .. "_non_reflexive"] local full_forms = alternant_multiword_spec.forms[slot] local variant_forms = alternant_multiword_spec.forms[slot .. "_variant"] -- Make sure same number of part and full forms, otherwise we can't match them up. if part_forms and full_forms and #part_forms == #full_forms and (				not variant_forms or #part_forms == #variant_forms) then -- Find part form the same as the non-lemma form we're generating the inflection(s) of, -- and accumulate properties into refl_forms_to_tags. for i, part_form in ipairs(part_forms) do					if part_form.form == non_lemma_form then local saw_existing = false for _, refl_form_to_tags in ipairs(refl_forms_to_tags) do							if refl_form_to_tags.form == full_forms[i].form then table.insert(refl_form_to_tags.tags, accel) saw_existing = true break end end if not saw_existing then table.insert(refl_forms_to_tags, {								form = full_forms[i].form,								tags = {accel},								variant = variant_forms and variant_forms[i].form,							}) end end end end end

if #refl_forms_to_tags > 0 then local parts = {} for _, refl_form_to_tags in ipairs(refl_forms_to_tags) do				local only_used_in local tags = refl_forms_to_tags.tags if refl_form_to_tags.variant then only_used_in = frame:preprocess((", syntactic variant of "):format( refl_form_to_tags.variant, refl_form_to_tags.form)) else only_used_in = frame:preprocess((""):format(refl_form_to_tags.form)) end if refl_form_to_tags.form == lemma then table.insert(parts, only_used_in) else local inflection_of = generate_inflection_of(refl_form_to_tags.tags, lemma) table.insert(parts, ("%s, %s"):format(only_used_in, inflection_of)) end end return table.concat(parts, "\n# ") end end

error(("'%s' is not any of the forms of the verb '%s'"):format(non_lemma_form, table.concat(lemmas, "/"))) end

return export