Module:User:Benwing2/nl-headword

local export = {}
local pos_functions = {}

local lang = require("Module:languages").getByCode("nl")
local headword_module = "Module:User:Benwing2/headword"
local nl_common_module = "Module:nl-common"
local parse_utilities_module = "Module:parse utilities"

local param_mods = {
	-- ] expects part genders in `.genders`.
	g = {item_dest = "genders", sublist = true},
	id = {},
	q = {type = "qualifier"},
	qq = {type = "qualifier"},
	l = {type = "labels"},
	ll = {type = "labels"},
	-- ] expects part references in `.refs`.
	ref = {item_dest = "refs", type = "references"},
}

local function parse_term_with_modifiers(paramname, val)
	local function generate_obj(term, parse_err)
		return {term = term}
	end

	if val:find("<") then
		return require(parse_utilities_module).parse_inline_modifiers(val, {
			paramname = paramname,
			param_mods = param_mods,
			generate_obj = generate_obj,
		})
	else
		return generate_obj(val)
	end
end

local function parse_term_list_with_modifiers(paramname, list)
	local first, restpref
	if type(paramname) == "table" then
		first = paramname
		restpref = paramname
	else
		first = paramname
		restpref = paramname
	end
	for i, val in ipairs(list) do
		list = parse_term_with_modifiers(i == 1 and first or restpref .. i, val)
	end
	return list
end

-- The main entry point.
-- This is the only function that can be invoked from a template.
function export.show(frame)
	-- The part of speech. This is also the name of the category that
	-- entries go in. However, the two are separate (the "cat" parameter)
	-- because you sometimes want something to behave as an adjective without
	-- putting it in the adjectives category.
	local poscat = frame.args or error("Part of speech has not been specified. Please pass parameter 1 to the module invocation.")

	local params = {
		 = {list = true},
		 = {}, -- for testing
	}

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

	local args = require("Module:parameters").process(frame:getParent().args, params)

	local pagename = args.pagename or mw.loadData("Module:headword/data").pagename -- Accounts for unsupported titles.

	local data = {
		lang = lang,
		pos_category = poscat,
		categories = {},
		heads = args,
		genders = {},
		inflections = {},
		tracking_categories = {},
		pagename = args.pagename,
		-- This is always set, and in the case of unsupported titles, it's the displayed version (e.g. 'C|N>K' instead
		-- of 'Unsupported titles/C through N to K').
		displayed_pagename = pagename,
	}

	if pos_functions then
		pos_functions.func(args, data)
	end

	return require(headword_module).full_headword(data) ..
		require("Module:utilities").format_categories(data.tracking_categories, lang, nil)
end

-- Display additional inflection information for an adjective
pos_functions = {
	params = {
		 = {list = "comp"},
		 = {list = "sup"},
		 = {},
		},
	func = function(args, data)
		local mode = args
		local pagename = data.displayed_pagename

		if mode == "inv" then
			table.insert(data.inflections, {label = "]"})
			table.insert(data.categories, "Dutch indeclinable adjectives")
			args = args
			args = args
		elseif mode == "pred" then
			table.insert(data.inflections, {label = "used only ]ly"})
			table.insert(data.categories, "Dutch predicative-only adjectives")
			args = args
			args = args
		end

		local comp_mode = args

		if comp_mode == "-" then
			table.insert(data.inflections, {label = "not ]"})
		else
			-- Gather parameters
			local comparatives = parse_term_list_with_modifiers({"1", "comp"}, args)
			comparatives.label = "]"

			local superlatives = parse_term_list_with_modifiers({"2", "sup"}, args)
			superlatives.label = "]"

			-- Generate forms if none were given
			if #comparatives == 0 then
				if mode == "inv" or mode == "pred" then
					table.insert(comparatives, {term = "peri"})
				else
					table.insert(comparatives, {term = require("Module:nl-adjectives").make_comparative(pagename)})
				end
			end

			if #superlatives == 0 then
				if mode == "inv" or mode == "pred" then
					table.insert(superlatives, {term = "peri"})
				else
					-- Add preferred periphrastic superlative, if necessary
					if
						pagename:find("de$") or pagename:find("e$") or
						pagename:find("s$") or pagename:find("sch$") or pagename:find("x$") or
						pagename:find("sd$") or pagename:find("st$") or pagename:find("sk$") then
						table.insert(superlatives, {term = "peri"})
					end

					table.insert(superlatives, {term = require("Module:nl-adjectives").make_superlative(pagename)})
				end
			end

			-- Replace "peri" with phrase
			for _, val in ipairs(comparatives) do
				if val.term == "peri" then val.term = "] " .. pagename end
			end

			for _, val in ipairs(superlatives) do
				if val.term == "peri" then val.term = "] " .. pagename end
			end

			table.insert(data.inflections, comparatives)
			table.insert(data.inflections, superlatives)
		end
	end
}

