Modul:bg-headword

Bu modul uchun Modul:bg-headword/doc nomli hujjat sahifasini yaratishingiz mumkin

local export = {}
local pos_functions = {}

local headword_utilities_module = require("Module:headword utilities")

local lang = require("Module:languages").getByCode("bg")
local langname = lang:getCanonicalName()

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

local function glossary_link(anchor, text)
	text = text or anchor
	return "[[Appendix:Glossary#" .. anchor .. "|" .. text .. "]]"
end

-- The main entry point.
-- This is the only function that can be invoked from a template.
function export.show(frame)
	local poscat = frame.args[1] or error("Part of speech has not been specified. Please pass parameter 1 to the module invocation.")

	local params = {
		["head"] = {list = true, disallow_holes = true},
		[1] = {alias_of = "head"},
		["tr"] = {list = true, allow_holes = true},
		["id"] = {},
		["splithyph"] = {type = "boolean"},
		["nolinkhead"] = {type = "boolean"},
		["json"] = {type = "boolean"},
		["pagename"] = {}, -- for testing
	}

	if pos_functions[poscat] then
		for key, val in pairs(pos_functions[poscat].params) do
			params[key] = val
		end
	end

	local args = require("Module:parameters").process(frame:getParent().args, params)
	local pagename = args.pagename or mw.loadData("Module:headword/data").pagename

	local user_specified_heads = args.head
	local heads = user_specified_heads
	if args.nolinkhead then
		if #heads == 0 then
			heads = {pagename}
		else
			for i, head in ipairs(heads) do
				if head == auto_linked_head then
					track("redundant-head")
				end
				if not head or head == "+" then
					heads[i] = auto_linked_head
				end
			end
		end
	end

	local is_suffix = pagename:find("^%-") and poscat ~= "suffix forms"
	local orig_poscat = poscat
	poscat = pos_functions[poscat].overriding_poscat or poscat

	local data = {
		lang = lang,
		-- FIXME: Is the following necessary?
		pos_category = (mw.title.getCurrentTitle().nsText == "Reconstruction" and "reconstructed " or "") ..
			(is_suffix and "suffixes" or poscat),
		orig_poscat = orig_poscat,
		is_suffix = is_suffix,
		categories = {},
		heads = heads,
		user_specified_heads = user_specified_heads,
		no_redundant_head_cat = #user_specified_heads == 0,
		inflections = {},
		pagename = pagename,
		id = args.id,
		force_cat_output = force_cat,
	}

	if is_suffix then
		local singular_poscat = require("Module:string utilities").singularize(poscat)
		table.insert(data.categories, langname .. " " .. singular_poscat .. "-forming suffixes")
		table.insert(data.inflections, {label = singular_poscat .. "-forming suffix"})
	end

	if pos_functions[poscat] then
		pos_functions[poscat].func(args, data, is_suffix)
	end

	if args.json then
		return require("Module:JSON").toJSON(data)
	end

	return require("Module:headword").full_headword(data)
end


-- Returns the lemma we should use in acceleration tags, which contains
-- the stress mark for polysyllabic words.
local function get_accel_lemma(data)
	accel_lemma = nil
	
	if #data.heads > 0 then
		accel_lemma = data.heads[1]
	else
		accel_lemma = data.pagename
	end
	
	return accel_lemma
end


local function insert_infl(data, forms, label, accel)
	if forms and #forms > 0 then
		forms.label = label
		
		if accel then
			accel.lemma = get_accel_lemma(data)
			forms.accel = accel
		end
		
		table.insert(data.inflections, forms)
	end
end


local function handle_infl(args, data, argpref, label, accel)
	insert_infl(data, args[argpref], label, accel)
end


pos_functions["verbs"] = {
	params = {
		[2] = {},
		["pf"] = {list = true},
		["impf"] = {list = true},
		["impers"] = {type = "boolean"},
	},
	func = function(args, data)
		if args[2] == "pf" then
			data.genders = {"pf"}
		elseif args[2] == "impf" then
			data.genders = {"impf"}
		elseif args[2] == "both" or args[2] == "biasp" then
			data.genders = {"biasp"}
		elseif args[2] then
			error("Unrecognized aspect '" .. args[2] .. "'")
		end

		handle_infl(args, data, "pf", "perfective")
		handle_infl(args, data, "impf", "imperfective")
		if args.impers then
			table.insert(data.inflections, {label = "impersonal"})
			data.gloss = "third-singular present indicative"
		else
			data.gloss = "first-singular present indicative"
		end
	end
}

local function verify_genders(genders)
	for _, g in ipairs(genders) do
		if g == "m" or g == "m-p" or g == "f" or g == "f-p" or g == "n" or g == "n-p" or g == "p" or
			g == "mf" or g == "mf-p" or g == "mfbysense" or g == "mfbysense-p" then
			-- OK
		else
			error("Unrecognized gender: '" .. g .. "'")
		end
	end
end


local nouns = {
	params = {
		[2] = {alias_of = "g"},
		["g"] = {list = true},
		["m"] = {list = true},
		["f"] = {list = true},
		["adj"] = {list = true},
		["dim"] = {list = true},
		["aug"] = {list = true},
		["pej"] = {list = true},
		["indecl"] = {type = "boolean"},
	},
	func = function(args, data)
		verify_genders(args.g)
		data.genders = args.g
		if args.indecl then
			table.insert(data.inflections, {label = glossary_link("indeclinable")})
		end
		handle_infl(args, data, "m", "masculine")
		handle_infl(args, data, "f", "feminine", {form = "f"})
		handle_infl(args, data, "adj", "relational adjective", {form = "relational adjective"})
		handle_infl(args, data, "dim", "diminutive", {form = "diminutive"})
		handle_infl(args, data, "aug", "augmentative", {form = "augmentative"})
		handle_infl(args, data, "pej", "pejorative")
	end,
}

