模块:Lang：修订间差异

Lua support for the {{lang}}, {{langx}}, {{lang-??}}, and {{transliteration}} templates and replacement of various supporting templates.

 

require('strict');

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

local unicode = require ("Module:Unicode data"); -- for is_Latin() and is_rtl()

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

local sandbox = (mw.getCurrentFrame():getTitle():match ('/sandbox') or ''); -- when called from a sandbox template or module load sandbox data and sandbox configuration

 

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

local override_table = lang_data.override;

local cfg = mw.loadData ('Module:Lang/configuration' .. sandbox); -- for internationalization

 

local function make_error_span (template, msg)

return table.concat ({'<span class="error" style="font-size: 1em;">', cfg.misc_text_t.error, '：', template, msg, '</span>'})

 

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

--[[--------------------------< S U B S T I T U T E >----------------------------------------------------------

Substitutes $1, $2, etc in <message> with data from <data_t>. Returns plain-text substituted string when

<data_t> not nil; returns <message> else.

]]

local function substitute (message, data_t)

return data_t and mw.message.newRawMessage (message, data_t):plain() or message;

 

--[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------

 

Assembles an error message from template name, message text, help link, and error category.

local function make_error_msg (msg, args_t, template)

text = args_t.text or args_t[1]; -- for {{lang-xx}}

 

 

local category_link = ((0 == namespace or 10 == namespace) and not args_t.nocat) and substitute ('[[Category:$1]]', {category}) or '';

 

text = cfg.make_error_msg_t.empty

 

-- &#123;&#123;$3&#125;&#125; = {{$3}}

table.insert(error_msgs, substitute ('-{[$1]}-<span class="error" style="font-size: 1em; margin-left: 0.3em;">$2：&#123;&#123;$3&#125;&#125;：$4（[[:Category:$5|$6]]）</span>$7',

text,

 

 

--[[--------------------------< P A R A M E T E R _ V A L I D A T E >------------------------------------------

 

 

local function parameter_validate (args_t, template)

 

 

if cfg.templates_t.lang == template then -- for {{lang}}

for param, _ in pairs (args_t) do

if not cfg.known_params_t.params_lang_t[param] and -- unique {{lang}} parameters

not cfg.known_params_t.common_params_all_t[param] then -- common to all

table.insert(ret, substitute (err_msg, {param}))

end

elseif cfg.templates_t.langx == template then -- for {{langx}}

for param, _ in pairs (args_t) do

not cfg.known_params_t.params_x_t[param] and -- common to {{langx}} and {{lang-xx}}

not cfg.known_params_t.common_params_all_t[param] then -- common to all

table.insert(ret, substitute (err_msg, {param}))

end

elseif cfg.templates_t.langxx == template then -- for {{lang-xx}}

for param, _ in pairs (args_t) do

if not cfg.known_params_t.params_lang_xx_t[param] and -- unique {{lang-xx}} parameters

not cfg.known_params_t.params_x_t[param] and -- common to {{langx}} and {{lang-xx}}

not cfg.known_params_t.common_params_all_t[param] then -- common to all

table.insert(ret, substitute (err_msg, {param}))

end

 

return table.concat(ret, '、')

 

 

--[[--------------------------< I S _ S E T >------------------------------------------------------------------

 

Returns true if argument is set; false otherwise. Argument is 'set' when it exists (not nil) or when it is not

 

]]

local function is_set (var)

return not (var == nil or var == '');

apostrophes are converted to their HTML numeric entity equivalent so that the new italic markup doesn't become

source = source:gsub ("%f[\']\'%f[^\']", '&#39;'); -- protect single quote marks from being interpreted as bold markup

if '' ~= seg[1] and '' ~= seg[3] then -- extract the 'text'

seg[1] = invert_pattern_table[seg[1]] or seg[1]; -- replace leading markup according to pattern table

seg[3] = invert_pattern_table[seg[3]] or seg[3]; -- replace leading markup according to pattern table

Validates |italic= or |italics= assigned values.

When |italic= is set and has an acceptable assigned value, return the matching CSS font-style property value or,

When |italic= is not set, or has an unacceptable assigned value, return nil and a nil error message.

defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-??}} depending on

the individual template's requirements, 'italic' for {{transliteration}}) or to the value appropriate to |script=, if set ({{lang}}

and {{lang-??}} only).

local function validate_italic (args)

local properties = {[cfg.keywords_t.affirmative] = 'italic', [cfg.keywords_t.negative] = 'normal', [cfg.keywords_t.unset] = 'inherit', [cfg.keywords_t.invert] = 'invert', [cfg.keywords_t.default] = nil};

 

for _, arg in pairs {'italic', 'italics', 'i'} do

if args[arg] then

 

 

 

 

 

values for |nocat= and only negative values for |cat=; in both cases the 'other' sense (and non-sense) is not accepted and the

 

Sets args.nocat to true if categorization is to be turned off; to nil if the default behavior should apply.

 

'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 not (args.nocat or args.cat) then -- both are nil, so categorize

return;

 

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)

args.nocat = nil;

Whether needle is in haystack.

local function in_array (needle, haystack)

for n,v in ipairs (haystack) do

Prettify IETF tags to use recommended subtag formats:

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

 

 

Extracts and returns IETF language tag parts:

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

lang-x-private

 

each of lang, script, region, variant, and private, when used, must be valid.

For {{lang-??}} templates, the parameters |script=, |region=, and |variant= are supported (not supported in {{lang}}

because those parameters are superfluous to the IETF subtags in |code=).

Returns six  values; all lower case.  Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid

See http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1.

local code, script, region, variant, private; -- IETF tag parts

return nil, nil, nil, nil, nil, cfg.get_ietf_parts_t.missing_lang_tag;

local override = { -- 簡寫轉換爲正確的語言標籤

 

source = override[source] or source

 

{'^(%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

end

 

return nil, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_tag, {source}); -- don't know what we got but it is malformed

 

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, substitute (cfg.get_ietf_parts_t.unrecog_code, {code}); -- invalid language code, don't know about the others (don't care?)

 

table.insert (maint_cats, substitute (cfg.get_ietf_parts_t.maint_promo_cat, {code}));

table.insert (maint_msgs, substitute (cfg.get_ietf_parts_t.maint_promo_msg, {code, synonym_table[code]}));

return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_scr; -- both code with script and |script= not allowed

end

if not script_table[script] then

return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_scr_code, {script, code}); -- language code OK, invalid script, don't know about the others (don't care?)

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

