Module:form of: Difference between revisions

export.force_cat = false -- for testing; set to true to display categories even on non-mainspace pages

local form_of_cats_module = "Module:form of/cats"

local form_of_data_module = "Module:form of/data"

local sort = table.sort

local split_tag_set -- Defined below.

local type = type

contains = require(table_module).contains

return contains(...)

end

parse_inline_modifiers = require(parse_utilities_module).parse_inline_modifiers

return parse_inline_modifiers(...)

end

   common syncretism between simple past and past participle in English (and in this case, `spast` is itself a list

   shortcut that expands to `simple|past`).]==]

local function wrap_in_span(text, classes)

return text

end

end

the following fields:

* `.text`: Text to insert before the lemmas. Wrapped in the value of `.text_classes`, or its default; see below.

* `.lemmas`: List of objects describing the lemma(s) of which the term in question is a non-lemma form. These are passed

   text.

* `.lemma_face`: "Face" to use when displaying the lemma objects. Usually should be set to {"term"}.

* `.enclitics`: List of enclitics to display after the lemmas, in parens.

* `.enclitic_conj`: Conjunction or separator to use when joining multiple enclitics. Defaults to {"and"}.

* `.lemma_classes`: Additional CSS classes used to wrap the lemma links. Default is {"form-of-definition-link"}.

   Use `false` for no wrapping.

function export.format_form_of(data)

if type(data) ~= "table" then

end

local text_classes = data.text_classes

text_classes = "form-of-definition use-with-mention"

end

insert(parts, " ")

end

if data.lemmas then

if type(data.lemmas) == "string" then

local formatted_terms = {}

for _, lemma in ipairs(data.lemmas) do

end

end

end

for _, enclitic in ipairs(data.enclitics) do

-- FIXME, should we have separate clitic face and/or classes?

end

insert(parts, " (")

insert(parts, "</span>")

end

tags = base_lemma.paramobj.tags,

lemmas = base_lemma.lemmas,

nocat = true,

text_classes = data.text_classes,

}))

if text_classes then

insert(parts, "</span>")

end

end

format_form_of = export.format_form_of

return tag

end

return expansion

end

end

tag = expansion

return tag

end

tag = lookup_shortcut(tag, lang, do_track)

if type(tag) == "table" then

-- We found a list-tag shortcut; treat as if colon-separated.

components = tag

end

local normtags = {}

for _, component in ipairs(components) do

insert(normtags, normalize_single_tag(component, lang, do_track))

end

local normtags = {}

for _, single_tag in ipairs(split_tags) do

insert(normtags, normalize_multipart_component(single_tag, lang, do_track))

end

for _, tag in ipairs(tag_set) do

-- Expand the tag, which may generate a new tag (either a fully canonicalized tag, a multipart tag, or a list

-- of tags).

for _, t in ipairs(tag) do

insert(output_tag_set, normalize_tag(t, lang, do_track))

end

output_tag_set = {}

for i, tag in ipairs(tag_set) do

-- Expand the tag, which may generate a new tag (either a fully canonicalized tag, a multipart tag, or a list

-- of tags).

-- passed in must be a string (i.e. it cannot be a list describing a

-- multipart tag). To handle multipart tags, use get_tag_display_form().

local data = lookup_tag(normtag, lang)

local display = normtag

if data and data.display then

display = data.display

end

-- If there is a nonempty glossary index, then show a link to it

if link then

end

end

end

more), {"slash"} ("foo/bar"), {"en-dash"} ("foo–bar") or {nil}, which uses the global default found in

{multipart_join_strategy()} in [[Module:form of/functions]]. (NOTE: The global default is {"slash"} and this seems

if type(tagspec) == "string" then

end

-- We have a multipart tag. See if there's a display handler to display them specially.

local displayval = handler(tagspec, joiner)

if displayval then

return displayval

end

for _, first_level_tag in ipairs(tagspec) do

if type(first_level_tag) == "string" then

else

-- A first-level element of a two-level multipart tag. Currently we just separate the individual components

local components = {}

for _, component in ipairs(first_level_tag) do

end

insert(displayed_tags, concat(components, " "))

Given a normalized tag set (i.e. as output by {normalize_tag_set()}; all tags are in canonical form, multipart tags are

represented as lists, and two-level multipart tags as lists of lists), convert to displayed form (a string). See

local parts = {}

for _, tagspec in ipairs(normalized_tag_set) do

-- Maybe insert a space before inserting the display form of the tag. We insert a space if

-- (a) we're not the first tag; and

* `.nocat`: Suppress computation of categories (even if `.no_format_categories` is not given).

* `.notext`: Disable display of all tag text and `inflection of` text. (FIXME: Maybe not implemented correctly.)

* `.capfirst`: Capitalize the first word displayed.

* `.pretext`: Additional text to display before the inflection tags, but after any top-level labels.

   {"form-of-definition use-with-mention"}.

* `.lemma_classes`: Additional CSS classes used to wrap the lemma links. Default is {"form-of-definition-link"}.

A typical call might look like this (for {{m+|es|amo}}): {

extend(categories, this_categories)

end

if #cur_infl > 0 then

if tag_set.labels then

local of_text = data.lemmas and " of" or ""

if #inflections == 1 then

if need_per_tag_set_labels then

format_data.text = format_labels(overall_labels, data, data.notext) .. (data.pretext or "") .. (data.notext and "" or

((data.capfirst and ucfirst(inflections[1].infl_text) or inflections[1].infl_text) .. of_text))

else

format_data.text = format_labels(overall_labels, data, data.notext) .. (data.pretext or "") .. (data.notext and "" or

((data.capfirst and "Inflection" or "inflection") .. of_text))

format_data.posttext = (data.posttext or "") .. ":"

local text_classes = data.text_classes

text_classes = "form-of-definition use-with-mention"

end

end

formatted_text = link .. concat(inflections)

end

if not data.no_format_categories then

formatted_text = formatted_text .. format_categories(categories, data.lang,

data.sort, nil, export.force_cat)

return formatted_text, categories

end

function export.dump_form_of_data(frame)