Seeds of the Word

Module:Lang: Difference between revisions

Browse history interactively
← Older edit
Content deleted Content added
m 1 revision imported
m 1 revision imported
 
(14 intermediate revisions by 4 users not shown)
Line 5:
]=]
 
require('Module:No globalsstrict');
 
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()
 
local getArgs = require ('Module:Arguments').getArgs;
Line 13 ⟶ 11:
local yesno = require ('Module:Yesno');
 
local lang_name_tablelang_data = mw.loadData ('Module:Language/nameLang/data'); -- language name override and transliteration tool-tip tables
local lang_name_table = lang_data.lang_name_table; -- language codes, names, regions, scripts, suppressed scripts
local lang_table = lang_data.lang_name_table.lang;
local lang_dep_table = lang_data.lang_name_table.lang_dep;
local script_table = lang_data.lang_name_table.script;
local region_table = lang_data.lang_name_table.region;
local variant_table = lang_data.lang_name_table.variant;
local suppressed_table = lang_data.lang_name_table.suppressed;
local override_table = lang_data.override;
 
local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code
 
local lang_data = mw.loadData ('Module:Lang/data'); -- language name override and transliteration tool-tip tables
 
local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization
 
local this_wiki_langcontent_lang = mw.language.getContentLanguage().code; -- get this wiki's language
local this_wiki_lang_tag = content_lang.code; -- get this wiki's language tag
local this_wiki_lang_dir = content_lang:getDir(); -- get this wiki's language direction
 
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()
 
local maint_cats = {}; -- maintenance categories go here
Line 121 ⟶ 129:
 
if count > 1 then -- return nil and an error message if more than one is set
return nil, 'only one of ||italic=, ||italics=, or ||i= can be specified';
end
Line 186 ⟶ 194:
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
Line 216 ⟶ 229:
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
 
Line 306 ⟶ 319:
code = code:lower(); -- ensure that we use and return lower case version of this
if not (lang_data.overrideoverride_table[code] or lang_name_table.langlang_table[code] or synonym_table[code] or lang_dep_table[code]) then
return nil, nil, nil, nil, nil, table.concat ({'unrecognized language code: ', code}); -- invalid language code, don't know about the others (don't care?)
end
Line 326 ⟶ 339:
if is_set (script) then
script = script:lower(); -- ensure that we use and return lower case version of this
if not lang_name_table.scriptscript_table[script] then
return code, nil, nil, nil, nil, table.concat ({'unrecognized script: ', script, ' for code: ', code}); -- language code ok, invalid script, don't know about the others (don't care?)
end
end
if lang_name_table.suppressedsuppressed_table[script] then -- ensure that code-script does not use a suppressed script
if in_array (code, lang_name_table.suppressedsuppressed_table[script]) then
return code, nil, nil, nil, nil, table.concat ({'script: ', script, ' not supported for code: ', code}); -- language code ok, script is suppressed for this code
end
Line 346 ⟶ 359:
if is_set (region) then
region = region:lower(); -- ensure that we use and return lower case version of this
if not lang_name_table.regionregion_table[region] then
return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code});
end
Line 361 ⟶ 374:
if is_set (variant) then
variant = variant:lower(); -- ensure that we use and return lower case version of this
if not lang_name_table.variantvariant_table[variant] then -- make sure variant is valid
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant});
end -- does this duplicate/replace tests in lang() and lang_xx()?
if is_set (script) then -- if script set it must be part of the 'prefix'
if not in_array (table.concat ({code, '-', script}), lang_name_table.variantvariant_table[variant]['prefixes']) then
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', code, '-', script});
end
elseif is_set (region) then -- if region set, there are some prefixes that require lang code and region (en-CA-newfound)
if not in_array (code, lang_name_table.variantvariant_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}), lang_name_table.variantvariant_table[variant]['prefixes']) then -- now try for lang code and region (en-CA-newfound)
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-region pair: ', code, '-', region});
end
end
else -- cheap way to determine if there are prefixes; fonipa and others don't have prefixes; # operator always returns 0
else
if variant_table[variant]['prefixes'][1] and not in_array (code, lang_name_table.variantvariant_table[variant]['prefixes']) then
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code: ', code});
end
end
end
 