if in_array (code, suppressed_table[script]) then

return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.script_code, {script, code}); -- language code OK, script is suppressed for this code

return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_reg; -- both code with region and |region= not allowed

end

if not region_table[region] then

return code, script, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_reg_code, {region, code});

 

return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_var; -- both code with variant and |variant= not allowed

end

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

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var, {variant});

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

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_scr, {variant, code, script});

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, substitute (cfg.get_ietf_parts_t.unrecog_var_code_reg, {variant, code, region});

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

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

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code, {variant, code});

 

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, substitute (cfg.get_ietf_parts_t.unrecog_pri, {private});

--[[--------------------------< 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.

 

 

text = text:gsub('[^\n]+', '<p><i>%1</i></p>'); -- insert p and italic markup tags at each implied p (two or more consecutive '\n\n' sequences)

 

 

 

 

 

 

 

 

 

 

 

 

 

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

<i lang="es" title="Spanish language text">casa</i>

should be:

<span title="Spanish language text"><i lang="es">casa</i></span>

<div title="Spanish language text"><div lang="es"><spanish-language-text></div></div>

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

local html_t = {};

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

if 'span' == tag then -- default HTML tag for inline content

if 'italic' == style then -- but if italic

tag = 'i'; -- change to <i> tags

text = div_markup_add (text, style); -- handle implied <p>, implied <p> with <i>, and list markup (*;:#) with <i>

 

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

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

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

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

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

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

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

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

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

 

table.insert (html_t, table.concat ({'</', tag, '>'})); -- close the 'text' <i>, <span>, or <div> HTML tag

 

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

title_text = substitute ('$1$2', {language, cfg.make_text_html_t.zxx}); -- not a language so don't use 'language' in title text

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

title_text = substitute ('$1$2', {language, cfg.make_text_html_t.collective}); -- for collective languages

else

title_text = substitute ('$1$2', {language, cfg.make_text_html_t.individual}); -- for individual languages

end

 

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

return table.concat (html_t);

local noError, titleObject = pcall (mw.title.new, title)

if not noError then

return false

else

if titleObject then

end

For English:

For ISO 639-2 collective languages (and for 639-1 bh):

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

 

 

 

 

 

 

 

[[Category:含有非中文内容的条目]]

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

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

 

-- if mw.ustring.find (language_name, '语系', 1, true) then

-- return substitute ('[[$1 $2]]', {cfg.make_category_t.collective_cat, language_name});

-- end

 

if this_wiki_lang_tag == code and language_name == '中文' then -- 名稱必須是「中文」

return substitute ('[[$1$2$3$4]]', { -- unique category name for the local language

});

elseif (page_exists (substitute ('$1$2$3', {

cfg.make_category_t.cat_postfix,

}))) then

return substitute ('[[$1$2$3]]', { -- category for individual languages

});

return substitute ('[[$1$2$3]]', { -- 非中文内容

cfg.make_category_t.cat_nonezh,

cfg.make_category_t.cat_postfix,

});

Return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string.

The value |script= is not used in {{transliteration}} for this purpose; instead it uses |code.  Because language scripts

are listed in the {{transliteration}} switches they are included in the data tables.  The script parameter is introduced

to be |translit-script= (in this function, tscript).

For {{transliteration}}, style only applies when a language code is provided.

 

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

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

 

 

title_text = language_name; -- write a generic tool tip

title_text = substitute ('$1$2', {title_text, cfg.lang_xx_t.romanization}); -- 中文版添加

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

-- title_text = substitute ('$1-$2', {title_text, cfg.misc_text_t.language}); -- skip this text (individual and macro languages only)

-- end

-- title_text = substitute ('$1 $2', {title_text, mw.ustring.lower (cfg.engvar_t[engvar]['romanisz_lc'])}); -- finish the tool tip; use romanization when neither script nor standard supplied

 

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

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

if script_table[tscript] then

title_text = substitute ('$1$2（$3）$4', { -- add the appropriate text to the tool tip

title_t[std][tscript:lower()],

script_table[tscript],

cfg.make_translit_t.transliteration,

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

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

return translit

if not title_t[std] then

return translit

end

 

if title_t[std][code] then -- if language code is in the table (transl may not provide a language code)

title_text = substitute ('$1$2（$3）$4', { -- add the appropriate text to the tool tip

title_t[std][code:lower()],

language_name,

cfg.make_translit_t.transliteration,

});

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

if title_t['no_std'][tscript] then

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

elseif title_t['no_std'][code] then

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

title_text = substitute ('$1$2-$3$4', { -- write a script tool tip

language_name,

cfg.make_translit_t.script,

cfg.make_translit_t.transliteration,

});

-- 中文版不需要

-- elseif is_set (code) then

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

-- title_text = substitute ('$1-$2', { -- skip this text (individual and macro languages only)

-- end

-- title_text = substitute ('$1 $2', { -- finish the tool tip

title_text = substitute ('$1$2', { -- generic tool tip (can we ever get here?)

local tag

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

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

tag = string.format(tag, code, "%s")

tag = '<span>%s</span>' -- when no language code: no lang= attribute, not italic ({{transliteration}} only)

 

tag = string.format(tag, translit) -- add the translit text

return tag; -- done

return title_wrapper_make (title_text, tag, 'span'); -- wrap with a tool-tip span and done

--[[--------------------------< V A L I D A T E _ T E X T >----------------------------------------------------

error message. The tests are for empty or missing text and for improper or disallowed use of apostrophe markup.

either as ''itself'' or as '''''bold italic''''' unless |italic=unset or |italic=invert.

]]

make_error_msg (cfg.validate_text_t.no_text, args, template)

make_error_msg (cfg.validate_text_t.malformed_markup, args, template)

local style = args.italic or args.italics or args.i;

-- 中文版修改：|italic=no 和未指定 |italic= 時不檢查斜體標記

if style and (cfg.keywords_t.unset ~= style) and (cfg.keywords_t.negative ~= style) and (cfg.keywords_t.invert ~= style) then

make_error_msg (cfg.validate_text_t.italic_markup, args, template)

Render mainenance messages and categories.

local function render_maint (nocat)

 

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 ({msg, ''})); -- add message strings

 

if (0 < #maint_cats) and (0 == namespace) and not nocat then -- when there are maintenance categories; article namespace only

 

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

do nothing.