模块:Lang：修订间差异
imported>Xiplus per EP, User:Vozhuo提供 |
imported>Tigerzeng |
||
| 第1行： | 第1行： | ||
--[=[ | --[=[ 基于英文维基2021年2月23日版本 | ||
Lua support for the {{lang}}, {{lang-xx}}, and {{transl}} templates and replacement of various supporting templates. | Lua support for the {{lang}}, {{lang-xx}}, and {{transl}} templates and replacement of various supporting templates. | ||
| 第6行： | 第6行： | ||
require('Module:No globals'); | require('Module:No globals'); | ||
local | local getArgs = require ('Module:Arguments').getArgs; | ||
local unicode = require ("Module:Unicode data"); -- for is_latin() and is_rtl() | |||
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 = | 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 | local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization | ||
local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language | |||
local | 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 | ||
local maint_msgs = {}; -- and their messages go here | local maint_msgs = {}; -- and their messages go here | ||
--[[--------------------------< I S _ S E T >------------------------------------------------------------------ | --[[--------------------------< I S _ S E T >------------------------------------------------------------------ | ||
| 第44行： | 第41行： | ||
local function is_set( var ) | local function is_set( var ) | ||
return not (var == nil or var == ''); | return not (var == nil or var == ''); | ||
end | end | ||
| 第127行： | 第68行： | ||
local seg = {}; | local seg = {}; | ||
source = source:gsub ("%f[\']\'%f[^\']", '&# | source = source:gsub ("%f[\']\'%f[^\']", '''); -- protect single quote marks from being interpreted as bold markup | ||
seg[1] = source:match ('^(\'\'+%f[^\']).+') or ''; -- get leading markup, if any; ignore single quote | seg[1] = source:match ('^(\'\'+%f[^\']).+') or ''; -- get leading markup, if any; ignore single quote | ||
| 第142行： | 第83行： | ||
end | end | ||
seg[1] = seg[1] | seg[1] = invert_pattern_table[seg[1]] or seg[1]; -- replace leading markup according to pattern table | ||
seg[3] = seg[3] | seg[3] = invert_pattern_table[seg[3]] or seg[3]; -- replace leading markup according to pattern table | ||
return table.concat (seg); -- put it all back together and done | return table.concat (seg); -- put it all back together and done | ||
| 第175行： | 第116行： | ||
]] | ]] | ||
local function validate_italic ( | local function validate_italic (args) | ||
local properties = {['yes'] = 'italic', ['no'] = 'normal', ['unset'] = 'inherit', ['invert'] = 'invert', ['default'] = nil}; | local properties = {['yes'] = 'italic', ['no'] = 'normal', ['unset'] = 'inherit', ['invert'] = 'invert', ['default'] = nil}; | ||
local count = 0 | |||
for _, arg in pairs {'italic', 'italics', 'i'} do | |||
if args[arg] then | |||
count = count + 1 | |||
end | |||
end | |||
if count > 1 then -- return nil and an error message if more than one is set | |||
return nil, '只能指定|italic=、|italics=或|i=中的一个'; | |||
end | |||
return properties[args.italic or args.italics or args.i], nil; -- return an appropriate value and a nil error message | |||
end | |||
--[=[--------------------------< V A L I D A T E _ C A T _ A R G S >---------------------------------------------------------- | |||
Default behavior of the {{lang}} and {{lang-xx}} templates is to add categorization when the templates are used in mainspace. | |||
This default functionality may be suppressed by setting |nocat=yes or |cat=no. This function selects one of these two parameters | |||
to control categorization. | |||
Because having two parameters with 'opposite' names and 'opposite' values is confusing, this function accepts only affirmative | |||
values for |nocat= and only negative values for |cat=; in both cases the 'other' sense (and non-sense) is not accepted and the | |||
parameter is treated as if it were not set in the template. | |||
Sets args.nocat to true if categorization is to be turned off; to nil if the default behavior should apply. | |||
Accepted values for |nocat= are the text strings: | |||
'yes', 'y', 'true', 't', on, '1' -- [[Module:Yesno]] returns logical true for all of these; false or nil else | |||
for |cat= | |||
'no', 'n', 'false', 'f', 'off', '0' -- [[Module:Yesno]] returns logical false for all of these; true or nil else | |||
]=] | |||
if | local function validate_cat_args (args) | ||
return | if not (args.nocat or args.cat) then -- both are nil, so categorize | ||
return; | |||
end | end | ||
if false == yesno (args.cat) or true == yesno (args.nocat) then | |||
args.nocat = true; -- set to true when args.nocat is affirmative; nil else (as if the parameter were not set in the template) | |||
else -- args.nocat is the parameter actually used. | |||
args.nocat = nil; | |||
end | |||
end | end | ||
| 第192行： | 第172行： | ||
]] | ]] | ||
local function in_array( needle, haystack ) | local function in_array ( needle, haystack ) | ||
if needle == nil then | if needle == nil then | ||
return false; | return false; | ||
| 第212行： | 第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 | ||
| 第242行： | 第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 | ||
| 第261行： | 第246行： | ||
because those parameters are superfluous to the IETF subtags in |code=) | because those parameters are superfluous to the IETF subtags in |code=) | ||
returns six values. Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid | returns six values; all lower case. Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid | ||
parts are returned as nil; the sixth returned item is an error message (if an error detected) or nil. | parts are returned as nil; the sixth returned item is an error message (if an error detected) or nil. | ||
| 第269行： | 第254行： | ||
local function get_ietf_parts (source, args_script, args_region, args_variant) | local function get_ietf_parts (source, args_script, args_region, args_variant) | ||
local code | local code, script, region, variant, private; -- ietf tag parts | ||
if not is_set (source) then | if not is_set (source) then | ||
| 第279行： | 第260行： | ||
end | end | ||
local pattern = { -- table of tables holding acceptibe ietf tag patterns and short names of the ietf part captured by the pattern | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)%-(%d%d%d%d)$', 's', 'r', 'v'}, -- 1 - ll-Ssss-RR-variant (where variant is 4 digits) | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)%-(%d%d%d%d)$', 's', 'r', 'v'}, -- 2 - ll-Ssss-DDD-variant (where region is 3 digits; variant is 4 digits) | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)%-(%w%w%w%w%w%w?%w?%w?)$', 's', 'r', 'v'}, -- 3 - ll-Ssss-RR-variant (where variant is 5-8 alnum characters) | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)%-(%w%w%w%w%w%w?%w?%w?)$', 's', 'r', 'v'}, -- 4 - ll-Ssss-DDD-variant (where region is 3 digits; variant is 5-8 alnum characters) | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d%d)$', 's', 'v'}, -- 5 - ll-Ssss-variant (where variant is 4 digits) | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%w%w%w%w%w%w?%w?%w?)$', 's', 'v'}, -- 6 - ll-Ssss-variant (where variant is 5-8 alnum characters) | |||
{'^(%a%a%a?)%-(%a%a)%-(%d%d%d%d)$', 'r', 'v'}, -- 7 - ll-RR-variant (where variant is 4 digits) | |||
{'^(%a%a%a?)%-(%d%d%d)%-(%d%d%d%d)$', 'r', 'v'}, -- 8 - ll-DDD-variant (where region is 3 digits; variant is 4 digits) | |||
{'^(%a%a%a?)%-(%a%a)%-(%w%w%w%w%w%w?%w?%w?)$', 'r', 'v'}, -- 9 - ll-RR-variant (where variant is 5-8 alnum characters) | |||
{'^(%a%a%a?)%-(%d%d%d)%-(%w%w%w%w%w%w?%w?%w?)$', 'r', 'v'}, -- 10 - ll-DDD-variant (where region is 3 digits; variant is 5-8 alnum characters) | |||
{'^(%a%a%a?)%-(%d%d%d%d)$', 'v'}, -- 11 - ll-variant (where variant is 4 digits) | |||
{'^(%a%a%a?)%-(%w%w%w%w%w%w?%w?%w?)$', 'v'}, -- 12 - ll-variant (where variant is 5-8 alnum characters) | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)$', 's', 'r'}, -- 13 - ll-Ssss-RR | |||
{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)$', 's', 'r'}, -- 14 - ll-Ssss-DDD (region is 3 digits) | |||
{'^(%a%a%a?)%-(%a%a%a%a)$', 's'}, -- 15 - ll-Ssss | |||
{'^(%a%a%a?)%-(%a%a)$', 'r'}, -- 16 - ll-RR | |||
{'^(%a%a%a?)%-(%d%d%d)$', 'r'}, -- 17 - ll-DDD (region is 3 digits) | |||
{'^(%a%a%a?)$'}, -- 18 - ll | |||
{'^(%a%a%a?)%-x%-(%w%w?%w?%w?%w?%w?%w?%w?)$', 'p'}, -- 19 - ll-x-pppppppp (private is 1-8 alnum characters) | |||
} | |||
local t = {}; -- table of captures; serves as a translator between captured ietf tag parts and named variables | |||
for i, v in ipairs (pattern) do -- spin through the pattern table looking for a match | |||
local c1, c2, c3, c4; -- captures in the 'pattern' from the pattern table go here | |||
c1, c2, c3, c4 = source:match (pattern[i][1]); -- one or more captures set if source matches pattern[i]) | |||
if c1 then -- c1 always set on match | |||
code = c1; -- first capture is always code | |||
t = { | |||
[pattern[i][2] or 'x'] = c2, -- fill the table of captures with the rest of the captures | |||
[pattern[i][3] or 'x'] = c3, -- take index names from pattern table and assign sequential captures | |||
[pattern[i][4] or 'x'] = c4, -- index name may be nil in pattern[i] table so "or 'x'" spoofs a name for this index in this table | |||
}; | |||
script = t.s or ''; -- translate table contents to named variables; | |||
region = t.r or ''; -- absent table entries are nil so set named ietf parts to empty string for concatenation | |||
variant= t.v or ''; | |||
private = t.p or ''; | |||
break; -- and done | |||
end | |||
end | |||
if not code then | |||
return nil, nil, nil, nil, nil, table.concat ({'无法识别的语言标签：', source}); -- don't know what we got but it is malformed | return nil, nil, nil, nil, nil, table.concat ({'无法识别的语言标签：', source}); -- don't know what we got but it is malformed | ||
end | end | ||
| 第332行： | 第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 ({'无法识别的语言代码：', code}); -- invalid language code, don't know about the others (don't care?) | return nil, nil, nil, nil, nil, table.concat ({'无法识别的语言代码：', code}); -- invalid language code, don't know about the others (don't care?) | ||
end | end | ||
| 第352行： | 第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 ({'无法识别的文本：', script, '用于代码：', code}); -- language code ok, invalid script, don't know about the others (don't care?) | return code, nil, nil, nil, nil, table.concat ({'无法识别的文本：', script, '用于代码：', 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, '不支持代码：', code}); -- language code ok, script is suppressed for this code | return code, nil, nil, nil, nil, table.concat ({'文本：', script, '不支持代码：', code}); -- language code ok, script is suppressed for this code | ||
end | end | ||
| 第372行： | 第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 ({'无法识别的地区：', region, '用于代码：', code}); | return code, script, nil, nil, nil, table.concat ({'无法识别的地区：', region, '用于代码：', code}); | ||
end | end | ||
| 第387行： | 第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 ({' | return code, script, region, nil, nil, table.concat ({'无法识别的变体：', 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 ({' | return code, script, region, nil, nil, table.concat ({'无法识别的变体：', variant, '用于代码-文本对：', code, '-', script}); | ||
end | |||
elseif is_set (region) then -- if region set, there are some prefixes that require lang code and region (en-CA-newfound) | |||
if not in_array (code, 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 ({'无法识别的变体：', variant, '用于代码-文本对：', code, '-', region}); | |||
end | |||
end | end | ||
else | else | ||
if not in_array (code, | if not in_array (code, variant_table[variant]['prefixes']) then | ||
return code, script, region, nil, nil, table.concat ({' | return code, script, region, nil, nil, table.concat ({'无法识别的变体：', variant, '用于代码：', code}); | ||
end | end | ||
end | end | ||
| 第403行： | 第394行： | ||
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 ({'无法识别的私有标签： ', private}); | return code, script, region, nil, nil, table.concat ({'无法识别的私有标签：', private}); | ||
end | end | ||
end | end | ||
| 第421行： | 第412行： | ||
local category; | local category; | ||
if ' | if 'Transl' == template then | ||
category = ' | category = 'Transl'; | ||
else | else | ||
category = ' | category = 'Lang和lang-xx' | ||
end | end | ||
table.insert (out, table.concat ({' | table.insert (out, table.concat ({'[', args.text or '未定义', '] '})); -- for error messages output args.text if available | ||
table.insert (out, table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">错误：{{', template, '}}：'})); | table.insert (out, table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">错误：{{', template, '}}：'})); | ||
table.insert (out, msg); | table.insert (out, msg); | ||
table.insert (out, table.concat ({'（[[:Category:', category, '模板错误|帮助]]）'})); | table.insert (out, table.concat ({'（[[:Category:', category, '模板错误|帮助]]）'})); | ||
table.insert (out, '</span>'); | table.insert (out, '</span>'); | ||
if (0 == namespace) and not | 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, '模板错误]]'})); | table.insert (out, table.concat ({'[[Category:', category, '模板错误]]'})); | ||
end | end | ||
| 第462行： | 第453行： | ||
--[[--------------------------< M A K | --[[--------------------------< D I V _ M A R K U P _ A D D >-------------------------------------------------- | ||
adds <i> and </i> tags to list-item text or to implied <p>..</p> text. mixed not supported | |||
]] | |||
local function div_markup_add (text, style) | |||
local implied_p = {}; | |||
if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text | |||
if 'italic' == style then | |||
return mw.ustring.gsub (text, '(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item | |||
else | |||
return text; | |||
end | |||
end | |||
if text:find ('\n+') then -- look for any number of \n characters in text | |||
text = text:gsub ('([^\n])\n([^\n])', '%1 %2'); -- replace single newline characters with a space character which mimics mediawiki | |||
if 'italic' == style then | |||
text = text:gsub('[^\n]+', '<p><i>%1</i></p>'); -- insert p and italic markup tags at each impled p (two or more consecutive '\n\n' sequences) | |||
else | |||
text = text:gsub ('[^\n]+', '<p>%1</p>'); -- insert p markup at each impled p | |||
text = text:gsub ('\n', ''); -- strip newline characters | |||
end | |||
end | |||
return text; | |||
end | |||
--[[--------------------------< M A K E _ T E X T _ H T M L >-------------------------------------------------- | |||
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 | |||
]] | ]] | ||
local function | 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 | ||
if 'italic' == style then | if 'span' == tag then -- default html tag for inline content | ||
if 'italic' == style then -- but if italic | |||
tag = 'i'; -- change to <i> tags | |||
end | |||
else -- must be div so go | |||
text = div_markup_add (text, style); -- handle implied <p>, implied <p> with <i>, and list markup (*;:#) with <i> | |||
end | end | ||
if rtl then | table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag | ||
table.insert ( | table.insert (html, table.concat ({' lang="', code, '\"'})); -- add language attribute | ||
if rtl or unicode.is_rtl(text) then | |||
table.insert (html, ' dir="rtl"'); -- add direction attribute for right to left languages | |||
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 | ||
| 第505行： | 第523行： | ||
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 | ||
| 第513行： | 第531行： | ||
if is_set (language) then | 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 | if language:find ('languages') then | ||
table.insert ( | table.insert (html, '汇集文本'); -- for collective languages | ||
else | else | ||
table.insert ( | table.insert (html, '文本'); -- for individual languages | ||
end | end | ||
table.insert ( | table.insert (html, '\">'); -- close the opening html tag | ||
else | else | ||
table.insert ( | table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag | ||
end | end | ||
table.insert ( | table.insert (html, text); -- insert the text | ||
table.insert (html, table.concat ({'</', tag, '>'})); -- close the <i>, <span>, or <div> html tag | |||
if rtl then -- legacy; shouldn't be necessary because all of the rtl text is wrapped inside an html tag with dir="rtl" attribute | |||
table.insert (html, '‎'); -- make sure the browser knows that we're at the end of the rtl | |||
if rtl then -- legacy; shouldn't be necessary because all of the rtl text is wrapped | |||
table.insert ( | |||
end | end | ||
return table.concat (html); -- put it all together and done | |||
return table.concat ( | |||
end | end | ||
| 第609行： | 第623行： | ||
if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}}) | 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 | if not style then -- nil for the default italic style | ||
table.insert (tout, "< | 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); | ||
| 第624行： | 第638行： | ||
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 | table.insert (tout, language_name); -- write a generic tool tip | ||
if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name) | -- 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, ' | table.insert (tout, '羅馬化'); -- 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 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], '）转写'})); -- 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? | ||
| 第643行： | 第657行： | ||
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()], ' (', 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, '）转写'})); -- 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 | ||
| 第654行： | 第669行： | ||
else | else | ||
if is_set (tscript) then | if is_set (tscript) then | ||
table.insert (tout, table.concat ({language_name, '- | table.insert (tout, table.concat ({language_name, '-文字转写'})); -- write a script tool tip | ||
elseif is_set (code) then | elseif is_set (code) then | ||
if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name) | -- 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, ' | table.insert (tout, '转写'); -- finish the tool tip | ||
else | else | ||
table.insert (tout, ' | table.insert (tout, '转写'); -- generic tool tip (can we ever get here?) | ||
end | end | ||
end | end | ||
| 第668行： | 第683行： | ||
table.insert (tout, '">'); | table.insert (tout, '">'); | ||
table.insert (tout, translit); | table.insert (tout, translit); | ||
if is_set (code) and not style then | 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, "</ | table.insert (tout, "</i>"); -- close the italic tag | ||
else | else | ||
table.insert (tout, "</span>"); -- no language code so close the span tag | table.insert (tout, "</span>"); -- no language code so close the span tag | ||
| 第677行： | 第692行： | ||
--[ | --[[--------------------------< V A L I D A T E _ T E X T >---------------------------------------------------- | ||
This function checks the content of args.text and returns empty string if nothing is amiss else it returns an | This function checks the content of args.text and returns empty string if nothing is amiss else it returns an | ||
| 第683行： | 第698行： | ||
Italic rendering is controlled by the |italic= template parameter so italic markup should never appear in args.text | Italic rendering is controlled by the |italic= template parameter so italic markup should never appear in args.text | ||
either as ''itself | either as ''itself'' or as '''''bold italic''''' unless |italic=unset or |italic=invert. | ||
] | ]] | ||
local function validate_text (template, args) | local function validate_text (template, args) | ||
| 第696行： | 第711行： | ||
end | end | ||
local style = args.italic | local style = args.italic; | ||
if ('unset' ~= style) and ('invert' ~=style) then | if ('unset' ~= style) and ('invert' ~=style) then | ||
if args.text:find ("%f[\']\'\'%f[^\']") or args.text:find ("%f[\']\'\'\'\'\'%f[^\']") then -- italic but not bold, or bold italic | if args.text:find ("%f[\']\'\'%f[^\']") or args.text:find ("%f[\']\'\'\'\'\'%f[^\']") then -- italic but not bold, or bold italic | ||
| 第717行： | 第731行： | ||
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 | ||
| 第724行： | 第738行： | ||
end | end | ||
if (0 < #maint_cats) and (0 == namespace) and not | if (0 < #maint_cats) and (0 == namespace) and not nocat then -- when there are maintenance categories; article namespace only | ||
for _, cat in ipairs (maint_cats) do | for _, cat in ipairs (maint_cats) do | ||
table.insert (maint, table.concat ({'[[Category:', cat, ']]'})); -- format and add the categories | table.insert (maint, table.concat ({'[[Category:', cat, ']]'})); -- format and add the categories | ||
| 第736行： | 第750行： | ||
--[[--------------------------< P R O T O _ P R E F I X >------------------------------------------------------ | --[[--------------------------< P R O T O _ P R E F I X >------------------------------------------------------ | ||
for proto languages, text is prefixed with a splat. We do that here as a flag for | for proto languages, text is prefixed with a splat. We do that here as a flag for make_text_html() so that a splat | ||
will be rendered outside of italic markup (if used). If the first character in text here is already a splat, we | will be rendered outside of italic markup (if used). If the first character in text here is already a splat, we | ||
do nothing | do nothing | ||
proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and / or inhibits | |||
regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac | |||
]] | ]] | ||
local function proto_prefix (text, language_name) | local function proto_prefix (text, language_name, proto_param) | ||
if | if false == proto_param then -- when forced by |proto=no | ||
return | return text:gsub ('^%**', ''); -- return text without splat prefix regardless of language name or existing splat prefix in text | ||
elseif (language_name:find ('^Proto%-') or (true == proto_param)) then -- language is a proto or forced by |proto=yes | |||
return text:gsub ('^%**', '*'); -- prefix proto-language text with a splat; also removes duplicate prefixing splats | |||
end | end | ||
return text; | return text:gsub ('^%*+', '*'); -- return text unmolested except multiple splats reduced to one splat | ||
end | |||
--[[--------------------------< H A S _ P O E M _ T A G >------------------------------------------------------ | |||
looks for a poem strip marker in text; returns true when found; false else | |||
auto-italic detection disabled when text has poem stripmarker because it is not possible for this code to know | |||
the content that will replace the stripmarker. | |||
]] | |||
local function has_poem_tag (text) | |||
return text:find ('\127[^\127]*UNIQ%-%-poem%-[%a%d]+%-QINU[^\127]*\127') and true or false; | |||
end | |||
--[[--------------------------< H T M L _ T A G _ S E L E C T >------------------------------------------------ | |||
Inspects content of and selectively trims text. Returns text and the name of an appropriate html tag for text. | |||
If text contains: | |||
\n\n text has implied <p>..</p> tags - trim leading and trailing whitespace and return | |||
If text begins with list markup: | |||
\n* unordered | |||
\n; definition | |||
\n: definition | |||
\n# ordered | |||
trim all leading whitespace except \n and trim all trailing whitespace | |||
If text contains <poem>...</poem> stripmarker, return text unmodified and choose <div>..</div> tags because | |||
the stripmarker is replaced with text wrapped in <div>..</div> tags. | |||
]] | |||
local function html_tag_select (text) | |||
local tag; | |||
if has_poem_tag (text) then -- contains poem stripmarker (we can't know the content of that) | |||
tag = 'div'; -- poem replacement is in div tags so lang must use div tags | |||
elseif mw.text.trim (text):find ('\n\n+') then -- contains implied p tags | |||
text = mw.text.trim (text); -- trim leading and trailing whitespace characters | |||
tag = 'div'; -- must be div because span may not contain p tags (added later by MediaWiki); poem replacement is in div tags | |||
elseif text:find ('\n[%*:;%#]') then -- if text has list markup | |||
text = text:gsub ('^[\t\r\f ]*', ''):gsub ('%s*$', ''); -- trim all whitespace except leading newline character '\n' | |||
tag = 'div'; -- must be div because span may not contain ul, dd, dl, ol tags (added later by MediaWiki) | |||
else | |||
text = mw.text.trim (text); -- plain text | |||
tag = 'span'; -- so span is fine | |||
end | |||
return text, tag; | |||
end | |||
--[[--------------------------< V A L I D A T E _ P R O T O >-------------------------------------------------- | |||
validates value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false, | |||
empty string (or parameter omitted) returns as nil; any other value returns as nil with a second return value of | |||
true indicating that some other value has been assigned to |proto= | |||
]] | |||
local function validate_proto (proto_param) | |||
if 'yes' == proto_param then | |||
return true; | |||
elseif 'no' == proto_param then | |||
return false; | |||
elseif is_set (proto_param) then | |||
return nil, true; -- |proto= something other than 'yes' or 'no' | |||
else | |||
return nil; -- missing or empty | |||
end | |||
end | |||
--[[--------------------------< L A N G U A G E _ N A M E _ G E T >-------------------------------------------- | |||
common function to return language name from the data set according to IETF tag | |||
returns language name if found in data tables; nil else | |||
]] | |||
local function language_name_get (ietf, code, cat) | |||
ietf = ietf:lower(); -- ietf:lower() because format_ietf_tag() returns mixed case | |||
local name; -- remains nil if not found | |||
if override_table[ietf] then -- look for whole IETF tag in override table | |||
name = override_table[ietf][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和lang-xx使用弃用的ISO 639代码|', code})); | |||
table.insert (maint_msgs, table.concat ({'代码：', code, '已弃用'})); | |||
end | |||
return name; -- name from data tables or nil | |||
end | end | ||
--[[--------------------------< L A N G > | --[[--------------------------< _ L A N G >-------------------------------------------------------------------- | ||
entry point for {{lang}} | entry point for {{lang}} | ||
| 第758行： | 第886行： | ||
<includeonly>{{#invoke:lang|lang}}</includeonly> | <includeonly>{{#invoke:lang|lang}}</includeonly> | ||
parameters are | parameters are received from the template's frame (parent frame) | ||
]] | ]] | ||
function | local function _lang (args) | ||
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 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 ('冲突：{{{1}}} 和 | return make_error_msg ('冲突：{{{1}}} 和 |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 | ||
| 第777行： | 第909行： | ||
if args[2] and args.text then | if args[2] and args.text then | ||
return make_error_msg ('冲突：{{{2}}} 和 | return make_error_msg ('冲突：{{{2}}} 和 |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 ( | 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; | ||
end | end | ||
args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly | |||
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 | ||
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag | |||
if msg then | |||
return make_error_msg (table.concat ({'无效|proto=：', args.proto}), args, template); | |||
end | |||
code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (args.code); -- |script=, |region=, |variant= not supported because they should be part of args.code ({{{1}}} in {{lang}}) | code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (args.code); -- |script=, |region=, |variant= not supported because they should be part of args.code ({{{1}}} in {{lang}}) | ||
if msg then | if msg then | ||
return make_error_msg ( msg, args, | return make_error_msg ( msg, args, template); | ||
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, 'lang' | return make_error_msg (msg, args, template); | ||
end | |||
if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls | |||
if ('latn' == subtags.script) or -- script is latn | |||
(this_wiki_lang ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and unicode.is_Latin (args.text)) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics) | |||
args.italic = 'unset'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic | |||
else | |||
args.italic = 'inherit'; -- italic not set; script not latn; inherit current style | |||
end | |||
end | end | ||
| 第812行： | 第956行： | ||
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 | |||
if 'invert' == args.italic then | if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content | ||
args.text = invert_italics (args.text) | args.text = invert_italics (args.text) | ||
end | end | ||
-- 中文版特化部分：为非中文文字禁用繁简转换，中文文字和其他以汉字作为书写系统的汉语方言文字启用繁简转换。 | -- 中文版特化部分：为非中文文字禁用繁简转换，中文文字和其他以汉字作为书写系统的汉语方言文字启用繁简转换。 | ||
if 'zh' == code then | if 'zh' == code then | ||
| 第843行： | 第980行： | ||
end | end | ||
args.text = proto_prefix (args.text, language_name); | args.text = proto_prefix (args.text, language_name, args.proto); -- prefix proto-language text with a splat | ||
table.insert (out, | table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, language_name)); | ||
table.insert (out, make_category (code, language_name, args.nocat)); | table.insert (out, make_category (code, language_name, args.nocat)); | ||
table.insert (out, render_maint(args.nocat)); | table.insert (out, render_maint(args.nocat)); -- maintenance messages and categories | ||
return table.concat (out); -- put it all together and done | return table.concat (out); -- put it all together and done | ||
end | |||
--[[--------------------------< L A N G >---------------------------------------------------------------------- | |||
entry point for {{lang}} | |||
there should be no reason to set parameters in the {{lang}} {{#invoke:}} | |||
<includeonly>{{#invoke:lang|lang}}</includeonly> | |||
parameters are received from the template's frame (parent frame) | |||
]] | |||
local function lang (frame) | |||
local args = getArgs (frame, { -- this code so that we can detect and handle wiki list markup in text | |||
valueFunc = function (key, value) | |||
if 2 == key or 'text' == key then -- the 'text' parameter; do not trim wite space | |||
return value; -- return untrimmed 'text' | |||
elseif value then -- all other values: if the value is not nil | |||
value = mw.text.trim (value); -- trim whitespace | |||
if '' ~= value then -- empty string when value was only whitespace | |||
return value; | |||
end | |||
end | |||
return nil; -- value was empty or contained only whitespace | |||
end -- end of valueFunc | |||
}); | |||
return _lang (args); | |||
end | end | ||
| 第859行： | 第1,026行： | ||
that can have multiple writing systems, it may be appropriate to set |script= as well. | that can have multiple writing systems, it may be appropriate to set |script= as well. | ||
For each {{lang-xx}} template choose the appropriate entry-point function so that this function | For each {{lang-xx}} template choose the appropriate entry-point function so that this function knows the default | ||
styling that should be applied to text. | styling that should be applied to text. | ||
| 第871行： | 第1,038行： | ||
Supported parameters are: | Supported parameters are: | ||
|code = (required) the IANA language code | |code = (required) the IANA language code | ||
|script = IANA script code; especially for use with languages that use multiple writing systems | |script = IANA script code; especially for use with languages that use multiple writing systems | ||
|region = IANA region code | |region = IANA region code | ||
|variant = IANA variant code | |variant = IANA variant code | ||
|text = (required) the displayed text in language specified by code | |text = (required) the displayed text in language specified by code | ||
|link = boolean false ('no') | |link = boolean false ('no') does not link code-spcified language name to associated language article | ||
|rtl = boolean true ('yes') identifies the language specified by code as a right-to-left language | |rtl = boolean true ('yes') identifies the language specified by code as a right-to-left language | ||
|nocat = boolean true ('yes') inhibits normal categorization; error categories are not affected | |nocat = boolean true ('yes') inhibits normal categorization; error categories are not affected | ||
|cat = boolian false ('no') opposite form of |nocat= | |||
|italic = boolean true ('yes') renders displayed text in italic font; boolean false ('no') renders displayed text in normal font; not set renders according to initial_style_state | |italic = boolean true ('yes') renders displayed text in italic font; boolean false ('no') renders displayed text in normal font; not set renders according to initial_style_state | ||
|lit = text that is a literal translation of text | |lit = text that is a literal translation of text | ||
|label = 'none' to suppress all labeling (language name, 'translit.', 'lit.') | |label = 'none' to suppress all labeling (language name, 'translit.', 'lit.') | ||
any other text replaces language-name label - automatic wikilinking disabled | any other text replaces language-name label - automatic wikilinking disabled | ||
for those {{lang-xx}} templates that support transliteration (those | for those {{lang-xx}} templates that support transliteration (those templates where |text= is not entirely latn script): | ||
|translit = text that is a transliteration of text | |translit = text that is a transliteration of text | ||
|translit-std = the standard that applies to the transliteration | |translit-std = the standard that applies to the transliteration | ||
| 第896行： | 第1,064行： | ||
]] | ]] | ||
local function _lang_xx ( | local function _lang_xx (args) | ||
local out = {}; | local out = {}; | ||
local language_name; -- used to make display text, article links | local language_name; -- used to make display text, article links | ||
| 第908行： | 第1,075行： | ||
local translit_title; | local translit_title; | ||
local msg; -- for error messages | local msg; -- for error messages | ||
local tag = 'span'; -- initial value for make_text_html() | |||
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 ('冲突：{{{1}}} 和 | return make_error_msg ('冲突：{{{1}}} 和 |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 | ||
end | end | ||
msg = validate_text ( | msg = validate_text (template, args); -- ensure that |text= is set, does not contain italic markup and is protected from improper bolding | ||
if is_set (msg) then | if is_set (msg) then | ||
return msg; | return msg; | ||
end | end | ||
args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly | |||
if args[2] and args.translit then | if args[2] and args.translit then | ||
return make_error_msg ('冲突：{{{2}}} 和 | return make_error_msg ('冲突：{{{2}}} 和 |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 | ||
| 第927行： | 第1,098行： | ||
if args[3] and (args.translation or args.lit) then | if args[3] and (args.translation or args.lit) then | ||
return make_error_msg ('冲突：{{{3}}} 和 | return make_error_msg ('冲突：{{{3}}} 和 |lit= or |translation=', args, template); | ||
elseif args.translation and args.lit then | elseif args.translation and args.lit then | ||
return make_error_msg ('冲突： | return make_error_msg ('冲突：|lit= 和 |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 | ||
| 第935行： | 第1,106行： | ||
if args.links and args.link then | if args.links and args.link then | ||
return make_error_msg ('冲突： | return make_error_msg ('冲突：|links= 和 |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 | ||
end | end | ||
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 | ||
| 第945行： | 第1,118行： | ||
if msg then -- if an error detected then there is an error message | if msg then -- if an error detected then there is an error message | ||
return make_error_msg (msg, args, | return make_error_msg (msg, args, template); | ||
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, template); | ||
end | end | ||
| 第973行： | 第1,146行： | ||
end | end | ||
args. | args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag | ||
if msg then | |||
if | return make_error_msg (table.concat ({'无效 |proto=：', args.proto}), args, template); | ||
end | end | ||
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 | |||
category_name = language_name; -- category names retain IANA parenthetical diambiguators (if any) | category_name = language_name; -- category names retain IANA parenthetical diambiguators (if any) | ||
| 第1,002行： | 第1,165行： | ||
table.insert (out, language_name); -- language name without wikilink | table.insert (out, language_name); -- language name without wikilink | ||
else | else | ||
if lang_data.article_name[code] then | |||
table.insert (out, make_wikilink (lang_data.article_name[code][1], language_name)); -- language name with wikilink from override data | |||
else | |||
table.insert (out, make_wikilink (language_name)); -- language name with wikilink | |||
end | |||
end | end | ||
table.insert (out, '：'); -- separator | table.insert (out, '：'); -- separator | ||
| 第1,014行： | 第1,177行： | ||
args.text = invert_italics (args.text) | args.text = invert_italics (args.text) | ||
end | end | ||
-- 中文版特化部分：为非中文文字禁用繁简转换，中文文字和其他以汉字作为书写系统的汉语方言文字启用繁简转换。 | -- 中文版特化部分：为非中文文字禁用繁简转换，中文文字和其他以汉字作为书写系统的汉语方言文字启用繁简转换。 | ||
if 'zh' == code then | if 'zh' == code then | ||
| 第1,032行： | 第1,195行： | ||
end | end | ||
args.text = proto_prefix (args.text, language_name); | args.text = proto_prefix (args.text, language_name, args.proto); -- prefix proto-language text with a splat | ||
table.insert (out, | 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 | 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) | ||
table.insert (out, '，'); -- comma to separate text from translit | table.insert (out, '，'); -- comma to separate text from translit | ||
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 | ||
| 第1,048行： | 第1,210行： | ||
translit_title = mw.title.makeTitle (0, table.concat ({translit_script_name, '羅馬化'})); -- make a title object | translit_title = mw.title.makeTitle (0, table.concat ({translit_script_name, '羅馬化'})); -- make a title object | ||
if translit_title.exists and ('no' ~= args.link) then | if translit_title.exists and ('no' ~= args.link) then | ||
table.insert (out, make_wikilink ((translit_script_name or language_name) .. '羅馬化', ' | table.insert (out, make_wikilink ((translit_script_name or language_name) .. '羅馬化', '羅馬化')); -- make a wikilink if there is an article to link to | ||
else | else | ||
table.insert (out, ' | table.insert (out, '羅馬化'); -- else plain text | ||
end | end | ||
table.insert (out, '：</small>'); -- close the small tag | table.insert (out, '：</small>'); -- close the small tag | ||
| 第1,059行： | 第1,221行： | ||
table.insert (out, translit); | table.insert (out, translit); | ||
else | else | ||
return make_error_msg (table.concat ({'invalid translit-std: \'', args['translit-std'] or '[missing]'}), args, | return make_error_msg (table.concat ({'invalid translit-std: \'', args['translit-std'] or '[missing]'}), args, template); | ||
end | end | ||
end | end | ||
| 第1,081行： | 第1,243行： | ||
return table.concat (out); -- put it all together and done | return table.concat (out); -- put it all together and done | ||
end | |||
--[[--------------------------< L A N G _ X X _ A R G S _ G E T >---------------------------------------------- | |||
common function to get args table from {{lang-??}} templates | |||
returns table of args | |||
]] | |||
local function lang_xx_args_get (frame) | |||
local args = getArgs(frame, | |||
{ | |||
parentFirst= true, -- parameters in the template override parameters set in the {{#invoke:}} | |||
valueFunc = function (key, value) | |||
if 1 == key then -- the 'text' parameter; do not trim wite space | |||
return value; -- return untrimmed 'text' | |||
elseif value then -- all other values: if the value is not nil | |||
value = mw.text.trim (value); -- trim whitespace | |||
if '' ~= value then -- empty string when value was only whitespace | |||
return value; | |||
end | |||
end | |||
return nil; -- value was empty or contained only whitespace | |||
end -- end of valueFunc | |||
}); | |||
return args; | |||
end | end | ||
| 第1,090行： | 第1,281行： | ||
]] | ]] | ||
function | local function lang_xx_italic (frame) | ||
local args = lang_xx_args_get (frame); | |||
initial_style_state = 'italic'; | initial_style_state = 'italic'; | ||
return _lang_xx ( | return _lang_xx (args); | ||
end | |||
--[[--------------------------< _ L A N G _ X X _ I T A L I C >------------------------------------------------ | |||
Entry point ffrom another module. Sets the initial style state to italic. | |||
]] | |||
local function _lang_xx_italic (args) | |||
initial_style_state = 'italic'; | |||
return _lang_xx (args); | |||
end | end | ||
| 第1,102行： | 第1,307行： | ||
]] | ]] | ||
function | local function lang_xx_inherit (frame) | ||
local args = lang_xx_args_get (frame); | |||
initial_style_state = 'inherit'; | |||
return _lang_xx (args); | |||
end | |||
--[[--------------------------< _ L A N G _ X X _ I N H E R I T >---------------------------------------------- | |||
Entry point from another module. Sets the initial style state to inherit. | |||
]] | |||
local function _lang_xx_inherit (args) | |||
initial_style_state = 'inherit'; | initial_style_state = 'inherit'; | ||
return _lang_xx (frame); | return _lang_xx (args); | ||
end | |||
--[[--------------------------< _ I S _ I E T F _ T A G >------------------------------------------------------ | |||
Returns true when a language name associated with IETF language tag exists; nil else. IETF language tag must be valid. | |||
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function. | |||
Module entry point from another module | |||
]] | |||
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, variant, private, error message | |||
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 | |||
end | |||
--[[--------------------------< I S _ I E T F _ T A G >-------------------------------------------------------- | |||
Module entry point from an {{#invoke:}} | |||
]] | |||
local function 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 | |||
--[[--------------------------< I S _ I E T F _ T A G _ F R A M E >-------------------------------------------- | |||
Module entry point from an {{#invoke:}}; same as is_ietf_tag() except does not get parameters from the parent | |||
(template) frame. This function not useful when called by {{lang|fn=is_ietf_tag_frame|<tag>}} because <tag> | |||
is in the parent frame. | |||
]] | |||
local function is_ietf_tag_frame (frame) | |||
return _is_ietf_tag (getArgs (frame, {frameOnly = true,})[1]); -- args[1] is the ietf language tag to be tested; do not get parent frame | |||
end | end | ||
--[[--------------------------< N A M E _ F R O M _ | --[[--------------------------< _ N A M E _ F R O M _ T A G >-------------------------------------------------- | ||
Returns language name associated with IETF language tag if valid; | 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. | ||
Set invoke's |link= parameter to yes to get wikilinked version of the language name. | |||
Module entry point from another module | |||
]] | ]] | ||
function | local function _name_from_tag (args) | ||
local subtags = {}; -- IETF subtags script, region, variant, and private | local subtags = {}; -- IETF subtags script, region, variant, and private | ||
local raw_code = | 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 code; -- the language code | ||
local msg; -- | local msg; -- gets an error message if IETF language tag is malformed or invalid | ||
local language_name = ''; | local language_name = ''; | ||
code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code); | code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code); | ||
if msg then | if msg then | ||
return ''; | 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\">错误：', 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 | |||
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 = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them | |||
if | if link then -- when |link=yes, wikilink the language name | ||
language_name = | if 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 | |||
language_name = make_wikilink (language_name, label or language_name); -- language name with wikilink | |||
end | end | ||
else | end | ||
return language_name; | |||
end | |||
--[[--------------------------< N A M E _ F R O M _ T A G >---------------------------------------------------- | |||
Module entry point from an {{#invoke:}} | |||
]] | |||
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 (getArgs(frame)) -- pass-on the args table, nothing else; getArgs() so we also get parent frame | |||
end | |||
--[[--------------------------< _ T A G _ F R O M _ N A M E >-------------------------------------------------- | |||
Returns the ietf language tag associated with the language name. Spelling of language name must be correct | |||
according to the spelling in the source tables. When a standard language name has a parenthetical disambiguator, | |||
that disambiguator must be omitted (they are not present in the data name-to-tag tables). | |||
Module entry point from another module | |||
]] | |||
local function _tag_from_name (args) -- entry point from another module | |||
local msg; | |||
if args[1] and '' ~= args[1] then | |||
local data = mw.loadData ('Module:Lang/tag from name'); -- get the reversed data tables TODO: change when going live | |||
local lang = args[1]:lower(); -- allow any-case for the language name (speeling must till be correct) | |||
local tag = data.rev_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 | |||
return tag, true; -- language name found so return tag and done; second return used by is_lang_name() | |||
else | |||
msg = '语言：' .. args[1] .. '未找到' -- language name not found, error message | |||
end | end | ||
else | |||
msg = '缺少语言名称' -- language name not provided, error message | |||
end | |||
local template = ''; | |||
if args.template and '' ~= args.template then | |||
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\">错误：', template, msg, '</span>'}); | |||
end | |||
--[[--------------------------< T A G _ F R O M _ N A M E >---------------------------------------------------- | |||
Module entry point from an {{#invoke:}} | |||
]] | |||
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 | ||
--[[--------------------------< T R A N S L > | --[[--------------------------< _ T R A N S L >---------------------------------------------------------------- | ||
Module entry point from another module | |||
]] | ]] | ||
function | local function _transl (args) | ||
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 | ||
| 第1,168行： | 第1,501行： | ||
if not title_table[args.translit_std] then | if not title_table[args.translit_std] then | ||
return make_error_msg (table.concat ({'无法识别的转译标准：', args.translit_std}), args, ' | return make_error_msg (table.concat ({'无法识别的转译标准：', args.translit_std}), args, 'Transl'); | ||
end | end | ||
else | else | ||
| 第1,175行： | 第1,508行： | ||
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 (' | return make_error_msg ('无文本', 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 ('缺少语言/文字代码', args, ' | return make_error_msg ('缺少语言/文字代码', args, 'Transl'); | ||
end | end | ||
end | end | ||
| 第1,187行： | 第1,520行： | ||
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 ({'无法识别的语言/文字代码：', args[1]}), args, ' | return make_error_msg (table.concat ({'无法识别的语言/文字代码：', args[1]}), args, 'Transl'); -- invalid language / script code | ||
end | end | ||
else | else | ||
return make_error_msg ('缺少语言/文字代码', args, ' | return make_error_msg ('缺少语言/文字代码', 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 | ||
| 第1,202行： | 第1,535行： | ||
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 ({'无法识别的语言/文字代码：', args.code}), args, ' | return make_error_msg (table.concat ({'无法识别的语言/文字代码：', 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 | ||
| 第1,218行： | 第1,553行： | ||
return | --[[--------------------------< T R A N S L >------------------------------------------------------------------ | ||
Module entry point from an {{#invoke:}} | |||
]] | |||
local function transl (frame) | |||
return _transl (getArgs(frame)); | |||
end | |||
--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >-------------------------------------------- | |||
Returns category name associated with IETF language tag if valid; error message else | |||
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function. | |||
Module entry point from another module | |||
]] | |||
local function _category_from_tag (args) | |||
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\">错误：', 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 | |||
--[[--------------------------< E X P O R T E D F U N C T I O N S >------------------------------------------ | |||
]] | |||
return { | |||
category_from_tag = category_from_tag, | |||
lang = lang, -- entry point for {{lang}} | |||
lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}} | |||
lang_xx_italic = lang_xx_italic, | |||
is_ietf_tag = is_ietf_tag, | |||
is_ietf_tag_frame = is_ietf_tag_frame, | |||
is_lang_name = is_lang_name, | |||
tag_from_name = tag_from_name, -- returns ietf tag associated with language name | |||
name_from_tag = name_from_tag, -- used for template documentation; possible use in ISO 639 name from code templates | |||
transl = transl, -- entry point for {{transl}} | |||
_category_from_tag = _category_from_tag, -- entry points when this module is require()d into other modules | |||
_lang = _lang, | |||
_lang_xx_inherit = _lang_xx_inherit, | |||
_lang_xx_italic = _lang_xx_italic, | |||
_is_ietf_tag = _is_ietf_tag, | |||
get_ietf_parts = get_ietf_parts, | |||
_tag_from_name = _tag_from_name, | |||
_name_from_tag = _name_from_tag, | |||
_transl = _transl, | |||
}; | |||