-- Display additional inflection information for an adverb
pos_functions = {
	params = {
		 = {list = "comp"},
		 = {list = "sup"},
		},
	func = function(args, data)
		local pagename = data.displayed_pagename

		if args then
			-- Gather parameters
			local comparatives = parse_term_list_with_modifiers({"1", "comp"}, args)
			comparatives.label = "]"

			local superlatives = parse_term_list_with_modifiers({"2", "sup"}, args)
			superlatives.label = "]"

			if not superlatives then
				superlatives = {term = pagename .. "st"}
			end

			table.insert(data.inflections, comparatives)
			table.insert(data.inflections, superlatives)
		end
	end
}

-- Display information for a noun's gender
-- This is separate so that it can also be used for proper nouns
local function noun_gender(args, data)
	for _, g in ipairs(args) do
		if g == "c" then
			table.insert(data.categories, "Dutch nouns with common gender")
		elseif g == "p" then
			table.insert(data.categories, "Dutch pluralia tantum")
		elseif g ~= "m" and g ~= "f" and g ~= "n" then
			g = nil
		end

		table.insert(data.genders, g)
	end

	if #data.genders == 0 then
		table.insert(data.genders, "?")
	end

	-- Most nouns that are listed as f+m should really have only f
	if data.genders == "f" and data.genders == "m" then
		table.insert(data.categories, "Dutch nouns with f+m gender")
	end
end

local function generate_plurals(pagename)
	local m_common = require(nl_common_module)
	local generated = {}

	generated = pagename .. "s"
	generated = pagename .. "'s"

	local stem_FF = m_common.add_e(pagename, false, false)
	local stem_TF = m_common.add_e(pagename, true, false)
	local stem_FT = m_common.add_e(pagename, false, true)

	generated = stem_FF .. "s"
	generated = stem_TF .. "s"
	generated = stem_FT .. "s"

	generated = stem_FF .. "n"
	generated = stem_TF .. "n"
	generated = stem_FT .. "n"

	generated = m_common.add_e(pagename .. (pagename:find("n$") and "d" or ""), false, false) .. "ren"
	generated = stem_FT .. "ren"

	if pagename:find("f$") then
		local stem = pagename:gsub("f$", "v")
		local stem_FF = m_common.add_e(stem, false, false)
		local stem_TF = m_common.add_e(stem, true, false)
		local stem_FT = m_common.add_e(stem, false, true)

		generated = stem_FF .. "s"
		generated = stem_TF .. "s"
		generated = stem_FT .. "s"

		generated = stem_FF .. "n"
		generated = stem_TF .. "n"
		generated = stem_FT .. "n"

		generated = stem_FF .. "ren"
		generated = stem_FT .. "ren"
	elseif pagename:find("s$") then
		local stem = pagename:gsub("s$", "z")
		local stem_FF = m_common.add_e(stem, false, false)
		local stem_TF = m_common.add_e(stem, true, false)
		local stem_FT = m_common.add_e(stem, false, true)

		generated = stem_FF .. "s"
		generated = stem_TF .. "s"
		generated = stem_FT .. "s"

		generated = stem_FF .. "n"
		generated = stem_TF .. "n"
		generated = stem_FT .. "n"

		generated = stem_FF .. "ren"
		generated = stem_FT .. "ren"
	elseif pagename:find("heid$") then
		generated = pagename:gsub("heid$", "heden")
	end

	return generated
end