pos_functions["nouns"] = nouns
pos_functions["proper nouns"] = nouns

-- Handle comparatives and superlatives for adjectives and adverbs, including user-specified comparatives and
-- superlatives and default-requested comparatives/superlatives using '+'. Code is the same for adjectives and adverbs.
local function handle_adj_adv_comp(args, data)
	local lemma = data.pagename
	local plpos = data.pos_category:gsub("^reconstructed ", "")

	if args.comp[1] == "-" then
		table.remove(args.comp, 1)
		if #args.comp > 0 then
			table.insert(data.inflections, {label = "sometimes " .. glossary_link("comparable")})
			table.insert(data.categories, langname .. " comparable " .. plpos)
			table.insert(data.categories, langname .. " uncomparable " .. plpos)
		else
			table.insert(data.inflections, {label = "not " .. glossary_link("comparable")})
			table.insert(data.categories, langname .. " uncomparable " .. plpos)
		end
	elseif #args.comp > 0 then
		table.insert(data.categories, langname .. " comparable " .. plpos)
	end

	-- If comp=+, use default comparative 'по́-...', and set a default superlative if unspecified.
	local saw_comp_plus = false
	local comps = {}
	for i, compval in ipairs(args.comp) do
		if compval == "+" then
			saw_comp_plus = true
			for _, head in ipairs(data.heads) do
				table.insert(comps, "по́-" .. head)
			end
		else
			table.insert(comps, compval)
		end
	end
	if saw_comp_plus and #args.sup == 0 then
		args.sup = {"+"}
	end
	insert_infl(data, comps, "comparative", {form = "comparative"})

	local sups = {}
	if args.sup[1] == "-" then
		table.insert(data.inflections, {label = "no superlative"})
	else
		-- If sup=+ (possibly from comp=+), use default superlative 'на́й-...'.
		for i, supval in ipairs(args.sup) do
			if supval == "+" then
				for _, head in ipairs(data.heads) do
					table.insert(sups, "на́й-" .. head)
				end
			else
				table.insert(sups, supval)
			end
		end
	end
	insert_infl(data, sups, "superlative", {form = "superlative"})
end

pos_functions["adverbs"] = {
	params = {
		[2] = {alias_of = "comp"},
		["comp"] = {list = true},
		[3] = {alias_of = "sup"},
		["sup"] = {list = true},
	},
	func = function(args, data)
		handle_adj_adv_comp(args, data)
	end,
}


local function make_adjective_pos_function(pos)
	local params = {
		["indecl"] = {type = "boolean"},
		["dim"] = {list = true},
	}
	if pos == "adjectives" then
		params[2] = {alias_of = "comp"}
		params["comp"] = {list = true}
		params[3] = {alias_of = "sup"}
		params["sup"] = {list = true}
		params["adv"] = {list = true}
		params["absn"] = {list = true}
	end
	return {
		params = params,
		overriding_poscat = pos == "numerals" and "numerals" or nil,
		func = function(args, data)
			if args.indecl then
				table.insert(data.inflections, {label = glossary_link("indeclinable")})
			end
			handle_adj_adv_comp(args, data)
			handle_infl(args, data, "dim", "diminutive")
			handle_infl(args, data, "adv", "adverb")
			handle_infl(args, data, "absn", "abstract noun", {form = "abstract noun", pos = "noun"})
		end,
	}
end

pos_functions["adjectives"] = make_adjective_pos_function("adjectives")
pos_functions["determiners"] = make_adjective_pos_function("determiners")
pos_functions["pronouns"] = make_adjective_pos_function("pronouns")
pos_functions["numerals-adjective"] = make_adjective_pos_function("numerals")


pos_functions["participles"] = {
	params = {
		[2] = {required = true, list = true, default = "aor"},
	},
	func = function(args, data)
		table.insert(data.categories, "Bulgarian verb forms")
		for _, part in ipairs(args[2]) do
			if part == "adv" then
				table.insert(data.categories, "Bulgarian adverbial participles")
			elseif part == "aor" then
				table.insert(data.categories, "Bulgarian past active aorist participles")
			elseif part == "impf" then
				table.insert(data.categories, "Bulgarian past active imperfect participles")
			elseif part == "pres" then
				table.insert(data.categories, "Bulgarian present active participles")
			elseif part == "pass" or part == "ppp" then
				table.insert(data.categories, "Bulgarian past passive participles")
			elseif part == "prespass" then
				table.insert(data.categories, "Bulgarian present passive participles")
			else
				error("Unrecognized participle type '" .. part .. "': Should be adv, aor, impf, pres, pass or prespass")
			end
		end
	end
}


pos_functions["participle forms"] = {
	params = {
		["g"] = {list = true},
	},
	func = function(args, data)
		verify_genders(args.g)
		data.genders = args.g
		table.insert(data.categories, "Bulgarian verb forms")
	end
}


pos_functions["verbal nouns"] = {
	params = {
		-- Verbal nouns in Bulgarian are overwhelmingly formed with the suffixes
		-- "-не" or "-ние", which both have neuter gender. 
		["g"] = {list = true, default = "n"},
	},
	overriding_poscat = "nouns",
	func = function(args, data)
		verify_genders(args.g)
		data.genders = args.g
	end
}


pos_functions["verbal noun forms"] = {
	params = {
		["g"] = {list = true},
	},
	overriding_poscat = "noun forms",
	func = function(args, data)
		verify_genders(args.g)
		data.genders = args.g
	end
}


return export