Module:Lang: Difference between revisions
Content added Content deleted
m (1 revision imported from wikipedia:Module:Lang: ADDING TEMPLATES. AGAIN) |
No edit summary |
||
Line 6: | Line 6: | ||
require('Module:No globals'); |
require('Module:No globals'); |
||
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic() |
|||
local getArgs = require ('Module:Arguments').getArgs; |
local getArgs = require ('Module:Arguments').getArgs; |
||
Line 13: | Line 11: | ||
local yesno = require ('Module:Yesno'); |
local yesno = require ('Module:Yesno'); |
||
local |
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 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 namespace = mw.title.getCurrentTitle().namespace; -- used for categorization |
||
local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language |
local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language |
||
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic() |
|||
local maint_cats = {}; -- maintenance categories go here |
local maint_cats = {}; -- maintenance categories go here |
||
Line 121: | Line 127: | ||
if count > 1 then -- return nil and an error message if more than one is set |
if count > 1 then -- return nil and an error message if more than one is set |
||
return nil, 'only one of |
return nil, 'only one of |italic=, |italics=, or |i= can be specified'; |
||
end |
end |
||
Line 186: | Line 192: | ||
region: upper case |
region: upper case |
||
variant: lower 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 = {}; |
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()); |
table.insert (out, code:lower()); |
||
if is_set (script) then |
if is_set (script) then |
||
Line 216: | Line 227: | ||
script subtag - four character IANA script code |
script subtag - four character IANA script code |
||
region subtag - two-letter or three digit IANA region 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 |
private subtag - x- followed by 1-8 alnum private code; only supported with the primary language tag |
||
Line 306: | Line 317: | ||
code = code:lower(); -- ensure that we use and return lower case version of this |
code = code:lower(); -- ensure that we use and return lower case version of this |
||
if not ( |
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?) |
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 |
end |
||
Line 326: | Line 337: | ||
if is_set (script) then |
if is_set (script) then |
||
script = script:lower(); -- ensure that we use and return lower case version of this |
script = script:lower(); -- ensure that we use and return lower case version of this |
||
if not |
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?) |
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 |
end |
||
end |
end |
||
if |
if suppressed_table[script] then -- ensure that code-script does not use a suppressed script |
||
if in_array (code, |
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 |
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 |
end |
||
Line 346: | Line 357: | ||
if is_set (region) then |
if is_set (region) then |
||
region = region:lower(); -- ensure that we use and return lower case version of this |
region = region:lower(); -- ensure that we use and return lower case version of this |
||
if not |
if not region_table[region] then |
||
return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code}); |
return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code}); |
||
end |
end |
||
Line 361: | Line 372: | ||
if is_set (variant) then |
if is_set (variant) then |
||
variant = variant:lower(); -- ensure that we use and return lower case version of this |
variant = variant:lower(); -- ensure that we use and return lower case version of this |
||
if not |
if not variant_table[variant] then -- make sure variant is valid |
||
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant}); |
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant}); |
||
end -- does this duplicate/replace tests in lang() and lang_xx()? |
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 is_set (script) then -- if script set it must be part of the 'prefix' |
||
if not in_array (table.concat ({code, '-', script}), |
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}); |
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', code, '-', script}); |
||
end |
end |
||
elseif is_set (region) then -- if region set, there are some prefixes that require lang code and region (en-CA-newfound) |
|||
else |
|||
if not in_array (code, |
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}), 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 |
|||
end |
|||
else -- cheap way to determine if there are prefixes; fonipa and others don't have prefixes; # operator always returns 0 |
|||
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}); |
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code: ', code}); |
||
end |
end |
||
end |
end |
||
end |
end |
||
if is_set (private) then |
if is_set (private) then |
||
private = private:lower(); -- ensure that we use and return lower case version of this |
private = private:lower(); -- ensure that we use and return lower case version of this |
||
if not |
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}); |
return code, script, region, nil, nil, table.concat ({'unrecognized private tag: ', private}); |
||
end |
end |
||
Line 395: | Line 412: | ||
local category; |
local category; |
||
if ' |
if 'Transl' == template then |
||
category = ' |
category = 'Transl'; |
||
else |
else |
||
category = ' |
category = 'Lang and lang-xx' |
||
end |
end |
||
table.insert (out, table.concat ({' |
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\"> |
table.insert (out, table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: {{', template, '}}: '})); |
||
table.insert (out, msg); |
table.insert (out, msg); |
||
table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'})); |
table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'})); |
||
table.insert (out, '</span>'); |
table.insert (out, '</span>'); |
||
if (0 == namespace) and not args.nocat then -- |
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]]'})); |
table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'})); |
||
end |
end |
||
Line 493: | Line 510: | ||
table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag |
table.insert (html, 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, table.concat ({' lang="', code, '\"'})); -- add language attribute |
||
Line 500: | Line 518: | ||
if 'normal' == style then -- when |italic=no |
if 'normal' == style then -- when |italic=no |
||
table.insert (html, ' style=\"font-style:normal;'); -- override external markup, if any |
table.insert (html, ' style=\"font-style: normal;'); -- override external markup, if any |
||
style_added = '\"'; -- remember that style attribute added and is not yet closed |
style_added = '\"'; -- remember that style attribute added and is not yet closed |
||
end |
end |
||
Line 506: | Line 524: | ||
if is_set (size) then -- when |size=<something> |
if is_set (size) then -- when |size=<something> |
||
if is_set (style_added) then |
if is_set (style_added) then |
||
table.insert (html, table.concat ({' font-size:', size, ';'})); -- add when style attribute already inserted |
table.insert (html, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted |
||
else |
else |
||
table.insert (html, table.concat ({' style=\"font-size:', size, ';'})); -- create style attribute |
table.insert (html, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute |
||
style_added = '\"'; -- remember that style attribute added and is not yet closed |
style_added = '\"'; -- remember that style attribute added and is not yet closed |
||
end |
end |
||
Line 516: | Line 534: | ||
table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text |
table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text |
||
if language:find ('languages') then |
if language:find ('languages') then |
||
table.insert (html, ' collective text |
table.insert (html, ' collective text'); -- for collective languages |
||
else |
else |
||
table.insert (html, ' |
table.insert (html, '-language text'); -- for individual languages |
||
end |
end |
||
table.insert (html, '>'); -- close the opening html tag |
table.insert (html, '\">'); -- close the opening html tag |
||
else |
else |
||
table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag |
table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag |
||
Line 531: | Line 549: | ||
table.insert (html, '‎'); -- make sure the browser knows that we're at the end of the rtl |
table.insert (html, '‎'); -- make sure the browser knows that we're at the end of the rtl |
||
end |
end |
||
return table.concat (html); -- put it all together and done |
return table.concat (html); -- put it all together and done |
||
end |
end |
||
Line 544: | Line 561: | ||
[[Category:Articles containing explicitly cited English-language text]] |
[[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): |
for ISO 639-2 collective languages (and for 639-1 bh): |
||
[[Category:Articles with text |
[[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 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 |
return ''; -- return empty string for concatenation |
||
end |
end |
||
if language_name:find ('languages') then |
if language_name:find ('languages') then |
||
return table.concat ({'[[Category:Articles with text |
return table.concat ({'[[Category:Articles with text in ', language_name, ']]'}); |
||
end |
end |
||
table.insert (cat, '[[Category:Articles containing '); |
table.insert (cat, '[[Category:Articles containing '); |
||
if 'en' == code then |
if 'en' == code then |
||
table.insert (cat, 'explicitly cited |
table.insert (cat, 'explicitly cited ' .. language_name); -- falls back to English if regional name not available |
||
elseif 'art' == code then |
|||
table.insert (cat, 'constructed') |
|||
else |
else |
||
table.insert (cat, language_name); |
table.insert (cat, language_name); |
||
Line 575: | Line 588: | ||
table.insert (cat, '-language text]]'); |
table.insert (cat, '-language text]]'); |
||
return table.concat (cat); |
return table.concat (cat); |
||
end |
end |
||
Line 606: | Line 619: | ||
table.insert (tout, "<i lang=\""); -- so use <i> tag |
table.insert (tout, "<i lang=\""); -- so use <i> tag |
||
else |
else |
||
table.insert (tout, table.concat ({'<span style=\"font-style:', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it |
table.insert (tout, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it |
||
end |
end |
||
table.insert (tout, code); |
table.insert (tout, code); |
||
Line 625: | Line 638: | ||
if title_table[std] then -- and if standard is legitimate |
if title_table[std] then -- and if standard is legitimate |
||
if title_table[std][tscript] then -- and if script for that 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()], ' (', |
table.insert (tout, table.concat ({title_table[std][tscript:lower()], ' (', script_table[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip |
||
else |
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? |
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? |
||
Line 637: | Line 650: | ||
if title_table[std][code] then -- if language code is in the table (transl may not provide a language code) |
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()], ' (', |
-- 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 |
|||
else -- code doesn't match |
else -- code doesn't match |
||
table.insert (tout, title_table[std]['default']); -- so use the standard's default |
table.insert (tout, title_table[std]['default']); -- so use the standard's default |
||
Line 710: | Line 724: | ||
if 0 < #maint_msgs then -- when there are maintenance messages |
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 |
for _, msg in ipairs (maint_msgs) do |
||
table.insert (maint, table.concat ({msg, ' '})); -- add message strings |
table.insert (maint, table.concat ({msg, ' '})); -- add message strings |
||
Line 822: | Line 836: | ||
--[[--------------------------< L A N G > |
--[[--------------------------< 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][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 |
|||
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 |
|||
--[[--------------------------< _ L A N G >-------------------------------------------------------------------- |
|||
entry point for {{lang}} |
entry point for {{lang}} |
||
Line 836: | Line 886: | ||
local out = {}; |
local out = {}; |
||
local language_name; -- used to make category names |
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 subtags = {}; -- IETF subtags script, region, variant, and private |
||
local code; -- the language code |
local code; -- the language code |
||
local msg; -- for error messages |
local msg; -- for error messages |
||
local tag = 'span'; -- initial value for make_text_html() |
local tag = 'span'; -- initial value for make_text_html() |
||
local template = args.template or ' |
local template = args.template or 'Lang'; |
||
validate_cat_args (args); -- determine if categorization should be suppressed |
|||
if args[1] and args.code then |
if args[1] and args.code then |
||
return make_error_msg ('conflicting: {{{1}}} and |
return make_error_msg ('conflicting: {{{1}}} and |code=', args, template); |
||
else |
else |
||
args.code = args[1] or args.code; -- prefer args.code |
args.code = args[1] or args.code; -- prefer args.code |
||
Line 849: | Line 902: | ||
if args[2] and args.text then |
if args[2] and args.text then |
||
return make_error_msg ('conflicting: {{{2}}} and |
return make_error_msg ('conflicting: {{{2}}} and |text=', args, template); |
||
else |
else |
||
args.text = args[2] or args.text; -- prefer args.text |
args.text = args[2] or args.text; -- prefer args.text |
||
end |
end |
||
msg = validate_text (template, args); |
msg = validate_text (template, args); -- ensure that |text= is set |
||
if is_set (msg) then -- msg is an already-formatted error message |
if is_set (msg) then -- msg is an already-formatted error message |
||
return msg; |
return msg; |
||
Line 860: | Line 913: | ||
args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly |
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 |
args.rtl = args.rtl == 'yes'; -- convert to boolean: 'yes' -> true, other values -> false |
||
Line 867: | Line 918: | ||
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag |
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag |
||
if msg then |
if msg then |
||
return make_error_msg (table.concat ({'invalid |
return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template); |
||
end |
end |
||
Line 898: | Line 949: | ||
end |
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[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 |
if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content |
||
Line 1,010: | Line 1,052: | ||
local msg; -- for error messages |
local msg; -- for error messages |
||
local tag = 'span'; -- initial value for make_text_html() |
local tag = 'span'; -- initial value for make_text_html() |
||
local template = args.template or ' |
local template = args.template or 'Lang-xx'; |
||
if args[1] and args.text then |
if args[1] and args.text then |
||
return make_error_msg ('conflicting: {{{1}}} and |
return make_error_msg ('conflicting: {{{1}}} and |text=', args, template); |
||
else |
else |
||
args.text = args[1] or args.text; -- prefer args.text |
args.text = args[1] or args.text; -- prefer args.text |
||
Line 1,026: | Line 1,068: | ||
if args[2] and args.translit then |
if args[2] and args.translit then |
||
return make_error_msg ('conflicting: {{{2}}} and |
return make_error_msg ('conflicting: {{{2}}} and |translit=', args, template); |
||
else |
else |
||
args.translit = args[2] or args.translit -- prefer args.translit |
args.translit = args[2] or args.translit -- prefer args.translit |
||
Line 1,032: | Line 1,074: | ||
if args[3] and (args.translation or args.lit) then |
if args[3] and (args.translation or args.lit) then |
||
return make_error_msg ('conflicting: {{{3}}} and |
return make_error_msg ('conflicting: {{{3}}} and |lit= or |translation=', args, template); |
||
elseif args.translation and args.lit then |
elseif args.translation and args.lit then |
||
return make_error_msg ('conflicting: |
return make_error_msg ('conflicting: |lit= and |translation=', args, template); |
||
else |
else |
||
args.translation = args[3] or args.translation or args.lit; -- prefer args.translation |
args.translation = args[3] or args.translation or args.lit; -- prefer args.translation |
||
Line 1,040: | Line 1,082: | ||
if args.links and args.link then |
if args.links and args.link then |
||
return make_error_msg ('conflicting: |
return make_error_msg ('conflicting: |links= and |link=', args, template); |
||
else |
else |
||
args.link = args.link or args.links; -- prefer args.link |
args.link = args.link or args.links; -- prefer args.link |
||
Line 1,082: | Line 1,124: | ||
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag |
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag |
||
if msg then |
if msg then |
||
return make_error_msg (table.concat ({'invalid |
return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template); |
||
end |
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 |
|||
end |
|||
category_name = language_name; -- category names retain IANA parenthetical diambiguators (if any) |
category_name = language_name; -- category names retain IANA parenthetical diambiguators (if any) |
||
Line 1,133: | Line 1,158: | ||
args.text = proto_prefix (args.text, language_name, args.proto); -- prefix proto-language text with a splat |
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) |
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,139: | Line 1,164: | ||
if 'none' ~= args.label then |
if 'none' ~= args.label then |
||
table.insert (out, '<small>'); |
table.insert (out, '<small>'); |
||
if |
if script_table[args['translit-script']] then -- when |translit-script= is set, try to use the script's name |
||
translit_script_name = |
translit_script_name = script_table[args['translit-script'][1]]; |
||
else |
else |
||
translit_script_name = language_name; -- fall back on language name |
translit_script_name = language_name; -- fall back on language name |
||
Line 1,170: | Line 1,195: | ||
table.insert (out, make_wikilink ('Literal translation', 'lit.')); |
table.insert (out, make_wikilink ('Literal translation', 'lit.')); |
||
end |
end |
||
table.insert (out, "& |
table.insert (out, " </small>"); |
||
end |
end |
||
table.insert (out, table.concat ({''', args.translation, '''})); -- use html entities to avoid wiki markup confusion |
table.insert (out, table.concat ({''', args.translation, '''})); -- use html entities to avoid wiki markup confusion |
||
Line 1,268: | Line 1,293: | ||
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function. |
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function. |
||
The purpose of this function is to replace {{#ifexist:Template:ISO 639 name xx|<exists>|<does not exist>}} in |
|||
templates that are better served by using {{#invoke:lang|name_from_tag|<code>}} |
|||
Module entry point from another module |
Module entry point from another module |
||
Line 1,277: | Line 1,299: | ||
local function _is_ietf_tag (tag) -- entry point when this module is require()d into another |
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 |
c, s, r, v, p, err = get_ietf_parts (tag); -- disassemble tag into constituent part and validate |
||
return ((c and not err) and true) or nil; -- return true when code portion has a value without error message; nil else |
return ((c and not err) and true) or nil; -- return true when code portion has a value without error message; nil else |
||
end |
end |
||
Line 1,290: | Line 1,312: | ||
]] |
]] |
||
local function is_ietf_tag (frame) |
local function is_ietf_tag (frame) |
||
return _is_ietf_tag (frame |
return _is_ietf_tag (getArgs (frame)[1]); -- args[1] is the ietf language tag to be tested; also get parent frame |
||
end |
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 |
|||
Returns language name associated with IETF language tag if valid; empty string else. |
|||
(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 _ T A G >-------------------------------------------------- |
|||
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. |
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function. |
||
Line 1,311: | Line 1,346: | ||
local raw_code = args[1]; -- save a copy of the input IETF subtag |
local raw_code = args[1]; -- save a copy of the input IETF subtag |
||
local link = 'yes' == args['link']; -- make a boolean |
local link = 'yes' == args['link']; -- make a boolean |
||
local label = args.label; |
|||
local code; -- the language code |
local code; -- the language code |
||
local msg; -- gets an error message if IETF language tag is malformed or invalid |
local msg; -- gets an error message if IETF language tag is malformed or invalid |
||
Line 1,318: | Line 1,354: | ||
if msg then |
if msg then |
||
local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template) |
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\"> |
return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: ', template, msg, '</span>'}); |
||
end |
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 |
|||
end |
|||
language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them |
language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them |
||
Line 1,339: | Line 1,364: | ||
if link then -- when |link=yes, wikilink the language name |
if link then -- when |link=yes, wikilink the language name |
||
if language_name:find ('languages') then |
if language_name:find ('languages') then |
||
language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink |
|||
elseif lang_data.article_name[code] then |
elseif lang_data.article_name[code] then |
||
language_name = make_wikilink (lang_data.article_name[code][1], label or language_name); -- language name with wikilink from override data |
|||
else |
else |
||
language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink |
|||
end |
end |
||
end |
end |
||
return language_name; |
return language_name; |
||
end |
end |
||
--[[--------------------------< N A M E _ F R O M _ |
--[[--------------------------< N A M E _ F R O M _ T A G >---------------------------------------------------- |
||
Module entry point from an {{#invoke:}} |
Module entry point from an {{#invoke:}} |
||
Line 1,359: | Line 1,383: | ||
local function name_from_tag (frame) -- entry point from an {{#invoke:Lang|name_from_tag|<ietf tag>|link=<yes>|template=<template name>}} |
local function name_from_tag (frame) -- entry point from an {{#invoke:Lang|name_from_tag|<ietf tag>|link=<yes>|template=<template name>}} |
||
return _name_from_tag (frame |
return _name_from_tag (getArgs(frame)) -- pass-on the args table, nothing else; getArgs() so we also get parent frame |
||
end |
end |
||
Line 1,377: | Line 1,401: | ||
if args[1] and '' ~= args[1] then |
if args[1] and '' ~= args[1] then |
||
local data = mw.loadData ('Module:Lang/ |
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 lang = args[1]:lower(); -- allow any-case for the language name (speeling must till be correct) |
||
local tag = data. |
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 |
if tag then |
||
return tag; |
return tag, true; -- language name found so return tag and done; second return used by is_lang_name() |
||
else |
else |
||
msg = 'language: ' .. args[1] .. ' not found' -- language name not found, error message |
msg = 'language: ' .. args[1] .. ' not found' -- language name not found, error message |
||
Line 1,394: | Line 1,418: | ||
template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template) |
template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template) |
||
end |
end |
||
return table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\"> |
return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: ', template, msg, '</span>'}); |
||
end |
end |
||
Line 1,405: | Line 1,429: | ||
local function tag_from_name (frame) -- entry point from an {{#invoke:Lang|tag_from_name|<language name>|link=<yes>|template=<template name>}} |
local function tag_from_name (frame) -- entry point from an {{#invoke:Lang|tag_from_name|<language name>|link=<yes>|template=<template name>}} |
||
local result, _ = _tag_from_name (getArgs(frame)) -- pass-on the args table, nothing else; getArgs() so we also get parent frame; supress second return used by is_lang_name() |
|||
return result; |
|||
end |
|||
--[[--------------------------< I S _ L A N G _ N A M E >------------------------------------------------------ |
|||
Module entry point from an {{#invoke:}} |
|||
]] |
|||
local function is_lang_name (frame) |
|||
local _, result = _tag_from_name (getArgs(frame)) -- pass-on the args table, nothing else; getArgs() so we also get parent frame; supress second return used by tag_from_name() |
|||
return result and true or nil; |
|||
end |
end |
||
Line 1,418: | Line 1,455: | ||
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_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 language_name; -- language name that matches language code; used for tool tip |
||
local translit; -- |
local translit; -- transliterated text to display |
||
local script; -- IANA script |
local script; -- IANA script |
||
local msg; -- for when called functions return an error message |
local msg; -- for when called functions return an error message |
||
Line 1,427: | Line 1,464: | ||
if not title_table[args.translit_std] then |
if not title_table[args.translit_std] then |
||
return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, ' |
return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'Transl'); |
||
end |
end |
||
else |
else |
||
Line 1,434: | Line 1,471: | ||
else |
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?$') then -- args[2] missing; is args[1] a code or its it the transliterated text? |
||
return make_error_msg ('no text', args, ' |
return make_error_msg ('no text', args, 'Transl'); -- args[1] is a code so we're missing text |
||
else |
else |
||
args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message |
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, ' |
return make_error_msg ('missing language / script code', args, 'Transl'); |
||
end |
end |
||
end |
end |
||
Line 1,446: | Line 1,483: | ||
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); lower case because table indexes are lower case |
||
else |
else |
||
return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, ' |
return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'Transl'); -- invalid language / script code |
||
end |
end |
||
else |
else |
||
return make_error_msg ('missing language / script code', args, ' |
return make_error_msg ('missing language / script code', args, 'Transl'); -- missing language / script code so quit |
||
end |
end |
||
args.italic, msg = validate_italic (args); |
args.italic, msg = validate_italic (args); |
||
if msg then |
if msg then |
||
return make_error_msg (msg, args, ' |
return make_error_msg (msg, args, 'Transl'); |
||
end |
end |
||
Line 1,461: | Line 1,498: | ||
end |
end |
||
if |
if override_table[args.code] then -- is code a language code defined in the override table? |
||
language_name = |
language_name = override_table[args.code][1]; |
||
elseif |
elseif lang_table[args.code] then -- is code a language code defined in the standard language code tables? |
||
language_name = |
language_name = lang_table[args.code][1]; |
||
elseif |
elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables? |
||
language_name = |
language_name = lang_dep_table[args.code][1]; |
||
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][1]; |
|||
script = args.code; -- code was an ISO 15924 script so use that instead |
script = args.code; -- code was an ISO 15924 script so use that instead |
||
args.code = ''; -- unset because not a language code |
args.code = ''; -- unset because not a language code |
||
else |
else |
||
return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, ' |
return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'Transl'); -- invalid language / script code |
||
end |
end |
||
-- here only when all parameters passed to make_translit() are valid |
-- here only when all parameters passed to make_translit() are valid |
||
Line 1,484: | Line 1,523: | ||
local function transl (frame) |
local function transl (frame) |
||
return _transl (getArgs(frame)); |
|||
end |
|||
return _transl (args); |
|||
--[[--------------------------< 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) |
|||
local subtags = {}; -- IETF subtags script, region, variant, and private |
|||
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 |
|||
local category_name = ''; |
|||
code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code); |
|||
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>'}); |
|||
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 ('[%[%]]', ''); |
|||
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 |
end |
||
Line 1,493: | Line 1,575: | ||
return { |
return { |
||
category_from_tag = category_from_tag, |
|||
lang = lang, -- entry point for {{lang}} |
lang = lang, -- entry point for {{lang}} |
||
lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}} |
lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}} |
||
lang_xx_italic = lang_xx_italic, |
lang_xx_italic = lang_xx_italic, |
||
is_ietf_tag = is_ietf_tag, |
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 |
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 |
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}} |
transl = transl, -- entry point for {{transl}} |
||
_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_inherit = _lang_xx_inherit, |
||
_lang_xx_italic = _lang_xx_italic, |
_lang_xx_italic = _lang_xx_italic, |
||
_is_ietf_tag = _is_ietf_tag, |
_is_ietf_tag = _is_ietf_tag, |
||
get_ietf_parts = get_ietf_parts, |
|||
_tag_from_name = _tag_from_name, |
_tag_from_name = _tag_from_name, |
||
_name_from_tag = _name_from_tag, |
_name_from_tag = _name_from_tag, |