Module:Lang: Difference between revisions

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

'\239\188\129-\239\188\188', -- Halfwidth and Fullwidth Forms U+FF01-U+FF3C (EF BC 81 - EF BC BC)

validates |italic= or |italics= assigned values.

When |italic= is not set, or has an unacceptible assigned value, return nil and a nil error message.

When both |italic= and |italics= are set, returns nil and a 'conflicting' error message.

The return value nil causes the calling lang, lang_xx, or transl function to set args.italic according to the template's

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).

nil - when |italic= absent or not set; returns nil

default - for completeness, should rarely if ever be used; returns nil

yes - force args.text to be rendered in italic font; returns 'italic'

no - force args.text to be rendered in normal font; returns 'normal'

unset - disables font control so that font-style applied to text is dictated by markup inside or outside the template; returns 'inherit'

local function validate_italic (italic, italics)

if italic and italics then -- return nil and an error message if both are set

return nil, 'conflicting: |italic= and |italics=';

end

return properties[italic or italics], nil; -- return an appropriate value and a nil error message

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

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

assembles an error message from template name, message text, help link, and error category.

local function make_error_msg (msg, args, template)

local category;

if 'transl' == template then

category = 'transl';

else

category = 'lang and lang-xx'

end

table.insert (out, table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: {{', template, '}}: '}));

table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'}));

table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'}));

if text:match ('^%*') then

table.insert (span, '*'); -- move proto language text prefix outside of italic markup if any

text = text:gsub ('^%*', ''); -- remove the spat from the text

end

--[=[-------------------------< M A K E _ C A T E G O R Y >----------------------------------------------------

For individual language, <language>, returns:

[[Category:Articles containing <language>-language text]]

for English:

[[Category:Articles containing explicitly cited English-language text]]

for artificial languages (code: art)

[[Category:Articles containing constructed-language text]]

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

[[Category:Articles with text from the <language> languages collective]]

]=]

if language_name:find ('languages') then

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

end

if 'en' == code then

This function is used by both lang_xx() and transl()

lang_xx() always provides code, language_name, and translit; may provide tscript; never provides style

transl() always provides language_name, translit, and one of code or tscript, never both; always provides style

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

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

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

if not style then -- nil for is the default italic style

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

else

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

end

table.insert (tout, code);

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

else

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

end

table.insert (tout, '-language transliteration');

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()], ' (', lang_name_table.script[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip

else

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?

end

return ''; -- 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_name_table.lang[code][1], ' language) transliteration'})); -- add the appropriate text to the tool tip

if is_set (tscript) then

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

elseif is_set (code) then

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

else

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

end

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

else

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

end

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

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

if ('unset' ~= args.italic) and ('unset' ~= args.italics) then -- allow italic markup when |italic=unset or |italics=unset

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

for proto languages, text is prefixed with a splat. We do that here as a flag for make_text_span() 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

if language_name:find ('^Proto%-') and not text:find ('^*') then -- language is a proto and text does not already have leading splat

return make_error_msg ('conflicting: {{{1}}} and &#124;code=', args, 'lang');

return make_error_msg ('conflicting: {{{2}}} and &#124;text=', args, 'lang');

return make_error_msg ( msg, args, 'lang');

args.italic, msg = validate_italic (args.italic, args.italics);

if msg then

return make_error_msg (msg, args, 'lang');

args.text = proto_prefix (args.text, language_name); -- prefix proto-language text with a splat

local language_name; -- used to make display text, article links

local category_name; -- same as language_name except that it retains any parenthetical disambiguators (if any) from the data set

return make_error_msg ('conflicting: {{{1}}} and &#124;text=', args, 'lang-xx');

return make_error_msg ('conflicting: {{{2}}} and &#124;translit=', args, 'lang-xx');

return make_error_msg ('conflicting: {{{3}}} and &#124;lit= or &#124;translation=', args, 'lang-xx');

