Module:Lang: Difference between revisions

(11 intermediate revisions by 4 users not shown)

Line 5:

]=]

require('~~Module:No globals~~');

require('strict');

local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()

local getArgs = require ('Module:Arguments').getArgs;

Line 13:

Line 11:

local yesno = require ('Module:Yesno');

local ~~lang_name_table~~ = mw.loadData ('Module:~~Language/name~~/data');

local lang_data = mw.loadData ('Module:Lang/data'); -- language name override and transliteration tool-tip tables

local lang_name_table = lang_data.lang_name_table; -- language codes, names, regions, scripts, suppressed scripts

local lang_table = lang_data.lang_name_table.lang;

local lang_dep_table = lang_data.lang_name_table.lang_dep;

local script_table = lang_data.lang_name_table.script;

local region_table = lang_data.lang_name_table.region;

local variant_table = lang_data.lang_name_table.variant;

local suppressed_table = lang_data.lang_name_table.suppressed;

local override_table = lang_data.override;

local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code

local lang_data = mw.loadData ('Module:Lang/data'); -- language name override and transliteration tool-tip tables

local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization

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

local content_lang = mw.language.getContentLanguage();

local this_wiki_lang_tag = content_lang.code; -- get this wiki's language tag

local this_wiki_lang_dir = content_lang:getDir(); -- get this wiki's language direction

local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()

local maint_cats = {}; -- maintenance categories go here

Line 121:

Line 129:

if count > 1 then -- return nil and an error message if more than one is set

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

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

end

Line 186:

Line 194:

region: upper case

variant: lower case

private: lower case prefixed with -x-

]]

local function format_ietf_tag (code, script, region, variant)

local function format_ietf_tag (code, script, region, variant, private)

local out = {};

if is_set (private) then

return table.concat ({code:lower(), 'x', private:lower()}, '-'); -- if private, all other tags ignored

end

table.insert (out, code:lower());

if is_set (script) then

Line 216:

Line 229:

script subtag - four character IANA script code

region subtag - two-letter or three digit IANA region code

variant subtag - four digit or 5-8 alnum variant code

variant subtag - four digit or 5-8 alnum variant code; only one variant subtag supported

private subtag - x- followed by 1-8 alnum private code; only supported with the primary language tag

Line 306:

Line 319:

code = code:lower(); -- ensure that we use and return lower case version of this

if not (~~lang_data.override~~[code] or ~~lang_name_table.lang~~[code]) then

if not (override_table[code] or lang_table[code] or synonym_table[code] or lang_dep_table[code]) then

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

end

Line 326:

Line 339:

if is_set (script) then

script = script:lower(); -- ensure that we use and return lower case version of this

if not ~~lang_name_table.script~~[script] then

if not script_table[script] then

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

end

if ~~lang_name_table.suppressed~~[script] then -- ensure that code-script does not use a suppressed script

if suppressed_table[script] then -- ensure that code-script does not use a suppressed script

if in_array (code, ~~lang_name_table.suppressed~~[script]) then

if in_array (code, suppressed_table[script]) then

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

end

Line 346:

Line 359:

if is_set (region) then

region = region:lower(); -- ensure that we use and return lower case version of this

if not ~~lang_name_table.region~~[region] then

if not region_table[region] then

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

end

Line 361:

Line 374:

if is_set (variant) then

variant = variant:lower(); -- ensure that we use and return lower case version of this

if not ~~lang_name_table.variant~~[variant] then -- make sure variant is valid

if not variant_table[variant] then -- make sure variant is valid

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

end -- does this duplicate/replace tests in lang() and lang_xx()?

if is_set (script) then -- if script set it must be part of the 'prefix'

if not in_array (table.concat ({code, '-', script}), ~~lang_name_table.variant~~[variant]['prefixes']) then

if not in_array (table.concat ({code, '-', script}), variant_table[variant]['prefixes']) then

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

end

elseif is_set (region) then -- if region set, there are some prefixes that require lang code and region (en-CA-newfound)

if not in_array (code, ~~lang_name_table.variant~~[variant]['prefixes']) then -- first see if lang code is all that's required (en-oxendict though en-GB-oxendict is preferred)

if not in_array (code, variant_table[variant]['prefixes']) then -- first see if lang code is all that's required (en-oxendict though en-GB-oxendict is preferred)