if is_set (private) then
private = private:lower(); -- ensure that we use and return lower case version of this
if not lang_data.overrideoverride_table[table.concat ({code, '-x-', private})] then -- make sure private tag is valid; note that index
return code, script, region, nil, nil, table.concat ({'unrecognized private tag: ', private});
end
Line 401 ⟶ 414:
local category;
if 'translTransl' == template then
category = 'translTransl';
else
category = 'langLang and lang-xx'
end
table.insert (out, table.concat ({'[[', args.text or 'undefined', ']] '})); -- for error messages output args.text if available
table.insert (out, table.concat ({'<span style=\"font-sizecolor:100%; font-style:normal;\" class=\"error#d33\">errorError: {{', template, '}}: '}));
table.insert (out, msg);
table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'}));
table.insert (out, '</span>');
if (0 == namespace or 10 == namespace) and not args.nocat then -- only categorize in article space (and template space to take care of broken usages)
table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'}));
end
Line 453 ⟶ 466:
if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text
if 'italic' == style then
return mw.ustring.text:gsub (text, '(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item
else
return text;
Line 471 ⟶ 484:
 
return text;
end
 
 
--[[--------------------------< T I T L E _ W R A P P E R _ M A K E >------------------------------------------
 
makes a <span title="<title text>"><content_text></span> or <div title="<title text>"><content_text></div> where
<title text> is in the tool-tip in the wiki's local language and <content_text> is non-local-language text in
html markup. This because the lang= attibute applies to the content of its enclosing tag.
 
<tag> holds a string 'div' or 'span' used to choose the correct wrapping tag
]]
 
local function title_wrapper_make (title_text, content_text, tag)
local wrapper_t = {};
table.insert (wrapper_t, table.concat ({'<', tag})); -- open opening wrapper tag
table.insert (wrapper_t, ' title=\"'); -- begin title attribute
table.insert (wrapper_t, title_text); -- add <title_text>
table.insert (wrapper_t, '\">'); -- end title attribute and close opening wrapper tag
table.insert (wrapper_t, content_text); -- add <content_text>
table.insert (wrapper_t, table.concat ({'</', tag, '>'})); -- add closing wrapper tag
 
return table.concat (wrapper_t); -- make a big string and done
end
 
Line 478 ⟶ 514:
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 make_text_html (code, text, tag, rtl, style, size, language)
local htmlhtml_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
table.insert (htmlhtml_t, '&#42;'); -- 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
Line 498 ⟶ 543:
end
 
table.insert (htmlhtml_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, table.concat ({' lang="', code, '\"'})); -- add language attribute
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 (htmlhtml_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 (htmlhtml_t, ' style=\"font-style: normal;'); -- override external markup, if any
style_added = '\"'; -- remember that style attribute added and is not yet closed
end
Line 512 ⟶ 560:
if is_set (size) then -- when |size=<something>
if is_set (style_added) then
table.insert (htmlhtml_t, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted
else
table.insert (htmlhtml_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
if is_set (language) then
table.insert (htmlhtml_t, table.concat ({style_added, ' title=\"', language})text); --start theinsert titlethe text
if language:find ('languages') then
table.insert (html, ' collective text\"'); -- for collective languages
else
table.insert (html, ' language text\"'); -- for individual languages
end
table.insert (html, '>'); -- close the opening html tag
else
table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag
end
table.insert (html, text); -- insert the text
 
table.insert (htmlhtml_t, table.concat ({'</', tag, '>'})); -- close the 'text' <i>, <span>, or <div> html tag
 
if rtlis_set (language) then -- legacy;create shouldn'ta be<title_text> necessarystring because all offor the rtltitle= textattribute isin wrappeda insidewrapper anspan html tag with dir="rtl" attributeor div
local title_text;
table.insert (html, '&lrm;'); -- make sure the browser knows that we're at the end of the rtl
if 'zxx' == code then -- special case for this tag 'no linguistic content'
title_text = table.concat ({language, ' text'}); -- not a language so don't use 'language' in title text
elseif mw.ustring.find (language, 'languages', 1, true) then
title_text = table.concat ({language, ' collective text'}); -- for collective languages
else
title_text = table.concat ({language, '-language text'}); -- for individual languages
end
 
return title_wrapper_make (title_text, table.concat (html_t), wrapper_tag);
else
return table.concat (html_t);
end
return table.concat (html); -- put it all together and done
end
 
Line 549 ⟶ 597:
[[Category:Articles containing explicitly cited English-language text]]
for artificial languages (code: art)
[[Category:Articles containing constructed-language text]]
 
for ISO 639-2 collective languages (and for 639-1 bh):
[[Category:Articles with text from thein <language> languages collective]]
 
]=]
 
local function make_category (code, language_name, nocat, name_get)
local cat = {};
local retval;
 
if (0 ~= namespace) or nocat then -- only categorize in article space
if ((0 ~= namespace) or nocat) and not name_get then -- only categorize in article space
return ''; -- return empty string for concatenation
end
 
if language_name:mw.ustring.find (language_name, 'languages', 1, true) then
-- return table.concat ({'[[Category:Articles with text from thein ', language_name, ' collective]]'});
return table.concat ({'[[Category:Articles with text from ', language_name, ']]'});
end
table.insert (cat, '[[Category:Articles containing ');
 
if 'en'this_wiki_lang_tag == code then
table.insert (cat, 'explicitly cited English' .. language_name); -- unique category name for the local language
elseif 'art' == code then
table.insert (cat, 'constructed')
else
table.insert (cat, language_name);
Line 581 ⟶ 624:
table.insert (cat, '-language text]]');
 
return table.concat (cat);
end
 
Line 605 ⟶ 648:
local function make_translit (code, language_name, translit, std, tscript, style)
local title;
local toutout_t = {};
local title_tabletitle_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
if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
if not style then -- nil for the default italic style
table.insert (tout, "<i lang=\""); -- so use <i> tag
else
table.insert (tout, table.concat ({'<span style=\"font-style:', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it
end
table.insert (tout, code);
table.insert (tout, "-Latn\" title=\""); -- transliterations are always Latin script
else
table.insert (tout, "<span title=\""); -- when no language code: no lang= attribute, not italic ({{transl}} only)
end
std = std and std:lower(); -- lower case for table indexing
if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified
table.inserttitle_text (tout,= language_name); -- write a generic tool tip
if not language_name:mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name)
table.inserttitle_text (tout,= title_text .. '-language') ; -- skip this text (individual and macro languages only)
end
table.inserttitle_text (tout,= title_text .. ' romanization'); -- finish the tool tip; use romanization when neither script nor standard supplied
 
elseif is_set (std) and is_set (tscript) then -- when both are specified
if title_tabletitle_t[std] then -- and if standard is legitimate
if title_tabletitle_t[std][tscript] then -- and if script for that standard is legitimate
if script_table[tscript] then
table.insert (tout, table.concat ({title_table[std][tscript:lower()], ' (', lang_name_table.script[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip
title_text = title_text .. table.concat ({title_t[std][tscript:lower()], ' (', script_table[tscript], ' script) transliteration'}); -- add the appropriate text to the tool tip
else
title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?
end
else
table.inserttitle_text (tout,= title_text .. title_tabletitle_t[std]['default']); -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?
end
else
Line 640 ⟶ 677:
 
elseif is_set (std) then -- translit-script not set, use language code
if not title_tabletitle_t[std] then return ''; end -- invalid standard, setup for error message
if title_tabletitle_t[std][code] then -- if language code is in the table (transl may not provide a language code)
tabletitle_text = title_text ..insert (tout, table.concat ({title_tabletitle_t[std][code:lower()], ' (', lang_name_table.lang[code][1]language_name, ' language) transliteration'})); -- add the appropriate text to the tool tip
else -- code doesn't match
table.inserttitle_text (tout,= title_text .. title_tabletitle_t[std]['default']); -- so use the standard's default
end
 
else -- here if translit-script set but translit-std not set
if title_tabletitle_t['no_std'][tscript] then
table.inserttitle_text (tout,= title_text .. title_tabletitle_t['no_std'][tscript]); -- use translit-script if set
elseif title_tabletitle_t['no_std'][code] then
table.inserttitle_text (tout,= title_text .. title_tabletitle_t['no_std'][code]); -- use language code
else
if is_set (tscript) then
table.inserttitle_text (tout,= title_text .. table.concat ({language_name, '-script transliteration'})); -- write a script tool tip
elseif is_set (code) then
if not language_name:mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name)
table.inserttitle_text (tout,= title_text .. '-language') ; -- skip this text (individual and macro languages only)
end
table.inserttitle_text (tout,= title_text .. ' transliteration'); -- finish the tool tip
else
table.inserttitle_text (tout,= title_text .. ' transliteration'); -- generic tool tip (can we ever get here?)
end
end
end
 
local close_tag;
table.insert (tout, '">');
if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
table.insert (tout, translit);
code = code:match ('^(%a%a%a?)'); -- strip all subtags leaving only the language subtag
if is_set (code) and not style then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
 
table.insert (tout, "</i>"); -- close the italic tag
if not style then -- nil for the default italic style
table.insert (out_t, "<i lang=\""); -- so use <i> tag
close_tag = '</i>'; -- tag to be used when closing
else
table.insert (out_t, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it
close_tag = '</span>'; -- tag to be used when closing
end
table.insert (out_t, code);
table.insert (out_t, "-Latn\">"); -- transliterations are always Latin script
else
table.insert (out_t, "<span>"); -- when no language code: no lang= attribute, not italic ({{transl}} only)
close_tag = '</span>';
end
 
table.insert (out_t, translit); -- add the translit text
table.insert (out_t, close_tag); -- and add the appropriate </i> or </span>
 
if '' == title_text then -- when there is no need for a tool-tip
return table.concat (out_t); -- make a string and done
else
return title_wrapper_make (title_text, table.insertconcat (toutout_t), "</'span>"'); -- nowrap languagewith codea sotool-tip closespan the spanand tagdon
end
return table.concat (tout);
end
 
Line 716 ⟶ 772:
if 0 < #maint_msgs then -- when there are maintenance messages
table.insert (maint, table.concat ({'<span class="lang-comment" style="font-style: normal; display: none; color: #33aa33; margin-left: 0.3em;">'})); -- opening <span> tag
for _, msg in ipairs (maint_msgs) do
table.insert (maint, table.concat ({msg, ' '})); -- add message strings
Line 825 ⟶ 881:
return nil; -- missing or empty
end
end
 
 
--[[--------------------------< 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
 
]]
 
local function language_name_get (ietf, code, cat)
ietf = ietf:lower(); -- ietf:lower() because format_ietf_tag() returns mixed case
local name; -- remains nil if not found
if override_table[ietf] then -- look for whole IETF tag in override table
name = override_table[ietf];
elseif override_table[code] then -- not there so try basic language tag
name = override_table[code];
elseif lang_table[code] then -- shift to iana active tag/name table
name = lang_table[code];
elseif lang_dep_table[code] then -- try the iana deprecated tag/name table
name = lang_dep_table[code];
end
 
if lang_dep_table[code] and cat then -- because deprecated code may have been overridden to en.wiki preferred name
table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code}));
table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'}));
end
 
return name; -- name from data tables or nil
end
 
Line 842 ⟶ 930:
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 'langLang';
 
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
 
if args[1] and args.code then
return make_error_msg ('conflicting: {{{1}}} and &#124;|code=', args, template);
else
args.code = args[1] or args.code; -- prefer args.code
Line 855 ⟶ 949:
 
if args[2] and args.text then
return make_error_msg ('conflicting: {{{2}}} and &#124;|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;
Line 866 ⟶ 960:
args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly
 
validate_cat_args (args); -- determine if categorization should be suppressed
 
args.rtl = args.rtl == 'yes'; -- convert to boolean: 'yes' -> true, other values -> false
Line 873 ⟶ 965:
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag
if msg then
return make_error_msg (table.concat ({'invalid &#124;|proto=: ', args.proto}), args, template);
end
 
Line 889 ⟶ 981:
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_langthis_wiki_lang_tag ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and unicode.is_Latin (args.text)) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics)
args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic
else
Line 904 ⟶ 996:
end
 
args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private
language_name = language_name_get (args.code, code, true); -- get language name; try ietf tag first, then code w/o variant then code w/ variant
 
subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag
 
if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization
language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name
elseif lang_data.override[code] then
language_name = lang_data.override[code][1] -- then language names taken from the override table
elseif lang_name_table.lang[code] then
language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one
end
 
if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content
Line 957 ⟶ 1,040:
 
return _lang (args);
end
 
 
--[[--------------------------< T R A N S L A T I O N _ M A K E >----------------------------------------------
 
stand-alone function to create literal translation of main text
 
Also used by {{lang-x2}}
 
]]
 
local function translation_make (args_t)
local translation_t = {', '}; -- initialize output
 
if 'none' ~= args_t.label then -- if we want a label
table.insert (translation_t, '<small>'); -- open the <small> html tag
if 'no' == args_t.link then
table.insert (translation_t, '<abbr title="literal translation">lit.</abbr>'); -- unlinked form
else
table.insert (translation_t, make_wikilink ('Literal translation', 'lit.')); -- linked form
end
table.insert (translation_t, "&thinsp;</small>"); -- close the <small> html tag
end
table.insert (translation_t, table.concat ({'&#39;', args_t.translation, '&#39;'})); -- use html entities to avoid wiki markup confusion
return table.concat (translation_t); -- make a big string and done
end
 
Line 1,016 ⟶ 1,124:
local msg; -- for error messages
local tag = 'span'; -- initial value for make_text_html()
local template = args.template or 'langLang-xx';
 
maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once
maint_msgs = {};
if args[1] and args.text then
return make_error_msg ('conflicting: {{{1}}} and &#124;|text=', args, template);
else
args.text = args[1] or args.text; -- prefer args.text
Line 1,032 ⟶ 1,143:
 
if args[2] and args.translit then
return make_error_msg ('conflicting: {{{2}}} and &#124;|translit=', args, template);
else
args.translit = args[2] or args.translit -- prefer args.translit
Line 1,038 ⟶ 1,149:
if args[3] and (args.translation or args.lit) then
return make_error_msg ('conflicting: {{{3}}} and &#124;|lit= or &#124;|translation=', args, template);
elseif args.translation and args.lit then
return make_error_msg ('conflicting: &#124;|lit= and &#124;|translation=', args, template);
else
args.translation = args[3] or args.translation or args.lit; -- prefer args.translation
Line 1,046 ⟶ 1,157:
 
if args.links and args.link then
return make_error_msg ('conflicting: &#124;|links= and &#124;|link=', args, template);
else
args.link = args.link or args.links; -- prefer args.link
Line 1,088 ⟶ 1,199:
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag
if msg then
return make_error_msg (table.concat ({'invalid &#124;|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
subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag
 
if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization
language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name
elseif lang_data.override[args.code:lower()] then -- look for whole IETF tag in override table
language_name = lang_data.override[args.code:lower()][1]; -- args.code:lower() because format_ietf_tag() returns mixed case
elseif lang_data.override[code] then -- not there so try basic language code
language_name = lang_data.override[code][1];
elseif not is_set (subtags.variant) then
if lang_name_table.lang[code] then
language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one
end
else -- TODO: is this the right thing to do: take language display name from variants table?
if lang_name_table.variant[subtags.variant] then -- TODO: there is some discussion at Template talk:Lang about having a label parameter for use when variant name is not desired among other things
language_name = lang_name_table.variant[subtags.variant]['descriptions'][1]; -- table entries sometimes have multiple names, always take the first one
end
end
 
category_name = language_name; -- category names retain IANA parenthetical diambiguators (if any)
Line 1,122 ⟶ 1,216:
table.insert (out, language_name); -- language name without wikilink
else
if language_name: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[code] then
table.insert (out, make_wikilink (lang_data.article_name[code][1], language_name)); -- language name with wikilink from override data
else
table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink
Line 1,139 ⟶ 1,233:
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))
 
if is_set (args.translit) and not unicode.is_Latin (args.text) then -- transliteration (not supported in {{lang}}); not supported when args.text is wholly latn text (this is an imperfect test)
Line 1,145 ⟶ 1,239:
if 'none' ~= args.label then
table.insert (out, '<small>');
if lang_name_table.scriptscript_table[args['translit-script']] then -- when |translit-script= is set, try to use the script's name
translit_script_name = lang_name_table.scriptscript_table[args['translit-script'][1]];
else
translit_script_name = language_name; -- fall back on language name
Line 1,168 ⟶ 1,262:
if is_set (args.translation) then -- translation (not supported in {{lang}})
table.insert (out, ',translation_make '(args));
if 'none' ~= args.label then
table.insert (out, '<small>');
if 'no' == args.link then
table.insert (out, '<abbr title="literal translation">lit.</abbr>');
else
table.insert (out, make_wikilink ('Literal translation', 'lit.'));
end
table.insert (out, "&nbsp;</small>");
end
table.insert (out, table.concat ({'&#39;', args.translation, '&#39;'})); -- use html entities to avoid wiki markup confusion
end
Line 1,274 ⟶ 1,358:
 
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
 
The purpose of this function is to replace {{#ifexist:Template:ISO 639 name xx|<exists>|<does not exist>}} in
templates that are better served by using {{#invoke:lang|name_from_tag|<code>}}
 
Module entry point from another module
Line 1,283 ⟶ 1,364:
 
local function _is_ietf_tag (tag) -- entry point when this module is require()d into another
local c, s, r, v, p, err; -- code, script, region, variant, private, error message
c, s, r, v, p, err = get_ietf_parts (tag); -- disassemble tag into constituent part and validate
 
Line 1,297 ⟶ 1,378:
 
local function is_ietf_tag (frame)
return _is_ietf_tag (getArgs (frame)[1]); -- args[1] is the ietf language tag to be tested; getArgs() so we also get parent frame
end
 
 
--[[--------------------------< I S _ I E T F _ T A G _ F R A M E >--------------------------------------------
 
Module entry point from an {{#invoke:}}; same as is_ietf_tag() except does not get parameters from the parent
(template) frame. This function not useful when called by {{lang|fn=is_ietf_tag_frame|<tag>}} because <tag>
is in the parent frame.
 
]]
 
local function is_ietf_tag_frame (frame)
return _is_ietf_tag (getArgs (frame, {frameOnly = true,})[1]); -- args[1] is the ietf language tag to be tested; do not get parent frame
end
 
 
--[[--------------------------< _ N A M E _ F R O M _ CT OA D EG >--------------------------------------------------
 
Returns language name associated with IETF language tag if valid; emptyerror stringmessage else.
 
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
Line 1,317 ⟶ 1,411:
local raw_code = args[1]; -- save a copy of the input IETF subtag
local link = 'yes' == args['link']; -- make a boolean
local label = args.label;
local code; -- the language code
local msg; -- gets an error message if IETF language tag is malformed or invalid
Line 1,324 ⟶ 1,419:
if msg then
local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template)
return table.concat ({'<span style=\"font-sizecolor:100%; font-style:normal;\" class=\"error#d33\">errorError: ', template, msg, '</span>'});
end
 
raw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private
if lang_data.override[raw_code:lower()] then -- look for whole IETF tag in override table (force lower case)
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 = lang_data.override[raw_code:lower()][1];
elseif lang_data.override[code] then -- not there so try basic language code in override table
language_name = lang_data.override[code][1];
elseif not is_set (subtags.variant) then
if lang_name_table.lang[code] then
language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one
end
else -- TODO: is this the right thing to do: take language display name from variants table?
if lang_name_table.variant[subtags.variant] then -- TODO: there is some discussion at Template talk:Lang about having a label parameter for use when variant name is not desired among other things
language_name = lang_name_table.variant[subtags.variant]['descriptions'][1]; -- table entries sometimes have multiple names, always take the first one
end
end
 
language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them
 
if link then -- when |link=yes, wikilink the language name
if language_name:mw.ustring.find (language_name, 'languages', 1, true) then
language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink
elseif lang_data.article_name[code] then
language_name = make_wikilink (lang_data.article_name[code][1], label or language_name); -- language name with wikilink from override data
else
language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink
end
end
 
return language_name;
 
end
 
Line 1,383 ⟶ 1,466:
 
if args[1] and '' ~= args[1] then
local data = mw.loadData ('Module:Lang/nametag tofrom tagname'); -- get the reversed data tables TODO: change when going live
local lang = args[1]:lower(); -- allow any-case for the language name (speeling must till be correct)
local tag = data.rev_lang_datarev_override_table[lang] or data.rev_lang_name_tablerev_lang_table[lang] or data.rev_lang_dep_table[lang]; -- get the code; look first in the override then in the standard
 
if tag then
Line 1,400 ⟶ 1,483:
template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template)
end
return table.concat ({'<span style=\"font-sizecolor:100%; font-style:normal;\" class=\"error#d33\">errorError: ', template, msg, '</span>'});
end
 
Line 1,437 ⟶ 1,520:
local title_table = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards
local language_name; -- language name that matches language code; used for tool tip
local translit; -- translitteratedtransliterated text to display
local script; -- IANA script
local msg; -- for when called functions return an error message
 
maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once
maint_msgs = {};
if is_set (args[3]) then -- [3] set when {{transl|code|standard|text}}
args.text = args[3]; -- get the transliterated text
Line 1,446 ⟶ 1,532:
 
if not title_table[args.translit_std] then
return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'translTransl');
end
else
Line 1,452 ⟶ 1,538:
args.text = args[2]; -- get the transliterated text
else
if args[1] and (args[1]:match ('^%a%a%a?%a?$') thenor -- args[2] missing; is args[1] a codelanguage or itsscript tag or is it the transliterated text?
return make_error_msgargs[1]:match ('no text', args, 'transl^%a%a%a?%-x%-');) then -- or is args[1] is a code so we're missingprivate-use texttag
return make_error_msg ('no text', args, 'Transl'); -- args[1] is a code so we're missing text
else
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 ('missing language / script code', args, 'translTransl');
end
end
Line 1,462 ⟶ 1,549:
 
if is_set (args[1]) then -- IANA language code used for html lang= attribute; or ISO 15924 script code
if args[1]:match ('^%a%a%a?%a?$') or args[1]:match ('^%a%a%a?%-x%-') then -- args[1] has correct form?
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
return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'translTransl'); -- invalid language / script code
end
else
return make_error_msg ('missing language / script code', args, 'translTransl'); -- missing language / script code so quit
end
 
args.italic, msg = validate_italic (args);
if msg then
return make_error_msg (msg, args, 'translTransl');
end
Line 1,480 ⟶ 1,567:
end
 
if lang_data.overrideoverride_table[args.code] then -- is code a language code defined in the override table?
language_name = lang_data.overrideoverride_table[args.code][1];
elseif args.code = lang_name_table.lang[args.code]:match then ('^%a%a%a?'); -- isif codeprivate ause, languagestrip codeall defined in the standardbut language code tables?subtag
elseif lang_table[args.code] then -- is code a language code defined in the standard language code tables?
language_name = lang_name_table.lang[args.code][1];
language_name = lang_table[args.code];
elseif lang_name_table.script[args.code] then -- if here, code is not a language code; is it a script code?
elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables?
language_name = lang_name_table.script[args.code][1];
language_name = lang_dep_table[args.code];
elseif script_table[args.code] then -- if here, code is not a language code; is it a script code?
language_name = script_table[args.code];
script = args.code; -- code was an ISO 15924 script so use that instead
args.code = ''; -- unset because not a language code
else
return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'translTransl'); -- invalid language / script code
end
-- here only when all parameters passed to make_translit() are valid
Line 1,504 ⟶ 1,594:
local function transl (frame)
return _transl (getArgs(frame));
end
 
 
--[[--------------------------< 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
 
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
 
Module entry point from another module
 
]]
 
local function _category_from_tag (args_t)
local subtags = {}; -- IETF subtags script, region, variant, and private
local raw_code = args_t[1]; -- save a copy of the input IETF subtag
local link = 'yes' == args_t.link; -- make a boolean
local label = args_t.label;
local code; -- the language code
local msg; -- gets an error message if IETF language tag is malformed or invalid
local category_name = '';
code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code);
if msg then
local template = (args_t.template and table.concat ({'{{', args_t.template, '}}: '})) or ''; -- make template name (if provided by the template)
return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});
end
 
raw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private
category_name = language_name_get (raw_code, code); -- get language name; try ietf tag first, then code w/o variant then code w/ variant
category_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', '');
 
if link then
return table.concat ({'[[:', category_name, ']]'});
else
return category_name;
end
end
 
 
--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------
 
Module entry point from an {{#invoke:}}
 
]]
 
local function category_from_tag (frame) -- entry point from an {{#invoke:Lang|category_from_tag|<ietf tag>|template=<template name>}}
return _category_from_tag (getArgs (frame)); -- pass-on the args table, nothing else; getArgs() so we also get parent frame
end
 
Line 1,511 ⟶ 1,649:
 
return {
category_from_tag = category_from_tag,
lang = lang, -- entry point for {{lang}}
lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}}
lang_xx_italic = lang_xx_italic,
is_ietf_tag = is_ietf_tag,
is_ietf_tag_frame = is_ietf_tag_frame,
is_lang_name = is_lang_name,
tag_from_name = tag_from_name, -- returns ietf tag associated with language name
name_from_tag = name_from_tag, -- used for template documentation; possible use in ISO 639 name from code templates
transl = transl, -- entry point for {{transl}}
 
_lang_category_from_tag = _lang_category_from_tag, -- entry points when this module is require()d into other modules
_lang = _lang,
_lang_xx_inherit = _lang_xx_inherit,
_lang_xx_italic = _lang_xx_italic,
_is_ietf_tag = _is_ietf_tag,
get_ietf_parts = get_ietf_parts,
_tag_from_name = _tag_from_name,
_name_from_tag = _name_from_tag,
_transl = _transl,
_translation_make = translation_make,
};
Retrieved from "https://en.seminaverbi.bibleget.io/wiki/Module:Lang"