Module:Lang: Difference between revisions

Lua support for the {{lang}}, {{lang-xx}}, and {{transl}} templates and replacement of various supporting templates.  

require('Module:No globals');

local unicode = require ("Module:Unicode data"); -- for is_latin() and is_rtl()

local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language

Returns true if argument is set; false otherwise. Argument is 'set' when it exists (not nil) or when it is not an empty string.

local function is_set( var )

validates |italic= or |italics= assigned values.

defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-xx}} depending on

the individual template's requirements, 'italic' for {{transl}}) or to the value appropriate to |script=, if set ({{lang}}

and {{lang-xx}} only).

local properties = {['yes'] = 'italic', ['no'] = 'normal', ['unset'] = 'inherit', ['invert'] = 'invert', ['default'] = nil};

return nil, 'only one of |italic=, |italics=, or |i= can be specified';

Default behavior of the {{lang}} and {{lang-xx}} templates is to add categorization when the templates are used in mainspace.

Whether needle is in haystack

local function in_array ( needle, haystack )

for n,v in ipairs( haystack ) do

prettify ietf tags to use recommended subtag formats:

extracts and returns IETF language tag parts:

each of lang, script, region, variant, and private, when used, must be valid

For {{lang-xx}} templates, the parameters |script=, |region=, and |variant= are supported (not supported in {{lang}}

because those parameters are superfluous to the IETF subtags in |code=)

returns six  values; all lower case.  Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid

see http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1

 

return nil, nil, nil, nil, nil, 'missing language tag';

return nil, nil, nil, nil, nil, table.concat ({'unrecognized language tag: ', source}); -- don't know what we got but it is malformed

return nil, nil, nil, nil, nil, table.concat ({'unrecognized language code: ', code}); -- invalid language code, don't know about the others (don't care?)

table.insert (maint_cats, table.concat ({'Lang and lang-xx code promoted to ISO 639-1|', code}));

table.insert (maint_msgs, table.concat ({'code: ', code, ' promoted to code: ', synonym_table[code]}));

return code, nil, nil, nil, nil, 'redundant script tag'; -- both code with script and |script= not allowed

return code, nil, nil, nil, nil, table.concat ({'unrecognized script: ', script, ' for code: ', code}); -- language code ok, invalid script, don't know about the others (don't care?)

return code, nil, nil, nil, nil, table.concat ({'script: ', script, ' not supported for code: ', code}); -- language code ok, script is suppressed for this code

return code, nil, nil, nil, nil, 'redundant region tag'; -- both code with region and |region= not allowed

return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code});

return code, nil, nil, nil, nil, 'redundant variant tag'; -- both code with variant and |variant= not allowed

return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant});

return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', code, '-', script});

return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-region pair: ', code, '-', region});

else

if not in_array (code, variant_table[variant]['prefixes']) then

return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code: ', code});

end

return code, script, region, nil, nil, table.concat ({'unrecognized private tag: ', private});

adds <i> and </i> tags to list-item text or to implied <p>..</p> text. mixed not supported