if not in_array (table.concat ({code, '-', region}), ~~lang_name_table.variant~~[variant]['prefixes']) then -- now try for lang code and region (en-CA-newfound)

if not in_array (table.concat ({code, '-', region}), variant_table[variant]['prefixes']) then -- now try for lang code and region (en-CA-newfound)

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

end

else -- cheap way to determine if there are prefixes; fonipa and others don't have prefixes; # operator always returns 0

else

if not in_array (code, ~~lang_name_table.variant~~[variant]['prefixes']) then

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

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

end

if is_set (private) then

private = private:lower(); -- ensure that we use and return lower case version of this

if not ~~lang_data.override~~[table.concat ({code, '-x-', private})] then -- make sure private tag is valid; note that index

if not override_table[table.concat ({code, '-x-', private})] then -- make sure private tag is valid; note that index

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

end

Line 401:

Line 414:

local category;

if '~~transl~~' == template then

if 'Transl' == template then

category = '~~transl~~';

category = 'Transl';

else

category = '~~lang~~ and lang-xx'

category = 'Lang and lang-xx'

end

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

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

table.insert (out, table.concat ({'<span style=\"color:#d33\">Error: {{', template, '}}: '}));

table.insert (out, msg);

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

table.insert (out, '</span>');

if (0 == namespace) and not args.nocat then -- ~~only~~ categorize in article space

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

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

end

Line 432:

Line 445:

if is_set (link) then

if is_set (display) then

return table.concat ({'[[~~wikipedia:~~', link, '|', display, ']]'});

return table.concat ({'[[', link, '|', display, ']]'});

else

return table.concat ({'[[~~wikipedia', link, '|~~', link, ']]'});

return table.concat ({'[[', link, ']]'});

end

else

Line 453:

Line 466:

if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text

if 'italic' == style then

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

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

else

return text;

Line 471:

Line 484:

return text;

end

--[[--------------------------< T I T L E _ W R A P P E R _ M A K E >------------------------------------------

makes a <span title="<title text>"><content_text></span> or <div title="<title text>"><content_text></div> where

<title text> is in the tool-tip in the wiki's local language and <content_text> is non-local-language text in

html markup. This because the lang= attibute applies to the content of its enclosing tag.

<tag> holds a string 'div' or 'span' used to choose the correct wrapping tag

]]

local function title_wrapper_make (title_text, content_text, tag)

local wrapper_t = {};

table.insert (wrapper_t, table.concat ({'<', tag})); -- open opening wrapper tag

table.insert (wrapper_t, ' title=\"'); -- begin title attribute

table.insert (wrapper_t, title_text); -- add <title_text>

table.insert (wrapper_t, '\">'); -- end title attribute and close opening wrapper tag

table.insert (wrapper_t, content_text); -- add <content_text>

table.insert (wrapper_t, table.concat ({'</', tag, '>'})); -- add closing wrapper tag

return table.concat (wrapper_t); -- make a big string and done

end

Line 478:

Line 514:

Add the html markup to text according to the type of content that it is: <span> or <i> tags for inline content or

<div> tags for block content

The lang= attribute also applies to the content of the tag where it is placed so this is wrong because 'Spanish

language text' is English:

should be:

or for <div>...</div>:

]]

local function make_text_html (code, text, tag, rtl, style, size, language)

local ~~html~~ = {};

local html_t = {};

local style_added = '';

local wrapper_tag = tag; -- <tag> gets modified so save a copy for use when/if we create a wrapper span or div

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

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

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

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

end

Line 498:

Line 543:

end

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

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

code = code:gsub ('%-x%-.*', ''); -- strip private use subtag from code tag because meaningless outside of wikipedia

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

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

if rtl or unicode.is_rtl(text) then

if (rtl or unicode.is_rtl(text)) and ('ltr' == this_wiki_lang_dir) then -- text is right-to-left on a left-to-right wiki

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

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

elseif not (rtl or unicode.is_rtl(text)) and ('rtl' == this_wiki_lang_dir) then -- text is left-to-right on a right-to-left wiki

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

end

if 'normal' == style then -- when |italic=no

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

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

style_added = '\"'; -- remember that style attribute added and is not yet closed

end

Line 512:

Line 560:

if is_set (size) then -- when |size=<something>

if is_set (style_added) then

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

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

else

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

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

style_added = '\"'; -- remember that style attribute added and is not yet closed

