Module:headword: difference between revisions

Definition from Wiktionary, the free dictionary
Jump to: navigation, search
m
(2 intermediate revisions by the same user not shown)
Line 1: Line 1:
 
local languages = mw.loadData("Module:languages")
 
local languages = mw.loadData("Module:languages")
  +
local m_links = require("Module:links")
   
 
local export = {}
 
local export = {}
Line 77: Line 78:
 
if term ~= "" then
 
if term ~= "" then
 
 
-- Does this term contain a link?
+
-- Apply processing to the term, for formatting links and such
-- Todo: Replace this by a call to [[Module:links]], which is more sophisticated.
+
term = m_links.language_link(term, nil, lang, langinfo.names[1])
if not term:find("[[", nil, true) then
 
-- If not, then link the term
 
term = "[[" .. term .. (term ~= PAGENAME and "#" .. langinfo.names[1] .. "|" .. term or "") .. "]]"
 
end
 
 
 
 
-- Format the term with the script code template
 
-- Format the term with the script code template
Line 121: Line 122:
 
head = SUBPAGENAME
 
head = SUBPAGENAME
 
end
 
end
  +
end
  +
  +
-- Apply processing to the headword, for formatting links and such
  +
if head:find("[[", nil, true) then
  +
head = m_links.language_link(head, nil, langinfo)
 
end
 
end
 
 

Revision as of 16:36, 16 July 2013

The following documentation is located at Module:headword/documentation. [edit]

This module is used to show headword lines, along with any annotations like genders, transliterations and inflections. It's used by the template {{head}}, via the submodule Module:headword/templates.

format_headword

format_headword(heads, lang, sc)