return mw.ustring.gsub (text, '(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item

local html = {};

table.insert (html, '&#42;'); -- move proto language text prefix outside of italic markup if any; use numeric entity because plain splat confuses MediaWiki

table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag

table.insert (html, table.concat ({' lang="', code, '\"'})); -- add language attribute

if rtl or unicode.is_rtl(text) then

table.insert (html, ' dir="rtl"'); -- add direction attribute for right to left languages

table.insert (html, ' style=\"font-style: normal;'); -- override external markup, if any

table.insert (html, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted

table.insert (html, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute

if is_set (language) then

table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text

table.insert (html, ' collective text'); -- for collective languages

table.insert (html, ' language text'); -- for individual languages

else

table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag

table.insert (html, table.concat ({'</', tag, '>'})); -- close the <i>, <span>, or <div> html tag

if rtl then -- legacy; shouldn't be necessary because all of the rtl text is wrapped inside an html tag with dir="rtl" attribute

table.insert (html, '&lrm;'); -- make sure the browser knows that we're at the end of the rtl

for English:

for ISO 639-2 collective languages (and for 639-1 bh):

if language_name:find ('languages') then

return table.concat ({'[[Category:Articles with text in ', language_name, ']]'});

 

if 'en' == code then

table.insert (cat, 'explicitly cited ' .. language_name); -- falls back to English if regional name not available

table.insert (cat, language_name);

return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string

The value |script= is not used in {{transl}} for this purpose; instead it uses |code.  Because language scripts

are listed in the {{transl}} switches they are included in the data tables.  The script parameter is introduced

to be |translit-script= (in this function, tscript)

For {{transl}}, style only applies when a language code is provided

local function make_translit (code, language_name, translit, std, tscript, style)

local title;

local title_table = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards

table.insert (tout, "<i lang=\""); -- so use <i> tag

table.insert (tout, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it

table.insert (tout, "-Latn\" title=\""); -- transliterations are always Latin script

table.insert (tout, "<span title=\""); -- when no language code: no lang= attribute, not italic ({{transl}} only)

table.insert (tout, language_name); -- write a generic tool tip

if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name)

table.insert (tout, '-language') -- skip this text (individual and macro languages only)

table.insert (tout, ' romanization'); -- finish the tool tip; use romanization when neither script nor standard supplied

if title_table[std] then -- and if standard is legitimate

if title_table[std][tscript] then -- and if script for that standard is legitimate

table.insert (tout, table.concat ({title_table[std][tscript:lower()], ' (', script_table[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip

table.insert (tout, title_table[std]['default']); -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?

if not title_table[std] then return ''; end -- invalid standard, setup for error message

if title_table[std][code] then -- if language code is in the table (transl may not provide a language code)

-- table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', lang_table[code][1], ' language) transliteration'})); -- add the appropriate text to the tool tip

table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', language_name, ' language) transliteration'})); -- add the appropriate text to the tool tip

table.insert (tout, title_table[std]['default']); -- so use the standard's default

if title_table['no_std'][tscript] then

table.insert (tout, title_table['no_std'][tscript]); -- use translit-script if set

elseif title_table['no_std'][code] then

table.insert (tout, title_table['no_std'][code]); -- use language code

table.insert (tout, table.concat ({language_name, '-script transliteration'})); -- write a script tool tip

if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name)

table.insert (tout, '-language') -- skip this text (individual and macro languages only)

table.insert (tout, ' transliteration'); -- finish the tool tip

table.insert (tout, ' transliteration'); -- generic tool tip (can we ever get here?)

table.insert (tout, '">');

if is_set (code) and not style then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})

table.insert (tout, "</i>"); -- close the italic tag

table.insert (tout, "</span>"); -- no language code so close the span tag

error message. The tests are for empty or missing text and for improper or disallowed use of apostrophe markup.

return make_error_msg ('no text', args, template);

return make_error_msg ('text has malformed markup', args, template);

if ('unset' ~= style) and ('invert' ~=style) then

return make_error_msg ('text has italic markup', args, template);

render mainenance messages and categories

local function render_maint(nocat)

for proto languages, text is prefixed with a splat. We do that here as a flag for make_text_html() so that a splat

will be rendered outside of italic markup (if used). If the first character in text here is already a splat, we

do nothing

proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and / or inhibits

regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac

looks for a poem strip marker in text; returns true when found; false else

auto-italic detection disabled when text has poem stripmarker because it is not possible for this code to know

validates value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false,

empty string (or parameter omitted) returns as nil; any other value returns as nil with a second return value of

if 'yes' == proto_param then

elseif 'no' == proto_param then

return nil, true; -- |proto= something other than 'yes' or 'no'

common function to return language name from the data set according to IETF tag

returns language name if found in data tables; nil else

name = override_table[ietf][1];

elseif override_table[code] then -- not there so try basic language code

name = override_table[code][1];

elseif lang_table[code] then -- shift to iana code/name table

name = lang_table[code][1]; -- table entries sometimes have multiple names, always take the first one

elseif lang_dep_table[code] then

-- if cat then

-- table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code}));