end

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

if is_set (language) then

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

table.insert (html_t, text); -- insert the 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

table.insert (html_t, table.concat ({'</', tag, '>'})); -- close the 'text' <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~~

if is_set (language) then -- create a <title_text> string for the title= attribute in a wrapper span or div

local title_text;

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

if 'zxx' == code then -- special case for this tag 'no linguistic content'

title_text = table.concat ({language, ' text'}); -- not a language so don't use 'language' in title text

elseif mw.ustring.find (language, 'languages', 1, true) then

title_text = table.concat ({language, ' collective text'}); -- for collective languages

else

title_text = table.concat ({language, '-language text'}); -- for individual languages

end

return title_wrapper_make (title_text, table.concat (html_t), wrapper_tag);

else

return table.concat (html_t);

end

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

end

Line 549:

Line 597:

[[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~~]]

[[Category:Articles with text in <language> languages]]

]=]

local function make_category (code, language_name, nocat)

local function make_category (code, language_name, nocat, name_get)

local cat = {};

local retval;

if (0 ~= namespace) or nocat then -- only categorize in article space

if ((0 ~= namespace) or nocat) and not name_get then -- only categorize in article space

return ''; -- return empty string for concatenation

end

if ~~language_name:~~find ('languages') then

if mw.ustring.find (language_name, 'languages', 1, true) then

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

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

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

end

table.insert (cat, '[[Category:Articles containing ');

if ~~'en'~~ == code then

if this_wiki_lang_tag == code then

table.insert (cat, 'explicitly cited ~~English~~');

table.insert (cat, 'explicitly cited ' .. language_name); -- unique category name for the local language

elseif 'art' == code then

table.insert (cat, 'constructed')

else

table.insert (cat, language_name);

Line 581:

Line 624:

table.insert (cat, '-language text]]');

return table.concat (cat);

end

Line 605:

Line 648:

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

local title;

local ~~tout~~ = {};

local out_t = {};

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

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

local title_text = ''; -- tool tip text for title= attribute

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

std = std and std:lower(); -- lower case for table indexing

if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified

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

title_text = language_name; -- write a generic tool tip

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

if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name)

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

title_text = title_text .. '-language'; -- skip this text (individual and macro languages only)

end

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

title_text = title_text .. ' romanization'; -- finish the tool tip; use romanization when neither script nor standard supplied

elseif is_set (std) and is_set (tscript) then -- when both are specified

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

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

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

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

if script_table[tscript] then

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

title_text = title_text .. table.concat ({title_t[std][tscript:lower()], ' (', script_table[tscript], ' script) transliteration'}); -- add the appropriate text to the tool tip

else

title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?

end

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?

title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?

end

else

Line 640:

Line 677:

elseif is_set (std) then -- translit-script not set, use language code

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

if not title_t[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)

if title_t[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

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

else -- code doesn't match

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

title_text = title_text .. title_t[std]['default']; -- so use the standard's default

end

else -- here if translit-script set but translit-std not set

if ~~title_table~~['no_std'][tscript] then

if title_t['no_std'][tscript] then

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

title_text = title_text .. title_t['no_std'][tscript]; -- use translit-script if set

elseif ~~title_table~~['no_std'][code] then

elseif title_t['no_std'][code] then

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

title_text = title_text .. title_t['no_std'][code]; -- use language code

else

if is_set (tscript) then

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

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

elseif is_set (code) then

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

if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name)

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

title_text = title_text .. '-language'; -- skip this text (individual and macro languages only)

end

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

title_text = title_text .. ' transliteration'; -- finish the tool tip

else

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

title_text = title_text .. ' transliteration'; -- generic tool tip (can we ever get here?)

end

local close_tag;

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

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

table.insert (tout, translit);

code = code:match ('^(%a%a%a?)'); -- strip all subtags leaving only the language subtag

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

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

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

close_tag = '</i>'; -- tag to be used when closing

else

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

close_tag = '</span>'; -- tag to be used when closing

end

table.insert (out_t, code);

table.insert (out_t, "-Latn\">"); -- transliterations are always Latin script

else

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

close_tag = '</span>';

end

table.insert (out_t, translit); -- add the translit text

table.insert (out_t, close_tag); -- and add the appropriate </i> or </span>

if '' == title_text then -- when there is no need for a tool-tip