local function generate_diminutive(pagename, dim)
	local m_common = require(nl_common_module)
	if dim == "+" then
		dim = m_common.default_dim(pagename)
	elseif dim == "++" then
		dim = m_common.default_dim(pagename, "final multisyllable stress")
	elseif dim == "++/+" then
		dim = m_common.default_dim(pagename, false, "modifier final multisyllable stress")
	elseif dim == "++/++" then
		dim = m_common.default_dim(pagename, "final multisyllable stress", "modifier final multisyllable stress")
	elseif dim == "+first" then
		dim = m_common.default_dim(pagename, false, false, "first only")
	elseif dim == "++first" then
		dim = m_common.default_dim(pagename, "final multisyllable stress", false, "first only")
	elseif dim:sub(1, 1) == "-" then
		dim = pagename .. dim:sub(2)
	end
	return dim
end

pos_functions = {
	params = {
		 = {list = "g"},
		 = {list = true},
		 = {list = true},
		 = {list = true},
		},
	func = function(args, data)
		noun_gender(args, data)

		local adjectives = parse_term_list_with_modifiers("adj", args)
		local mdems = parse_term_list_with_modifiers("mdem", args)
		local fdems = parse_term_list_with_modifiers("fdem", args)
		local nm = #mdems
		local nf = #fdems
		local demonyms = {label = "demonym"}

		--adjective for toponyms
		if adjectives then
			adjectives.label = "adjective"
			table.insert(data.inflections, adjectives)
		end
		--demonyms for toponyms
		if nm + nf > 0 then
			for i, m in ipairs(mdems) do
				if not m.genders then
					m.genders = {"m"}
				end
				demonyms = m
			end
			for i, f in ipairs(fdems) do
				if not f.genders then
					f.genders = {"f"}
				end
				demonyms = f
			end
			table.insert(data.inflections, demonyms)
		end
	end
}

