Importer, Bürokraten, Moderatoren (CommentStreams), Strukturierte-Diskussionen-Bots, Oberflächenadministratoren, Push-Abonnementverwalter, Oversighter, Administratoren, Kampagnenbearbeiter (Hochladeassistent)
855
Bearbeitungen
Modul:Lang: Unterschied zwischen den Versionen
K
3 Versionen von skanwiki:Modul:Lang importiert
Keine Bearbeitungszusammenfassung |
K (3 Versionen von skanwiki:Modul:Lang importiert) |
||
| Zeile 5: | Zeile 5: | ||
]=] | ]=] | ||
require(' | 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; | ||
| Zeile 11: | Zeile 13: | ||
local yesno = require ('Module:Yesno'); | local yesno = require ('Module:Yesno'); | ||
local | local lang_name_table = mw.loadData ('Module:Language/name/data'); | ||
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 | local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language | ||
local maint_cats = {}; -- maintenance categories go here | local maint_cats = {}; -- maintenance categories go here | ||
| Zeile 129: | Zeile 121: | ||
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 | ||
| Zeile 194: | Zeile 186: | ||
region: upper case | region: upper case | ||
variant: lower case | variant: lower case | ||
]] | ]] | ||
local function format_ietf_tag (code, script, region, variant | local function format_ietf_tag (code, script, region, variant) | ||
local out = {}; | local out = {}; | ||
table.insert (out, code:lower()); | table.insert (out, code:lower()); | ||
if is_set (script) then | if is_set (script) then | ||
| Zeile 229: | Zeile 216: | ||
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 | ||
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 | ||
| Zeile 319: | Zeile 306: | ||
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 (lang_data.override[code] or lang_name_table.lang[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 | ||
| Zeile 339: | Zeile 326: | ||
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 lang_name_table.script[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 lang_name_table.suppressed[script] then -- ensure that code-script does not use a suppressed script | ||
if in_array (code, | if in_array (code, lang_name_table.suppressed[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 | ||
| Zeile 359: | Zeile 346: | ||
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 lang_name_table.region[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 | ||
| Zeile 374: | Zeile 361: | ||
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 lang_name_table.variant[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}), lang_name_table.variant[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 | ||
else | |||
if not in_array (code, | if not in_array (code, lang_name_table.variant[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 lang_data.override[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 | ||
| Zeile 414: | Zeile 395: | ||
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=\" | 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 | if (0 == namespace) and not args.nocat then -- only categorize in article space | ||
table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'})); | table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'})); | ||
end | end | ||
| Zeile 466: | Zeile 447: | ||
if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text | if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text | ||
if 'italic' == style then | if 'italic' == style then | ||
return | return mw.ustring.gsub (text, '(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item | ||
else | else | ||
return text; | return text; | ||
| Zeile 484: | Zeile 465: | ||
return text; | return text; | ||
end | end | ||
| Zeile 514: | Zeile 472: | ||
Add the html markup to text according to the type of content that it is: <span> or <i> tags for inline content or | 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 | <div> tags for block content | ||
]] | ]] | ||
local function make_text_html (code, text, tag, rtl, style, size, language) | local function make_text_html (code, text, tag, rtl, style, size, language) | ||
local | local html = {}; | ||
local style_added = ''; | local style_added = ''; | ||
if text:match ('^%*') then | if text:match ('^%*') then | ||
table.insert ( | table.insert (html, '*'); -- 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 | text = text:gsub ('^%*', ''); -- remove the splat from the text | ||
end | end | ||
| Zeile 543: | Zeile 492: | ||
end | end | ||
table.insert ( | table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag | ||
table.insert (html, table.concat ({' lang="', code, '\"'})); -- add language attribute | |||
table.insert ( | |||
if | if rtl or unicode.is_rtl(text) then | ||
table.insert ( | table.insert (html, ' dir="rtl"'); -- add direction attribute for right to left languages | ||
end | end | ||
if 'normal' == style then -- when |italic=no | if 'normal' == style then -- when |italic=no | ||
table.insert ( | 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 | ||
| Zeile 560: | Zeile 506: | ||
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 ( | table.insert (html, table.concat ({' font-size:', size, ';'})); -- add when style attribute already inserted | ||
else | else | ||
table.insert ( | 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 | ||
end | end | ||
table.insert ( | if is_set (language) then | ||
table.insert ( | table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text | ||
if language:find ('languages') then | |||
table.insert (html, ' collective text\"'); -- for collective languages | |||
else | |||
table.insert (html, ' language text\"'); -- for individual languages | |||
end | |||
table.insert (html, '>'); -- close the opening html tag | |||
else | |||
table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag | |||
end | |||
table.insert (html, text); -- insert the text | |||
table.insert ( | table.insert (html, table.concat ({'</', tag, '>'})); -- close the <i>, <span>, or <div> html tag | ||
if | if rtl then -- legacy; shouldn't be necessary because all of the rtl text is wrapped inside an html tag with dir="rtl" attribute | ||
table.insert (html, '‎'); -- 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 | |||
end | end | ||
| Zeile 597: | Zeile 544: | ||
[[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 from the <language> languages collective]] | ||
]=] | ]=] | ||
local function make_category (code, language_name, nocat | local function make_category (code, language_name, nocat) | ||
local cat = {}; | local cat = {}; | ||
if (0 ~= namespace) or nocat then -- only categorize in article space | |||
if | |||
return ''; -- return empty string for concatenation | return ''; -- return empty string for concatenation | ||
end | end | ||
if | if language_name:find ('languages') then | ||
return table.concat ({'[[Category:Articles with text | return table.concat ({'[[Category:Articles with text from the ', language_name, ' collective]]'}); | ||
end | end | ||
table.insert (cat, '[[Category:Articles containing '); | table.insert (cat, '[[Category:Articles containing '); | ||
if | if 'en' == code then | ||
table.insert (cat, 'explicitly cited ' . | table.insert (cat, 'explicitly cited English'); | ||
elseif 'art' == code then | |||
table.insert (cat, 'constructed') | |||
else | else | ||
table.insert (cat, language_name); | table.insert (cat, language_name); | ||
| Zeile 624: | Zeile 575: | ||
table.insert (cat, '-language text]]'); | table.insert (cat, '-language text]]'); | ||
return table.concat (cat); | return table.concat (cat); | ||
end | end | ||
| Zeile 648: | Zeile 599: | ||
local function make_translit (code, language_name, translit, std, tscript, style) | local function make_translit (code, language_name, translit, std, tscript, style) | ||
local title; | local title; | ||
local | local tout = {}; | ||
local | local title_table = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards | ||
if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}}) | |||
if not style then -- nil for the default italic style | |||
table.insert (tout, "<i lang=\""); -- so use <i> tag | |||
else | |||
table.insert (tout, table.concat ({'<span style=\"font-style:', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it | |||
end | |||
table.insert (tout, code); | |||
table.insert (tout, "-Latn\" title=\""); -- transliterations are always Latin script | |||
else | |||
table.insert (tout, "<span title=\""); -- when no language code: no lang= attribute, not italic ({{transl}} only) | |||
end | |||
std = std and std:lower(); -- lower case for table indexing | 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 | 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 | |||
if not | if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name) | ||
table.insert (tout, '-language') -- skip this text (individual and macro languages only) | |||
end | end | ||
table.insert (tout, ' 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 | elseif is_set (std) and is_set (tscript) then -- when both are specified | ||
if | if title_table[std] then -- and if standard is legitimate | ||
if | if title_table[std][tscript] then -- and if script for that standard is legitimate | ||
table.insert (tout, table.concat ({title_table[std][tscript:lower()], ' (', lang_name_table.script[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip | |||
else | else | ||
table.insert (tout, title_table[std]['default']); -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard? | |||
end | end | ||
else | else | ||
| Zeile 677: | Zeile 634: | ||
elseif is_set (std) then -- translit-script not set, use language code | elseif is_set (std) then -- translit-script not set, use language code | ||
if not | if not title_table[std] then return ''; end -- invalid standard, setup for error message | ||
if | if title_table[std][code] then -- if language code is in the table (transl may not provide a language code) | ||
table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', lang_name_table.lang[code][1], ' language) transliteration'})); -- add the appropriate text to the tool tip | |||
else -- code doesn't match | else -- code doesn't match | ||
table.insert (tout, title_table[std]['default']); -- so use the standard's default | |||
end | end | ||
else -- here if translit-script set but translit-std not set | else -- here if translit-script set but translit-std not set | ||
if | if title_table['no_std'][tscript] then | ||
table.insert (tout, title_table['no_std'][tscript]); -- use translit-script if set | |||
elseif | elseif title_table['no_std'][code] then | ||
table.insert (tout, title_table['no_std'][code]); -- use language code | |||
else | else | ||
if is_set (tscript) then | if is_set (tscript) then | ||
table.insert (tout, table.concat ({language_name, '-script transliteration'})); -- write a script tool tip | |||
elseif is_set (code) then | elseif is_set (code) then | ||
if not | if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name) | ||
table.insert (tout, '-language') -- skip this text (individual and macro languages only) | |||
end | end | ||
table.insert (tout, ' transliteration'); -- finish the tool tip | |||
else | else | ||
table.insert (tout, ' transliteration'); -- generic tool tip (can we ever get here?) | |||
end | end | ||
end | end | ||
end | end | ||
table.insert (tout, '">'); | |||
if is_set (code) then | table.insert (tout, translit); | ||
if is_set (code) and not style then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}}) | |||
table.insert (tout, "</i>"); -- close the italic tag | |||
else | else | ||
table.insert (tout, "</span>"); -- no language code so close the span tag | |||
end | end | ||
return table.concat (tout); | |||
end | end | ||
| Zeile 770: | Zeile 710: | ||
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 | 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 | ||
| Zeile 882: | Zeile 822: | ||
--[[--------------------------< L A N G | --[[--------------------------< L A N G >---------------------------------------------------------------------- | ||
entry point for {{lang}} | entry point for {{lang}} | ||
| Zeile 928: | Zeile 836: | ||
local out = {}; | local out = {}; | ||
local language_name; -- used to make category names | local language_name; -- used to make category names | ||
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'; | ||
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 | ||
| Zeile 947: | Zeile 849: | ||
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; | ||
| Zeile 958: | Zeile 860: | ||
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 | ||
| Zeile 963: | Zeile 867: | ||
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 | ||
| Zeile 979: | Zeile 883: | ||
if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls | 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 | 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) | ||
args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic | args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic | ||
else | else | ||
| Zeile 994: | Zeile 898: | ||
end | end | ||
args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant | args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant); -- format to recommended subtag styles; private omitted because private | ||
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 | ||
| Zeile 1.038: | Zeile 951: | ||
return _lang (args); | return _lang (args); | ||
end | end | ||
| Zeile 1.122: | Zeile 1.010: | ||
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 | ||
| Zeile 1.141: | Zeile 1.026: | ||
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 | ||
| Zeile 1.147: | Zeile 1.032: | ||
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 | ||
| Zeile 1.155: | Zeile 1.040: | ||
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 | ||
| Zeile 1.197: | Zeile 1.082: | ||
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 | args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant); -- format to recommended subtag styles | ||
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) | ||
| Zeile 1.214: | Zeile 1.116: | ||
table.insert (out, language_name); -- language name without wikilink | table.insert (out, language_name); -- language name without wikilink | ||
else | else | ||
if | if language_name:find ('languages') then | ||
table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink | table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink | ||
elseif lang_data.article_name[code] then | elseif lang_data.article_name[code] then | ||
table.insert (out, make_wikilink (lang_data.article_name[code], language_name)); -- language name with wikilink from override data | table.insert (out, make_wikilink (lang_data.article_name[code][1], language_name)); -- language name with wikilink from override data | ||
else | else | ||
table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink | table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink | ||
| Zeile 1.231: | Zeile 1.133: | ||
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)) | ||
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) | ||
| Zeile 1.237: | Zeile 1.139: | ||
if 'none' ~= args.label then | if 'none' ~= args.label then | ||
table.insert (out, '<small>'); | table.insert (out, '<small>'); | ||
if | if lang_name_table.script[args['translit-script']] then -- when |translit-script= is set, try to use the script's name | ||
translit_script_name = | translit_script_name = lang_name_table.script[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 | ||
| Zeile 1.260: | Zeile 1.162: | ||
if is_set (args.translation) then -- translation (not supported in {{lang}}) | if is_set (args.translation) then -- translation (not supported in {{lang}}) | ||
table.insert (out, | table.insert (out, ', '); | ||
if 'none' ~= args.label then | |||
table.insert (out, '<small>'); | |||
if 'no' == args.link then | |||
table.insert (out, '<abbr title="literal translation">lit.</abbr>'); | |||
else | |||
table.insert (out, make_wikilink ('Literal translation', 'lit.')); | |||
end | |||
table.insert (out, " </small>"); | |||
end | |||
table.insert (out, table.concat ({''', args.translation, '''})); -- use html entities to avoid wiki markup confusion | |||
end | end | ||
| Zeile 1.356: | Zeile 1.268: | ||
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 | ||
| Zeile 1.362: | Zeile 1.277: | ||
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 | local c, s, r, v, p, err; -- code, script, region, 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 | ||
| Zeile 1.375: | Zeile 1.290: | ||
]] | ]] | ||
local function is_ietf_tag (frame) | local function is_ietf_tag (frame) -- entry point from an {{#invoke:Lang|is_ietf_tag|<ietf tag>}} | ||
return _is_ietf_tag (frame.args[1]); -- frame.args[1] is the ietf language tag | |||
return _is_ietf_tag | |||
end | end | ||
--[[--------------------------< _ N A M E _ F R O M _ | --[[--------------------------< _ N A M E _ F R O M _ C O D E >------------------------------------------------ | ||
Returns language name associated with IETF language tag if valid; | Returns language name associated with IETF language tag if valid; empty string 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. | ||
| Zeile 1.409: | Zeile 1.311: | ||
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 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 | ||
| Zeile 1.417: | Zeile 1.318: | ||
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=\" | return table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: ', template, msg, '</span>'}); | ||
end | end | ||
raw_code = | if lang_data.override[raw_code:lower()] then -- look for whole IETF tag in override table (force lower case) | ||
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 | ||
if link then -- when |link=yes, wikilink the language name | if link then -- when |link=yes, wikilink the language name | ||
if | if language_name:find ('languages') then | ||
return make_wikilink (language_name); -- collective language name uses simple wikilink | |||
elseif lang_data.article_name[code] then | elseif lang_data.article_name[code] then | ||
return make_wikilink (lang_data.article_name[code][1], language_name); -- language name with wikilink from override data | |||
else | else | ||
return make_wikilink (language_name .. ' language', 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 _ C O D E >-------------------------------------------------- | ||
Module entry point from an {{#invoke:}} | Module entry point from an {{#invoke:}} | ||
| Zeile 1.446: | Zeile 1.359: | ||
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 | return _name_from_tag (frame.args); -- pass-on the args table, nothing else | ||
end | end | ||
| Zeile 1.464: | Zeile 1.377: | ||
if args[1] and '' ~= args[1] then | if args[1] and '' ~= args[1] then | ||
local data = mw.loadData ('Module:Lang/tag | local data = mw.loadData ('Module:Lang/name to tag'); -- get the reversed data tables | ||
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_lang_data[lang] or data.rev_lang_name_table[lang];-- get the code; look first in the override then in the standard | ||
if tag then | if tag then | ||
return tag | return tag; -- language name found so return tag and done | ||
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 | ||
| Zeile 1.481: | Zeile 1.394: | ||
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=\" | return table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: ', template, msg, '</span>'}); | ||
end | end | ||
| Zeile 1.492: | Zeile 1.405: | ||
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>}} | ||
return _tag_from_name (frame.args); -- pass-on the args table, nothing else | |||
end | end | ||
| Zeile 1.518: | Zeile 1.418: | ||
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; -- translitterated 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 | ||
if is_set (args[3]) then -- [3] set when {{transl|code|standard|text}} | if is_set (args[3]) then -- [3] set when {{transl|code|standard|text}} | ||
args.text = args[3]; -- get the transliterated text | args.text = args[3]; -- get the transliterated text | ||
| Zeile 1.530: | Zeile 1.427: | ||
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 | ||
| Zeile 1.536: | Zeile 1.433: | ||
args.text = args[2]; -- get the transliterated text | args.text = args[2]; -- get the transliterated text | ||
else | else | ||
if args[1] and args[1]:match ('^%a%a%a?%a?$') then -- args[2] missing; is args[1] a code or | 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 | ||
| Zeile 1.549: | Zeile 1.446: | ||
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 | ||
| Zeile 1.564: | Zeile 1.461: | ||
end | end | ||
if | if lang_data.override[args.code] then -- is code a language code defined in the override table? | ||
language_name = | language_name = lang_data.override[args.code][1]; | ||
elseif | elseif lang_name_table.lang[args.code] then -- is code a language code defined in the standard language code tables? | ||
language_name = | language_name = lang_name_table.lang[args.code][1]; | ||
elseif lang_name_table.script[args.code] then -- if here, code is not a language code; is it a script code? | |||
language_name = lang_name_table.script[args.code][1]; | |||
elseif | |||
language_name = | |||
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 | ||
| Zeile 1.589: | Zeile 1.484: | ||
local function transl (frame) | local function transl (frame) | ||
local args = getArgs(frame); -- no {{#invoke:}} parameters | |||
return _transl (args); | |||
return | |||
end | end | ||
| Zeile 1.645: | Zeile 1.493: | ||
return { | return { | ||
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, | ||
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}} | ||
_lang = _lang, -- entry points when this module is require()d into other modules | |||
_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, | ||
_tag_from_name = _tag_from_name, | _tag_from_name = _tag_from_name, | ||
_name_from_tag = _name_from_tag, | _name_from_tag = _name_from_tag, | ||
_transl = _transl, | _transl = _transl, | ||
}; | }; | ||