Module:Lang#L-94--L-135

--[=[

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 lang_data = mw.loadData ('Module:Lang/data'); -- language name override and transliteration tool-tip tables

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

local lang_table = lang_data.lang_name_table.lang;

local lang_dep_table = lang_data.lang_name_table.lang_dep;

local script_table = lang_data.lang_name_table.script;

local region_table = lang_data.lang_name_table.region;

local variant_table = lang_data.lang_name_table.variant;

local suppressed_table = lang_data.lang_name_table.suppressed;

local override_table = lang_data.override;

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

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

local is_latn_data = mw.loadData ('Module:Lang/data/is latn data');

local sizeof_ranges_t = is_latn_data.sizeof_ranges_t;

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

local content_lang = mw.language.getContentLanguage();

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

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

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

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

local maint_msgs = {}; -- and their messages go here

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

]]

local function make_error_span (template, msg)

return table.concat ({'', cfg.misc_text_t.error, ': ', template, msg, ''})

end

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

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

not nil; returns else.

]]

local function substitute (message, data_t)

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

end

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

local category;

local text; -- handle the oddity that is {{langx}}

if cfg.templates_t.langxx == template then

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

else

text = args_t.text or args_t[2]; -- for {{lang}}, {{langx}}, and {{transliteration}}

end

if cfg.templates_t.transliteration == template then

category = cfg.make_error_msg_t.xlit_err_cat;

else

category = cfg.make_error_msg_t.lang_err_cat;

end

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

return substitute ('[$1] $2: {{$3}}: $4 ($6)$7', -- { prevents template name from being treated as a template call in certain situations

{

text or cfg.make_error_msg_t.undefined,

cfg.misc_text_t.error,

template,

msg,

category,

cfg.misc_text_t.help,

category_link

})

end

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

]]

local function parameter_validate (args_t, template)

local err_msg = cfg.parameter_validate_t.invalid_param;

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

return substitute (err_msg, {param}); -- not found so abandon

end

end

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

for param, _ in pairs (args_t) do

if not cfg.known_params_t.params_langx_t[param] and -- unique {{langx}} 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

return substitute (err_msg, {param}); -- not found so abandon

end

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

return substitute (err_msg, {param}); -- not found so abandon

end

end

end

end

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

an empty string.

]]

local function is_set (var)

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

end

--[[--------------------------< I N V E R T _ I T A L I C S >-------------------------------------------------

This function attempts to invert the italic markup a args.text by adding/removing leading/trailing italic markup

in args.text. Like |italic=unset, |italic=invert disables automatic italic markup. Individual leading/trailing

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

bold markup inadvertently.

Leading and trailing wiki markup is extracted from args.text into separate table elements. Addition, removal,

replacement of wiki markup is handled by a string.gsub() replacement table operating only on these separate elements.

In the string.gsub() matching pattern, '.*' matches empty string as well as the three expected wiki markup patterns.

This function expects that markup in args.text is complete and correct; if it is not, oddness may result.

]]

local function invert_italics (source)

local invert_pattern_table = { -- leading/trailing markup add/remove/replace patterns

[""]="\'\'", -- empty string becomes italic markup

["\'\'"]="", -- italic markup becomes empty string

["\'\'\'"]="\'\'\'\'\'", -- bold becomes bold italic

["\'\'\'\'\'"]="\'\'\'", -- bold italic become bold

};

local seg = {};

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[3] = source:match ('.+(%f[\']\'\'+)$') or ''; -- get trailing markup, if any; ignore single quote

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

seg[2] = source:match ('^\'\'+%f[^\'](.+)%f[\']\'\'+$') -- from between leading and trailing markup

elseif '' ~= seg[1] then

seg[2] = source:match ('^\'\'+%f[^\'](.+)') -- following leading markup

elseif '' ~= seg[3] then

seg[2] = source:match ('(.+)%f[\']\'\'+$') -- preceding trailing markup

else

seg[2] = source -- when there is no markup

end

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

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

end

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

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,

for the special case 'default', return nil.

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

When both |italic= and |italics= are set, returns nil and a 'conflicting' error message.

The return value nil causes the calling lang, lang_xx, or xlit function to set args.italic according to the template's

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

Accepted values and the values that this function returns are are:

nil - when |italic= absent or not set; returns nil

