Module:form of doc: Difference between revisions

--[=[

Lua code. See [[Module:form of doc/templates]] for the function meant to be

Author: Benwing2

]=]

local export = {}

local m_template_link = require("Module:template link")

local m_languages = require("Module:languages")

local usub = mw.ustring.sub

local function rsub(term, foo, bar)

local retval = rsubn(term, foo, bar)

local function lang_name(langcode, param)

local lang = m_languages.getByCode(langcode) or m_languages.err(langcode, param)

return lang:getCanonicalName()

local function ucfirst(text)

return uupper(usub(text, 1, 1)) .. usub(text, 2)

-- and without any language-specific prefixes (e.g. 'el-' or 'bsl-ine-pro-')

local PAGENAME = mw.title.getCurrentTitle().text

local tempname = rsub(PAGENAME, "/documentation$", "")

local newname = rsub(tempname, "^[a-z][a-z][a-z]?%-", "")

local langname = args.lang and lang_name(args.lang, "lang")

table.insert(exlangnames, lang_name(exlang, "exlang"))

parts = {}

table.insert(parts, "This template creates a definition line for ")

table.insert(parts, args.pldesc or rsub(template_name(), " of$", "") .. "s")

table.insert(parts, " ")

table.insert(parts, args.primaryentrytext or "of primary entries")

if args.lang then

table.insert(parts, " in " .. langname)

elseif #args.exlang > 0 then

table.insert(parts, ", e.g. in " .. m_table.serialCommaJoin(exlangnames, {conj = "or"}))

table.insert(parts, ".")

if #args.cat > 0 then

table.insert(parts, " It also categorizes the page into ")

for _, cat in ipairs(args.cat) do

table.insert(catparts, "[[:Category:" .. langname .. " " .. cat .. "]]")

else

table.insert(catparts, "the proper language-specific subcategory of [[:Category:" .. ucfirst(cat) .. " by language]] (e.g. [[:Category:" .. (exlangnames[1] or "English") .. " " .. cat .. "]])")

table.insert(parts, m_table.serialCommaJoin(catparts))

table.insert(parts, ".")

table.insert(parts, " ")

table.insert(parts, args.addlintrotext)

table.insert(parts, "\n")