-- table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'}));

name = lang_dep_table[code][1]; -- table entries sometimes have multiple names, always take the first one

table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code}));

table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'}));

entry point for {{lang}}

there should be no reason to set parameters in the {{lang}} {{#invoke:}}

parameters are received from the template's frame (parent frame)

local template = args.template or 'Lang';

return make_error_msg ('conflicting: {{{1}}} and |code=', args, template);

return make_error_msg ('conflicting: {{{2}}} and |text=', args, template);

args.rtl = args.rtl == 'yes'; -- convert to boolean: 'yes' -> true, other values -> false

return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template);

return make_error_msg ( msg, args, template);

(this_wiki_lang ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and unicode.is_Latin (args.text)) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics)

if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content

table.insert (out, render_maint(args.nocat)); -- maintenance messages and categories

entry point for {{lang}}

there should be no reason to set parameters in the {{lang}} {{#invoke:}}

parameters are received from the template's frame (parent frame)

local args = getArgs (frame, { -- this code so that we can detect and handle wiki list markup in text

return _lang (args);

--[[--------------------------< L A N G _ X X >----------------------------------------------------------------

For the {{lang-xx}} templates, the only parameter required to be set in the template is the language code.  All

other parameters can, usually should, be written in the template call.  For {{lang-xx}} templates for languages

For each {{lang-xx}} template choose the appropriate entry-point function so that this function knows the default

for those {{lang-xx}} templates that support transliteration (those templates where |text= is not entirely latn script):

For {{lang-xx}}, the positional parameters are:

local function _lang_xx (args)

local template = args.template or 'Lang-xx';

if args[1] and args.text then

return make_error_msg ('conflicting: {{{1}}} and |text=', args, template);

args.text = args[1] or args.text; -- prefer args.text

if args[2] and args.translit then

return make_error_msg ('conflicting: {{{2}}} and |translit=', args, template);

args.translit = args[2] or args.translit -- prefer args.translit

if args[3] and (args.translation or args.lit) then

return make_error_msg ('conflicting: {{{3}}} and |lit= or |translation=', args, template);

return make_error_msg ('conflicting: |lit= and |translation=', args, template);

args.translation = args[3] or args.translation or args.lit; -- prefer args.translation

return make_error_msg ('conflicting: |links= and |link=', args, template);

args.rtl = args.rtl == 'yes'; -- convert to boolean: 'yes' -> true, other values -> false

 

if nil == args.italic then -- args.italic controls

if is_set (subtags.script) then

if 'latn' == subtags.script then

args.italic = 'italic'; -- |script=Latn; set for font-style:italic

args.italic = initial_style_state; -- italic not set; script is not latn; set for font-style:<initial_style_state>

return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template);

if 'no' == args.link then

if language_name:find ('languages') then

elseif lang_data.article_name[code] then

table.insert (out, make_wikilink (lang_data.article_name[code][1], language_name)); -- language name with wikilink from override data

table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink

if 'invert' == args.italic then

table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, nil))

if is_set (args.translit) and not unicode.is_Latin (args.text) then -- transliteration (not supported in {{lang}}); not supported when args.text is wholly latn text (this is an imperfect test)

translit_script_name = script_table[args['translit-script'][1]];

translit_title = mw.title.makeTitle (0, table.concat ({'Romanization of ', translit_script_name})); -- make a title object

if translit_title.exists and ('no' ~= args.link) then

table.insert (out, make_wikilink ('Romanization of ' .. translit_script_name or language_name, 'romanized') .. ':'); -- make a wikilink if there is an article to link to