Formats a headword, using the format appropriate for the given language object and script (see Module:script utilities#tag_text).

The heads parameter can either be a single string or a table of strings. If it's a table, then each string in the table is shown as a headword, separated by "or". This allows you to show multiple alternative headwords, such as when the same written form can be accented in different ways.

It has special behaviour in certain cases as well:

  • If an item in the heads parameter contains wikilinks, they are converted into language-section links for the given language (using Module:links#language_link, which is also used by {{l}}). For example, giving "[[give]] [[up]]" if the language provided is English will produce: [[give#English|give]] [[up#English|up]]. If string is prefixed with * or if any of the links are, then they are interpreted as reconstructed terms and it will create links to the appendix namespace as appropriate.
  • If heads is empty (nil or the empty table), it will default to mw.title.getCurrentTitle().subpageText (equivalent to {{SUBPAGENAME}} in templates).
    • If the page name contains spaces, it is split and each individual word is automatically wikilinked as above.
    • If the current page is in the appendix namespace, and the language's type (in Module:languages) is not appendix-constructed, then a * will be prepended to the headword to indicate that it is a reconstructed term.

format_transliteration

format_transliteration(tr, lang)

If the transliteration is specified and non-empty, adds some stuff before and after it. For example, if the transliteration is 'foo' and the language is Hebrew, produces
 [[Wiktionary:Hebrew transliteration|•]] (<span lang="">foo</span>)
which looks like “ (foo)”.

(Note: the bullet/link is only added if the linked-to page actually exists.)

format_genders

format_genders(genders, lang)

Format gender specifications using Module:gender and number. This function currently has fairly limited capabilities, but more may be added later.

format_inflections

format_inflections(inflections, lang, sc)

Format a list (table) of inflections, which are then concatenated together with commas and surrounded by parentheses. For example:

format_inflections({"first", "second", "third"}, "en", "Latn")

gives:

 (first, second, third)

displays as: (first, second, third)

If an element of the table is itself a table, then it is taken to consist of a list of labelled inflections:

  • The table must have a .label value which contains the label. It is displayed in italics and not linked.
  • The table may optionally have a .accel value. This value is used to support accelerated entry creation using WT:ACCEL. The "form-of" and "lang-(code)" classes are added automatically, so only the "(form)-form-of" class needs to be given, along with any other classes that may be needed.
  • The table may optionally have a .nolink value. If true, this will tell the function not to link to the terms, but only display them.
  • Numbered values in the table are the actual forms. They are formatted in bold text and converted to a link to the term. If a term already contains a link, it is converted into a section link using Module:links#language_link, just like in format_headword.
  • Forms are optional. If the table contains only the .label, then just the label is shown with no forms. If there is more than one form, they are shown with "or" between them.

For example:

format_inflections({
    {label = "present", "krama"},
    {label = "past", "kramade"},
    {label = "past participle", "kramat"},
    "sv", "Latn")
format_inflections({
    {label = "plural", accel = "plural-form-of", "voorbeelden"},
    "nl", "Latn")

gives:

 (''present'' <b lang=\"sv\">[[krama#Swedish|krama]]</b>, ''past'' <b lang=\"sv\">[[kramade#Swedish|kramade]]</b>, ''past participle'' <b lang=\"sv\">[[kramat#Swedish|kramat]]</b>)
 (''plural'' <span class=\"form-of lang-nl plural-form-of\"><b lang=\"nl\">[[voorbeelden#Dutch|voorbeelden]]</b></span>)

displays as:

(present krama, past kramade, past participle kramat)
(plural voorbeelden)

It is also possible, but optional, to supply a table instead of a term. This table can contain the keys .term (the actual term), .alt (alternative display form), .sc (script), .id (sense id) and .genders (list of genders). These are used the same way as for full_link in Module:links, and are passed directly to it.

Example:

format_inflections({
    {label = "diminutive", {term = "Hündchen", genders = {"n"}}},
    "de", "Latn")

gives:

 (''diminutive'' <b lang=\"de\">[[Hündchen#German|Hündchen]]</b> <span class=\"gender\"><abbr title="neuter gender">n</abbr></span>)

displays as:

(diminutive Hündchen n)

Proposed/planned changes

  • Automatic transliteration for languages that support it. Note that the parameters of format_transliteration will need change for this to be implemented.
  • Checking for invalid genders, given a list genders that are valid for a particular language.

local languages = mw.loadData("Module:languages")
local m_links = require("Module:links")
 
local export = {}
 
-- The main entry point.
-- This is the only function that can be invoked from a template.
function export.show(frame)
    local args = frame:getParent().args
    PAGENAME = mw.title.getCurrentTitle().text
    SUBPAGENAME = mw.title.getCurrentTitle().subpageText
    NAMESPACE = mw.title.getCurrentTitle().nsText
    local ret = ""
    local categories = {}
 
    -- Get language and script information
    local lang = args[1] or (NAMESPACE == "Template" and "und")  or error("Language code has not been specified. Please pass parameter 1 to the module invocation.")
    local langinfo = languages[lang] or error("The language code \"" .. lang .. "\" is not valid.")
    local sc = args["sc"] or ""; if sc == "" then sc = langinfo.scripts[1] end
 
    -- Gather basic parameters
    local head = args["head"]; if head == "" then head = nil end
    local sort_key = args["sort"]; if sort_key == "" then sort_key = nil end
    local pos = args[2]; if pos == "" then pos = nil end
    local cat2 = args["cat2"]; if cat2 == "" then cat2 = nil end
    local cat3 = args["cat3"]; if cat3 == "" then cat3 = nil end
    local tr = args["tr"]; if tr == "" then tr = nil end
 
    -- Get/set categories
    if pos then
        -- Make the plural form of the part of speech
        if pos:find("x$") then
            pos = pos .. "es"
        elseif pos ~= "punctuation" or pos ~= "phrasebook" then
            pos = pos .. "s"
        end
 
        table.insert(categories, langinfo.names[1] .. " " .. pos)
    end
 
    if cat2 then
        table.insert(categories, langinfo.names[1] .. " " .. cat2)
    end
 
    if cat3 then
        table.insert(categories, langinfo.names[1] .. " " .. cat3)
    end
 
    -- Gather gender and number specifications
    -- Iterate over all gn parameters (g2, g3 and so on) until one is empty
    local genders = {}
    local g = args["g"] or ""
    local i = 2
 
    while g ~= "" do
        -- If any of the specifications contains a "?", add the entry
        -- to a cleanup category.
        if g:find("?", nil, true) then
            table.insert(categories, langinfo.names[1] .. " terms with incomplete gender")
        end
 
        table.insert(genders, g)
        g = args["g" .. i] or ""
        i = i + 1
    end
 
    -- Gather inflected forms
    local inflections = {}
 
    local i = 3
    local label = args[i] or ""
    local term = args[i+1] or ""
    local parts = {}
 
    while label ~= "" do
        table.insert(parts, label)
 
        if term ~= "" then
 
            -- Apply processing to the term, for formatting links and such
            term = m_links.language_link(term, nil, lang, langinfo.names[1])
 
            -- Format the term with the script code template
            term = frame:expandTemplate{ title = sc, args = { term, lang = lang, face = "bold" } }
 
            table.insert(parts, term)
        end
 
        i = i + 2
        label = args[i] or ""
        term = args[i+1] or ""
 
        -- If the next label is "or" then continue adding to the current parts list.
        -- Otherwise, insert the previous one and create a new one.
        if label ~= "or" then
            table.insert(inflections, parts)
            parts = {}
        end
    end
 
    table.insert(inflections, part)
 
    -- Format and return all the gathered information
    return
        export.format_headword(head, lang, sc) ..
        export.format_transliteration(tr) ..
        export.format_genders(genders) ..
        export.format_inflections(inflections, lang, sc) ..
        export.format_categories(categories, sort_key)
end
 
-- Format a headword
function export.format_headword(head, lang, sc)
    if not head then
        NAMESPACE = NAMESPACE or mw.title.getCurrentTitle().nsText
        SUBPAGENAME = SUBPAGENAME or mw.title.getCurrentTitle().subpageText
        local langinfo = languages[lang] or error("The language code \"" .. lang .. "\" is not valid.")
 
        if NAMESPACE == "Appendix" and langinfo.type ~= "appendix-constructed" then
            head = "*" .. SUBPAGENAME
        else
            head = SUBPAGENAME
        end
    end
 
    -- Apply processing to the headword, for formatting links and such
    if head:find("[[", nil, true) then
        head = m_links.language_link(head, nil, langinfo)
    end
 
    -- Call the script code template
    return mw.getCurrentFrame():expandTemplate{ title = sc, args = { head, lang = lang, face = "head" } }
end
 
-- Format transliteration
function export.format_transliteration(tr)
    if tr then
        return " (" .. tr .. ")"
    else
        return ""
    end
end
 
function export.format_genders(genders, lang)
    if #genders > 0 then
        local gen = require("Module:gender and number")
        return " " .. gen.format_list(genders)
    else
        return ""
    end
end
 
-- Format the inflections following the headword
function export.format_inflections(inflections, lang, sc)
    if #inflections > 0 then
        -- Format each inflection "part" individually
        for key, part in ipairs(inflections) do
            -- If this "part" is a table, it contains alternating label-term pairs.
            -- Format them too.
            if type(part) == "table" then
                for key2, text in ipairs(part) do
                    -- Odd-numbered keys are labels, even-numbered keys are terms
                    if key2 % 2 == 1 then
                        part[key2] = "''" .. text .. "''"
                    end
                end
 
                inflections[key] = table.concat(part, " ")
            end
        end
 
        return " (" .. table.concat(inflections, ", ") .. ")"
    else
        return ""
    end
end
 
-- Format the categories with the appropriate sort key
function export.format_categories(categories, sort_key)
    NAMESPACE = NAMESPACE or mw.title.getCurrentTitle().nsText
 
    if NAMESPACE == "" or NAMESPACE == "Appendix" then
        PAGENAME = PAGENAME or mw.title.getCurrentTitle().text
        SUBPAGENAME = SUBPAGENAME or mw.title.getCurrentTitle().subpageText
 
        -- Generate a default sort key
        if not sort_key then
            sort_key = mw.ustring.gsub(SUBPAGENAME, "^[-־]", "")
        end
 
        -- If the key is the same as the wiki software's default, remove it
        if sort_key == PAGENAME then
            sort_key = nil
        end
 
        for key, cat in ipairs(categories) do
            categories[key] = "[[Category:" .. cat .. (sort_key and "|" .. sort_key or "") .. "]]"
        end
 
        return table.concat(categories, "")
    else
        return ""
    end
end
 
return export