Module:Lang: Difference between revisions

local unicode = require ("Module:Unicode data"); -- for is_latin() and is_rtl()

local cfg = mw.loadData ('Module:Lang/Configuration'); -- for internationalization

local templates = {

lang = 'Lang',

langx = 'Langx',

langxx = 'Lang-xx',

substitutes $1, $2, etc in <message> with data from <data_t>. Returns plain-text substituted string when

<data_t> not nil; returns <message> else

assembles an error message from template name, message text, help link, and error category.

if templates.langxx == template then

if 'Transliteration' == template then

local category_link = ((0 == namespace or 10 == namespace) and not args_t.nocat) and substitute ('[[Category:$1 $2]]', {category, cfg.make_error_msg_t.template_errs}) or '';

return substitute ('[$1] <span style="color:#d33">$2: {{$3}}: $4 ([[:Category:$5 template errors|help]])</span>$6',

if templates.lang == template then -- for {{lang}}

elseif templates.langx == template then -- for {{langx}}

elseif templates.langxx == template then -- for {{lang-xx}}

local function is_set( var )

validates |italic= or |italics= assigned values.

local properties = {[cfg.keywords_t.affirmative] = 'italic', [cfg.keywords_t.negative] = 'normal', ['unset'] = 'inherit', ['invert'] = 'invert', ['default'] = nil};

Whether needle is in haystack

local function in_array ( needle, haystack )

for n,v in ipairs( haystack ) do

prettify ietf tags to use recommended subtag formats:

extracts and returns IETF language tag parts:

each of lang, script, region, variant, and private, when used, must be valid

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

see http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1

adds <i> and </i> tags to list-item text or to implied <p>..</p> text. mixed not supported

makes a <span title="<title text>"><content_text></span> or <div title="<title text>"><content_text></div> where

<tag> holds a string 'div' or 'span' used to choose the correct wrapping tag

for English:

for ISO 639-2 collective languages (and for 639-1 bh):

return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string

to be |translit-script= (in this function, tscript)

For {{transliteration}}, style only applies when a language code is provided

title_text = substitute ('$1 $2', {title_text, lang_data.engvar_t[engvar]['romanisz_lc']}); -- finish the tool tip; use romanization when neither script nor standard supplied

title_text = substitute ('$1$2 ($3 $4) $5', { -- add the appropriate text to the tool tip

local close_tag;

table.insert (out_t, "<i lang=\""); -- so use <i> tag

close_tag = '</i>'; -- tag to be used when closing

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

table.insert (out_t, code);

table.insert (out_t, "-Latn\">"); -- transliterations are always Latin script

table.insert (out_t, "<span>"); -- when no language code: no lang= attribute, not italic ({{transliteration}} only)

 

table.insert (out_t, translit); -- add the translit text

 

return table.concat (out_t); -- make a string and done

title_text = 'gb_t' == 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, table.concat (out_t), 'span'); -- wrap with a tool-tip span and done

error message. The tests are for empty or missing text and for improper or disallowed use of apostrophe markup.

return make_error_msg ('no text', args, template);

render mainenance messages and categories

for proto languages, text is prefixed with a splat. We do that here as a flag for make_text_html() so that a splat

will be rendered outside of italic markup (if used). If the first character in text here is already a splat, we

do nothing

proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and / or inhibits

regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac

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

validates value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false,

common function to return language name from the data set according to IETF tag

returns language name if found in data tables; nil else

returns an error message when mismatch detected; nil else

local function text_script_match_test (script, is_latn_text)

if ('Latn' ~= script and 'latn' ~= script) then -- but a non-Latn script is specified

return cfg.text_script_match_test_t.latn_txt_mismatch; -- emit an error message

if ('Latn' == script or 'latn' == script) then -- but Latn script is specified

return cfg.text_script_match_test_t.latn_scr_mismatch; -- emit an error message

--[[--------------------------< _ L A N G >--------------------------------------------------------------------

entry point for {{lang}}

<includeonly>{{#invoke:lang|lang}}</includeonly>

 

local function _lang (args)

local out = {};

local language_name; -- used to make category names

local subtags = {}; -- IETF subtags script, region, variant, and private

local tag = 'span'; -- initial value for make_text_html()

maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once

validate_cat_args (args); -- determine if categorization should be suppressed

 

if args[1] and args.code then

return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {'1', 'code'}), args, template);

args.code = args[1] or args.code; -- prefer args.code

if args[2] and args.text then

else

args.text = args[2] or args.text; -- prefer args.text

msg = validate_text (template, args); -- ensure that |text= is set

if is_set (msg) then -- msg is an already-formatted error message

return msg;

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

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 = unicode.is_Latin (args.text); -- make a boolean

 

msg = text_script_match_test (subtags.script, is_latn_text)

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

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

 

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

entry point for {{lang}}

there should be no reason to set parameters in the {{lang}} {{#invoke:}}

parameters are received from the template's frame (parent frame)

local args_t = getArgs (frame, { -- this code so that we can detect and handle wiki list markup in text

local msg = parameter_validate (args_t, templates.lang); -- verify that all supplied parameters are supported by {{lang-??}}

return make_error_msg (msg, args_t, templates.lang); -- when template has unsupported params, abandon with error message

stand-alone function to create literal translation of main text

Also used by {{lang-x2}}

local text_idx = (templates.langx == base_template) and 2 or 1; -- for {{langx}} 'text' positional parameter is '2'

local translit_idx = (templates.langx == base_template) and 3 or 2;

local xlate_idx = (templates.langx == base_template) and 4 or 3;

return make_error_msg (substitute (cfg.lang_xx_t.conflict_n_param, {translit_idx, 'text'}), args, template);

return make_error_msg (substitute (cfg.lang_xx_t.conflict_n_param, {translit_idx, 'translit'}), args, template);

args.engvar = lang_data.engvar_sel_t[args.engvar] or 'us_t'; -- either 'gb_t' or 'us_t' when |engvar= valid; 'us_t' else

return make_error_msg (substitute (cfg.lang_xx_t.conflict_n_lit, {translit_idx, '&#124;lit= or &#124;translation='}), args, template);

args.rtl = args.rtl == cfg.keywords_t.affirmative; -- convert to boolean: 'yes' -> true, other values -> false

local is_latn_text = unicode.is_Latin (args.text); -- make a boolean

msg = text_script_match_test (subtags.script, is_latn_text)

if templates.langx == base_template then -- auto-italics  for {{langx}} templates; adapted from {{lang}} (no support for poem tag)  

return make_error_msg (table.concat ({'invalid &#124;proto=: ', args.proto}), args, template);

substitute ('$1', {lang_data.engvar_t[args.engvar]['romanisz_pt']})) .. ':'); -- make a wikilink if there is an article to link to; engvar the display text

table.insert (out, substitute ('$1:', {lang_data.engvar_t[args.engvar]['romanisz_pt']})); -- else plain text per engvar

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

if ((templates.langx == base_template) and 2 or 1) == key then -- the 'text' positional parameter; 1 for {{lang-??}}, 2 for {{langx}}; do not trim wite space

Entry point for those {{lang-??}} templates that call lang_xx_italic(). Sets the initial style state to italic.

local args = lang_xx_args_get (frame, templates.langxx);

local msg = parameter_validate (args, templates.langxx); -- verify that all supplied parameters are supported by {{lang-??}}

return make_error_msg (msg, args, templates.langxx); -- when template has unsupported params, abandon with error message

return _lang_xx (args, templates.langxx) .. '[[Category:Pages using Lang-xx templates]]'; -- temporary category

Entry point from another module. Sets the initial style state to italic.

return _lang_xx (args, templates.langxx);

Entry point for those {{lang-??}} templates that call lang_xx_inherit(). Sets the initial style state to inherit.

local args = lang_xx_args_get (frame, templates.langxx);

local msg = parameter_validate (args, templates.langxx); -- verify that all supplied parameters are supported by {{lang-??}}

return make_error_msg (msg, args, templates.langxx); -- when template has unsupported params, abandon with error message

return _lang_xx (args, templates.langxx) .. '[[Category:Pages using Lang-xx templates]]'; -- temporary category

Entry point from another module. Sets the initial style state to inherit.

return _lang_xx (args, templates.langxx);

local msg = parameter_validate (args_t, templates.langx);

return make_error_msg (msg, args_t, templates.langx);

return make_error_msg (cfg.get_ietf_parts_t.missing_lang_tag, args_t, templates.langx);

return _lang_xx (args_t, templates.langx);

this function calls _lang_xx() to render non-English text. The {{lang-??}} templates have three positional paramters

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 args_t = lang_xx_args_get (frame, templates.langx); -- get the arguments; 'Langx' is the <base_template> used to decide which positional param is 'text', 'translit', 'lit'

Module entry point from another module

Module entry point from an {{#invoke:}}

Module entry point from another module

local link = cfg.keywords_t.affirmative == args['link']; -- make a boolean

return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});

language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them

Module entry point from an {{#invoke:}}

Module entry point from another module

return substitute ('<span style=\"color:#d33\">$1: $2$3</span>', {cfg.misc_text_t.error, template, msg});

Module entry point from an {{#invoke:}}

Module entry point from an {{#invoke:}}

Module entry point from another module

return make_error_msg (substitute (cfg.transl_t.unrecog_xlit_std, {args.translit_std}), args, 'Transliteration');

return make_error_msg (cfg.transl_t.no_text, args, 'Transliteration'); -- args[1] is a code so we're missing text

return make_error_msg (cfg.transl_t.missing_lang_scr, args, 'Transliteration');

return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args[1]}), args, 'Transliteration'); -- invalid language / script code

return make_error_msg (cfg.transl_t.missing_lang_scr, args, 'Transliteration'); -- missing language / script code so quit

return make_error_msg (msg, args, 'Transliteration');

args.engvar = lang_data.engvar_sel_t[args.engvar] or 'us_t'; -- either 'gb_t' or 'us_t' when |engvar= valid; 'us_t' else

return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args.code}), args, 'Transliteration'); -- invalid language / script code

Module entry point from an {{#invoke:}}

Returns category name associated with IETF language tag if valid; error message else

Module entry point from another module

return table.concat ({'<span style="color:#d33">Error: ', template, msg, '</span>'});

Module entry point from an {{#invoke:}}