return make_error_msg ('conflicting: &#124;lit= and &#124;translation=', args, 'lang-xx');

return make_error_msg ('conflicting: &#124;links= and &#124;link=', args, 'lang-xx');

return make_error_msg (msg, args, 'lang-xx');

args.italic, msg = validate_italic (args.italic, args.italics);

if msg then

return make_error_msg (msg, args, 'lang-xx');

category_name = language_name; -- category names retain IANA parenthetical diambiguators (if any)

language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them

table.insert (out, language_name); -- language name without wikilink

if language_name:find ('languages') then

table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink

else

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

end

table.insert (out, ': '); -- separator

args.text = proto_prefix (args.text, language_name); -- prefix proto-language text with a splat

table.insert (out, ', '); -- comma to separate text from translit

if lang_name_table.script[args['translit-script']] then -- when |translit-script= is set, try to use the script's name

translit_script_name = lang_name_table.script[args['translit-script'][1]];

else

translit_script_name = language_name; -- fall back on language name

end

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

table.insert (out, '&nbsp;</small>'); -- close the small tag

return make_error_msg (table.concat ({'invalid translit-std: \'', args['translit-std'] or '[missing]'}), args, 'lang-xx');

table.insert (out, make_category (code, category_name, args.nocat));

Entry point for those {{lang-xx}} templates that call lang_xx_italic(). Sets the initial style state to italic.

Entry point for those {{lang-xx}} templates that call lang_xx_inherit(). Sets the initial style state to inherit.

language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them

--[[--------------------------< T R A N S L >------------------------------------------------------------------

Prospective replacement for the template {{transl}}

]]

function p.transl (frame)

local args = getArgs(frame); -- no {{#invoke:}} parameters

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

local language_name; -- language name that matches language code; used for tool tip

local translit; -- translitterated text to display

local script; -- IANA script

local msg; -- for when called functions return an error message

if is_set (args[3]) then -- [3] set when {{transl|code|standard|text}}

args.text = args[3]; -- get the transliterated text

args.translit_std = args[2]; -- get the standard

if not title_table[args.translit_std] then

return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'transl');

end

else

if is_set (args[2]) then -- [2] set when {{transl|code|text}}

args.text = args[2]; -- get the transliterated text

else

if args[1]:match ('^%a%a%a?%a?$') then -- args[2] missing; is args[1] a code or its it the transliterated text?

return make_error_msg ('no text', args, 'transl'); -- args[1] is a code so we're missing text

else

args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message

return make_error_msg ('missing language / script code', args, 'transl');

end

end

end

if is_set (args[1]) then -- IANA language code used for html lang= attribute; or ISO 15924 script code

args.code = args[1]:match ('^%a%a%a?%a?'):lower(); -- use the language/script code portion only (2, 3, or 4 alpha characters); lower case because table indexes are lower case

else

return make_error_msg ('missing language / script code', args, 'transl'); -- missing language / script code so quit

end

args.italic, msg = validate_italic (args.italic, args.italics);

if msg then

return make_error_msg (msg, args, 'transl');

end

if 'italic' == args.italic then -- 'italic' when |italic=yes; because that is same as absent or not set and |italic=default

args.italic = nil; -- set to nil;

end

if lang_data.override[args.code] then -- is code a language code defined in the override table?

language_name = lang_data.override[args.code][1];

elseif lang_name_table.lang[args.code] then -- is code a language code defined in the standard language code tables?

language_name = lang_name_table.lang[args.code][1];

elseif lang_name_table.script[args.code] then -- if here, code is not a language code; is it a script code?

language_name = lang_name_table.script[args.code][1];

script = args.code; -- code was an ISO 15924 script so use that instead

args.code = ''; -- unset because not a language code

else

return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'transl'); -- invalid language / script code

end

-- here only when all parameters passed to make_translit() are valid

return make_translit (args.code, language_name, args.text, args.translit_std, script, args.italic);

end