return table.concat (out_t); -- make a string and done

else

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

return title_wrapper_make (title_text, table.concat (out_t), 'span'); -- wrap with a tool-tip span and don

end

return table.concat (tout);

end

Line 716:

Line 772:

if 0 < #maint_msgs then -- when there are maintenance messages

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

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

for _, msg in ipairs (maint_msgs) do

table.insert (maint, table.concat ({msg, ' '})); -- add message strings

Line 825:

Line 881:

return nil; -- missing or empty

end

--[[--------------------------< L A N G U A G E _ N A M E _ G E T >--------------------------------------------

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

returns language name if found in data tables; nil else

]]

local function language_name_get (ietf, code, cat)

ietf = ietf:lower(); -- ietf:lower() because format_ietf_tag() returns mixed case

local name; -- remains nil if not found

if override_table[ietf] then -- look for whole IETF tag in override table

name = override_table[ietf];

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

name = override_table[code];

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

name = lang_table[code];

elseif lang_dep_table[code] then -- try the iana deprecated tag/name table

name = lang_dep_table[code];

end

if lang_dep_table[code] and cat then -- because deprecated code may have been overridden to en.wiki preferred name

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

return name; -- name from data tables or nil

end

Line 842:

Line 930:

local out = {};

local language_name; -- used to make category names

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

local subtags = {}; -- IETF subtags script, region, variant, and private

local code; -- the language code

local msg; -- for error messages

local tag = 'span'; -- initial value for make_text_html()

local template = args.template or '~~lang~~';

local template = args.template or 'Lang';

maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once

maint_msgs = {};

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

if args[1] and args.code then

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

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

else

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

Line 855:

Line 949:

if args[2] and args.text then

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

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

else

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

end

msg = validate_text (template, args); -- ensure that |text= is set

if is_set (msg) then -- msg is an already-formatted error message

return msg;

Line 866:

Line 960:

args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly

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

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

Line 873:

Line 965:

args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag

if msg then

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

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

end

Line 889:

Line 981:

if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls

if ('latn' == subtags.script) or -- script is latn

(~~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)

(this_wiki_lang_tag ~= 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)

args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic

else

Line 904:

Line 996:

end

args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant); -- format to recommended subtag styles~~; private omitted because private~~

args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles

language_name = language_name_get (args.code, code, true); -- get language name; try ietf tag first, then code w/o variant then code w/ variant

subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag

if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization

language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name

elseif lang_data.override[code] then

language_name = lang_data.override[code][1] -- then language names taken from the override table

elseif lang_name_table.lang[code] then

language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one

end

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

Line 957:

Line 1,040:

return _lang (args);

end

--[[--------------------------< T R A N S L A T I O N _ M A K E >----------------------------------------------

stand-alone function to create literal translation of main text

Also used by {{lang-x2}}

]]

local function translation_make (args_t)

local translation_t = {', '}; -- initialize output

if 'none' ~= args_t.label then -- if we want a label

table.insert (translation_t, '<small>'); -- open the <small> html tag

if 'no' == args_t.link then

table.insert (translation_t, '<abbr title="literal translation">lit.</abbr>'); -- unlinked form

else

table.insert (translation_t, make_wikilink ('Literal translation', 'lit.')); -- linked form

end

table.insert (translation_t, " </small>"); -- close the <small> html tag

end

table.insert (translation_t, table.concat ({''', args_t.translation, '''})); -- use html entities to avoid wiki markup confusion

return table.concat (translation_t); -- make a big string and done

end

Line 1,016:

Line 1,124:

local msg; -- for error messages

local tag = 'span'; -- initial value for make_text_html()

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

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

maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once

maint_msgs = {};

if args[1] and args.text then

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

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

else

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

Line 1,032:

Line 1,143:

if args[2] and args.translit then

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

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

else

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

Line 1,038:

Line 1,149:

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: {{{3}}} and |lit= or |translation=', args, template);

elseif args.translation and args.lit then

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

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

else

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

Line 1,046:

Line 1,157:

if args.links and args.link then

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

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

else

args.link = args.link or args.links; -- prefer args.link

Line 1,088:

Line 1,199:

args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag

if msg then

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

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

end

args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant); -- format to recommended subtag styles

args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles

language_name = language_name_get (args.code, code, true); -- get language name; try ietf tag first, then code w/o variant then code w/ variant

subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag

if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization

language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name

elseif lang_data.override[args.code:lower()] then -- look for whole IETF tag in override table

language_name = lang_data.override[args.code:lower()][1]; -- args.code:lower() because format_ietf_tag() returns mixed case

elseif lang_data.override[code] then -- not there so try basic language code

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

elseif not is_set (subtags.variant) then

if lang_name_table.lang[code] then

language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one

end

else -- TODO: is this the right thing to do: take language display name from variants table?

if lang_name_table.variant[subtags.variant] then -- TODO: there is some discussion at Template talk:Lang about having a label parameter for use when variant name is not desired among other things

language_name = lang_name_table.variant[subtags.variant]['descriptions'][1]; -- table entries sometimes have multiple names, always take the first one

end

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

Line 1,122:

Line 1,216:

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

else

if ~~language_name:~~find ('languages') then

if mw.ustring.find (language_name, 'languages', 1, true) then

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

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 (lang_data.article_name[code], language_name)); -- language name with wikilink from override data

else

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

Line 1,139:

Line 1,233:

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

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

table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, ('none' == args.label) and language_name or 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)

Line 1,145:

Line 1,239:

if 'none' ~= args.label then

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

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

if script_table[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~~]];

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

else

translit_script_name = language_name; -- fall back on language name

Line 1,168:

Line 1,262:

if is_set (args.translation) then -- translation (not supported in {{lang}})

table.insert (out, ', ');

table.insert (out, translation_make (args));

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, " </small>");

end

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

end

Line 1,280:

Line 1,364:

local function _is_ietf_tag (tag) -- entry point when this module is require()d into another

local c, s, r, v, p, err; -- code, script, region, private, error message

local c, s, r, v, p, err; -- code, script, region, variant, private, error message

c, s, r, v, p, err = get_ietf_parts (tag); -- disassemble tag into constituent part and validate

Line 1,294:

Line 1,378:

local function is_ietf_tag (frame)

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 _is_ietf_tag (getArgs (frame)[1]); -- args[1] is the ietf language tag to be tested; also get parent frame

end