-- Display additional inflection information for a noun
pos_functions = {
	params = {
		 = {list = "g"},
		 = {list = "pl", disallow_holes = true},
		-- FIXME, remove this in favor of inline modifiers
		 = {list = true, allow_holes = true},
		 = {list = "dim"},

		 = {list = true},
		 = {list = true},
		},
	func = function(args, data, called_from)
		local pagename = data.displayed_pagename

		noun_gender(args, data)

		local plurals = parse_term_list_with_modifiers({called_from == "dimtant" and "1" or "2", "pl"}, args)
		local pl_qualifiers = args
		local diminutives = parse_term_list_with_modifiers({"3", "dim"}, args)
		local feminines = parse_term_list_with_modifiers("f", args)
		local masculines = parse_term_list_with_modifiers("m", args)

		-- Plural
		if data.genders == "p" then
			table.insert(data.inflections, {label = "]"})
		elseif plurals and plurals.term == "-" then
			table.insert(data.inflections, {label = "]"})
			table.insert(data.categories, "Dutch uncountable nouns")
		else
			local generated = generate_plurals(pagename)

			-- Process the plural forms
			for i, pobj in ipairs(plurals) do
				local p = pobj.term
				-- Is this a shortcut form?
				if p:sub(1,1) == "-" then
					if not generated then
						error("The shortcut plural " .. p .. " could not be generated.")
					end

					if p:sub(-2) == "es" then
						table.insert(data.categories, "Dutch nouns with plural in -es")
					elseif p:sub(-1) == "s" then
						table.insert(data.categories, "Dutch nouns with plural in -s")
					elseif p:sub(-4) == "eren" then
						table.insert(data.categories, "Dutch nouns with plural in -eren")
					else
						table.insert(data.categories, "Dutch nouns with plural in -en")
					end

					if p:sub(2,2) == ":" then
						table.insert(data.categories, "Dutch nouns with lengthened vowel in the plural")
					end

					p = generated
				-- Not a shortcut form, but the plural form specified directly.
				else
					local matches = {}

					for pi, g in pairs(generated) do
						if g == p then
							table.insert(matches, pi)
						end
					end

					if #matches > 0 then
						table.insert(data.tracking_categories, "nl-noun plural matches generated form")
					elseif not pagename:find("") then
						if p == pagename then
							table.insert(data.categories, "Dutch indeclinable nouns")
						elseif
							p == pagename .. "den" or p == pagename:gsub("ee$", "eden") or
							p == pagename .. "des" or p == pagename:gsub("ee$", "edes") then
							table.insert(data.categories, "Dutch nouns with plural in -den")
						elseif p == pagename:gsub("()$", "%1%1ien") or p == pagename:gsub("oe$", "oeien") then
							table.insert(data.categories, "Dutch nouns with glide vowel in plural")
						elseif p == pagename:gsub("y$", "ies") then
							table.insert(data.categories, "Dutch nouns with English plurals")
						elseif
							p == pagename:gsub("a$", "ae") or
							p == pagename:gsub("x$", "ices") or
							p == pagename:gsub("is$", "es") or
							p == pagename:gsub("men$", "mina") or
							p == pagename:gsub("ns$", "ntia") or
							p == pagename:gsub("o$", "ones") or
							p == pagename:gsub("o$", "onen") or
							p == pagename:gsub("s$", "tes") or
							p == pagename:gsub("us$", "era") or
							p == mw.ustring.gsub(pagename, "s$", "i") or
							p == mw.ustring.gsub(pagename, "m$", "a") or
							p == pagename:gsub("x$", "ges") then
							table.insert(data.categories, "Dutch nouns with Latin plurals")
						elseif
							p == pagename:gsub("os$", "oi") or
							p == pagename:gsub("on$", "a") or
							p == pagename:gsub("a$", "ata") then
							table.insert(data.categories, "Dutch nouns with Greek plurals")
						else
							table.insert(data.categories, "Dutch irregular nouns")
						end

						if plural and not mw.title.new(plural).exists then
							table.insert(data.categories, "Dutch nouns with missing plurals")
						end
					end
				end

				pobj.term = p
				if pl_qualifiers then
					pobj.q = {pl_qualifiers}
				end
			end

			-- Add the plural forms
			plurals.label = "plural"
			plurals.accel = {form = "p"}
			plurals.request = true
			table.insert(data.inflections, plurals)
		end

		-- Add the diminutive forms
		if diminutives and diminutives.term == "-" then
			-- do nothing
		else
			-- Process the diminutive forms
			for _, dimobj in ipairs(diminutives) do
				dimobj.term = generate_diminutive(pagename, dimobj.term)
				if not dimobj.genders then
					dimobj.genders = {"n"}
				end
			end

			diminutives.label = "]"
			diminutives.accel = {form = "diminutive"}
			diminutives.request = true
			table.insert(data.inflections, diminutives)
		end

		-- Add the feminine forms
		if feminines then
			feminines.label = "feminine"
			table.insert(data.inflections, feminines)
		end

		-- Add the masculine forms
		if masculines then
			masculines.label = "masculine"
			table.insert(data.inflections, masculines)
		end
	end
}

-- Display additional inflection information for a diminutive noun
pos_functions = {
	params = {
		 = {},
		 = {list = "pl"},
		},
	func = function(args, data)
		if not (args == "n" or args == "p") then
			args = {"n"}
		else
			args = {args}
		end

		if not args then
			args = {"-s"}
		end

		args = {"-"}
		args = {}
		args = {}
		-- FIXME: Remove this.
		args = {}

		pos_functions.func(args, data, "dim")
	end
}

-- Display additional inflection information for diminutiva tantum nouns ({{nl-noun-dim-tant}}).
pos_functions = {
	params = {
		 = {list = "pl", disallow_holes = true},
		-- FIXME: Remove this.
		 = {list = true, allow_holes = true},

		 = {list = true},
		 = {list = true},
		},
	func = function(args, data)
		data.pos_category = "nouns"
		table.insert(data.categories, "Dutch diminutiva tantum")
		args = args
		args = {"n"}

		if not args then
			args = {"-s"}
		end

		args = {"-"}

		pos_functions.func(args, data, "dimtant")
	end
}

pos_functions = {
	params = {
		 = {},
	},
	func = function(args, data)
		if args == "-" then
			table.insert(data.inflections, {label = "not used adjectivally"})
			table.insert(data.categories, "Dutch non-adjectival past participles")
		end
	end
}

pos_functions = {
	params = {
		 = {},
		},
	func = function(args, data)
		if args == "-" then
			table.insert(data.inflections, {label = "not inflected"})
			table.insert(data.categories, "Dutch uninflected verbs")
		end
	end
}

return export