default - for completeness, should rarely if ever be used; returns nil

yes - force args.text to be rendered in italic font; returns 'italic'

no - force args.text to be rendered in normal font; returns 'normal'

unset - disables font control so that font-style applied to text is dictated by markup inside or outside the template; returns 'inherit'

invert - disables font control so that font-style applied to text is dictated by markup outside or inverted inside the template; returns 'invert'

]]

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};

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, cfg.validate_italic_t.multi_italic;

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-??}} templates is to add categorization when the templates are used in main space.

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

]=]

local function validate_cat_args (args)

if not (args.nocat or args.cat) then -- both are nil, so categorize

return;

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

--[[--------------------------< I N _ A R R A Y >--------------------------------------------------------------

Whether needle is in haystack.

]]

local function in_array (needle, haystack)

if needle == nil then

return false;

end

for n,v in ipairs (haystack) do

if v == needle then

return n;

end

end

return false;

end

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

Prettify IETF tags to use recommended subtag formats:

code: lower case

script: sentence case

region: upper case

variant: lower case

private: lower case prefixed with -x-

]]

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

local out = {};

if is_set (private) then

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

end

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

if is_set (script) then

script = script:lower():gsub ('^%a', string.upper);

table.insert (out, script);

end

if is_set (region) then

table.insert (out, region:upper());

end

if is_set (variant) then

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

end

return table.concat (out, '-');

end

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

Extracts and returns IETF language tag parts:

primary language subtag (required) - 2 or 3 character IANA language code

script subtag - four character IANA script code

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

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

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

in any one of these forms

lang lang-variant

lang-script lang-script-variant

lang-region lang-region-variant

lang-script-region lang-script-region-variant

lang-x-private

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

Languages with both two- and three-character code synonyms are promoted to the two-character synonym because

the IANA registry file omits the synonymous three-character code; we cannot depend on browsers understanding

the synonymous three-character codes in the lang= attribute.

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

parts are returned as nil; the sixth returned item is an error message (if an error detected) or nil.

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

]]

local function get_ietf_parts (source, args_script, args_region, args_variant)

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

if not is_set (source) then

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

end

local pattern = { -- table of tables holding acceptable 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, substitute (cfg.get_ietf_parts_t.unrecog_tag, {source}); -- don't know what we got but it is malformed

end

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

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

end

if synonym_table[code] then -- if 639-2/639-2T code has a 639-1 synonym

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]}));

code = synonym_table[code]; -- use the synonym

end

if is_set (script) then

if is_set (args_script) then

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

end

else

script = args_script or ''; -- use args.script if provided

end

if is_set (script) then

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

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

end

end

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

end

end

if is_set (region) then

if is_set (args_region) then

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

end

else

region = args_region or ''; -- use args.region if provided

end

if is_set (region) then

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

if not region_table[region] then

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

end

end

if is_set (variant) then

if is_set (args_variant) then

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

end

else

variant = args_variant or ''; -- use args.variant if provided

end

if is_set (variant) then

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

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});

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

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

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

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

end

end

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

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

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

end

end

end

if is_set (private) then

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

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});

end

end

return code, script, region, variant, private, nil; -- return the good bits; make sure that msg is nil

end

--[=[-------------------------< M A K E _ W I K I L I N K >----------------------------------------------------

Makes a wikilink; when both link and display text is provided, returns a wikilink in the form D; if only

link is provided, returns a wikilink in the form L; if neither are provided or link is omitted, returns an

empty string.

]=]

local function make_wikilink (link, display)

if is_set (link) then

if is_set (display) then

return table.concat ({'', display, ''});

else

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

end

else

return '';

end

end

--[[--------------------------< D I V _ M A R K U P _ A D D >--------------------------------------------------

Adds and tags to list-item text or to implied

..

text. Mixed not supported.

]]

local function div_markup_add (text, style)

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

if 'italic' == style then

return text:gsub ('(\n[%*:;#]+)([^\n]+)', '%1%2'); -- 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]+', '

%1

'); -- insert p and italic markup tags at each implied p (two or more consecutive '\n\n' sequences)

else

text = text:gsub ('[^\n]+', '

%1

'); -- insert p markup at each implied p

text = text:gsub ('\n', ''); -- strip newline characters

end

end

return text;

end

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

Makes a or

where