lang

--[=[  Lua support for the {{lang}}, {{lang-xx}}, and {{transl}} 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 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   --[[--------------------------< 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 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's defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-xx}} depending on the individual template's requirements, 'italic' for {{transl}}) or to the value appropriate to |script=, if set ({{lang}} and {{lang-xx}} 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 = {['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, 'only one of |italic=, |italics=, or |i= can be specified'; 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  ]=]  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 langlang-variant lang-scriptlang-script-variant lang-regionlang-region-variant lang-script-regionlang-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-xx}} 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, 'missing language tag'; 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 ({'unrecognized language 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, table.concat ({'unrecognized language 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, table.concat ({'Lang and lang-xx code promoted to ISO 639-1|', code})); table.insert (maint_msgs, table.concat ({'code: ', code, ' promoted to 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, 'redundant script tag';-- 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, table.concat ({'unrecognized script: ', script, ' for code: ', 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, table.concat ({'script: ', script, ' not supported for code: ', 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, 'redundant region tag';-- 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, table.concat ({'unrecognized region: ', region, ' for code: ', code}); end end  if is_set (variant) then if is_set (args_variant) then return code, nil, nil, nil, nil, 'redundant variant tag';-- 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, table.concat ({'unrecognized variant: ', 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, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', 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 ({'unrecognized variant: ', variant, ' for code-region pair: ', 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, table.concat ({'unrecognized variant: ', variant, ' for code: ', 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, table.concat ({'unrecognized private tag: ', 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 _ 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, template) local out = {}; local category;  if 'Transl' == template then category = 'Transl'; else category = 'Lang and lang-xx' end  table.insert (out, table.concat ({'[', args.text or 'undefined', '] '}));-- for error messages output args.text if available table.insert (out, table.concat ({'\"color:#d33\">Error: {{', template, '}}: '})); table.insert (out, msg); table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'})); table.insert (out, '');  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, ' template errors]]'})); end  return table.concat (out); 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 [[L|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 ({'[[', link, '|', 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) 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 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