Module:Lang: Difference between revisions
No edit summary |
EnWikiAdmin (talk | contribs) m 1 revision imported |
||
| (6 intermediate revisions by 3 users not shown) | |||
| Line 8: | Line 8: | ||
local getArgs = require ('Module:Arguments').getArgs; | local getArgs = require ('Module:Arguments').getArgs; | ||
local unicode = require ("Module:Unicode data"); -- for | local unicode = require ("Module:Unicode data"); -- for is_Latin() and is_rtl() | ||
local yesno = require ('Module:Yesno'); | local yesno = require ('Module:Yesno'); | ||
| Line 22: | Line 22: | ||
local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code | local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code | ||
local cfg = mw.loadData ('Module:Lang/configuration' .. (mw.getCurrentFrame():getTitle():match ('/sandbox') or '')); -- for internationalization | |||
local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization | local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization | ||
| Line 35: | Line 37: | ||
--[[--------------------------< | --[[--------------------------< M A K E _ E R R O R _ S P A N >-------------------------------------------------- | ||
]] | ]] | ||
local function | local function make_error_span (template, msg) | ||
return | return table.concat ({'<span style="color:#d33">', cfg.misc_text_t.error, ': ', template, msg, '</span>'}) | ||
end | end | ||
--[[--------------------------< I | --[[--------------------------< S U B S T I T U T E >---------------------------------------------------------- | ||
Substitutes $1, $2, etc in <message> with data from <data_t>. Returns plain-text substituted string when | |||
<data_t> not nil; returns <message> else. | |||
]] | |||
local function substitute (message, data_t) | |||
return data_t and mw.message.newRawMessage (message, data_t):plain() or message; | |||
end | |||
--[[--------------------------< M A K E _ E R R O R _ M S G >-------------------------------------------------- | |||
Assembles an error message from template name, message text, help link, and error category. | |||
]] | ]] | ||
local function | local function make_error_msg (msg, args_t, template) | ||
local | local category; | ||
local text; -- handle the oddity that is {{langx}} | |||
[ | if cfg.templates_t.langxx == template then | ||
[ | text = args_t.text or args_t[1]; -- for {{lang-xx}} | ||
else | |||
text = args_t.text or args_t[2]; -- for {{lang}}, {{langx}}, and {{transliteration}} | |||
end | |||
if cfg.templates_t.transliteration == template then | |||
category = cfg.make_error_msg_t.xlit_err_cat; | |||
else | else | ||
category = cfg.make_error_msg_t.lang_err_cat; | |||
end | end | ||
local category_link = ((0 == namespace or 10 == namespace) and not args_t.nocat) and substitute ('[[Category:$1]]', {category}) or ''; | |||
return substitute ('[$1] <span style="color:#d33">$2: {{$3}}: $4 ([[:Category:$5|$6]])</span>$7', | |||
{ | |||
text or cfg.make_error_msg_t.undefined, | |||
cfg.misc_text_t.error, | |||
template, | |||
msg, | |||
category, | |||
cfg.misc_text_t.help, | |||
category_link | |||
}) | |||
end | |||
--[[--------------------------< P A R A M E T E R _ V A L I D A T E >------------------------------------------ | |||
]] | |||
local function parameter_validate (args_t, template) | |||
local err_msg = cfg.parameter_validate_t.invalid_param; | |||
return | if cfg.templates_t.lang == template then -- for {{lang}} | ||
for param, _ in pairs (args_t) do | |||
if not cfg.known_params_t.params_lang_t[param] and -- unique {{lang}} parameters | |||
not cfg.known_params_t.common_params_all_t[param] then -- common to all | |||
return substitute (err_msg, {param}); -- <param> not found so abandon | |||
end | |||
end | |||
elseif cfg.templates_t.langx == template then -- for {{langx}} | |||
for param, _ in pairs (args_t) do | |||
if not cfg.known_params_t.params_langx_t[param] and -- unique {{langx}} parameters | |||
not cfg.known_params_t.params_x_t[param] and -- common to {{langx}} and {{lang-xx}} | |||
not cfg.known_params_t.common_params_all_t[param] then -- common to all | |||
return substitute (err_msg, {param}); -- <param> not found so abandon | |||
end | |||
end | |||
elseif cfg.templates_t.langxx == template then -- for {{lang-xx}} | |||
for param, _ in pairs (args_t) do | |||
if not cfg.known_params_t.params_lang_xx_t[param] and -- unique {{lang-xx}} parameters | |||
not cfg.known_params_t.params_x_t[param] and -- common to {{langx}} and {{lang-xx}} | |||
not cfg.known_params_t.common_params_all_t[param] then -- common to all | |||
return substitute (err_msg, {param}); -- <param> not found so abandon | |||
end | |||
end | |||
end | |||
end | end | ||
--[[--------------------------< | --[[--------------------------< I S _ S E T >------------------------------------------------------------------ | ||
Returns true if argument is set; false otherwise. Argument is 'set' when it exists (not nil) or when it is not | |||
an empty string. | |||
]] | |||
local function is_set (var) | |||
return not (var == nil or var == ''); | |||
end | |||
--[[--------------------------< I N V E R T _ I T A L I C S >------------------------------------------------- | |||
This function attempts to invert the italic markup a args.text by adding/removing leading/trailing italic markup | |||
in args.text. Like |italic=unset, |italic=invert disables automatic italic markup. Individual leading/trailing | |||
apostrophes are converted to their html numeric entity equivalent so that the new italic markup doesn't become | |||
bold markup inadvertently. | |||
Leading and trailing wiki markup is extracted from args.text into separate table elements. Addition, removal, | |||
replacement of wiki markup is handled by a string.gsub() replacement table operating only on these separate elements. | |||
In the string.gsub() matching pattern, '.*' matches empty string as well as the three expected wiki markup patterns. | |||
This function expects that markup in args.text is complete and correct; if it is not, oddness may result. | |||
]] | ]] | ||
local function | local function invert_italics (source) | ||
local | local invert_pattern_table = { -- leading/trailing markup add/remove/replace patterns | ||
[""]="\'\'", -- empty string becomes italic markup | |||
["\'\'"]="", -- italic markup becomes empty string | |||
["\'\'\'"]="\'\'\'\'\'", -- bold becomes bold italic | |||
["\'\'\'\'\'"]="\'\'\'", -- bold italic become bold | |||
}; | |||
local seg = {}; | |||
source = source:gsub ("%f[\']\'%f[^\']", '''); -- protect single quote marks from being interpreted as bold markup | |||
seg[1] = source:match ('^(\'\'+%f[^\']).+') or ''; -- get leading markup, if any; ignore single quote | |||
seg[3] = source:match ('.+(%f[\']\'\'+)$') or ''; -- get trailing markup, if any; ignore single quote | |||
if '' ~= seg[1] and '' ~= seg[3] then -- extract the 'text' | |||
seg[2] = source:match ('^\'\'+%f[^\'](.+)%f[\']\'\'+$') -- from between leading and trailing markup | |||
elseif '' ~= seg[1] then | |||
seg[2] = source:match ('^\'\'+%f[^\'](.+)') -- following leading markup | |||
elseif '' ~= seg[3] then | |||
seg[2] = source:match ('(.+)%f[\']\'\'+$') -- preceding trailing markup | |||
else | |||
seg[2] = source -- when there is no markup | |||
end | end | ||
seg[1] = invert_pattern_table[seg[1]] or seg[1]; -- replace leading markup according to pattern table | |||
seg[3] = invert_pattern_table[seg[3]] or seg[3]; -- replace leading markup according to pattern table | |||
return table.concat (seg); -- put it all back together and done | |||
return | |||
end | 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-??}} depending on | |||
the individual template's requirements, 'italic' for {{transliteration}}) or to the value appropriate to |script=, if set ({{lang}} | |||
and {{lang-??}} only). | |||
local function | Accepted values and the values that this function returns are are: | ||
if | nil - when |italic= absent or not set; returns nil | ||
return; | default - for completeness, should rarely if ever be used; returns nil | ||
yes - force args.text to be rendered in italic font; returns 'italic' | |||
no - force args.text to be rendered in normal font; returns 'normal' | |||
unset - disables font control so that font-style applied to text is dictated by markup inside or outside the template; returns 'inherit' | |||
invert - disables font control so that font-style applied to text is dictated by markup outside or inverted inside the template; returns 'invert' | |||
]] | |||
local function validate_italic (args) | |||
local properties = {[cfg.keywords_t.affirmative] = 'italic', [cfg.keywords_t.negative] = 'normal', [cfg.keywords_t.unset] = 'inherit', [cfg.keywords_t.invert] = 'invert', [cfg.keywords_t.default] = nil}; | |||
local count = 0 | |||
for _, arg in pairs {'italic', 'italics', 'i'} do | |||
if args[arg] then | |||
count = count + 1 | |||
end | |||
end | |||
if count > 1 then -- return nil and an error message if more than one is set | |||
return nil, cfg.validate_italic_t.multi_italic; | |||
end | end | ||
return properties[args.italic or args.italics or args.i], nil; -- return an appropriate value and a nil error message | |||
end | end | ||
--[[--------------------------< I | --[=[--------------------------< V A L I D A T E _ C A T _ A R G S >---------------------------------------------------------- | ||
Default behavior of the {{lang}} and {{lang-??}} templates is to add categorization when the templates are used in mainspace. | |||
This default functionality may be suppressed by setting |nocat=yes or |cat=no. This function selects one of these two parameters | |||
to control categorization. | |||
Because having two parameters with 'opposite' names and 'opposite' values is confusing, this function accepts only affirmative | |||
values for |nocat= and only negative values for |cat=; in both cases the 'other' sense (and non-sense) is not accepted and the | |||
parameter is treated as if it were not set in the template. | |||
Sets args.nocat to true if categorization is to be turned off; to nil if the default behavior should apply. | |||
Accepted values for |nocat= are the text strings: | |||
'yes', 'y', 'true', 't', on, '1' -- [[Module:Yesno]] returns logical true for all of these; false or nil else | |||
for |cat= | |||
'no', 'n', 'false', 'f', 'off', '0' -- [[Module:Yesno]] returns logical false for all of these; true or nil else | |||
]=] | |||
local function validate_cat_args (args) | |||
if not (args.nocat or args.cat) then -- both are nil, so categorize | |||
return; | |||
end | |||
if false == yesno (args.cat) or true == yesno (args.nocat) then | |||
args.nocat = true; -- set to true when args.nocat is affirmative; nil else (as if the parameter were not set in the template) | |||
else -- args.nocat is the parameter actually used. | |||
args.nocat = nil; | |||
end | |||
end | |||
--[[--------------------------< I N _ A R R A Y >-------------------------------------------------------------- | |||
Whether needle is in haystack. | |||
]] | ]] | ||
local function | local function in_array (needle, haystack) | ||
if needle == nil then | |||
return false; | |||
return | |||
end | end | ||
for n,v in ipairs (haystack) do | |||
if v == needle then | |||
return n; | |||
end | |||
end | end | ||
return false; | |||
end | |||
--[[--------------------------< F O R M A T _ I E T F _ T A G >------------------------------------------------ | |||
-- | Prettify ietf tags to use recommended subtag formats: | ||
code: lower case | |||
script: sentence case | |||
region: upper case | |||
variant: lower case | |||
private: lower case prefixed with -x- | |||
]] | |||
local function format_ietf_tag (code, script, region, variant, private) | |||
local out = {}; | |||
if is_set (private) then | |||
return table.concat ({code:lower(), 'x', private:lower()}, '-'); -- if private, all other tags ignored | |||
end | |||
table.insert (out, code:lower()); | |||
if is_set (script) then | |||
script = script:lower():gsub ('^%a', string.upper); | |||
table.insert (out, script); | |||
end | |||
if is_set (region) then | |||
table.insert (out, region:upper()); | |||
end | |||
if is_set (variant) then | |||
table.insert (out, variant:lower()); | |||
end | |||
return table.concat (out, '-'); | |||
end | |||
--[[--------------------------< G E T _ I E T F _ P A R T S >-------------------------------------------------- | |||
Extracts and returns IETF language tag parts: | |||
primary language subtag (required) - 2 or 3 character IANA language code | |||
script subtag - four character IANA script code | |||
region subtag - two-letter or three digit IANA region code | |||
variant subtag - four digit or 5-8 alnum variant code; only one variant subtag supported | |||
private subtag - x- followed by 1-8 alnum private code; only supported with the primary language tag | |||
in any one of these forms | |||
lang lang-variant | |||
lang-script lang-script-variant | |||
lang-region lang-region-variant | |||
lang-script-region lang-script-region-variant | |||
lang-x-private | |||
each of lang, script, region, variant, and private, when used, must be valid. | |||
if not is_set (source) then | Languages with both two- and three-character code synonyms are promoted to the two-character synonym because | ||
return nil, nil, nil, nil, nil, | the IANA registry file omits the synonymous three-character code; we cannot depend on browsers understanding | ||
end | the synonymous three-character codes in the lang= attribute. | ||
For {{lang-??}} templates, the parameters |script=, |region=, and |variant= are supported (not supported in {{lang}} | |||
because those parameters are superfluous to the IETF subtags in |code=). | |||
Returns six values; all lower case. Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid | |||
parts are returned as nil; the sixth returned item is an error message (if an error detected) or nil. | |||
See http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1. | |||
]] | |||
local function get_ietf_parts (source, args_script, args_region, args_variant) | |||
local code, script, region, variant, private; -- ietf tag parts | |||
if not is_set (source) then | |||
return nil, nil, nil, nil, nil, cfg.get_ietf_parts_t.missing_lang_tag; | |||
end | |||
local pattern = { -- table of tables holding acceptibe ietf tag patterns and short names of the ietf part captured by the pattern | local pattern = { -- table of tables holding acceptibe ietf tag patterns and short names of the ietf part captured by the pattern | ||
| Line 314: | Line 407: | ||
if not code then | if not code then | ||
return nil, nil, nil, nil, nil, | return nil, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_tag, {source}); -- don't know what we got but it is malformed | ||
end | end | ||
| Line 320: | Line 413: | ||
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, | return nil, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_code, {code}); -- invalid language code, don't know about the others (don't care?) | ||
end | 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.insert (maint_cats, substitute (cfg.get_ietf_parts_t.maint_promo_cat, {code})); | ||
table.insert (maint_msgs, | table.insert (maint_msgs, substitute (cfg.get_ietf_parts_t.maint_promo_msg, {code, synonym_table[code]})); | ||
code = synonym_table[code]; -- use the synonym | code = synonym_table[code]; -- use the synonym | ||
end | end | ||
| Line 331: | Line 424: | ||
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, cfg.get_ietf_parts_t.redundant_scr; -- both code with script and |script= not allowed | ||
end | end | ||
else | else | ||
| Line 340: | Line 433: | ||
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, | return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_scr_code, {script, code}); -- language code ok, invalid script, don't know about the others (don't care?) | ||
end | end | ||
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, | return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.script_code, {script, code}); -- language code ok, script is suppressed for this code | ||
end | end | ||
end | end | ||
| Line 351: | Line 444: | ||
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, cfg.get_ietf_parts_t.redundant_reg; -- both code with region and |region= not allowed | ||
end | end | ||
else | else | ||
| Line 360: | Line 453: | ||
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, | return code, script, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_reg_code, {region, code}); | ||
end | end | ||
end | end | ||
| Line 366: | Line 459: | ||
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, cfg.get_ietf_parts_t.redundant_var; -- both code with variant and |variant= not allowed | ||
end | end | ||
else | else | ||
| Line 375: | Line 468: | ||
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, | return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var, {variant}); | ||
end -- does this duplicate/replace tests in lang() and lang_xx()? | 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, | return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_scr, {variant, 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, | return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_reg, {variant, 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, | return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code, {variant, code}); | ||
end | end | ||
end | end | ||
| Line 397: | Line 490: | ||
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, | return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_pri, {private}); | ||
end | end | ||
end | end | ||
| Line 404: | Line 497: | ||
--[[ | --[=[-------------------------< M A K E _ W I K I L I N K >---------------------------------------------------- | ||
Makes a wikilink; when both link and display text is provided, returns a wikilink in the form [[L|D]]; if only | |||
link is provided, returns a wikilink in the form [[L]]; if neither are provided or link is omitted, returns an | |||
empty string. | |||
]] | ]=] | ||
local function | local function make_wikilink (link, display) | ||
return | if is_set (link) then | ||
if is_set (display) then | |||
return table.concat ({'[[', link, '|', display, ']]'}); | |||
else | |||
return table.concat ({'[[', link, ']]'}); | |||
end | |||
else | |||
return ''; | |||
end | |||
end | end | ||
--[[--------------------------< M A K | --[[--------------------------< 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 | local function div_markup_add (text, style) | ||
if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text | |||
if 'italic' == style then | |||
return text:gsub ('(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item | |||
else | |||
return text; | |||
end | |||
end | end | ||
-- | if text:find ('\n+') then -- look for any number of \n characters in text | ||
text = text:gsub ('([^\n])\n([^\n])', '%1 %2'); -- replace single newline characters with a space character which mimics mediawiki | |||
if 'italic' == style then | |||
text = text:gsub('[^\n]+', '<p><i>%1</i></p>'); -- insert p and italic markup tags at each impled p (two or more consecutive '\n\n' sequences) | |||
if | |||
else | else | ||
text = text:gsub ('[^\n]+', '<p>%1</p>'); -- insert p markup at each impled p | |||
text = text:gsub ('\n', ''); -- strip newline characters | |||
end | end | ||
end | end | ||
return text; | |||
end | 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 | local function title_wrapper_make (title_text, content_text, tag) | ||
local | 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 | |||
--[[--------------------------< 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 | |||
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 | local function make_text_html (code, text, tag, rtl, style, size, language) | ||
local | local html_t = {}; | ||
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 | |||
end | 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 | |||
end | |||
if 'span' == tag then -- default html tag for inline content | |||
if 'italic' == style then -- but if italic | |||
tag = 'i'; -- change to <i> tags | |||
end | |||
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_t, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag | ||
code = code:gsub ('%-x%-.*', ''); -- strip private use subtag from code tag because meaningless outside of wikipedia | |||
table.insert (html_t, table.concat ({' lang="', code, '\"'})); -- add language attribute | |||
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 (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 | |||
if 'normal' == style then -- when |italic=no | |||
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 | |||
end | |||
if is_set (size) then -- when |size=<something> | |||
if is_set (style_added) then | |||
table.insert (html_t, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted | |||
else | |||
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 | |||
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 | |||
if | 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 = substitute ('$1 $2', {language, cfg.make_text_html_t.zxx}); -- not a language so don't use 'language' in title text | |||
elseif mw.ustring.find (language, 'languages', 1, true) then | |||
title_text = substitute ('$1 $2', {language, cfg.make_text_html_t.collective}); -- for collective languages | |||
else | |||
title_text = substitute ('$1-$2', {language, cfg.make_text_html_t.individual}); -- for individual languages | |||
end | |||
return title_wrapper_make (title_text, table.concat (html_t), wrapper_tag); | |||
else | |||
return table.concat (html_t); | |||
else | |||
end | end | ||
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): | |||
[[Category:Articles with text in <language> languages]] | |||
]=] | |||
if | local function make_category (code, language_name, nocat, name_get) | ||
if ((0 ~= namespace) or nocat) and not name_get then -- only categorize in article space | |||
return ''; -- return empty string for concatenation | |||
end | end | ||
if | if mw.ustring.find (language_name, 'languages', 1, true) then | ||
return substitute ('[[$1 $2]]', {cfg.make_category_t.collective_cat, language_name}); | |||
end | end | ||
if this_wiki_lang_tag == code then | |||
return substitute ('[[$1 $2 $3-$4]]', { -- unique category name for the local language | |||
cfg.make_category_t.cat_prefix, | |||
cfg.make_category_t.explicit_cat, | |||
language_name, | |||
cfg.make_category_t.cat_postfix, | |||
}); | |||
else | else | ||
return | return substitute ('[[$1 $2-$3]]', { -- category for individual languages | ||
cfg.make_category_t.cat_prefix, | |||
language_name, | |||
cfg.make_category_t.cat_postfix, | |||
}); | |||
end | end | ||
end | end | ||
--[ | --[[--------------------------< M A K E _ T R A N S L I T >---------------------------------------------------- | ||
Return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string. | |||
for | The value |script= is not used in {{transliteration}} for this purpose; instead it uses |code. Because language scripts | ||
are listed in the {{transliteration}} 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 {{transliteration}}, style only applies when a language code is provided. | |||
]] | |||
local function make_translit (code, language_name, translit, std, tscript, style, engvar) | |||
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 | |||
local function make_translit (code, language_name, translit, std, tscript, style, engvar) | |||
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 not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified | if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified | ||
title_text = language_name; -- write a generic tool tip | 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) | 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 .. | title_text = substitute ('$1-$2', {title_text, cfg.misc_text_t.language}); -- skip this text (individual and macro languages only) | ||
end | end | ||
title_text = substitute ('$1 $2', {title_text, | title_text = substitute ('$1 $2', {title_text, mw.ustring.lower (cfg.engvar_t[engvar]['romanisz_lc'])}); -- 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 | ||
| Line 674: | Line 726: | ||
if title_t[std][tscript] then -- and if script for that standard is legitimate | if title_t[std][tscript] then -- and if script for that standard is legitimate | ||
if script_table[tscript] then | if script_table[tscript] then | ||
title_text = | title_text = substitute ('$1$2 ($3 $4) $5', { -- add the appropriate text to the tool tip | ||
title_text, | |||
title_t[std][tscript:lower()], | |||
script_table[tscript], | |||
cfg.make_translit_t.script, | |||
cfg.make_translit_t.transliteration, | |||
}); | |||
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? | 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? | ||
| Line 689: | Line 747: | ||
if title_t[std][code] then -- if language code is in the table (transl may not provide a language code) | if title_t[std][code] then -- if language code is in the table (transl may not provide a language code) | ||
title_text = | title_text = substitute ('$1$2 ($3 $4) $5', { -- add the appropriate text to the tool tip | ||
title_text, | |||
title_t[std][code:lower()], | |||
language_name, | |||
cfg.misc_text_t.language, | |||
cfg.make_translit_t.transliteration, | |||
}); | |||
else -- code doesn't match | else -- code doesn't match | ||
title_text = title_text .. title_t[std]['default']; -- so use the standard's default | title_text = title_text .. title_t[std]['default']; -- so use the standard's default | ||
| Line 701: | Line 765: | ||
else | else | ||
if is_set (tscript) then | if is_set (tscript) then | ||
title_text = | title_text = substitute ('$1$2-$3 $4', { -- write a script tool tip | ||
title_text, | |||
language_name, | |||
cfg.make_translit_t.script, | |||
cfg.make_translit_t.transliteration, | |||
}); | |||
elseif is_set (code) then | elseif is_set (code) then | ||
if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name) | 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 = substitute ('$1-$2', { -- skip this text (individual and macro languages only) | ||
title_text, | |||
cfg.misc_text_t.language, | |||
}); | |||
end | end | ||
title_text = substitute ('$1 $2', { -- finish the tool tip | |||
title_text, | |||
cfg.make_translit_t.transliteration, | |||
}); | |||
else | else | ||
title_text = substitute ('$1 $2', { -- generic tool tip (can we ever get here?) | |||
title_text, | |||
cfg.make_translit_t.transliteration, | |||
}); | |||
end | end | ||
end | end | ||
end | end | ||
local | local tag | ||
if is_set (code) then -- when a language code is provided (always with {{lang-??}} templates, not always with {{transliteration}}) | if is_set (code) then -- when a language code is provided (always with {{lang-??}} templates, not always with {{transliteration}}) | ||
code = code:match ('^(%a%a%a?)'); -- strip all subtags leaving only the language subtag | code = code:match ('^(%a%a%a?)'); -- strip all subtags leaving only the language subtag | ||
if not style then -- nil for the default italic style | if not style then -- nil for the default italic style | ||
tag = '<i lang="%s-Latn">%s</i>' | |||
else | else | ||
tag = '<span style="font-style: %s" lang="%s-Latn">%s</span>' -- non-standard style, construct a span tag for it | |||
tag = string.format(tag, style, "%s", "%s") | |||
end | end | ||
tag = string.format(tag, code, "%s") | |||
else | else | ||
tag = '<span>%s</span>' -- when no language code: no lang= attribute, not italic ({{transliteration}} only) | |||
end | end | ||
tag = string.format(tag, translit) -- add the translit text | |||
if '' == title_text then -- when there is no need for a tool-tip | if '' == title_text then -- when there is no need for a tool-tip | ||
return | return tag; -- done | ||
else | else | ||
title_text = | title_text = cfg.engvar_sel_t.gb == engvar and title_text:gsub ('([Rr]omani)z', '%1s') or title_text; -- gb eng when engvar specifies gb eng; us eng else | ||
return title_wrapper_make (title_text, | return title_wrapper_make (title_text, tag, 'span'); -- wrap with a tool-tip span and done | ||
end | end | ||
end | end | ||
| Line 746: | Line 819: | ||
This function checks the content of args.text and returns empty string if nothing is amiss else it returns an | This function checks the content of args.text and returns empty string if nothing is amiss else it returns an | ||
error message. | 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 | Italic rendering is controlled by the |italic= template parameter so italic markup should never appear in args.text | ||
| Line 755: | Line 828: | ||
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 (cfg.validate_text_t.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 (cfg.validate_text_t.malformed_markup, args, template); | ||
end | end | ||
local style = args.italic; | local style = args.italic; | ||
if ( | if (cfg.keywords_t.unset ~= style) and (cfg.keywords_t.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 (cfg.validate_text_t.italic_markup, args, template); | ||
end | end | ||
end | end | ||
| Line 774: | Line 847: | ||
--[[--------------------------< R E N D E R _ M A I N T >------------------------------------------------------ | --[[--------------------------< R E N D E R _ M A I N T >------------------------------------------------------ | ||
Render mainenance messages and categories. | |||
]] | ]] | ||
local function render_maint(nocat) | local function render_maint (nocat) | ||
local maint = {}; | local maint = {}; | ||
| Line 801: | Line 874: | ||
--[[--------------------------< P R O T O _ P R E F I X >------------------------------------------------------ | --[[--------------------------< P R O T O _ P R E F I X >------------------------------------------------------ | ||
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). | will be rendered outside of italic markup (if used). If the first character in text here is already a splat, we | ||
do nothing | do nothing. | ||
proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and | proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and inhibits | ||
regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac | regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac. | ||
]] | ]] | ||
| Line 823: | Line 896: | ||
--[[--------------------------< H A S _ P O E M _ T A G >------------------------------------------------------ | --[[--------------------------< 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. | the content that will replace the stripmarker. | ||
| Line 880: | Line 953: | ||
--[[--------------------------< V A L I D A T E _ P R O T O >-------------------------------------------------- | --[[--------------------------< 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 | empty string (or parameter omitted) returns as nil; any other value returns nil with <proto_param> as second | ||
return value for use in error message. | |||
]] | ]] | ||
local function validate_proto (proto_param) | local function validate_proto (proto_param) | ||
if | if cfg.keywords_t.affirmative == proto_param then | ||
return true; | return true; | ||
elseif | elseif cfg.keywords_t.negative == proto_param then | ||
return false; | return false; | ||
elseif is_set (proto_param) then | elseif is_set (proto_param) then | ||
return nil, | return nil, proto_param; -- |proto= something other than 'yes' or 'no' | ||
else | else | ||
return nil; -- missing or empty | return nil; -- missing or empty | ||
| Line 901: | Line 974: | ||
--[[--------------------------< L A N G U A G E _ N A M E _ G E T >-------------------------------------------- | --[[--------------------------< 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. | |||
]] | ]] | ||
| Line 923: | Line 996: | ||
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.insert (maint_cats, substitute (cfg.language_name_get_t.deprecated_cat, {code})); | ||
table.insert (maint_msgs, | table.insert (maint_msgs, substitute (cfg.language_name_get_t.deprecated_msg, {code})); | ||
end | end | ||
| Line 931: | Line 1,004: | ||
--[[--------------------------< _ | --[[--------------------------< T E X T _ S C R I P T _ M A T C H _ T E S T >---------------------------------- | ||
IETF script subtag should match the script of the <text>. This module does not attempt to know all scripts and | |||
what they look like. It does know what Latn script looks like so when <text> is written using other than the Latn | |||
script, the IETF script subtag, if present, should not be Latn. | |||
Conversely, when <text> is written using the Latn script, the IETF script subtag, if present, should be Latn. | |||
For the purposes of this test, Latf (Fraktur) and Latg (Gaelic) are considered to be equivalent to Latn because | |||
unicode treats these two scripts as font-specific variants of Latn. | |||
Returns an error message when mismatch detected; nil else. | |||
]] | ]] | ||
local function | local function text_script_match_test (script, is_latn_text, pos) | ||
local | local scripts_t = {['latf'] = true, ['latg'] = true, ['latn'] = true}; -- unicode 'latn' scripts; 'latf' and 'latg' are font variants so there are no Fraktur or Gaelic codepoints | ||
if is_set (script) then -- don't bother with the rest of this if <script> is nil or empty string | |||
script = script:lower(); -- lower case to index into <scripts_t> | |||
if is_latn_text then -- when text is wholly Latn script | |||
if not scripts_t[script] then -- but a non-Latn script is specified | |||
return cfg.text_script_match_test_t.latn_txt_mismatch; -- emit an error message | |||
end | |||
else -- when text is not wholly Latn script | |||
if scripts_t[script] then -- but a Latn script is specified | |||
return substitute (cfg.text_script_match_test_t.latn_scr_mismatch, {pos}); -- emit an error message with position of first offending character | |||
end | |||
end | |||
end | |||
end | |||
--[[--------------------------< I S _ L A T I N >-------------------------------------------------------------- | |||
Created because unicode does not have Latin theta 'θ' character. The Greek 'θ' is, apparently, commonly used | |||
in certain romanizations. This function attempts to discover if <text> script is Latn with Greek 'θ' or some | |||
other script with Greek 'θ'. | |||
when <text> is or has Greek 'θ': | |||
for {{lang}}, {{langx}}, and {{lang-??}}, returns boolean true when <text>: | |||
has theta and all other characters are Latn | |||
has theta as the only character, <script> is Latn | |||
for {{transliteration}}, returns boolean true when <text>: | |||
has theta and all other characters are Latn | |||
has theta as the only character | |||
]] | |||
local function is_latin (text, script, transl) | |||
text = mw.text.decode (text); -- convert html entities to characters | |||
script = (script and script:lower()) or nil; -- ensure lowercase for comparisons | |||
local whitelist = '[ʻʼʽʾʿΔαβγδθλσφχϑъьӾӿᾱῑ῾上入去平阳阴]' | |||
if not transl then -- testing {{lang}} or {{langx}} <text> | |||
if '' == mw.ustring.gsub (text, whitelist, '') then -- when <text> uses only whitelisted characters | |||
return ('latn' == script); -- true when latn script; false when other script or no script | |||
end | |||
end | end | ||
if | if mw.ustring.find (text, whitelist) then -- does <text> contain characters from the whitelist? | ||
text = mw.ustring.gsub (text, whitelist, 'x'); -- replace whitelisted characters from <text> with known Latn-script char 'x' | |||
-- if 0 == text:len() then -- will be zero if theta was the only character in <text> | |||
if '' == text then -- will be empty string if the only character(s) in <text> are in <whitelist> | |||
if transl then -- not nil for {{transliteration}}; assume Latn because this is 'transliteration' template | |||
return true; | |||
end | |||
return (script and ('latn' == script)) or false; -- {{lang}}, {{langx}}, and {{lang-??}}; true when script is Latn; false else | |||
end | |||
return unicode.is_Latin (text); -- return true when all characters in modified <text> are Latn script; false else | |||
end | end | ||
return unicode.is_Latin (text); -- return true when all characters in <text> are Latn script; false else | |||
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). | |||
]] | |||
if | 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 cfg.templates_t.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 | |||
return | if args[1] and args.code then | ||
end | return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {'1', cfg.lang_t.conflict_n_param_types.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 (substitute (cfg.lang_t.conflict_n_param, {'2', cfg.lang_t.conflict_n_param_types.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 == cfg.keywords_t.affirmative; -- 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 (substitute (cfg.lang_t.invalid_proto, {msg}), 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 | |||
local is_latn_text, pos = is_latin (args.text, subtags.script); -- make a boolean | |||
msg = text_script_match_test (subtags.script, is_latn_text, pos) | |||
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 -- nil when |italic= absent or not set or |italic=default; args.italic controls | |||
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 is_latn_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 | else | ||
args.italic = 'inherit'; -- italic not set; script not latn; inherit current style | |||
end | |||
end | |||
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 | ||
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 cfg.keywords_t.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 | |||
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 | local function lang (frame) | ||
local args_t = 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 | |||
end | |||
return nil; -- value was empty or contained only whitespace | |||
end -- end of valueFunc | |||
}); | |||
args_t.fn = nil; -- unset because not supported but this function might have been called by {{lang|fn=lang|...}} | |||
local msg = parameter_validate (args_t, cfg.templates_t.lang); -- verify that all supplied parameters are supported by {{lang-??}} | |||
if msg then | |||
return make_error_msg (msg, args_t, cfg.templates_t.lang); -- when template has unsupported params, abandon with error message | |||
local | end | ||
return _lang (args_t); | |||
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}}. | |||
]] | |||
if | 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 cfg.keywords_t.negative == args_t.link then | |||
table.insert (translation_t, substitute ('<abbr title="$1">$2</abbr>', {cfg.translation_make_t.lit_xlation, cfg.translation_make_t.lit_abbr})); -- unlinked form | |||
else | |||
table.insert (translation_t, make_wikilink (cfg.translation_make_t.lit_xlation, cfg.translation_make_t.lit_abbr)); -- linked form | |||
end | |||
table.insert (translation_t, " </small>"); -- close the <small> html tag | |||
end | 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 | |||
--[[--------------------------< _ L A N G _ X X >-------------------------------------------------------------- | |||
For the {{lang-??}} 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-??}} templates for languages | |||
that can have multiple writing systems, it may be appropriate to set |script= as well. | |||
For each {{lang-??}} 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: | |||
if nil == args.italic then | <includeonly>{{#invoke:lang|lang_xx_inherit|code=xx}}</includeonly> | ||
if is_set (subtags.script) then | 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 | |||
end | |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-??}} 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-??}}, the positional parameters are: | |||
{{{1}}} text | |||
{{{2}}} transliterated text | |||
{{{3}}} literal translation text | |||
no other positional parameters are allowed | |||
]] | |||
local function _lang_xx (args, base_template) -- base_template will be either of 'Langx' or 'Lang-xx' | |||
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 msg; -- for error messages | |||
local tag = 'span'; -- initial value for make_text_html() | |||
local template = args.template or base_template; | |||
maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once | |||
maint_msgs = {}; | |||
local text_idx = (cfg.templates_t.langx == base_template) and 2 or 1; -- for {{langx}} 'text' positional parameter is '2' | |||
local translit_idx = (cfg.templates_t.langx == base_template) and 3 or 2; | |||
local xlate_idx = (cfg.templates_t.langx == base_template) and 4 or 3; | |||
if args[text_idx] and args.text then | |||
return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {translit_idx, cfg.lang_t.conflict_n_param_types.text}), args, template); | |||
else | |||
args.text = args[text_idx] or args.text; -- prefer positional 'text' parameter | |||
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[translit_idx] and args.translit then | |||
return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {translit_idx, cfg.lang_t.conflict_n_param_types.translit}), args, template); | |||
else | |||
args.translit = args[translit_idx] or args.translit -- prefer positional 'translit' parameter | |||
end | |||
if args.translit then | |||
local latn, pos = is_latin (args.translit, nil, true); | |||
if not latn then | |||
return make_error_msg (substitute (cfg.lang_xx_t.translit_nonlatn, {pos}), args, template); | |||
end | |||
end | |||
args.engvar = cfg.engvar_sel_t[args.engvar] or cfg.default_engvar; -- |engvar= when valid; cfg.default_engvar else | |||
if args[xlate_idx] and (args.translation or args.lit) then | |||
return make_error_msg (substitute (cfg.lang_xx_t.conflict_n_lit, {translit_idx}), args, template); | |||
elseif args.translation and args.lit then | |||
return make_error_msg (cfg.lang_xx_t.conflict_lit, args, template); | |||
else | |||
args.translation = args[xlate_idx] or args.translation or args.lit; -- prefer positional 'translation' parameter | |||
end | |||
if args.links and args.link then | |||
return make_error_msg (cfg.lang_xx_t.conflict_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 == cfg.keywords_t.affirmative; -- 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 | |||
local is_latn_text, pos = is_latin (args.text, subtags.script); -- make a boolean | |||
msg = text_script_match_test (subtags.script, is_latn_text, pos) | |||
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 cfg.templates_t.langx == base_template then -- auto-italics for {{langx}} templates; adapted from {{lang}} (no support for poem tag) | |||
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_tag ~= code and not is_set (subtags.script) and is_latn_text) then -- text is not this wiki's language, no script specified and is wholly latn script (auto-italics) | |||
args.italic = 'italic'; -- set font-style:italic | |||
else | |||
args.italic = 'inherit'; -- italic not set; script not latn; inherit current style | |||
end | |||
end | |||
else -- {{lang-xx}} does not do auto italics; retained for those wikis that don't support {{langx}} | |||
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> | |||
end | |||
end | |||
end | |||
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 (substitute (cfg.lang_t.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 cfg.keywords_t.negative == args.link then | |||
table.insert (out, language_name); -- language name without wikilink | |||
else | |||
if mw.ustring.find (language_name, 'languages', 1, true) then | |||
table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink | |||
elseif lang_data.article_name[args.code:lower()] then -- is ietf tag in article name over ride? | |||
table.insert (out, make_wikilink (lang_data.article_name[args.code:lower()], language_name)); -- language name with wikilink from override data | |||
elseif lang_data.article_name[code] then -- is language tag in article override | |||
table.insert (out, make_wikilink (lang_data.article_name[code], language_name)); -- language name with wikilink from override data | |||
else | |||
table.insert (out, make_wikilink (substitute ('$1 $2', {language_name, cfg.misc_text_t.language}), language_name)); -- language name with wikilink | |||
end | |||
end | |||
table.insert (out, ': '); -- separator | |||
end | |||
if cfg.keywords_t.invert == args.italic then | |||
args.text = invert_italics (args.text) | |||
end | 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, ('none' == args.label) and language_name or nil)) | |||
args. | if is_set (args.translit) and not is_latn_text then -- transliteration; 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']]; | |||
else | |||
translit_script_name = language_name; -- fall back on language name | |||
end | |||
local translit_title_obj = mw.title.makeTitle (0, substitute ('$1 $2',{cfg.lang_xx_t.romanization, translit_script_name})); -- make a title object; no engvar, article titles use US spelling | |||
if translit_title_obj.exists and (cfg.keywords_t.negative ~= args.link) then | |||
table.insert (out, make_wikilink (substitute ('$1 $2', {cfg.lang_xx_t.romanization, translit_script_name or language_name}), | |||
substitute ('$1', {cfg.engvar_t[args.engvar]['romanisz_pt']})) .. ':'); -- make a wikilink if there is an article to link to; engvar the display text | |||
else | |||
table.insert (out, substitute ('$1:', {cfg.engvar_t[args.engvar]['romanisz_pt']})); -- else plain text per engvar | |||
end | |||
table.insert (out, ' </small>'); -- close the small tag | |||
table.insert (out | |||
end | end | ||
translit = make_translit (args.code, language_name, args.translit, args['translit-std'], args['translit-script'], nil, args.engvar) | |||
table.insert (out, | if is_set (translit) then | ||
table.insert (out, translit); | |||
else | else | ||
return make_error_msg (substitute ('$1: $2', {cfg.lang_xx_t.invalid_xlit_std, args['translit-std'] or '[missing]'}), args, template); | |||
end | end | ||
elseif is_set (args.translit) and is_latn_text then -- when creating a transliteration of Latn script <text> | |||
return make_error_msg (cfg.lang_xx_t.xlit_of_latn, args, template); -- emit error message and abandon | |||
end | end | ||
if is_set (args.translation) then -- translation (not supported in {{lang}}) | |||
table.insert (out, translation_make (args)); | |||
if is_set (args.translation) then -- translation (not supported in {{lang}}) | |||
table.insert (out, translation_make (args)); | |||
end | end | ||
| Line 1,311: | Line 1,494: | ||
--[[--------------------------< L A N G _ X X _ A R G S _ G E T >---------------------------------------------- | --[[--------------------------< 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. | |||
Text positional parameters are not trimmed here but are selectively trimmed at html_tag_select(). | |||
]] | ]] | ||
| Line 1,324: | Line 1,507: | ||
parentFirst= true, -- parameters in the template override parameters set in the {{#invoke:}} | parentFirst= true, -- parameters in the template override parameters set in the {{#invoke:}} | ||
valueFunc = function (key, value) | valueFunc = function (key, value) | ||
if (( | if ((cfg.templates_t.langx == base_template) and 2 or 1) == key then -- the 'text' positional parameter; 1 for {{lang-??}}, 2 for {{langx}}; do not trim wite space | ||
return value; -- return untrimmed 'text' positional parameter | return value; -- return untrimmed 'text' positional parameter | ||
elseif value then -- all other values: if the value is not nil | elseif value then -- all other values: if the value is not nil | ||
| Line 1,342: | Line 1,525: | ||
--[[--------------------------< L A N G _ X X _ I T A L I C >-------------------------------------------------- | --[[--------------------------< L A N G _ X X _ I T A L I C >-------------------------------------------------- | ||
Entry point for those {{lang-??}} templates that call lang_xx_italic(). | Entry point for those {{lang-??}} templates that call lang_xx_italic(). Sets the initial style state to italic. | ||
]] | ]] | ||
local function lang_xx_italic (frame) | local function lang_xx_italic (frame) | ||
local args = lang_xx_args_get (frame, | local args = lang_xx_args_get (frame, cfg.templates_t.langxx); | ||
args.fn = nil; -- unset because not supported but this function might have been called by {{lang|fn=lang_xx_italic|...}} | |||
local msg = parameter_validate (args, cfg.templates_t.langxx); -- verify that all supplied parameters are supported by {{lang-??}} | |||
if msg then | |||
return make_error_msg (msg, args, cfg.templates_t.langxx); -- when template has unsupported params, abandon with error message | |||
end | |||
initial_style_state = 'italic'; | initial_style_state = 'italic'; | ||
return _lang_xx (args, | return _lang_xx (args, cfg.templates_t.langxx) .. '[[Category:Pages using Lang-xx templates]]'; -- temporary category | ||
end | end | ||
| Line 1,356: | Line 1,545: | ||
--[[--------------------------< _ L A N G _ X X _ I T A L I C >------------------------------------------------ | --[[--------------------------< _ L A N G _ X X _ I T A L I C >------------------------------------------------ | ||
Entry point from another module. | Entry point from another module. Sets the initial style state to italic. | ||
]] | ]] | ||
| Line 1,362: | Line 1,551: | ||
local function _lang_xx_italic (args) | local function _lang_xx_italic (args) | ||
initial_style_state = 'italic'; | initial_style_state = 'italic'; | ||
return _lang_xx (args, | return _lang_xx (args, cfg.templates_t.langxx); | ||
end | end | ||
| Line 1,368: | Line 1,557: | ||
--[[--------------------------< L A N G _ X X _ I N H E R I T >------------------------------------------------ | --[[--------------------------< L A N G _ X X _ I N H E R I T >------------------------------------------------ | ||
Entry point for those {{lang-??}} templates that call lang_xx_inherit(). | Entry point for those {{lang-??}} templates that call lang_xx_inherit(). Sets the initial style state to inherit. | ||
]] | ]] | ||
local function lang_xx_inherit (frame) | local function lang_xx_inherit (frame) | ||
local args = lang_xx_args_get (frame, | local args = lang_xx_args_get (frame, cfg.templates_t.langxx); | ||
args.fn = nil; -- unset because not supported but this function might have been called by {{lang|fn=lang_xx_inherit|...}} | |||
local msg = parameter_validate (args, cfg.templates_t.langxx); -- verify that all supplied parameters are supported by {{lang-??}} | |||
if msg then | |||
return make_error_msg (msg, args, cfg.templates_t.langxx); -- when template has unsupported params, abandon with error message | |||
end | |||
initial_style_state = 'inherit'; | initial_style_state = 'inherit'; | ||
return _lang_xx (args, | return _lang_xx (args, cfg.templates_t.langxx) .. '[[Category:Pages using Lang-xx templates]]'; -- temporary category | ||
end | end | ||
| Line 1,382: | Line 1,577: | ||
--[[--------------------------< _ L A N G _ X X _ I N H E R I T >---------------------------------------------- | --[[--------------------------< _ L A N G _ X X _ I N H E R I T >---------------------------------------------- | ||
Entry point from another module. | Entry point from another module. Sets the initial style state to inherit. | ||
]] | ]] | ||
| Line 1,388: | Line 1,583: | ||
local function _lang_xx_inherit (args) | local function _lang_xx_inherit (args) | ||
initial_style_state = 'inherit'; | initial_style_state = 'inherit'; | ||
return _lang_xx (args, | return _lang_xx (args, cfg.templates_t.langxx); | ||
end | end | ||
| Line 1,400: | Line 1,595: | ||
local function _langx (args_t) | local function _langx (args_t) | ||
local langx_data = mw.loadData ('Module:Lang/langx'); -- get necessary data | local langx_data = mw.loadData ('Module:Lang/langx'); -- get necessary data | ||
local rtl_t = langx_data.rtl_t; -- get list of language tags for languages that are rendered right-to-left | local rtl_t = langx_data.rtl_t; -- get list of language tags for languages that are rendered right-to-left | ||
local link_t = langx_data.link_t; -- get list of language tags for {{lang-??}} templates that set |link=<something> | local link_t = langx_data.link_t; -- get list of language tags for {{lang-??}} templates that set |link=<something> | ||
local size_t = langx_data.size_t; -- get list of language tags for {{lang-??}} templates that set |size=<something> | local size_t = langx_data.size_t; -- get list of language tags for {{lang-??}} templates that set |size=<something> | ||
local msg = parameter_validate (args_t, cfg.templates_t.langx); | |||
if msg then | |||
return make_error_msg (msg, args_t, cfg.templates_t.langx); | |||
end | |||
args_t.code = args_t[1] or args_t.code; -- get the language tag; must be {{{1}}} or |code= | args_t.code = args_t[1] or args_t.code; -- get the language tag; must be {{{1}}} or |code= | ||
if not args_t.code then | if not args_t.code then | ||
return make_error_msg ( | return make_error_msg (cfg.get_ietf_parts_t.missing_lang_tag, args_t, cfg.templates_t.langx); | ||
end | end | ||
args_t.rtl = args_t.rtl or (rtl_t[args_t.code] and | args_t.rtl = args_t.rtl or (rtl_t[args_t.code] and cfg.keywords_t.affirmative); -- prefer |rtl= in template call, use rtl_t else | ||
args_t.link = args_t.link or link_t[args_t.code]; -- prefer |link= in template call, use link_t felse | args_t.link = args_t.link or link_t[args_t.code]; -- prefer |link= in template call, use link_t felse | ||
args_t.size = args_t.size or size_t[args_t.code]; -- prefer |size= in template call, use size_t else | args_t.size = args_t.size or size_t[args_t.code]; -- prefer |size= in template call, use size_t else | ||
| Line 1,419: | Line 1,616: | ||
local lang_subtag = args_t.code; -- use only the base language subtag for unsupported tag test; some args_t.code are modified by |script= etc | local lang_subtag = args_t.code; -- use only the base language subtag for unsupported tag test; some args_t.code are modified by |script= etc | ||
return _lang_xx (args_t, cfg.templates_t.langx); | |||
return _lang_xx (args_t, | |||
end | end | ||
| Line 1,429: | Line 1,624: | ||
Entry point for {{langx}}. | Entry point for {{langx}}. | ||
this function calls _lang_xx() to render non-English text. | this function calls _lang_xx() to render non-English text. The {{lang-??}} templates have three positional paramters | ||
but {{langx}} has four: | but {{langx}} has four: | ||
| 1 | 2 | 3 | 4 | | 1 | 2 | 3 | 4 | ||
{{lang-xx |<text> |<transl> |<xlate> }} | {{lang-xx |<text> |<transl> |<xlate> }} | ||
{{langx |<tag> |<text> |<transl> |<xlate> }} | {{langx |<tag> |<text> |<transl> |<xlate> }} | ||
The calls to lang_xx_args_get() and _lang_xx() use 'Langx' as a flag for those functions to select the proper | The calls to lang_xx_args_get() and _lang_xx() use 'Langx' as a flag for those functions to select the proper | ||
positional parameters. | positional parameters. | ||
{{lang-??}} depends on the calling template to select 'inherit' or 'italic' | {{lang-??}} depends on the calling template to select 'inherit' or 'italic' to establish the default rendering. | ||
{{langx}} can't do that | |||
{{langx}} can't do that. The initial version of {{langx}} relied on a list of language tags (inherit_t in ~/langx) | |||
scraped from those {{lang-??}} templates that call lang_xx_inherit() to render text in upright font. Langx now | |||
uses auto-italics code adapted from {{lang}} (doesn't support poem tags). | |||
]] | ]] | ||
local function langx (frame) | local function langx (frame) | ||
local args_t = lang_xx_args_get (frame, | local args_t = lang_xx_args_get (frame, cfg.templates_t.langx); -- get the arguments; 'Langx' is the <base_template> used to decide which positional param is 'text', 'translit', 'lit' | ||
return _langx (args_t); | return _langx (args_t); | ||
| Line 1,458: | Line 1,655: | ||
All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function. | All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function. | ||
Module entry point from another module | Module entry point from another module. | ||
]] | ]] | ||
| Line 1,472: | Line 1,669: | ||
--[[--------------------------< I S _ I E T F _ T A G >-------------------------------------------------------- | --[[--------------------------< I S _ I E T F _ T A G >-------------------------------------------------------- | ||
Module entry point from an {{#invoke:}} | Module entry point from an {{#invoke:}}. | ||
]] | ]] | ||
| Line 1,502: | Line 1,699: | ||
Set invoke's |link= parameter to yes to get wikilinked version of the language name. | Set invoke's |link= parameter to yes to get wikilinked version of the language name. | ||
Module entry point from another module | Module entry point from another module. | ||
]] | ]] | ||
| Line 1,509: | Line 1,706: | ||
local subtags = {}; -- IETF subtags script, region, variant, and private | local subtags = {}; -- IETF subtags script, region, variant, and private | ||
local raw_code = args[1]; -- save a copy of the input IETF subtag | local raw_code = args[1]; -- save a copy of the input IETF subtag | ||
local link = | local link = cfg.keywords_t.affirmative == args['link']; -- make a boolean | ||
local label = args.label; | local label = args.label; | ||
local code; -- the language code | local code; -- the language code | ||
| Line 1,518: | Line 1,715: | ||
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 | return make_error_span (template, msg); | ||
end | end | ||
| Line 1,524: | Line 1,721: | ||
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_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()', ''); | if 'yes' ~= args.raw then | ||
language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them | |||
end | |||
if link then -- when |link=yes, wikilink the language name | if link then -- when |link=yes, wikilink the language name | ||
| Line 1,534: | Line 1,733: | ||
language_name = make_wikilink (lang_data.article_name[code], label or language_name); -- language name with wikilink from override data | 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 .. | language_name = make_wikilink (substitute ('$1 $2', {language_name, cfg.misc_text_t.language}), label or language_name); -- language name with wikilink | ||
end | end | ||
end | end | ||
| Line 1,544: | Line 1,743: | ||
--[[--------------------------< N A M E _ F R O M _ T A G >---------------------------------------------------- | --[[--------------------------< N A M E _ F R O M _ T A G >---------------------------------------------------- | ||
Module entry point from an {{#invoke:}} | Module entry point from an {{#invoke:}}. | ||
]] | ]] | ||
| Line 1,559: | Line 1,758: | ||
that disambiguator must be omitted (they are not present in the data name-to-tag tables). | that disambiguator must be omitted (they are not present in the data name-to-tag tables). | ||
Module entry point from another module | Module entry point from another module. | ||
]] | ]] | ||
| Line 1,574: | Line 1,773: | ||
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 = substitute (cfg.tag_from_name_t.lang_not_found, {args[1]}); -- language name not found, error message | ||
end | end | ||
else | else | ||
msg = | msg = cfg.tag_from_name_t.missing_lang_name; -- language name not found, error message | ||
end | end | ||
| Line 1,584: | Line 1,783: | ||
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 | return make_error_span (template, msg); | ||
end | end | ||
| Line 1,590: | Line 1,790: | ||
--[[--------------------------< T A G _ F R O M _ N A M E >---------------------------------------------------- | --[[--------------------------< T A G _ F R O M _ N A M E >---------------------------------------------------- | ||
Module entry point from an {{#invoke:}} | Module entry point from an {{#invoke:}}. | ||
]] | ]] | ||
| Line 1,602: | Line 1,802: | ||
--[[--------------------------< I S _ L A N G _ N A M E >------------------------------------------------------ | --[[--------------------------< I S _ L A N G _ N A M E >------------------------------------------------------ | ||
Module entry point from an {{#invoke:}} | Module entry point from an {{#invoke:}}. | ||
]] | ]] | ||
| Line 1,614: | Line 1,814: | ||
--[[--------------------------< _ T R A N S L >---------------------------------------------------------------- | --[[--------------------------< _ T R A N S L >---------------------------------------------------------------- | ||
Module entry point from another module | Module entry point from another module. | ||
]] | ]] | ||
| Line 1,624: | Line 1,824: | ||
local script; -- IANA script | local script; -- IANA script | ||
local msg; -- for when called functions return an error message | local msg; -- for when called functions return an error message | ||
local template = args.template or cfg.templates_t.transliteration; | |||
maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once | maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once | ||
| Line 1,633: | Line 1,834: | ||
if not title_table[args.translit_std] then | if not title_table[args.translit_std] then | ||
return make_error_msg ( | return make_error_msg (substitute (cfg.transl_t.unrecog_xlit_std, {args.translit_std}), args, template); | ||
end | end | ||
else | else | ||
| Line 1,641: | Line 1,842: | ||
if args[1] and (args[1]:match ('^%a%a%a?%a?$') or -- args[2] missing; is args[1] a language or script tag or is it the transliterated text? | if args[1] and (args[1]:match ('^%a%a%a?%a?$') or -- args[2] missing; is args[1] a language or script tag or is it the transliterated text? | ||
args[1]:match ('^%a%a%a?%-x%-')) then -- or is args[1] a private-use tag | args[1]:match ('^%a%a%a?%-x%-')) then -- or is args[1] a private-use tag | ||
return make_error_msg ( | return make_error_msg (cfg.transl_t.no_text, args, template); -- 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 (cfg.transl_t.missing_lang_scr, args, template); | ||
end | end | ||
end | end | ||
| Line 1,653: | Line 1,854: | ||
args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters) or private-use; 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) or private-use; lower case because table indexes are lower case | ||
else | else | ||
return make_error_msg ( | return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args[1]}), args, template); -- invalid language / script code | ||
end | end | ||
else | else | ||
return make_error_msg ( | return make_error_msg (cfg.transl_t.missing_lang_scr, args, template); -- missing language / script code so quit | ||
end | end | ||
local latn, pos = is_latin (args.text, nil, true); | |||
if not latn then -- text is not latn | |||
return make_error_msg (substitute (cfg.lang_xx_t.translit_nonlatn, {pos}), args, template); | |||
end | |||
args.italic, msg = validate_italic (args); | args.italic, msg = validate_italic (args); | ||
if msg then | if msg then | ||
return make_error_msg (msg, args, | return make_error_msg (msg, args, template); | ||
end | end | ||
| Line 1,668: | Line 1,875: | ||
end | end | ||
args.engvar = | args.engvar = cfg.engvar_sel_t[args.engvar] or cfg.default_engvar; -- |engvar= when valid; cfg.default_engvar else | ||
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? | ||
| Line 1,682: | Line 1,889: | ||
args.code = ''; -- unset because not a language code | args.code = ''; -- unset because not a language code | ||
else | else | ||
return make_error_msg ( | return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args.code}), args, template); -- 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 | ||
| Line 1,691: | Line 1,898: | ||
--[[--------------------------< T R A N S L >------------------------------------------------------------------ | --[[--------------------------< T R A N S L >------------------------------------------------------------------ | ||
Module entry point from an {{#invoke:}} | Module entry point from an {{#invoke:}}. | ||
]] | ]] | ||
| Line 1,702: | Line 1,909: | ||
--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >-------------------------------------------- | --[[--------------------------< C A T E G O R Y _ F R O M _ T A G >-------------------------------------------- | ||
Returns category name associated with IETF language tag if valid; error message else | Returns category name associated with IETF language tag if valid; error message else. | ||
All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function. | All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function. | ||
Module entry point from another module | Module entry point from another module. | ||
]] | ]] | ||
| Line 1,713: | Line 1,920: | ||
local subtags = {}; -- IETF subtags script, region, variant, and private | local subtags = {}; -- IETF subtags script, region, variant, and private | ||
local raw_code = args_t[1]; -- save a copy of the input IETF subtag | local raw_code = args_t[1]; -- save a copy of the input IETF subtag | ||
local link = | local link = cfg.keywords_t.affirmative == args_t.link; -- make a boolean | ||
local label = args_t.label; | local label = args_t.label; | ||
local code; -- the language code | local code; -- the language code | ||
| Line 1,722: | Line 1,929: | ||
if msg then | if msg then | ||
local template = (args_t.template and table.concat ({'{{', args_t.template, '}}: '})) or ''; -- make template name (if provided by the template) | local template = (args_t.template and table.concat ({'{{', args_t.template, '}}: '})) or ''; -- make template name (if provided by the template) | ||
return | return make_error_span (template, msg); | ||
end | end | ||
| Line 1,739: | Line 1,946: | ||
--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >-------------------------------------------- | --[[--------------------------< C A T E G O R Y _ F R O M _ T A G >-------------------------------------------- | ||
Module entry point from an {{#invoke:}} | Module entry point from an {{#invoke:}}. | ||
]] | ]] | ||