--[[--------------------------< I S _ I E T F _ T A G _ F R A M E >--------------------------------------------

Module entry point from an {{#invoke:}}; same as is_ietf_tag() except does not get parameters from the parent

(template) frame. This function not useful when called by {{lang|fn=is_ietf_tag_frame|<tag>}} because <tag>

is in the parent frame.

]]

local function is_ietf_tag_frame (frame)

return _is_ietf_tag (getArgs (frame, {frameOnly = true,})[1]); -- args[1] is the ietf language tag to be tested; do not get parent frame

end

--[[--------------------------< _ N A M E _ F R O M _ C O ~~D E~~ >------------------------------------------------

--[[--------------------------< _ N A M E _ F R O M _ T A G >--------------------------------------------------

Returns language name associated with IETF language tag if valid; ~~empty~~ ~~string~~ else.

Returns language name associated with IETF language tag if valid; error message else.

All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.

Line 1,314:

Line 1,411:

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 code; -- the language code

local msg; -- gets an error message if IETF language tag is malformed or invalid

Line 1,321:

Line 1,419:

if msg then

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 table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});

end

raw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private

if lang_data.override[raw_code:lower()] then -- look for whole IETF tag in override table (force lower case)

language_name = language_name_get (raw_code, code); -- get language name; try ietf tag first, then code w/o variant then code w/ variant

language_name = lang_data.override[raw_code:lower()][1];

elseif lang_data.override[code] then -- not there so try basic language code in override table

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

elseif not is_set (subtags.variant) then

if lang_name_table.lang[code] then

language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one

end

else -- TODO: is this the right thing to do: take language display name from variants table?

if lang_name_table.variant[subtags.variant] then -- TODO: there is some discussion at Template talk:Lang about having a label parameter for use when variant name is not desired among other things

language_name = lang_name_table.variant[subtags.variant]['descriptions'][1]; -- table entries sometimes have multiple names, always take the first one

end

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

if link then -- when |link=yes, wikilink the language name

if ~~language_name:~~find ('languages') then

if mw.ustring.find (language_name, 'languages', 1, true) then

language_name = make_wikilink (language_name); -- collective language name uses simple wikilink

language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink

elseif lang_data.article_name[code] then

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

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

else

language_name = make_wikilink (language_name .. ' language', language_name); -- language name with wikilink

language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink

end

return language_name;

end

Line 1,380:

Line 1,466:

if args[1] and '' ~= args[1] then

local data = mw.loadData ('Module:Lang/~~name~~ to ~~tag~~'); -- get the reversed data tables

local data = mw.loadData ('Module:Lang/tag from name'); -- get the reversed data tables TODO: change when going live

local lang = args[1]:lower(); -- allow any-case for the language name (speeling must till be correct)

local tag = data.~~rev_lang_data~~[lang] or data.~~rev_lang_name_table~~[lang]; -- get the code; look first in the override then in the standard

local tag = data.rev_override_table[lang] or data.rev_lang_table[lang] or data.rev_lang_dep_table[lang]; -- get the code; look first in the override then in the standard

if tag then

Line 1,397:

Line 1,483:

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

end

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

return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});

end

Line 1,434:

Line 1,520:

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 translit; -- transliterated text to display

local script; -- IANA script

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

maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once

maint_msgs = {};

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

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

Line 1,443:

Line 1,532:

if not title_table[args.translit_std] then

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

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

end

else

Line 1,449:

Line 1,538:

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

else

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?

if args[1] and (args[1]:match ('^%a%a%a?%a?$') or -- args[2] missing; is args[1] a language or script tag or is it the transliterated text?

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

args[1]:match ('^%a%a%a?%-x%-')) then -- or is args[1] a private-use tag

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

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

end

Line 1,459:

Line 1,549:

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

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

if args[1]:match ('^%a%a%a?%a?$') or args[1]:match ('^%a%a%a?%-x%-') 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

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

else

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

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

end

else

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

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

end

args.italic, msg = validate_italic (args);

if msg then

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

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

end

Line 1,477:

Line 1,567:

end

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

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

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

language_name = override_table[args.code];

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

args.code = args.code:match ('^%a%a%a?'); -- if private use, strip all but language subtag

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

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

language_name = lang_table[args.code];

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

elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables?

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

language_name = lang_dep_table[args.code];

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

language_name = script_table[args.code];

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

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

Line 1,501:

Line 1,594:

local function transl (frame)

return _transl (getArgs(frame));

end

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

Returns category name associated with IETF language tag if valid; error message else

All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.

Module entry point from another module

]]

local function _category_from_tag (args_t)

local subtags = {}; -- IETF subtags script, region, variant, and private

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

local link = 'yes' == args_t.link; -- make a boolean

local label = args_t.label;

local code; -- the language code

local msg; -- gets an error message if IETF language tag is malformed or invalid

local category_name = '';

code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code);

if msg then

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

return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});

end

raw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private

category_name = language_name_get (raw_code, code); -- get language name; try ietf tag first, then code w/o variant then code w/ variant

category_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', '');

if link then

return table.concat ({'[[:', category_name, ']]'});

else

return category_name;

end

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

Module entry point from an {{#invoke:}}

]]

local function category_from_tag (frame) -- entry point from an {{#invoke:Lang|category_from_tag|<ietf tag>|template=<template name>}}

return _category_from_tag (getArgs (frame)); -- pass-on the args table, nothing else; getArgs() so we also get parent frame

end

Line 1,508:

Line 1,649:

return {

category_from_tag = category_from_tag,

lang = lang, -- entry point for {{lang}}

lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}}

lang_xx_italic = lang_xx_italic,

is_ietf_tag = is_ietf_tag,

is_ietf_tag_frame = is_ietf_tag_frame,

is_lang_name = is_lang_name,

tag_from_name = tag_from_name, -- returns ietf tag associated with language name

name_from_tag = name_from_tag, -- used for template documentation; possible use in ISO 639 name from code templates

transl = transl, -- entry point for {{transl}}

~~_lang~~ = ~~_lang~~, -- entry points when this module is require()d into other modules

_category_from_tag = _category_from_tag, -- entry points when this module is require()d into other modules

_lang = _lang,

_lang_xx_inherit = _lang_xx_inherit,

_lang_xx_italic = _lang_xx_italic,

_is_ietf_tag = _is_ietf_tag,

get_ietf_parts = get_ietf_parts,

_tag_from_name = _tag_from_name,

_name_from_tag = _name_from_tag,

_transl = _transl,

_translation_make = translation_make,

};