table.insert(parts, [===[

By default, this template displays its output as a full sentence, with an initial capital letter and a trailing period (full stop). This can be overridden using <code>|nocap=1</code> and/or <code>|nodot=1</code> (see below).

elseif args.withcap then

table.insert(parts, [===[

By default, this template displays its output with an initial capital letter. This can be overridden using <code>|nocap=1</code> (see below).

table.insert(parts, [===[

table.insert(parts, " For those sections, use <code>{{[[Template:" .. args.etymtemp .. "|" .. args.etymtemp .. "]]}}</code> instead.")

table.insert(parts, [===[

Note that users can customize how the output of this template displays by modifying their monobook.css files. See [[:Category:Form-of templates|“Form of” templates]] for details.

]===])

return table.concat(parts)

table.insert(listparts, "<code>|" .. p .. "=</code>")

table.insert(listparts, ", <code>|" .. p .. "2=</code>")

table.insert(listparts, ", <code>|" .. p .. "3=</code>")

table.insert(listparts, ", etc.")

table.insert(paramparts, table.concat(listparts))

return table.concat(paramparts, " or ") .. " " .. reqtext

table.insert(parts, "; ")

table.insert(parts, param(params, list, required))

table.insert(parts, "\n")

table.insert(parts, ": ")

table.insert(parts, doc)

table.insert(parts, "\n")

local art = args.art or rfind(tempname, "^[aeiouAEIOU]") and "an" or "a"

table.insert(parts, "''Positional (unnamed) parameters:''\n")

param_and_doc("1", false, true, "The term to link to (which this page is " .. sgdescof .. "). This should include any needed diacritics as appropriate to " .. lang_name(args.lang, "lang") .. ". These diacritics will automatically be stripped out in the appropriate fashion in order to create the link to the page.")

param_and_doc("2", false, false, "The text to be shown in the link to the term. If empty or omitted, the term specified by the first parameter will be used. This parameter is normally not necessary, and should not be used solely to indicate diacritics; instead, put the diacritics in the first parameter.")

param_and_doc("1", false, true, "The [[WT:LANGCODE|language code]] of the term linked to (which this page is " .. sgdescof .. "). See [[Wiktionary:List of languages]]. <small>The parameter <code>|lang=</code> is a deprecated synonym; please do not use. If this is used, all numbered parameters move down by one.</small>")

param_and_doc("2", false, true, "The term to link to (which this page is " .. sgdescof .. "). This should include diacritics as appropriate to the language (e.g. accents in Russian to mark the stress, vowel diacritics in Arabic, macrons in Latin to indicate vowel length, etc.). These diacritics will automatically be stripped out in a language-specific fashion in order to create the link to the page.")

param_and_doc("3", false, false, "The text to be shown in the link to the term. If empty or omitted, the term specified by the second parameter will be used. This parameter is normally not necessary, and should not be used solely to indicate diacritics; instead, put the diacritics in the second parameter.")

table.insert(parts, "''Named parameters:''\n")

param_and_doc({"t", args.lang and "3" or "4"}, false, false, "A gloss or short translation of the term linked to. <small>The parameter <code>|gloss=</code> is a deprecated synonym; please do not use.</small>")

param_and_doc("tr", false, false, "Transliteration for non-Latin-script terms, if different from the automatically-generated one.")

param_and_doc("ts", false, false, "Transcription for non-Latin-script terms whose transliteration is markedly different from the actual pronunciation. Should not be used for IPA pronunciations.")

param_and_doc("sc", false, false, "Script code to use, if script detection does not work. See [[Wiktionary:Scripts]].")

param_and_doc("from", true, false, "A label (see " .. m_template_link.format_link({"label"}) .. ") that gives additional information on the dialect that the term belongs to, the place that it originates from, or something similar.")

param_and_doc("dot", false, false, "A character to replace the final dot that is normally shown automatically.")

param_and_doc("nodot", false, false, "If <code>|nodot=1</code>, then no automatic dot will be shown.")

if args.withcap then

param_and_doc("nocap", false, false, "If <code>|nocap=1</code>, then the first letter will be in lowercase.")

param_and_doc("id", false, false, "A sense id for the term, which links to anchors on the page set by the " .. m_template_link.format_link({"senseid"}) .. " template.")

return table.concat(parts)

table.insert(exlangs, exlang)

exlangs = m_table.removeDuplicates(exlangs)

for i, langcode in ipairs(exlangs) do

table.insert(langparts, '<code>' .. langcode .. '</code> for ' .. lang_name(langcode, "exlang"))

sub.exlangs = m_table.serialCommaJoin(langparts, {conj = "or"})

sub.tempname = template_name("preserve lang code")

return strutils.format([===[

  # {\op}{\op}{tempname}|<var><primary entry goes here></var>{\cl}{\cl}

]===], sub) .. export.paramdoc(args)

return strutils.format([===[

  # {\op}{\op}{tempname}|<var><langcode></var>|<var><primary entry goes here></var>{\cl}{\cl}

where <code><var><langcode></var></code> is the [[Wiktionary:Languages|language code]], e.g. {exlangs}.

]===], sub) .. export.paramdoc(args)

local shortcuts = #args.shortcut > 0 and require("Module:shortcut box").show(args.shortcut) or ""

return docsubpage .. "\n" .. shortcuts .. introdoc .. "\n" .. usagedoc

args = require("Module:table").shallowcopy(args)

rsub(template_name(), " of$", "") .. (args.form and " " .. args.form or "")

return export.fulldoc(args)

local function sort_by_first(namedata1, namedata2)

return namedata1[1] < namedata2[1]

function export.tagtable()

m_data = mw.loadData("Module:form of/data")

m_data2 = mw.loadData("Module:form of/data2")

m_form_of = require("Module:form of")

local function organize_data(data_module)

local tab = {}

for name, data in pairs(data_module.tags) do

-- If we just skip it, it may never get fixed.

error("Tag '" .. name .. "' has no tag_type")

if not tab[data.tag_type] then

tab[data.tag_type] = {}

table.insert(tab[data.tag_type], {name, data})

local tag_type_order_set = require("Module:table").listToSet(tag_type_order)

for tag_type, tags_of_type in pairs(tab) do

if not tag_type_order_set[tag_type] then

-- See justification above for throwing an error.

error("Tag type '" .. tag_type .. "' not listed in tag_type_order")

end

table.sort(tags_of_type, sort_by_first)

local multitag_shortcuts = {}

local list_shortcuts = {}

local function get_display_form(tags)

local normtags = m_form_of.normalize_tags(tags)

for _, normtag in ipairs(normtags) do

table.insert(display_forms, m_form_of.get_tag_display_form(normtag))

end

return table.concat(display_forms, " ")

for shortcut, full in pairs(data_module.shortcuts) do

if type(full) == "table" then

table.insert(list_shortcuts, {shortcut, get_display_form(full)})

elseif full:find("//") then

table.insert(multitag_shortcuts, {shortcut, get_display_form({full})})

return tab, multitag_shortcuts, list_shortcuts

local data_tab, data_multitag_shortcuts, data_list_shortcuts = organize_data(m_data)

local data2_tab, data2_multitag_shortcuts, data2_list_shortcuts = organize_data(m_data2)

local function insert_group(group)

for _, namedata in ipairs(group) do

local name = namedata[1]

table.insert(sparts, "| <code>" .. name .. "</code> || ")

if data.shortcuts then

for _, shortcut in ipairs(data.shortcuts) do

table.insert(ssparts, "<code>" .. shortcut .. "</code>")

end

table.insert(sparts, table.concat(ssparts, ", ") .. " ")

table.insert(sparts, "|| " .. m_form_of.get_tag_display_form(name))

table.insert(parts, "|-")

table.insert(parts, table.concat(sparts))

local function insert_shortcut_group(shortcuts)

for _, namedisp in ipairs(shortcuts) do

local name = namedisp[1]

local disp = namedisp[2]

table.insert(parts, "|-")

table.insert(parts, "| || <code>" .. name .. "</code> || " .. disp)

table.insert(parts, '{|class="wikitable"')

table.insert(parts, "! Canonical tag !! Shortcut(s) !! Display form")

for _, tag_type in ipairs(tag_type_order) do

local group_tab = data_tab[tag_type]

if group_tab then

table.insert(parts, "|-")

table.insert(parts, '! colspan="3" style="text-align: center; background: #dddddd;" | ' ..

(tag_type_to_description[tag_type] or strutils.ucfirst(tag_type)) .. " (more common)")

insert_group(group_tab)

end

group_tab = data2_tab[tag_type]

if group_tab then

table.insert(parts, "|-")

table.insert(parts, '! colspan="3" style="text-align: center; background: #dddddd;" | ' ..

(tag_type_to_description[tag_type] or strutils.ucfirst(tag_type)) .. " (less common)")

insert_group(group_tab)

if #data_multitag_shortcuts > 0 then

table.insert(parts, "|-")

table.insert(parts, '! colspan="3" style="text-align: center; background: #dddddd;" | Multitag shortcuts (more common)')

insert_shortcut_group(data_multitag_shortcuts)

if #data2_multitag_shortcuts > 0 then

table.insert(parts, "|-")

table.insert(parts, '! colspan="3" style="text-align: center; background: #dddddd;" | Multitag shortcuts (less common)')

insert_shortcut_group(data2_multitag_shortcuts)

return table.concat(parts, "\n")

for shortcut, full in pairs(m_pos) do

table.insert(shortcut_tab[full], shortcut)

table.sort(shortcuts)

table.insert(shorcut_list, {full, shortcuts})

table.sort(shorcut_list, function(fs1, fs2) return fs1[1] < fs2[1] end)

table.insert(parts, '{|class="wikitable"')

table.insert(parts, "! Canonical part of speech !! Shortcut(s)")

table.insert(parts, "|-")

table.insert(sparts, "<code>" .. shortcut .. "</code>")

table.insert(parts, "| <code>" .. full .. "</code> || " .. table.concat(sparts, ", "))

table.insert(parts, "|}")

return table.concat(parts, "\n")

function export.cattable()

local m_cats = mw.loadData("Module:form of/cats")

local cats = {}

local function process_spec(spec)

if type(spec) == "string" then

local predicate = spec[1]

-- WARNING! #spec doesn't work for objects loaded from loadData()

if i > 1 then

process_spec(spec[4])

elseif predicate == "and" or predicate == "or" then

elseif predicate == "call" then

return

error("Unrecognized predicate: " .. predicate)

for lang, catspecs in pairs(m_cats) do

local cats = find_categories(catspecs)

table.insert(cats_by_lang, {lang, cats})

table.sort(cats_by_lang, sort_by_first)

for i, langcats in ipairs(cats_by_lang) do

local lang = langcats[1]

if lang == "und" then

if lang_independent_cat_index then

local lang_independent_cats = table.remove(cats_by_lang, lang_independent_cat_index)

end