14.457
edits
Changes
Jump to navigation
Jump to search
Sətir 1:
Sətir 1: − --[=[+ − Lua support for the {{lang}}, {{lang-xx}}, and {{transl}} templates and replacement of various supporting templates. + + − ]=]+ − + − require('Module:No globals');+ − + − 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 this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language − − 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. − − ]] − − − − [""]="\'\'", -- 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 − − 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 − + − 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 − + − + − return nil, 'only one of |italic=, |italics=, or |i= can be specified'; − + − − + − --[=[--------------------------< 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; − + − --[[--------------------------< I N _ A R R A Y >--------------------------------------------------------------+ − + − Whether needle is in haystack+ − + − ]]+ − + − − if needle == nil then − return false; − end − for n,v in ipairs( haystack ) do − if v == needle then − return n; − end − 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) − − − 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, '-'); − + − + − 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-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 code, script, region, variant, private; -- ietf tag parts − − − − + − + − {'^(%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]) − − 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 + − − 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+ + + − 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 − + − + − 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 − + − + − + − + + − 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 − if 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 − − 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 − + − + − assembles an error message from template name, message text, help link, and error category.+ − + − ]]+ − + − + − + − + − + − + − category = 'Transl';+ − else − category = 'Lang and lang-xx' + + + − table.insert (out, table.concat ({'[', args.text or 'undefined', '] '})); -- for error messages output args.text if available + − table.insert (out, table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: {{', template, '}}: '})); + − table.insert (out, msg);+ − table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'}));+ − table.insert (out, '</span>');+ − − 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]]'})); − + − return table.concat (out); − end − + − + − + − 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 − − − + − else − return ''; − end+ − + − + − --[[--------------------------< 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 − + − + − text = text:gsub ('([^\n])\n([^\n])', '%1 %2'); -- replace single newline characters with a space character which mimics mediawiki + − + − + − 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 + + + + + + + + + − + − 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 make_text_html (code, text, tag, rtl, style, size, language) − local html = {}; − local style_added = ''; − − if text:match ('^%*') then − 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 − + − + − + + + + + + + + + + + + + + + + + + + + + − 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 − − table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag − 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 − − if 'normal' == style then -- when |italic=no − table.insert (html, ' style=\"font-style: normal;'); -- override external markup, if any − style_added = '\"'; -- remember that style attribute added and is not yet closed − end − if is_set (size) then -- when |size=<something> − if is_set (style_added) then − table.insert (html, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted − else − table.insert (html, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute − style_added = '\"'; -- remember that style attribute added and is not yet closed − end − + − table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text + − + − table.insert (html, ' collective text'); -- for collective languages + − else+ − table.insert (html, ' language text'); -- for individual languages − table.insert (html, '\">'); -- close the opening html tag + − else − table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag − 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 − end − + + − --[=[-------------------------< M A K E _ C A T E G O R Y >---------------------------------------------------- − For individual language, <language>, returns:+ − [[Category:Articles containing <language>-language text]]+ − + − for English:+ − [[Category:Articles containing explicitly cited English-language text]]+ − + − for ISO 639-2 collective languages (and for 639-1 bh):+ − + − + − ]=]+ − + − + − + − + − + − + − return ''; -- return empty string for concatenation + + + + + + + + + − + − + − return table.concat ({'[[Category:Articles with text in ', language_name, ']]'}); + − end − − table.insert (cat, '[[Category:Articles containing '); − − if 'en' == code then − table.insert (cat, 'explicitly cited ' .. language_name); -- falls back to English if regional name not available − table.insert (cat, language_name); + + + + + + + + + + − table.insert (cat, '-language text]]');+ − − − + − + − + − return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string+ − + − The value |script= is not used in {{transl}} for this purpose; instead it uses |code. Because language scripts+ − are listed in the {{transl}} switches they are included in the data tables. The script parameter is introduced+ − at {{Language with name and transliteration}}. If |script= is set, this function uses it in preference to code.+ − + − To avoid confusion, in this module and the templates that use it, the transliteration script parameter is renamed+ − to be |translit-script= (in this function, tscript)+ − + − This function is used by both lang_xx() and transl() − lang_xx() always provides code, language_name, and translit; may provide tscript; never provides style − transl() always provides language_name, translit, and one of code or tscript, never both; always provides style − − For {{transl}}, style only applies when a language code is provided − ]] − − − local title; − local tout = {}; − local title_table = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards − + − if not style then -- nil for the default italic style + − table.insert (tout, "<i lang=\""); -- so use <i> tag+ − else + − table.insert (tout, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it − table.insert (tout, code); − table.insert (tout, "-Latn\" title=\""); -- transliterations are always Latin script − else − table.insert (tout, "<span title=\""); -- when no language code: no lang= attribute, not italic ({{transl}} only) − + − std = std and std:lower(); -- lower case for table indexing+ − + − 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') -- skip this text (individual and macro languages only) + + − table.insert (tout, ' romanization'); -- 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+ − if title_table[std] then -- and if 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()], ' (', script_table[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip − 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? − end − return ''; -- invalid standard, setup for error message + − end+ − + − elseif is_set (std) then -- translit-script not set, use language code − if not title_table[std] then return ''; end -- invalid standard, setup for error message − − 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, ' language) transliteration'})); -- add the appropriate text to the tool tip − else -- code doesn't match − − end − else -- here if translit-script set but translit-std not set − if title_table['no_std'][tscript] then − table.insert (tout, title_table['no_std'][tscript]); -- use translit-script if set − elseif title_table['no_std'][code] then − table.insert (tout, title_table['no_std'][code]); -- use language code − else − if is_set (tscript) then − table.insert (tout, table.concat ({language_name, '-script transliteration'})); -- write a script tool tip − elseif is_set (code) then − 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 − table.insert (tout, ' transliteration'); -- finish the tool tip − else − table.insert (tout, ' transliteration'); -- generic tool tip (can we ever get here?) − end − end − end − − table.insert (tout, '">'); − table.insert (tout, translit); − 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, "</i>"); -- close the italic tag − else − table.insert (tout, "</span>"); -- no language code so close the span tag − end − return table.concat (tout); − end − − − --[[--------------------------< 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 − error message. The tests are for empty or missing text and for improper or disallowed use of apostrophe markup. − − Italic rendering is controlled by the |italic= template parameter so italic markup should never appear in args.text − either as ''itself'' or as '''''bold italic''''' unless |italic=unset or |italic=invert. − − ]] − − local function validate_text (template, args) − if not is_set (args.text) then − return make_error_msg ('no text', args, template); − end − − if args.text:find ("%f[\']\'\'\'\'%f[^\']") or args.text:find ("\'\'\'\'\'[\']+") then -- because we're looking, look for 4 appostrophes or 6+ appostrophes − return make_error_msg ('text has malformed markup', args, template); − end − − local style = args.italic; − − 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 − return make_error_msg ('text has italic markup', args, template); − end+ − end+ − + − − --[[--------------------------< R E N D E R _ M A I N T >------------------------------------------------------ − − render mainenance messages and categories − − ]] − − local function render_maint(nocat) − local maint = {}; − 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+ − for _, msg in ipairs (maint_msgs) do+ − table.insert (maint, table.concat ({msg, ' '})); -- add message strings+ − end − table.insert (maint, '</span>'); -- close the span + − 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 + − table.insert (maint, table.concat ({'[[Category:', cat, ']]'})); -- format and add the categories+ − end+ − end+ − + − + + + + + + + + + + + + + − 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+ + + + − 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, proto_param) − − 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 − − 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)+ − − + − + − + − 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) − − − 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 − + − + + + + + − --[[--------------------------< 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 − − 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 + + + + + + + + + + + − --[[--------------------------< 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+ − + − ]]+ − + − + − 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 and lang-xx using deprecated ISO 639 codes|', code})); − table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'})); − end − − return name; -- name from data tables or nil − 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 (args) − local out = {}; − 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 code; -- the language code − 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 − return make_error_msg ('conflicting: {{{1}}} and |code=', args, template); − else − args.code = args[1] or args.code; -- prefer args.code − end − − if args[2] and args.text then − return make_error_msg ('conflicting: {{{2}}} and |text=', args, template); − else − args.text = args[2] or args.text; -- prefer args.text − end − − msg = validate_text (template, args); -- ensure that |text= is set − if is_set (msg) then -- msg is an already-formatted error message − return msg; − 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.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 ({'invalid |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}}) − − if msg then − return make_error_msg ( msg, args, template); − end − − args.italic, msg = validate_italic (args); − if msg then − 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 = 'italic'; -- 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 + + + − if is_set (subtags.script) then -- if script set, override rtl setting + − if in_array (subtags.script, lang_data.rtl_scripts) then − args.rtl = true; -- script is an rtl script − else − args.rtl = false; -- script is not an rtl script − 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 − − if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content − args.text = invert_italics (args.text) − end − − args.text = proto_prefix (args.text, language_name, args.proto); -- prefix proto-language text with a splat − − 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, render_maint(args.nocat)); -- maintenance messages and categories − − return table.concat (out); -- put it all together and done − + − --[[--------------------------< 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 − return nil; -- value was empty or contained only whitespace − end -- end of valueFunc − }); − − return _lang (args); − end − − − --[[--------------------------< L A N G _ X X >---------------------------------------------------------------- − − For the {{lang-xx}} templates, the only parameter required to be set in the template is the language code. All − other parameters can, usually should, be written in the template call. For {{lang-xx}} templates for languages − 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 knows the default − styling that should be applied to text. − − For normal, upright style: − <includeonly>{{#invoke:lang|lang_xx_inherit|code=xx}}</includeonly> − For italic style: − <includeonly>{{#invoke:lang|lang_xx_italic|code=xx}}</includeonly> − − All other parameters should be received from the template's frame (parent frame) − − Supported parameters are: − |code = (required) the IANA language code − |script = IANA script code; especially for use with languages that use multiple writing systems − |region = IANA region code − |variant = IANA variant code − |text = (required) the displayed text in language specified by code − |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 − |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 − |lit = text that is a literal translation of text − |label = 'none' to suppress all labeling (language name, 'translit.', 'lit.') − any other text replaces language-name label - automatic wikilinking disabled − − 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-std = the standard that applies to the transliteration − |translit-script = ISO 15924 script name; falls back to code − − For {{lang-xx}}, the positional parameters are: − {{{1}}} text − {{{2}}} transliterated text − {{{3}}} literal translation text − no other positional parameters are allowed − − ]] − − local function _lang_xx (args) − local out = {}; − local language_name; -- used to make display text, article links − 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, and variant − local code; -- the language code − − local translit_script_name; -- name associated with IANA (ISO 15924) script code − local translit; − local translit_title; − 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 − return make_error_msg ('conflicting: {{{1}}} and |text=', args, template); − else − args.text = args[1] or args.text; -- prefer args.text − end − − 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 − return msg; − 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 − return make_error_msg ('conflicting: {{{2}}} and |translit=', args, template); − else − args.translit = args[2] or args.translit -- prefer args.translit − end − − if args[3] and (args.translation or args.lit) then − return make_error_msg ('conflicting: {{{3}}} and |lit= or |translation=', args, template); − elseif args.translation and args.lit then − return make_error_msg ('conflicting: |lit= and |translation=', args, template); − else − args.translation = args[3] or args.translation or args.lit; -- prefer args.translation − end − − if args.links and args.link then − return make_error_msg ('conflicting: |links= and |link=', args, template); − else − args.link = args.link or args.links; -- prefer args.link − end − − validate_cat_args (args); -- determine if categorization should be suppressed − − args.rtl = args.rtl == 'yes'; -- convert to boolean: 'yes' -> true, other values -> false − − code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (args.code, args.script, args.region, args.variant); -- private omitted because private − − if msg then -- if an error detected then there is an error message − return make_error_msg (msg, args, template); − end − − args.italic, msg = validate_italic (args); − if msg then − return make_error_msg (msg, args, template); − end − − if nil == args.italic then -- args.italic controls − if is_set (subtags.script) then − if 'latn' == subtags.script then − args.italic = 'italic'; -- |script=Latn; set for font-style:italic − else − args.italic = initial_style_state; -- italic not set; script is not latn; set for font-style:<initial_style_state> − end − else − args.italic = initial_style_state; -- here when |italic= and |script= not set; set for font-style:<initial_style_state> − + − if is_set (subtags.script) then -- if script set override rtl setting+ − if in_array (subtags.script, lang_data.rtl_scripts) then + − args.rtl = true; -- script is an rtl script+ − else+ − args.rtl = false; -- script is not an rtl script − end − end − − 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 ({'invalid |proto=: ', args.proto}), args, template); − 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) − language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them − − if args.label then − if 'none' ~= args.label then − table.insert (out, table.concat ({args.label, ': '})); -- custom label − end − else − if 'no' == args.link then − table.insert (out, language_name); -- language name without wikilink − if language_name:find ('languages') then + − table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink − elseif 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', language_name)); -- language name with wikilink − end − + − end − − if 'invert' == args.italic then − args.text = invert_italics (args.text) + − args.text = proto_prefix (args.text, language_name, args.proto); -- prefix proto-language text with a splat + − + − table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, nil)) − 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+ − if 'none' ~= args.label then+ − table.insert (out, '<small>');+ − if script_table[args['translit-script']] then -- when |translit-script= is set, try to use the script's name+ − translit_script_name = script_table[args['translit-script'][1]];+ − else+ − translit_script_name = language_name; -- fall back on language name+ − end+ − translit_title = mw.title.makeTitle (0, table.concat ({'Romanization of ', translit_script_name})); -- make a title object − if translit_title.exists and ('no' ~= args.link) then − table.insert (out, make_wikilink ('Romanization of ' .. translit_script_name or language_name, 'romanized') .. ':'); -- make a wikilink if there is an article to link to − else − table.insert (out, 'romanized:'); -- else plain text − end − table.insert (out, ' </small>'); -- close the small tag − end − − translit = make_translit (args.code, language_name, args.translit, args['translit-std'], args['translit-script']) − if is_set (translit) then − table.insert (out, translit); − else − return make_error_msg (table.concat ({'invalid translit-std: \'', args['translit-std'] or '[missing]'}), args, template); + − if is_set (args.translation) then -- translation (not supported in {{lang}})+ − table.insert (out, ', '); − if 'none' ~= args.label then − table.insert (out, '<small>'); − if 'no' == args.link then − table.insert (out, '<abbr title="literal translation">lit.</abbr>'); − else − table.insert (out, make_wikilink ('Literal translation', 'lit.')); − end − table.insert (out, " </small>"); − end − table.insert (out, table.concat ({''', args.translation, '''})); -- use html entities to avoid wiki markup confusion − end − − table.insert (out, make_category (code, category_name, args.nocat)); − table.insert (out, render_maint(args.nocat)); -- maintenance messages and categories − − − 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 − − − --[[--------------------------< L A N G _ X X _ I T A L I C >-------------------------------------------------- − − Entry point for those {{lang-xx}} templates that call lang_xx_italic(). Sets the initial style state to italic. − − ]] − − local function lang_xx_italic (frame) − local args = lang_xx_args_get (frame); − − initial_style_state = 'italic'; − 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 − − − --[[--------------------------< L A N G _ X X _ I N H E R I T >------------------------------------------------ − − Entry point for those {{lang-xx}} templates that call lang_xx_inherit(). Sets the initial style state to inherit. − − ]] − − 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'; − 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 − + − --[[--------------------------< 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; getArgs() so we also get parent frame − end − − − --[[--------------------------< _ N A M E _ F R O M _ T A G >-------------------------------------------------- − − 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. − − Set invoke's |link= parameter to yes to get wikilinked version of the language name. − − Module entry point from another module − − ]] − − local function _name_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 language_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\">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 − 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 link then -- when |link=yes, wikilink the language name − if language_name:find ('languages') then − language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink − elseif 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 .. ' language', label or language_name); -- language name with wikilink − end − end − − return language_name; − end
Nəzərə çarpan dəyişiklik yoxdur.
local Langue = { }
local dataLangue = mw.loadData 'Module:Dil/Data'
local langErrorMess = '<span class="error">langue non reconnue : %s</span>'
-- premierParametre renvoie le premier paramètre de Frame, que celui-ci ait été passé au module par invoke, directement au modèle,
-- ou à l'intérieur d'un module sous forme de string dans un tableau ou directement de string.
-- Si aucun de ces arguments ne contient de chaine, la fonction renvoie nil.
-- Si le deuxième paramètre est true, la chaine est renvoyée trimée et en minuscules.
local function premierParametre( frame, lowerCase )
local arg
if type( frame ) == 'table' then
arg = ( frame.getParent and ( frame.args[1] or frame:getParent().args[1] ) ) or frame[1]
elseif type( frame ) == 'string' then
arg = frame
local function invert_italics (source)
local invert_pattern_table = { -- leading/trailing markup add/remove/replace patterns
elseif '' ~= seg[1] then
end
end
if type( arg ) ~= 'string' then
arg = nil
end
end
if arg and lowerCase then
if count > 1 then -- return nil and an error message if more than one is set
arg = mw.ustring.lower( mw.text.trim( arg ) )
end
end
return arg
return properties[args.italic or args.italics or args.i], nil; -- return an appropriate value and a nil error message
end
end
-- determinationCode retourne une table contenant le code de langue principal et la liste des subcode
-- si le code de langue principal n'est pas reconnu, retourne nil.
function Langue.determinationCode( langue )
if type( langue ) == 'string' and langue ~= '' then
local tabCode = mw.text.split( langue, '-' )
local tabLangue = dataLangue[ mw.ustring.lower( tabCode[1] ) ]
if tabLangue and tabLangue.code then
tabCode[1] = tabLangue.code
if tabLangue.invalide then
tabCode.invalide=true
end
return tabCode
end
]=]
end
end
end
end
-- Voir Modèle:Code langue
-- Paramètre :
-- 1 : nom de langue.
function Langue.codeLangue( frame )
local arg = premierParametre( frame, true )
local tabCode = Langue.determinationCode( arg )
return ( tabCode and table.concat( tabCode, '-' ) ) or arg or ''
local function in_array ( needle, haystack )
return false;
end
end
-- Voir Modèle:Code langue 2
-- Paramètre :
-- 1 : nom de langue.
function Langue.codeLangue2( frame )
local arg = premierParametre( frame, true )
local tabCode = Langue.determinationCode( arg )
return ( tabCode and table.concat( tabCode, '-' ) ) or ''
local out = {};
end
end
--[[--------------------------< G E T _ I E T F _ P A R T S >--------------------------------------------------
-- Voir Modèle:Direction langue
-- Paramètre :
-- 1 : nom de langue ou code IETF.
function Langue.directionLangue( frame )
local arg = premierParametre( frame, true )
if type( arg ) ~= 'string' or arg == '' then
return 'ltr'
local function get_ietf_parts (source, args_script, args_region, args_variant)
if not is_set (source) then
return nil, nil, nil, nil, nil, 'missing language tag';
end
end
-- séparation du code de langue en code principal et les différents subcode.
local pattern = { -- table of tables holding acceptibe ietf tag patterns and short names of the ietf part captured by the pattern
local tabCode = Langue.determinationCode( arg )
if tabCode then
-- on essaye de savoir si la direction est de droite à gauche
local codeScript = tabCode[2]
if codeScript and string.len( codeScript ) == 4 and dataLangue[ 'rtl script' ] then
-- il y a un subcode d'écritrure, c'est lui qui est pris en compte
codeScript = string.upper( string.sub( codeScript, 1, 1 ) ) .. string.sub( codeScript, 2 )
if dataLangue[ 'rtl script' ][ codeScript ] then
return 'rtl'
end
else
-- il n'y a pas de sub-code d'écriture, on prend en compte le code de langue principal.
local tabLangue = dataLangue[ tabCode[1] ]
if tabLangue and tabLangue.rtl then
return 'rtl'
if c1 then -- c1 always set on match
end
end
end
end
end
-- la langue n'est pas écrite de droite à gauche, donc ltr.
return 'ltr'
end
-- Voir Modèle:Nom langue
-- Paramètre :
-- 1 : code IETF de langue.
function Langue.nomLangue( frame )
local arg = premierParametre( frame, true )
if type( arg ) ~= 'string' or arg == '' then
return '<span class="error">langue non précisée</span>'
end
end
local tabLangue = dataLangue[ arg ]
if tabLangue == nil then
tabLangue = dataLangue[ mw.ustring.match( arg, '^(%a-)%-' ) ]
end
end
if not tabLangue then
if is_set (region) then
return string.format( langErrorMess, arg )
end
end
if type( tabLangue.page ) == 'string' then
if is_set (variant) then
if tabLangue.page ~= '' then
if is_set (args_variant) then
return '[[' .. tabLangue.page .. '|' .. tabLangue.nom .. ']]'
return code, nil, nil, nil, nil, 'redundant variant tag'; -- both code with variant and |variant= not allowed
else
return tabLangue.nom
end
end
else
else
return '[[' .. tabLangue.nom .. ']]'
end
end
end
end
--[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------
-- Voir Modèle:Langue
-- Paramètres :
-- 1 : code IETF de langue ;
-- texte ou 2 : texte dans cette langue ;
-- trans : translittération du texte ;
-- dir : direction de la langue (obsolète : peut être en paramètre 1, avec code en 2 et texte en 3).
local function make_error_msg (msg, args, template)
function Langue.langue( frame )
local out = {};
local args = ( frame.getParent and frame:getParent().args ) or frame -- préparation pour appel par modèle ou direct.
local category;
local code = mw.ustring.lower( mw.text.trim( args[1] or '' ) )
local texte = args.texte or ''
if 'Transl' == template then
if texte == '' then
texte = args[2] or ''
end
end
local dir = args.dir
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [12] = true, [14] = true, [100] = true }
local categorisation = namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] and not args.nocat
-- Décalage des paramètres si code contient la direction du texte (obsolète mais toujours possible).
if code == 'ltr' or code == 'rtl' then
dir = code
code = mw.ustring.lower( mw.text.trim( args[2] ) or '' )
texte = args[3] or ''
end
end
local codeArg = code
-- sortie immédiate s'il n'y a pas de texte
--[=[-------------------------< M A K E _ W I K I L I N K >----------------------------------------------------
if texte == '' then
if categorisation then
return '<span class="error">erreur du modèle [[modèle:Langue|{{langue}}]] : texte absent</span>[[Catégorie:Page utilisant un modèle avec une syntaxe erronée|Langue]]'
if is_set (display) then
return table.concat ({'[[', link, '|', display, ']]'});
else
else
return table.concat ({'[[', link, ']]'});
return ''
end
end
end
end
-- récursion si texte contient des blocs
if texte:match('\n *\n') or texte:match('\n[*#:]') then
-- les parenthèses permettent d'éliminer la seconde valeur retournée par gsub (nombre de remplacement)
return ( texte:gsub(
'(\n?[*#:]?%s*)([^\n]+)',
function ( init, ligne )
return init .. Langue.langue{ code, ligne }
end
) )
end
end
if text:find ('\n+') then -- look for any number of \n characters in text
-- Si la langue est reconnue, la valeur de la table est prise en compte (permet de corriger les noms de langue en toutes lettres).
local tabCode = Langue.determinationCode( code )
local tabLangue
if 'italic' == style then
if tabCode then
code = table.concat( tabCode, '-' )
tabLangue = dataLangue[ tabCode[1] ]
local codeScript = tabCode[2]
-- Si codeScript est bien un style d'écriture (len = 4) on applique sa direction
if codeScript and string.len( codeScript ) == 4 and dataLangue[ 'rtl script' ] then
-- formatage type Latn correspondant au fromat dans dataLangue[ 'rtl script' ]
codeScript = string.upper( string.sub( codeScript, 1, 1 ) ) .. string.sub( codeScript, 2 )
tabLangue = { code = tabLangue.code,
rtl = dataLangue[ 'rtl script' ][ codeScript ],
invalide = tabLangue.invalide
}
end
end
end
end
-- Préparation du rendu de direction du texte.
dir = dir and dir:lower()
if dir ~= 'ltr' and dir ~= 'rtl' then
dir = ( tabLangue and tabLangue.rtl and 'rtl' )
end
end
if 'span' == tag then -- default html tag for inline content
-- Compilation du texte à retourner.
if 'italic' == style then -- but if italic
local html = mw.html.create( '' )
tag = 'i'; -- change to <i> tags
if code == '' then
html:wikitext( texte )
else
html:tag( 'span' )
:addClass( 'lang-' .. code )
:addClass( args.class )
:attr{ lang = code, dir = dir }
:wikitext( texte )
:done()
-- Translittération.
if ( args.trans or '' ) ~= '' then
local trans = args.trans:gsub( "^''([^'].*[^'])''$", "%1" )
html:wikitext( " (''" )
:tag( 'span' )
:addClass( 'transcription lang-' .. code )
:attr( 'lang', code .. '-Latn' )
:attr( 'dir', 'ltr' )
:wikitext( trans )
:done()
:wikitext( "'')" )
end
end
end
end
if is_set (language) then
-- Ajout de la catégorie Page avec code de langue invalide si le code langue non reconnu ou invalide.
if categorisation and ( type( tabLangue ) ~= 'table' or tabCode.invalide ) then
if language:find ('languages') then
local erreur = string.format( langErrorMess, codeArg )
if codeArg == '' then
erreur = '<span class="error">langue non précisée</span>'
end
end
html:wikitext( '[[Catégorie:Page avec code de langue invalide|Langue]] ' .. erreur )
end
end
return tostring( html )
return table.concat (html); -- put it all together and done
end
end
-- Alias nom de fonction
Langue.lang = Langue.langue
-- Voir Modèle:Indication de langue
-- Paramètres :
-- 1 : nom de langue ;
-- 2 : code IETF ;
-- texte : texte dans cette langue ;
-- dir : direction de la langue.
function Langue.indicationDeLangue( frame )
[[Category:Articles with text in <language> languages]]
local args = ( frame.getParent and frame:getParent().args ) or frame
local nomLangue = mw.text.trim( args[1] or '' )
local code = mw.text.trim( args[2] or '' )
local texte = args.texte
local function make_category (code, language_name, nocat, name_get)
local dir = args.dir
local cat = {};
local wikiText = ''
local retval;
-- Cas où le premier et/ou le deuxième paramètre est vide.
if code == '' and nomLangue == '' then
if ((0 ~= namespace) or nocat) and not name_get then -- only categorize in article space
return texte
elseif nomLangue == '' then
nomLangue = dataLangue[ mw.ustring.lower( code ) ]
nomLangue = (nomLangue and nomLangue.nom or '???')
elseif code == '' then
code = dataLangue[ nomLangue ]
code = ( code and code.code or '' )
if code == '' then
return texte
end
end
end
-- Gestion du texte.
if language_name:find ('languages') then
if texte and texte ~= '' then
texte = '\194\160' .. Langue.lang{ code, dir = dir, texte = texte }
else
else
texte = ''
end
end
-- Compilation de l'indicateur de langue et du texte.
local html = mw.html.create()
html:tag( 'abbr' )
:addClass( 'abbr' )
:addClass( 'indicateur-langue' )
:attr( 'title', 'Langue : ' .. nomLangue )
:wikitext( '(' .. code .. ')' )
:done()
:wikitext( texte )
return tostring( html )
return table.concat (cat);
end
end
-- Voir Modèle:Mul
--[[--------------------------< M A K E _ T R A N S L I T >----------------------------------------------------
-- Paramètres : codes IETF ou noms de langue, en nombre indéfini (string ou nil uniquement).
function Langue.indicationMultilingue( frame )
local args = (frame.getParent and frame:getParent().args) or frame
local listeNom = { }
local listeCode = { }
local tabLangue
-- Valeur par défaut du premier paramètre = 'mul'.
local code = mw.text.trim( args[1] or '' )
if code == '' then
code = 'mul'
end
local function make_translit (code, language_name, translit, std, tscript, style)
if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
if not args[2] and not dataLangue[ mw.ustring.lower( code ) ] then
local split = mw.text.split( code, '[+,;:/ .]+' )
if #split > 1 then
return Langue.indicationMultilingue( split )
end
end
end
end
-- Ajout des noms et codes de langue de chaque paramètre dans listeNom et ListeCode.
local i = 1
repeat
code = mw.ustring.lower( code )
local tabLangue = dataLangue[ code ]
if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name)
if not tabLangue then
code = mw.text.split( code, '-' )[1]
tabLangue = dataLangue[ code ]
end
end
if type( tabLangue ) == 'table' then
table.insert( listeNom, tabLangue.nom )
table.insert( listeCode, tabLangue.code )
else
else
table.insert( listeNom, '???' )
local erreur = string.format( langErrorMess, code )
table.insert( listeCode, erreur )
table.insert (tout, title_table[std]['default']); -- so use the standard's default
end
end
i = i + 1
code = mw.text.trim( args[i] or '' )
until code == ''
-- Préparation et renvoi du texte.
local n = #listeCode
if n == 0 then
return ''
end
end
local plusieurs = ( n > 1 )
local html = mw.html.create( 'abbr' )
:addClass( 'abbr' )
:addClass( 'indicateur-langue' )
:attr( 'title', 'Langue' .. ( plusieurs and 's' or '' ) .. ' : ' .. mw.text.listToText( listeNom ) )
:wikitext( '(' .. table.concat( listeCode, '\194\160+\194\160' ) .. ')' )
return table.concat (maint);
return tostring( html )
end
end
--[[--------------------------< P R O T O _ P R E F I X >------------------------------------------------------
-- Voir Modèle:Langue avec nom
-- Paramètres :
-- 1 : code IETF de langue ;
-- texte ou 2 : texte dans cette langue ;
-- trans : translittération du texte ;
-- dir : direction de la langue.
function Langue.langueAvecNom( frame )
local args = ( frame.getParent and frame:getParent().args ) or frame
local code = mw.ustring.lower( mw.text.trim( args [1] or '') )
local texte = args.texte or args[2] or ''
local trans = args.trans
local dir = args.dir
local wikiText = ''
-- Détection de la direction du texte.
if code == 'ltr' or code == 'rtl' then
dir = code
code = mw.ustring.lower( mw.text.trim( args[2] ) )
texte = args[3] or ''
end
-- Définition du nom de la langue en français.
local nom = Langue.nomLangue{ code }
if texte ~= '' then
texte = '\194\160' .. Langue.lang{ code, dir = dir, texte = texte, trans = trans }
if false == proto_param then -- when forced by |proto=no
end
end
wikiText = nom .. ' :' .. texte
return wikiText
return text:find ('\127[^\127]*UNIQ%-%-poem%-[%a%d]+%-QINU[^\127]*\127') and true or false;
end
end
---
--[[--------------------------< H T M L _ T A G _ S E L E C T >------------------------------------------------
-- latinOnly détermine si la chaine fournie contient uniquement des caractères latin (étendu, unicode < 880)
function Langue.nonLatin( frame )
local texte = premierParametre( frame )
for codepoint in mw.ustring.gcodepoint( texte ) do
if codepoint > 879 and not ( -- > 036F
codepoint > 7423 and codepoint < 7936 or -- suppléments phonétique, diacritiques et latin (1D00 à 1EFF)
codepoint > 8191 and codepoint < 11392 or -- espace, indices, monaies et symboles divers (2000 à 2C7F)
codepoint > 42783 and codepoint < 43008 -- latin étendu D (A720 à A7FF)
) then
return true
end
local tag;
end
end
return false
return text, tag;
end
end
-- erreurModuleData affiche un message d'erreur si le Module:Langue/Data n'a pas été chargé correctement,
-- pour la page de discussion de la base de données et ceux qui veulent surveiller cette page.
function Langue.erreurModuleData()
if type( dataLangue ) ~= 'table' then
local message = [[<strong class="error">Le chargement du module Langue/Data génère une erreur : </strong> <br>%s <br>
<span class="error">Cette erreur doit être corrigée au plus vite car des milliers de pages ne s'affichent pas correctement.</span>
]]
]]
return string.format( message, resultat )
return true;
end
end
end
end
-- tableauLangues génère un tableau triable de la liste des langues disponible dans Module:langue/Data.
function Langue.tableauLangues()
local tableau = { }
local entete = [[{| class="wikitable alternance sortable"
|-
!scope=col|Alias
!scope=col|Code IETF
!scope=col|Nom principal
!scope=col|Page (si différente du nom)
!scope=col|RTL
!scope=col|Invalide]]
local ligneTab, ligneSrt
for i, v in pairs( dataLangue ) do
if v.code then
ligneTab = {
i,
v.code,
v.nom,
v.page or '',
local function language_name_get (ietf, code, cat)
v.rtl and '[[Image:Yes check.svg|15px|oui|lien=]]' or '',
v.invalide and '[[Image:Yes check.svg|15px|oui|lien=]]' or '',
}
ligneSrt = table.concat( ligneTab, '\n|' )
table.insert( tableau, ligneSrt )
]]
end
end
end
end
table.sort( tableau )
table.insert( tableau, 1, entete )
table.insert( tableau, '}' )
return table.concat( tableau, '\n|-\n|' )
end
end
-- listeCodeAlias génère une liste ; les langues sont de la forme : * code : alias1, alias2
function Langue.listeCodeAlias()
local languesTab, listeCodesAlias = { }, { }
local code, alias, codeAlias
for i, v in pairs( dataLangue ) do
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias
code = v.code
if code and not v.invalide then
languesTab[code] = languesTab[code] or { }
if i ~= mw.ustring.lower( code ) then
table.insert( languesTab[code], i )
end
end
end
end
end
end
for i, v in pairs( languesTab ) do
-- transformation en un table séquence, avec pour valeur une chaine correspondant à une ligne de la liste
alias = table.concat( v, ', ' )
if alias == '' then
codeAlias = '* <code>' .. i .. '</code>'
else
else
codeAlias = '* <code>' .. i .. '</code> : ' .. alias
end
end
table.insert (out, ': '); -- separator
table.insert( listeCodesAlias, codeAlias )
end
end
table.sort( listeCodesAlias )
return table.concat( listeCodesAlias, '\n' )
end
-- listeAliasCode génère une liste ; les langues sont de la forme : * alias : code
function Langue.listeAliasCode()
local languesTab = { }
local code
for i, v in pairs( dataLangue ) do
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias
code = v.code
if code and i ~= code and not v.invalide then
table.insert( languesTab, '* ' .. i .. ' = ' .. code )
end
end
end
end
table.sort( languesTab )
return table.concat( languesTab, '\n' )
return table.concat (out); -- put it all together and done
end
end
return Langue