Module:Lang: Difference between revisions

require('Module:No globals');

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

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

else

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

end

if 'transl' == template then

category = 'transl';

category = 'lang and lang-xx'

table.insert (out, table.concat ({'[', args.text or 'undefined', '] '})); -- for error messages output args.text if available

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

if (0 == namespace or 10 == namespace) and not args.nocat then -- categorize in article space (and template space to take care of broken usages)

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

if language:find ('languages') then

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

else

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

end

table.insert (html, '\">'); -- close the opening html tag

else

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

end

table.insert (html, text); -- insert the text

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

return table.concat (html); -- put it all together and done

[[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]]'});

-- return table.concat ({'[[Category:Articles with text from ', language_name, ']]'}); -- proposed version at Wikipedia:Categories_for_discussion/Log/2020_August_18#Category:Articles_with_text_from_the_Afro-Asiatic_languages_collective

if 'en' == code then

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

local tout = {};

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

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 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_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, '">');

table.insert (tout, translit);

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

return table.concat (tout);

table.insert (maint, table.concat ({'<span class="lang-comment" style="font-style:normal; display:none; color:#33aa33; margin-left:0.3em">'})); -- opening <span> tag

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'}));

-- end

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

local template = args.template or 'lang';

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

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

validate_cat_args (args); -- determine if categorization should be suppressed

return make_error_msg (table.concat ({'invalid &#124;proto=: ', args.proto}), 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)

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

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

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

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

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

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

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

if language_name:find ('languages') 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_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, nil))

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

table.insert (out, ', ');

if 'none' ~= args.label then

table.insert (out, '<small>');

if 'no' == args.link then

table.insert (out, '<abbr title="literal translation">lit.</abbr>');

else

table.insert (out, make_wikilink ('Literal translation', 'lit.'));

end

table.insert (out, "&nbsp;</small>");

end

table.insert (out, table.concat ({'&#39;', args.translation, '&#39;'})); -- use html entities to avoid wiki markup confusion

return _is_ietf_tag (getArgs(frame)[1]); -- args[1] is the ietf language tag to be tested; getArgs() so we also get parent frame

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

if language_name:find ('languages') then

language_name = make_wikilink (lang_data.article_name[code][1], label or language_name); -- language name with wikilink from override data

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

local translit; -- translitterated text to display

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

if args[1] and 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

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

if args[1]:match ('^%a%a%a?%a?$') then -- args[1] has correct form?

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

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

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

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

language_name = override_table[args.code][1];

language_name = lang_table[args.code][1];

language_name = lang_dep_table[args.code][1];

language_name = script_table[args.code][1];

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

local function _category_from_tag (args)

local raw_code = args[1]; -- save a copy of the input IETF subtag

local link = 'yes' == args['link']; -- make a boolean

local label = args.label;

local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template)

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

return category_name;