کاربر ناشناس
پودمان:Lang: تفاوت میان نسخه‌ها
بدون خلاصۀ ویرایش
جز (۱ نسخه واردشده) |
بدون خلاصۀ ویرایش |
||
| خط ۵: | خط ۵: | ||
]=] | ]=] | ||
require(' | require('strict'); | ||
local getArgs = require ('Module:Arguments').getArgs; | local getArgs = require ('Module:Arguments').getArgs; | ||
| خط ۲۵: | خط ۲۵: | ||
local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization | local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization | ||
local | 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 initial_style_state; -- set by lang_xx_normal() and lang_xx_italic() | ||
| خط ۱۲۷: | خط ۱۲۹: | ||
if count > 1 then -- return nil and an error message if more than one is set | if count > 1 then -- return nil and an error message if more than one is set | ||
return nil, ' | return nil, 'only one of |italic=, |italics=, or |i= can be specified'; | ||
end | end | ||
| خط ۲۵۷: | خط ۲۵۹: | ||
if not is_set (source) then | if not is_set (source) then | ||
return nil, nil, nil, nil, nil, ' | return nil, nil, nil, nil, nil, 'missing language tag'; | ||
end | end | ||
| خط ۳۱۲: | خط ۳۱۴: | ||
if not code then | if not code then | ||
return nil, nil, nil, nil, nil, table.concat ({' | return nil, nil, nil, nil, nil, table.concat ({'unrecognized language tag: ', source}); -- don't know what we got but it is malformed | ||
end | end | ||
| خط ۳۱۸: | خط ۳۲۰: | ||
if not (override_table[code] or lang_table[code] or synonym_table[code] or lang_dep_table[code]) then | 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 ({' | 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 | end | ||
if synonym_table[code] then -- if 639-2/639-2T code has a 639-1 synonym | if synonym_table[code] then -- if 639-2/639-2T code has a 639-1 synonym | ||
table.insert (maint_cats, table.concat ({' | table.insert (maint_cats, table.concat ({'Lang and lang-xx code promoted to ISO 639-1|', code})); | ||
table.insert (maint_msgs, table.concat ({' | table.insert (maint_msgs, table.concat ({'code: ', code, ' promoted to code: ', synonym_table[code]})); | ||
code = synonym_table[code]; -- use the synonym | code = synonym_table[code]; -- use the synonym | ||
end | end | ||
| خط ۳۲۹: | خط ۳۳۱: | ||
if is_set (script) then | if is_set (script) then | ||
if is_set (args_script) then | if is_set (args_script) then | ||
return code, nil, nil, nil, nil, ' | return code, nil, nil, nil, nil, 'redundant script tag'; -- both code with script and |script= not allowed | ||
end | end | ||
else | else | ||
| خط ۳۳۸: | خط ۳۴۰: | ||
script = script:lower(); -- ensure that we use and return lower case version of this | script = script:lower(); -- ensure that we use and return lower case version of this | ||
if not script_table[script] then | if not script_table[script] then | ||
return code, nil, nil, nil, nil, table.concat ({' | 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 | ||
end | end | ||
if suppressed_table[script] then -- ensure that code-script does not use a suppressed script | if suppressed_table[script] then -- ensure that code-script does not use a suppressed script | ||
if in_array (code, suppressed_table[script]) then | if in_array (code, suppressed_table[script]) then | ||
return code, nil, nil, nil, nil, table.concat ({' | 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 | ||
end | end | ||
| خط ۳۴۹: | خط ۳۵۱: | ||
if is_set (region) then | if is_set (region) then | ||
if is_set (args_region) then | if is_set (args_region) then | ||
return code, nil, nil, nil, nil, ' | return code, nil, nil, nil, nil, 'redundant region tag'; -- both code with region and |region= not allowed | ||
end | end | ||
else | else | ||
| خط ۳۵۸: | خط ۳۶۰: | ||
region = region:lower(); -- ensure that we use and return lower case version of this | region = region:lower(); -- ensure that we use and return lower case version of this | ||
if not region_table[region] then | if not region_table[region] then | ||
return code, script, nil, nil, nil, table.concat ({' | return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code}); | ||
end | end | ||
end | end | ||
| خط ۳۶۴: | خط ۳۶۶: | ||
if is_set (variant) then | if is_set (variant) then | ||
if is_set (args_variant) then | if is_set (args_variant) then | ||
return code, nil, nil, nil, nil, ' | return code, nil, nil, nil, nil, 'redundant variant tag'; -- both code with variant and |variant= not allowed | ||
end | end | ||
else | else | ||
| خط ۳۷۳: | خط ۳۷۵: | ||
variant = variant:lower(); -- ensure that we use and return lower case version of this | 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 | if not variant_table[variant] then -- make sure variant is valid | ||
return code, script, region, nil, nil, table.concat ({' | return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant}); | ||
end -- does this duplicate/replace tests in lang() and lang_xx()? | 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 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 | if not in_array (table.concat ({code, '-', script}), variant_table[variant]['prefixes']) then | ||
return code, script, region, nil, nil, table.concat ({' | return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', code, '-', script}); | ||
end | end | ||
elseif is_set (region) then -- if region set, there are some prefixes that require lang code and region (en-CA-newfound) | 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 (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) | 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 ({' | return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-region pair: ', code, '-', region}); | ||
end | end | ||
end | end | ||
else -- cheap way to determine if there are prefixes; fonipa and others don't have prefixes; # operator always returns 0 | 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 | if variant_table[variant]['prefixes'][1] and not in_array (code, variant_table[variant]['prefixes']) then | ||
return code, script, region, nil, nil, table.concat ({' | return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code: ', code}); | ||
end | end | ||
end | end | ||
| خط ۳۹۵: | خط ۳۹۷: | ||
private = private:lower(); -- ensure that we use and return lower case version of this | 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 | 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 ({' | return code, script, region, nil, nil, table.concat ({'unrecognized private tag: ', private}); | ||
end | end | ||
end | end | ||
| خط ۴۱۳: | خط ۴۱۵: | ||
if 'Transl' == template then | if 'Transl' == template then | ||
category = ' | category = 'Transl'; | ||
else | else | ||
category = ' | category = 'Lang and lang-xx' | ||
end | end | ||
table.insert (out, table.concat ({'[', args.text or 'undefined', '] '})); -- for error messages output args.text if available | table.insert (out, table.concat ({'[', args.text or 'undefined', '] '})); -- for error messages output args.text if available | ||
table.insert (out, table.concat ({'<span style=\" | table.insert (out, table.concat ({'<span style=\"color:#d33\">Error: {{', template, '}}: '})); | ||
table.insert (out, msg); | table.insert (out, msg); | ||
table.insert (out, table.concat ({' ([[: | table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'})); | ||
table.insert (out, '</span>'); | table.insert (out, '</span>'); | ||
if (0 == namespace or 10 == namespace) and not args.nocat then | 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 ({'[[ | table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'})); | ||
end | end | ||
| خط ۴۶۴: | خط ۴۶۶: | ||
if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text | if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text | ||
if 'italic' == style then | if 'italic' == style then | ||
return | return text:gsub ('(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item | ||
else | else | ||
return text; | return text; | ||
| خط ۴۸۲: | خط ۴۸۴: | ||
return text; | return text; | ||
end | |||
--[[--------------------------< T I T L E _ W R A P P E R _ M A K E >------------------------------------------ | |||
makes a <span title="<title text>"><content_text></span> or <div title="<title text>"><content_text></div> where | |||
<title text> is in the tool-tip in the wiki's local language and <content_text> is non-local-language text in | |||
html markup. This because the lang= attibute applies to the content of its enclosing tag. | |||
<tag> holds a string 'div' or 'span' used to choose the correct wrapping tag | |||
]] | |||
local function title_wrapper_make (title_text, content_text, tag) | |||
local wrapper_t = {}; | |||
table.insert (wrapper_t, table.concat ({'<', tag})); -- open opening wrapper tag | |||
table.insert (wrapper_t, ' title=\"'); -- begin title attribute | |||
table.insert (wrapper_t, title_text); -- add <title_text> | |||
table.insert (wrapper_t, '\">'); -- end title attribute and close opening wrapper tag | |||
table.insert (wrapper_t, content_text); -- add <content_text> | |||
table.insert (wrapper_t, table.concat ({'</', tag, '>'})); -- add closing wrapper tag | |||
return table.concat (wrapper_t); -- make a big string and done | |||
end | end | ||
| خط ۴۸۹: | خط ۵۱۴: | ||
Add the html markup to text according to the type of content that it is: <span> or <i> tags for inline content or | 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 | <div> tags for block content | ||
The lang= attribute also applies to the content of the tag where it is placed so this is wrong because 'Spanish | |||
language text' is English: | |||
<i lang="es" title="Spanish language text">casa</i> | |||
should be: | |||
<span title="Spanish language text"><i lang="es">casa</i></span> | |||
or for <div>...</div>: | |||
<div title="Spanish language text"><div lang="es"><spanish-language-text></div></div> | |||
]] | ]] | ||
local function make_text_html (code, text, tag, rtl, style, size, language) | local function make_text_html (code, text, tag, rtl, style, size, language) | ||
local | local html_t = {}; | ||
local style_added = ''; | local style_added = ''; | ||
local wrapper_tag = tag; -- <tag> gets modified so save a copy for use when/if we create a wrapper span or div | |||
if text:match ('^%*') then | if text:match ('^%*') then | ||
table.insert ( | table.insert (html_t, '*'); -- 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 | text = text:gsub ('^%*', ''); -- remove the splat from the text | ||
end | end | ||
| خط ۵۰۹: | خط ۵۴۳: | ||
end | end | ||
table.insert ( | table.insert (html_t, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag | ||
code = code:gsub ('%-x%-.*', ''); | code = code:gsub ('%-x%-.*', ''); -- strip private use subtag from code tag because meaningless outside of wikipedia | ||
table.insert ( | table.insert (html_t, table.concat ({' lang="', code, '\"'})); -- add language attribute | ||
if rtl or unicode.is_rtl(text) then | if (rtl or unicode.is_rtl(text)) and ('ltr' == this_wiki_lang_dir) then -- text is right-to-left on a left-to-right wiki | ||
table.insert ( | table.insert (html_t, ' dir="rtl"'); -- add direction attribute for right-to-left languages | ||
elseif not (rtl or unicode.is_rtl(text)) and ('rtl' == this_wiki_lang_dir) then -- text is left-to-right on a right-to-left wiki | |||
table.insert (html_t, ' dir="ltr"'); -- add direction attribute for left-to-right languages | |||
end | end | ||
if 'normal' == style then -- when |italic=no | if 'normal' == style then -- when |italic=no | ||
table.insert ( | table.insert (html_t, ' style=\"font-style: normal;'); -- override external markup, if any | ||
style_added = '\"'; -- remember that style attribute added and is not yet closed | style_added = '\"'; -- remember that style attribute added and is not yet closed | ||
end | end | ||
| خط ۵۲۴: | خط ۵۶۰: | ||
if is_set (size) then -- when |size=<something> | if is_set (size) then -- when |size=<something> | ||
if is_set (style_added) then | if is_set (style_added) then | ||
table.insert ( | table.insert (html_t, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted | ||
else | else | ||
table.insert ( | table.insert (html_t, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute | ||
style_added = '\"'; -- remember that style attribute added and is not yet closed | style_added = '\"'; -- remember that style attribute added and is not yet closed | ||
end | end | ||
end | end | ||
table.insert (html_t, table.concat ({style_added, '>'})); -- close the opening html tag | |||
table.insert (html_t, text); -- insert the text | |||
table.insert (html_t, table.concat ({'</', tag, '>'})); -- close the 'text' <i>, <span>, or <div> html tag | |||
table. | if is_set (language) then -- create a <title_text> string for the title= attribute in a wrapper span or div | ||
local title_text; | |||
if 'zxx' == code then -- special case for this tag 'no linguistic content' | |||
title_text = table.concat ({language, ' text'}); -- not a language so don't use 'language' in title text | |||
elseif mw.ustring.find (language, 'languages', 1, true) then | |||
title_text = table.concat ({language, ' collective text'}); -- for collective languages | |||
else | |||
title_text = table.concat ({language, '-language text'}); -- for individual languages | |||
end | |||
return title_wrapper_make (title_text, table.concat (html_t), wrapper_tag); | |||
table. | else | ||
return table.concat (html_t); | |||
end | end | ||
end | end | ||
| خط ۵۷۸: | خط ۶۱۰: | ||
end | end | ||
if mw.ustring.find(language_name, ' | if mw.ustring.find (language_name, 'languages', 1, true) then | ||
return table.concat ({'[[ | return table.concat ({'[[Category:Articles with text in ', language_name, ']]'}); | ||
end | end | ||
table.insert (cat, '[[ | table.insert (cat, '[[Category:Articles containing '); | ||
if | if this_wiki_lang_tag == code then | ||
table.insert (cat, ' | table.insert (cat, 'explicitly cited ' .. language_name); -- unique category name for the local language | ||
else | else | ||
table.insert (cat, | table.insert (cat, language_name); | ||
end | end | ||
table.insert (cat, ']]'); | table.insert (cat, '-language text]]'); | ||
return table.concat (cat); | return table.concat (cat); | ||
| خط ۶۱۶: | خط ۶۴۸: | ||
local function make_translit (code, language_name, translit, std, tscript, style) | local function make_translit (code, language_name, translit, std, tscript, style) | ||
local title; | local title; | ||
local | local out_t = {}; | ||
local | local title_t = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards | ||
local title_text = ''; -- tool tip text for title= attribute | |||
std = std and std:lower(); -- lower case for table indexing | |||
if is_set ( | if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified | ||
if not | title_text = language_name; -- write a generic tool tip | ||
if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name) | |||
title_text = title_text .. '-language'; -- skip this text (individual and macro languages only) | |||
end | end | ||
title_text = title_text .. ' 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 | elseif is_set (std) and is_set (tscript) then -- when both are specified | ||
if | if title_t[std] then -- and if standard is legitimate | ||
if | if title_t[std][tscript] then -- and if script for that standard is legitimate | ||
if script_table[tscript] then | |||
title_text = title_text .. table.concat ({title_t[std][tscript:lower()], ' (', script_table[tscript], ' script) transliteration'}); -- add the appropriate text to the tool tip | |||
else | |||
title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard? | |||
end | |||
else | else | ||
title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard? | |||
end | end | ||
else | else | ||
| خط ۶۵۳: | خط ۶۷۷: | ||
elseif is_set (std) then -- translit-script not set, use language code | elseif is_set (std) then -- translit-script not set, use language code | ||
if not | if not title_t[std] then return ''; end -- invalid standard, setup for error message | ||
if | if title_t[std][code] then -- if language code is in the table (transl may not provide a language code) | ||
title_text = title_text .. table.concat ({title_t[std][code:lower()], ' (', language_name, ' language) transliteration'}); -- add the appropriate text to the tool tip | |||
else -- code doesn't match | else -- code doesn't match | ||
title_text = title_text .. title_t[std]['default']; -- so use the standard's default | |||
end | end | ||
else -- here if translit-script set but translit-std not set | else -- here if translit-script set but translit-std not set | ||
if | if title_t['no_std'][tscript] then | ||
title_text = title_text .. title_t['no_std'][tscript]; -- use translit-script if set | |||
elseif | elseif title_t['no_std'][code] then | ||
title_text = title_text .. title_t['no_std'][code]; -- use language code | |||
else | else | ||
if is_set (tscript) then | if is_set (tscript) then | ||
title_text = title_text .. table.concat ({language_name, '-script transliteration'}); -- write a script tool tip | |||
elseif is_set (code) then | elseif is_set (code) then | ||
if not mw. | if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name) | ||
title_text = title_text .. '-language'; -- skip this text (individual and macro languages only) | |||
end | end | ||
title_text = title_text .. ' transliteration'; -- finish the tool tip | |||
else | else | ||
title_text = title_text .. ' transliteration'; -- generic tool tip (can we ever get here?) | |||
end | end | ||
end | end | ||
end | end | ||
local close_tag; | |||
if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}}) | |||
if is_set (code) | if not style then -- nil for the default italic style | ||
table.insert ( | table.insert (out_t, "<i lang=\""); -- so use <i> tag | ||
close_tag = '</i>'; -- tag to be used when closing | |||
else | |||
table.insert (out_t, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it | |||
close_tag = '</span>'; -- tag to be used when closing | |||
end | |||
table.insert (out_t, code); | |||
table.insert (out_t, "-Latn\">"); -- transliterations are always Latin script | |||
else | |||
table.insert (out_t, "<span>"); -- when no language code: no lang= attribute, not italic ({{transl}} only) | |||
close_tag = '</span>'; | |||
end | |||
table.insert (out_t, translit); -- add the translit text | |||
table.insert (out_t, close_tag); -- and add the appropriate </i> or </span> | |||
if '' == title_text then -- when there is no need for a tool-tip | |||
return table.concat (out_t); -- make a string and done | |||
else | else | ||
table. | return title_wrapper_make (title_text, table.concat (out_t), 'span'); -- wrap with a tool-tip span and don | ||
end | end | ||
end | end | ||
| خط ۷۰۳: | خط ۷۴۳: | ||
local function validate_text (template, args) | local function validate_text (template, args) | ||
if not is_set (args.text) then | if not is_set (args.text) then | ||
return make_error_msg (' | return make_error_msg ('no text', args, template); | ||
end | end | ||
if args.text:find ("%f[\']\'\'\'\'%f[^\']") or args.text:find ("\'\'\'\'\'[\']+") then -- because we're looking, look for 4 appostrophes or 6+ appostrophes | 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 (' | return make_error_msg ('text has malformed markup', args, template); | ||
end | end | ||
| خط ۷۱۴: | خط ۷۵۴: | ||
if ('unset' ~= style) and ('invert' ~=style) then | 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 | if args.text:find ("%f[\']\'\'%f[^\']") or args.text:find ("%f[\']\'\'\'\'\'%f[^\']") then -- italic but not bold, or bold italic | ||
return make_error_msg (' | return make_error_msg ('text has italic markup', args, template); | ||
end | end | ||
end | end | ||
| خط ۸۵۶: | خط ۸۹۶: | ||
if override_table[ietf] then -- look for whole IETF tag in override table | if override_table[ietf] then -- look for whole IETF tag in override table | ||
name = override_table[ietf | name = override_table[ietf]; | ||
elseif override_table[code] then -- not there so try basic language | elseif override_table[code] then -- not there so try basic language tag | ||
name = override_table[code | name = override_table[code]; | ||
elseif lang_table[code] then -- shift to iana | elseif lang_table[code] then -- shift to iana active tag/name table | ||
name = lang_table[code | name = lang_table[code]; | ||
elseif lang_dep_table[code] then | elseif lang_dep_table[code] then -- try the iana deprecated tag/name table | ||
-- | name = lang_dep_table[code]; | ||
name = lang_dep_table[code | |||
end | end | ||
if lang_dep_table[code] and cat then -- because deprecated code may have been overridden to en.wiki preferred name | 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 ({' | table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code})); | ||
table.insert (maint_msgs, table.concat ({' | table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'})); | ||
end | end | ||
| خط ۸۹۹: | خط ۹۳۵: | ||
local template = args.template or 'Lang'; | local template = args.template or 'Lang'; | ||
maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once | |||
maint_msgs = {}; | |||
validate_cat_args (args); -- determine if categorization should be suppressed | validate_cat_args (args); -- determine if categorization should be suppressed | ||
if args[1] and args.code then | if args[1] and args.code then | ||
return make_error_msg (' | return make_error_msg ('conflicting: {{{1}}} and |code=', args, template); | ||
else | else | ||
args.code = args[1] or args.code; -- prefer args.code | args.code = args[1] or args.code; -- prefer args.code | ||
| خط ۹۰۸: | خط ۹۴۷: | ||
if args[2] and args.text then | if args[2] and args.text then | ||
return make_error_msg (' | return make_error_msg ('conflicting: {{{2}}} and |text=', args, template); | ||
else | else | ||
args.text = args[2] or args.text; -- prefer args.text | args.text = args[2] or args.text; -- prefer args.text | ||
| خط ۹۲۴: | خط ۹۶۳: | ||
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag | args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag | ||
if msg then | if msg then | ||
return make_error_msg (table.concat ({'|proto= | return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template); | ||
end | end | ||
| خط ۹۴۰: | خط ۹۷۹: | ||
if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls | 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 | if ('latn' == subtags.script) or -- script is latn | ||
( | (this_wiki_lang_tag ~= 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 | args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic | ||
else | else | ||
| خط ۹۹۹: | خط ۱٬۰۳۸: | ||
return _lang (args); | return _lang (args); | ||
end | |||
--[[--------------------------< T R A N S L A T I O N _ M A K E >---------------------------------------------- | |||
stand-alone function to create literal translation of main text | |||
Also used by {{lang-x2}} | |||
]] | |||
local function translation_make (args_t) | |||
local translation_t = {', '}; -- initialize output | |||
if 'none' ~= args_t.label then -- if we want a label | |||
table.insert (translation_t, '<small>'); -- open the <small> html tag | |||
if 'no' == args_t.link then | |||
table.insert (translation_t, '<abbr title="literal translation">lit.</abbr>'); -- unlinked form | |||
else | |||
table.insert (translation_t, make_wikilink ('Literal translation', 'lit.')); -- linked form | |||
end | |||
table.insert (translation_t, " </small>"); -- close the <small> html tag | |||
end | |||
table.insert (translation_t, table.concat ({''', args_t.translation, '''})); -- use html entities to avoid wiki markup confusion | |||
return table.concat (translation_t); -- make a big string and done | |||
end | end | ||
| خط ۱٬۰۶۰: | خط ۱٬۱۲۴: | ||
local template = args.template or 'Lang-xx'; | local template = args.template or 'Lang-xx'; | ||
maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once | |||
maint_msgs = {}; | |||
if args[1] and args.text then | if args[1] and args.text then | ||
return make_error_msg (' | return make_error_msg ('conflicting: {{{1}}} and |text=', args, template); | ||
else | else | ||
args.text = args[1] or args.text; -- prefer args.text | args.text = args[1] or args.text; -- prefer args.text | ||
| خط ۱٬۰۷۴: | خط ۱٬۱۴۱: | ||
if args[2] and args.translit then | if args[2] and args.translit then | ||
return make_error_msg (' | return make_error_msg ('conflicting: {{{2}}} and |translit=', args, template); | ||
else | else | ||
args.translit = args[2] or args.translit -- prefer args.translit | args.translit = args[2] or args.translit -- prefer args.translit | ||
| خط ۱٬۰۸۰: | خط ۱٬۱۴۷: | ||
if args[3] and (args.translation or args.lit) then | if args[3] and (args.translation or args.lit) then | ||
return make_error_msg (' | return make_error_msg ('conflicting: {{{3}}} and |lit= or |translation=', args, template); | ||
elseif args.translation and args.lit then | elseif args.translation and args.lit then | ||
return make_error_msg (' | return make_error_msg ('conflicting: |lit= and |translation=', args, template); | ||
else | else | ||
args.translation = args[3] or args.translation or args.lit; -- prefer args.translation | args.translation = args[3] or args.translation or args.lit; -- prefer args.translation | ||
| خط ۱٬۰۸۸: | خط ۱٬۱۵۵: | ||
if args.links and args.link then | if args.links and args.link then | ||
return make_error_msg (' | return make_error_msg ('conflicting: |links= and |link=', args, template); | ||
else | else | ||
args.link = args.link or args.links; -- prefer args.link | args.link = args.link or args.links; -- prefer args.link | ||
| خط ۱٬۱۳۰: | خط ۱٬۱۹۷: | ||
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag | args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag | ||
if msg then | if msg then | ||
return make_error_msg (table.concat ({' | return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template); | ||
end | end | ||
| خط ۱٬۱۴۷: | خط ۱٬۲۱۴: | ||
table.insert (out, language_name); -- language name without wikilink | table.insert (out, language_name); -- language name without wikilink | ||
else | else | ||
if mw.ustring.find (language_name, ' | if mw.ustring.find (language_name, 'languages', 1, true) then | ||
table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink | table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink | ||
elseif lang_data.article_name[code] then | elseif lang_data.article_name[code] then | ||
table.insert (out, make_wikilink (lang_data.article_name[code | table.insert (out, make_wikilink (lang_data.article_name[code], language_name)); -- language name with wikilink from override data | ||
else | else | ||
table.insert (out, make_wikilink (' | table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink | ||
end | end | ||
end | end | ||
| خط ۱٬۱۶۷: | خط ۱٬۲۳۴: | ||
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) | 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, ' | table.insert (out, ', '); -- comma to separate text from translit | ||
if 'none' ~= args.label then | if 'none' ~= args.label then | ||
table.insert (out, '<small>'); | table.insert (out, '<small>'); | ||
if script_table[args['translit-script']] then -- when |translit-script= is set, try to use the script's name | 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' | translit_script_name = script_table[args['translit-script']]; | ||
else | else | ||
translit_script_name = language_name; -- fall back on language name | translit_script_name = language_name; -- fall back on language name | ||
end | end | ||
translit_title = mw.title.makeTitle (0, table.concat ({' | 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 | if translit_title.exists and ('no' ~= args.link) then | ||
table.insert (out, make_wikilink (' | 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 | else | ||
table.insert (out, ' | table.insert (out, 'romanized:'); -- else plain text | ||
end | end | ||
table.insert (out, ' </small>'); -- close the small tag | table.insert (out, ' </small>'); -- close the small tag | ||
| خط ۱٬۱۸۸: | خط ۱٬۲۵۵: | ||
table.insert (out, translit); | table.insert (out, translit); | ||
else | else | ||
return make_error_msg (table.concat ({'invalid translit-std: \'', args['translit-std'] or '[ | return make_error_msg (table.concat ({'invalid translit-std: \'', args['translit-std'] or '[missing]'}), args, template); | ||
end | end | ||
end | end | ||
if is_set (args.translation) then -- translation (not supported in {{lang}}) | if is_set (args.translation) then -- translation (not supported in {{lang}}) | ||
table.insert (out, | table.insert (out, translation_make (args)); | ||
end | end | ||
| خط ۱٬۳۶۰: | خط ۱٬۴۱۷: | ||
if msg then | if msg then | ||
local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template) | local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template) | ||
return table.concat ({'<span style=\" | return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'}); | ||
end | end | ||
| خط ۱٬۳۶۹: | خط ۱٬۴۲۶: | ||
if link then -- when |link=yes, wikilink the language name | if link then -- when |link=yes, wikilink the language name | ||
if mw.ustring.find (language_name, ' | if mw.ustring.find (language_name, 'languages', 1, true) then | ||
language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink | language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink | ||
elseif lang_data.article_name[code] then | elseif lang_data.article_name[code] then | ||
language_name = make_wikilink (lang_data.article_name[code | language_name = make_wikilink (lang_data.article_name[code], label or language_name); -- language name with wikilink from override data | ||
else | else | ||
language_name = make_wikilink (' | language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink | ||
end | end | ||
end | end | ||
| خط ۱٬۴۱۴: | خط ۱٬۴۷۱: | ||
return tag, true; -- language name found so return tag and done; second return used by is_lang_name() | return tag, true; -- language name found so return tag and done; second return used by is_lang_name() | ||
else | else | ||
msg = ' | msg = 'language: ' .. args[1] .. ' not found' -- language name not found, error message | ||
end | end | ||
else | else | ||
msg = ' | msg = 'missing language name' -- language name not provided, error message | ||
end | end | ||
| خط ۱٬۴۲۴: | خط ۱٬۴۸۱: | ||
template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template) | template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template) | ||
end | end | ||
return table.concat ({'<span style=\" | return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'}); | ||
end | end | ||
| خط ۱٬۴۶۵: | خط ۱٬۵۲۲: | ||
local msg; -- for when called functions return an error message | local msg; -- for when called functions return an error message | ||
maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once | |||
maint_msgs = {}; | |||
if is_set (args[3]) then -- [3] set when {{transl|code|standard|text}} | if is_set (args[3]) then -- [3] set when {{transl|code|standard|text}} | ||
args.text = args[3]; -- get the transliterated text | args.text = args[3]; -- get the transliterated text | ||
| خط ۱٬۴۷۰: | خط ۱٬۵۳۰: | ||
if not title_table[args.translit_std] then | if not title_table[args.translit_std] then | ||
return make_error_msg (table.concat ({' | return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'Transl'); | ||
end | end | ||
else | else | ||
| خط ۱٬۴۷۶: | خط ۱٬۵۳۶: | ||
args.text = args[2]; -- get the transliterated text | args.text = args[2]; -- get the transliterated text | ||
else | else | ||
if args[1] and args[1]:match ('^%a%a%a?%a?$') then -- args[2] missing; is args[1] a code or | if args[1] and args[1]:match ('^%a%a%a?%a?$') then -- args[2] missing; is args[1] a code or is it the transliterated text? | ||
return make_error_msg (' | return make_error_msg ('no text', args, 'Transl'); -- args[1] is a code so we're missing text | ||
else | else | ||
args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message | args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message | ||
return make_error_msg (' | return make_error_msg ('missing language / script code', args, 'Transl'); | ||
end | end | ||
end | end | ||
| خط ۱٬۴۸۹: | خط ۱٬۵۴۹: | ||
args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters); lower case because table indexes are lower case | args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters); lower case because table indexes are lower case | ||
else | else | ||
return make_error_msg (table.concat ({' | return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'Transl'); -- invalid language / script code | ||
end | end | ||
else | else | ||
return make_error_msg (' | return make_error_msg ('missing language / script code', args, 'Transl'); -- missing language / script code so quit | ||
end | end | ||
| خط ۱٬۵۰۵: | خط ۱٬۵۶۵: | ||
if override_table[args.code] then -- is code a language code defined in the override table? | if override_table[args.code] then -- is code a language code defined in the override table? | ||
language_name = override_table[args.code | language_name = override_table[args.code]; | ||
elseif lang_table[args.code] then -- is code a language code defined in the standard language code tables? | elseif lang_table[args.code] then -- is code a language code defined in the standard language code tables? | ||
language_name = lang_table[args.code | language_name = lang_table[args.code]; | ||
elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables? | elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables? | ||
language_name = lang_dep_table[args.code | language_name = lang_dep_table[args.code]; | ||
elseif script_table[args.code] then -- if here, code is not a language code; is it a script code? | elseif script_table[args.code] then -- if here, code is not a language code; is it a script code? | ||
language_name = script_table[args.code | language_name = script_table[args.code]; | ||
script = args.code; -- code was an ISO 15924 script so use that instead | script = args.code; -- code was an ISO 15924 script so use that instead | ||
args.code = ''; -- unset because not a language code | args.code = ''; -- unset because not a language code | ||
else | else | ||
return make_error_msg (table.concat ({' | return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'Transl'); -- invalid language / script code | ||
end | end | ||
-- here only when all parameters passed to make_translit() are valid | -- here only when all parameters passed to make_translit() are valid | ||
| خط ۱٬۵۴۳: | خط ۱٬۶۰۳: | ||
]] | ]] | ||
local function _category_from_tag ( | local function _category_from_tag (args_t) | ||
local subtags = {}; -- IETF subtags script, region, variant, and private | local subtags = {}; -- IETF subtags script, region, variant, and private | ||
local raw_code = | local raw_code = args_t[1]; -- save a copy of the input IETF subtag | ||
local link = 'yes' == | local link = 'yes' == args_t.link; -- make a boolean | ||
local label = | local label = args_t.label; | ||
local code; -- the language code | local code; -- the language code | ||
local msg; -- gets an error message if IETF language tag is malformed or invalid | local msg; -- gets an error message if IETF language tag is malformed or invalid | ||
| خط ۱٬۵۵۴: | خط ۱٬۶۱۴: | ||
code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code); | code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code); | ||
if msg then | if msg then | ||
local template = ( | local template = (args_t.template and table.concat ({'{{', args_t.template, '}}: '})) or ''; -- make template name (if provided by the template) | ||
return table.concat ({'<span style=\" | return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'}); | ||
end | end | ||
| خط ۱٬۵۶۲: | خط ۱٬۶۲۲: | ||
category_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', ''); | category_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', ''); | ||
return category_name; | if link then | ||
return table.concat ({'[[:', category_name, ']]'}); | |||
else | |||
return category_name; | |||
end | |||
end | end | ||
| خط ۱٬۶۰۱: | خط ۱٬۶۶۵: | ||
_name_from_tag = _name_from_tag, | _name_from_tag = _name_from_tag, | ||
_transl = _transl, | _transl = _transl, | ||
_translation_make = translation_make, | |||
}; | }; | ||