Module:Lang Explained

--[=[ 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_rtllocal yesno = require ('Module:Yesno');

local lang_data = mw.loadData ('Module:Lang/data'); -- language name override and transliteration tool-tip tableslocal lang_name_table = lang_data.lang_name_table; -- language codes, names, regions, scripts, suppressed scriptslocal 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 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 taglocal 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 herelocal 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 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 if cfg.templates_t.langxx

template then text = args_t.text or args_t[1]; -- for else text = args_t.text or args_t[2]; -- for , , and 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 ('',) or ; return substitute ('[$1]

$2: : $4 ($6)$7', )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 for param, _ in pairs (args_t) do if not cfg.known_params_t.params_lang_t[param] and -- unique parameters not cfg.known_params_t.common_params_all_t[param] then -- common to all return substitute (err_msg,); -- not found so abandon end end elseif cfg.templates_t.langx

template then -- for for param, _ in pairs (args_t) do if not cfg.known_params_t.params_langx_t[param] and -- unique parameters not cfg.known_params_t.params_x_t[param] and -- common to and not cfg.known_params_t.common_params_all_t[param] then -- common to all return substitute (err_msg,); -- not found so abandon end end elseif cfg.templates_t.langxx

template then -- for for param, _ in pairs (args_t) do if not cfg.known_params_t.params_lang_xx_t[param] and -- unique parameters not cfg.known_params_t.params_x_t[param] and -- common to and not cfg.known_params_t.common_params_all_t[param] then -- common to all return substitute (err_msg,); -- 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 notan empty string.

local function is_set (var) return not (var

nil or var

);end

--italic=unset, |italic=invert disables automatic italic markup. Individual leading/trailingapostrophes are converted to their html numeric entity equivalent so that the new italic markup doesn't becomebold 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 = ; 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 doneend

--italic= or |italics= assigned values.

When |italic= is set and has an acceptible 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 unacceptible 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 transl function to set args.italic according to the template'sdefined default ('inherit' for , 'inherit' or 'italic' for depending onthe individual template's requirements, 'italic' for) or to the value appropriate to |script=, if set (and 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 = ; local count = 0 for _, arg in pairs 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 messageend

--[=[--------------------------< 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 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 elsefor |cat= 'no', 'n', 'false', 'f', 'off', '0' -- 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; endend

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

--

local function format_ietf_tag (code, script, region, variant, private) local out = ;

if is_set (private) then return table.concat ('-'); -- 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

--script=, |region=, and |variant= are supported (not supported in 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, invalidparts 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 =

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 = ; 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,); -- 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,); -- 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,)); table.insert (maint_msgs, substitute (cfg.get_ietf_parts_t.maint_promo_msg,)); 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,); -- 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,); -- 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,); 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,); 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, variant_table[variant]['prefixes']) then return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_scr,); 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, 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,); 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,); 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,); end end return code, script, region, variant, private, nil; -- return the good bits; make sure that msg is nilend

--[=[-------------------------< 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 [[L|D]]; if onlylink is provided, returns a wikilink in the form L; if neither are provided or link is omitted, returns anempty string.

]=]

local function make_wikilink (link, display) if is_set (link) then if is_set (display) then return table.concat ; else return table.concat ; end else return ; endend

----------------------------< 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 impled p (two or more consecutive '\n\n' sequences) else text = text:gsub ('[^\n]+', '

%1

'); -- insert p markup at each impled 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