|
require ('Module:No globalsstrict');
--[[--------------------------< _ I SN _ CL A JN KG >------------------------------------------------------------------
implements {{in lang}}
return true if code is one of the listed Chinese, Japanese, Korean ISO 639 codes, false else.
Module entry point from another module
]]
|link=yes - creates wikilinked language names
local function is_cjk_code (code)
|template=<template name> - customizes error messages created by Module:lang
local cjk =
|list-cats=yes - documentation tool returns language-category names of cats populated by this template
{
['zh'] = true, ['cdo'] = true, ['cjy'] = true, ['cmn'] = true, -- Chinese language codes
['cpi'] = true, ['cpx'] = true, ['czh'] = true, ['czo'] = true,
['gan'] = true, ['hak'] = true, ['hsn'] = true, ['ltc'] = true,
['lzh'] = true, ['mnp'] = true, ['nan'] = true, ['och'] = true,
['wuu'] = true, ['yue'] = true, ['zhx'] = true,
['ja'] = true, ['jpx'] = true, ['ojp'] = true, -- Japanese language codes
['ko'] = true, ['okm'] = true, ['oko'] = true, -- Korean language codes
}
return cjk[code] or false;
end
--[[--------------------------< S E T _ I T A L I C S >--------------------------------------------------------
Created for use with Template:Infobox book and Template:Infobox document and perhaps others to replace hard-coded
italic markup in the call to {{lang}}. This module attempts to make sure that {{lang}} correctly applies italic
markup according to MOS:FOREIGNITALIC.
]]
local function set_italics (frame)
local code = frame.args[1] or frame.args['code'] or ''; -- empty string causes 'yes' return; {{lang}} will handle the missing code error
local text = frame.args[2] or frame.args['text'] or ''; -- empty string causes 'yes' return; {{lang}} will handle the missing text error
local is_latn = require ("Module:Unicode data").is_Latin;
if is_cjk_code (code) and not is_latn (text) then -- is_latn() is in Module:Lang
return 'no'; -- only case for 'no'
end
return 'yes'; -- everything else is yes
end
--[[--------------------------< I N _ L A N G >----------------------------------------------------------------
implements {{in lang}}
Module entry point from an {{#invoke:lang/utilities/sanbox|in_lang|<code>|<code2>|<code3>|<code...>|link=yes|template=Link language}}
<span class="languageicon">(in <language>)</span>
]]
local function in_lang_in_lang (frameargs)
local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code
local getArgs = require ('Module:Arguments').getArgs;
local list_cats = 'yes' == args['list-cats']; -- make a boolean
local args = getArgs(frame);
local list = {};
local cats = {};
local maint_msgs = {};
if not args[1] then
end
local module = 'Module:Lang' .. (framemw.getCurrentFrame():getTitle():match ('/sandbox') or ''); -- if this module is the sandbox,
local name_from_tag = require (module)._name_from_tag; -- use Module:Lang/sandbox; Module:Lang else
for i, lang in ipairs (args) do
local tcode = {args[i]:lower();
local t = {code, ['link'] = args['link'], ['template'] = args['template']}; -- build an 'args' table
lang = name_from_tag (t) -- get the language name
table.insert (list, lang) -- add this language or error message to the list
if 'ca-valencia' ~= code then -- except for valencian
if lang:find ('error') or (this_wiki_lang == args[i]) or (0 ~= namespace) then -- for these, no categorization
code = code:match ('^%a%a%a?%f[^%a]'); -- strip off region, script, and variant tags so that they aren't used to make category names
else
end
if lang:match ('%[%[.-|.-%]%]') then -- wikilinked individual language
if synonym_table[code] then -- if 639-2/639-2T code has a 639-1 synonym
lang = lang:match ('%[%[.-|(.-)%]%]');
if (0 == namespace) and not list_cats then -- when listing cats don't include this cat; TODO: right choice?
elseif lang:match ('%[%[.-%]%]') then -- wikilinked collective languages
table.insert (cats, table.concat ({'[[Category:Lang and lang-xx code promoted to ISO 639-1|', code ..']]'}));
lang = lang:match ('%[%[(.-)%]%]');
end
end -- neither of these then plain text language
table.insert (maint_msgs, ' <span class="lang-comment" style="font-style:normal; display:none; color:#33aa33; margin-left:0.3em">')
table.insert (maint_msgs, table.concat ({'code: ', code, ' promoted to code: ', synonym_table[code]}));
table.insert (maint_msgs, '</span>;');
code = synonym_table[code]; -- use the synonym
end
if (0 == namespace) or list_cats then -- when in article space
if lang:find ('languages') then
if lang:find ('error') then -- add error category (message provided by Module:Lang)
table.insert (cats, table.concat ({'[[Category:Articles with ', lang, '-collective sources (', args[i], ')]]'}));
if not list_cats then -- don't include this cat when listin cats; TODO: right choice?
else
table.insert (cats, table.concat ({'[[Category:Articles with ',in lang, '-languagetemplate sources (', args[i], ')errors]]'}));
end
elseif this_wiki_lang ~= code then -- categorize article only when code is not this wiki's language code
if lang:match ('%[%[.-|.-%]%]') then -- wikilinked individual language name
lang = lang:match ('%[%[.-|(.-)%]%]');
elseif lang:match ('%[%[.-%]%]') then -- wikilinked collective languages name
lang = lang:match ('%[%[(.-)%]%]');
end -- neither of these then plain-text language name
if lang:find ('languages') then -- add appropriate language-name category
table.insert (cats, table.concat ({'[[Category:Articles with ', lang, '-collective sources (', code, ')]]'}));
else
table.insert (cats, table.concat ({'[[Category:Articles with ', lang, '-language sources (', code, ')]]'}));
end
end
end
end
if list_cats then
local cats = table.concat (cats, ', '):gsub ('[%[%]]', ''); -- make a string of categories and then strip wikilink markup
return cats
end
local result = {'<span class="languageicon">('}; -- opening span and (
table.insert (result, 'yes' == args['cap'] and 'In ' or 'in '); -- add capitalized or uncapitalized 'in'
table.insert (result, mw.text.listToText (list, ', ', (2 < #list) and ', and ' or ' and ' )); -- and concatenatedconcatenate the language list
table.insert (result, ')</span>'); -- add closing ) and closing span
table.insert (result, table.concat (maint_msgs) or ''); -- add maint messages, if any
table.insert (result, table.concat (cats)); -- add categories
return table.concat (result); -- make a big string and done
end
--[[--------------------------< I N _ L A N G >----------------------------------------------------------------
implements {{in lang}}
Module entry point from an {{#invoke:lang/utilities/sanbox|in_lang|<code>|<code2>|<code3>|<code...>|link=yes|template=in lang|list-cats=yes}}
]]
local function in_lang (frame)
local args = require ('Module:Arguments').getArgs (frame);
return _in_lang (args);
end
--[[--------------------------< N A T I V E _ N A M E _ L A N G >----------------------------------------------
experimental code; may not be retained
implements combined is_ietf_tag() and tag_from_name() in Module:Lang for various infoboxen that support a
error messages else
entry point from an {{#invoke:Lang/utilities/sandbox|native_name_lang|<language name or tag>|template=<template name>}}
]]
--[[--------------------------< NC IA H O N G OT _ RT E N D E R ES RT >--------------------------------------------------------------
temporary test code to be deleted
shared support function for nihingo() and nihongo3() does final assembly and rendering
support for {{Category articles containing non-English-language text}} that tests the language parameters provided
]]
to that template against the category name.
{{#invoke:Lang/utilities/sandbox|cat_test}}
local function nihongo_renderer (args, formatting, extra2)
local output;
local index = 0; -- index into formatting{}
local param_weight = {8, 4, 2, 1}; -- binary parameter weights: [1] = english (8), [2] = japanese (4), [3] = romaji (2), [4] = extra (1)
]]
for i=1, 5 do -- calculate an index into formatting{}
index = index + (args[i] and param_weight[i] or 0);
end
local function cat_test (frame)
output = (0 ~= index) and string.format (formatting[index][1] and formatting[index][1], formatting[index][2][1], formatting[index][2][2], formatting[index][2][3], formatting[index][2][4]) or nil;
if extra2 then
output = output and (output .. ' ' .. extra2) or extra2;
end
return output;
end
--[=[-------------------------< N I H O N G O >----------------------------------------------------------------
An experiment to see how to implement {{nihongo}} using Module:Lang for language and transliteration markup
{{Nihongo|<English>|<kanji/kana>|<rōmaji>|<extra>|<extra2>|lead=yes}}
<English>, <kanji/kana>, and <rōmaji> are positional parameters
<English>: rendered as presented; purports to be English translation of <kanji/kana>
<kanji/kana>: Japanese language text using Japanese script; TODO: require?
<rōmaji>: Hepburn romanization (transliteration); TODO: in Module:Lang/data change tooltip text to 'Hepburn romanization'?
<extra> and <extra2> are positional or named: |extra= and |extra2=; mixing can be problematic
<extra> is rendered as presented preceeded with <comma><space>
<extra2> is rendered as presented preceeded with <space>
|lead=: takes one value 'yes'; renders language name same as {{lang-ja}} but also adds [[Hepburn romanization|Hepburn]]:<space> ahead of the romanization; TODO: in Module:Lang, turnoff tooltip for transl when |lead=yes
]=]
local function nihongo (frame)
local lang_module = require ('Module:Lang');
local args = require ('Module:Arguments').getArgs (frame);
local err = false; -- boolean set true when an error is detected; one error message only
local cat_page_title = mw.title.getCurrentTitle().text; -- get the category title
local lang_name;
local index; -- positional parameter index
local lc_lang_name, lc_lang_name_col; -- individual and collective cat names are different
local lc_title;
for i, v in ipairs (args) do -- pairs because ipairs stops at nil value (empty positional parameter)
local english = args[1]; -- meaningful names
if 'number' == type (i) and args[i] then -- only positional parameters and only when they have a value
local japanese = args[2];
if lang_module._is_ietf_tag (v) then -- see if this thing 'v' is an ietf tag
local romaji = args[3];
local t = {v}; -- it is so make an args table for _name_from_tag()
local extra = args[4] or args.extra;
lang_name = lang_module._name_from_tag (t); -- get the language name
local extra2 = args[5] or args.extra2;
else
local lead = 'yes' == args.lead; -- make boolean
lang_name = v; -- not a valid tag so presume it is a name
end
mw.logObject (lang_name, 'lang_name')
lc_lang_name = table.concat ({ -- build a string to match category name form for individual and macro languages
'containing ',
mw.ustring.lower (lang_name); -- to lowercase for comparisons
'-language',
});
mw.logObject (lc_lang_name, 'lc_lang_name')
lc_lang_name_col = table.concat ({ -- build a string to match category name form for collective languages
'the ',
mw.ustring.lower (lang_name); -- to lowercase for comparisons
' ', -- next word is languages which is included in the name retrieved from Module:lang
});
mw.logObject (lc_lang_name_col, 'lc_lang_name_col')
lc_title = mw.ustring.lower (cat_page_title);
if not mw.ustring.find (lc_title, lc_lang_name, 1, true) and -- if lang name not found in cat title
if japanese then
not mw.ustring.find (lc_title, lc_lang_name_col, 1, true) then
japanese = lead and lang_module._lang_xx_inherit ({['code']='ja', japanese}) or lang_module._lang ({'ja', japanese}); -- add ja script with/without language prefix
err = true; -- set a flag
index = i; -- remember which positional param failed the test
break; -- abandon the search on first error
end
end
end
-- create error message and done
if romaji then
return err and table.concat ({
romaji = (lead and english and '[[Hepburn romanization|Hepburn]]: ' or '') .. lang_module._transl ({'ja', 'hepburn', romaji}) or nil;
'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: language: ',
end
lang_name, -- the thing that we think is the language name
' from {{{',
local formatting = {
{'(%s)'index, {extra}}, -- the positional parameter index: 1 -in (extra){{{1}}}
'}}} (',
{'%s', {romaji}}, -- 2 - romaji
{'%s (%s)', {romaji, extra}}args[index], -- 3the -content of the romajipositional (extra)parameter
') does not match category title.</span>[[Category:Lang and lang-xx template errors]]'
{'(%s)', {japanese}}, -- 4 - japanese
}) or nil;
{'(%s, %s)', {japanese, extra}}, -- 5 - (japanese, extra)
{'%s (%s)', {romaji, japanese}}, -- 6 - romaji (japanese)
{'%s (%s, %s)', {romaji, japanese, extra}}, -- 7 - romaji (japanese, extra)
{'%s', {english}}, -- 8 - english
{'%s (%s)', {english, extra}}, -- 9 - english (extra)
{'%s (%s)', {english, romaji}}, -- 10 - english (romaji)
{'%s (%s, %s)', {english, romaji, extra}}, -- 11 - english (romaji, extra)
{'%s (%s)', {english, japanese}}, -- 12 - english (japanese)
{'%s (%s, %s)', {english, japanese, extra}}, -- 13 - english (japanese, extra)
{'%s (%s, %s)', {english, japanese, romaji}}, -- 14 - english (japanese, romaji)
{'%s (%s, %s, %s)', {english, japanese, romaji, extra}}, -- 15 - english (japanese, romaji, extra)
}
return nihongo_renderer (args, formatting, extra2);
end
--[=[-------------------------< N I H O N G O 3 >--------------------------------------------------------------
An experiment to see how to implement {{nihongo3}} using Module:Lang for language and transliteration markup
Similar to {{nihongo}} but changes rendered order and does not support |lead=
{{Nihongo3|<English>|<kanji/kana>|<rōmaji>|<extra>|<extra2>}}
<English>, <kanji/kana>, and <rōmaji> are positional parameters
<English>: rendered as presented; purports to be English translation of <kanji/kana>
<kanji/kana>: Japanese language text using Japanese script; TODO: require?
<rōmaji>: Hepburn romanization (transliteration); TODO: in Module:Lang/data change tooltip text to 'Hepburn romanization'?
<extra> and <extra2> are positional or named: |extra= and |extra2=; mixing can be problematic
<extra> is rendered as presented preceeded with <comma><space>
<extra2> is rendered as presented preceeded with <space>
]=]
local function nihongo3 (frame)
local lang_module = require ('Module:Lang');
local args = require ('Module:Arguments').getArgs (frame);
local english = args[1]; -- meaningful names
local japanese = args[2];
local romaji = args[3];
local extra = args[4] or args.extra;
local extra2 = args[5] or args.extra2;
japanese = japanese and lang_module._lang ({'ja', japanese}) or nil;
romaji = romaji and lang_module._transl ({'ja', 'hepburn', romaji}) or nil;
local formatting = {
{'(%s)', {extra}}, -- 1 - (extra)
{'%s', {romaji}}, -- 2 - romaji
{'%s (%s)', {romaji, extra}}, -- 3 - romaji (extra)
{'(%s)', {japanese}}, -- 4 - japanese
{'(%s, %s)', {japanese, extra}}, -- 5 - (japanese, extra)
{'%s (%s)', {romaji, japanese}}, -- 6 - romaji (japanese)
{'%s (%s, %s)', {romaji, japanese, extra}}, -- 7 - romaji (japanese, extra)
{'%s', {english}}, -- 8 - english
{'%s (%s)', {english, extra}}, -- 9 - english (extra)
{'%s (%s)', {romaji, english}}, -- 10 - romaji (english)
{'%s (%s, %s)', {romaji, english, extra}}, -- 11 - romaji (english, extra)
{'%s (%s)', {english, japanese}}, -- 12 - english (japanese)
{'%s (%s, %s)', {english, japanese, extra}}, -- 13 - english (japanese, extra)
{'%s (%s, %s)', {romaji, japanese, english}}, -- 14 - romaji (japanese, english)
{'%s (%s, %s, %s)', {romaji, japanese, english, extra}}, -- 15 - romaji (japanese, english, extra)
}
return nihongo_renderer (args, formatting, extra2);
end
--[=[-------------------------< N I H O N G O _ F O O T >------------------------------------------------------
An experiment to see how to implement {{nihongo_foot}} using Module:Lang for language and transliteration markup
{{Nihongo foot|<English>|<kanji/kana>|<rōmaji>|<extra>|<extra2>|<post>|lead=yes|group}}
<English>, <kanji/kana>, and <rōmaji> are positional parameters
<English>: rendered as presented; purports to be English translation of <kanji/kana>
<kanji/kana>: Japanese language text using Japanese script; TODO: require?
<rōmaji>: Hepburn romanization (transliteration); TODO: in Module:Lang/data change tooltip text to 'Hepburn romanization'?
<extra> and <extra2> are positional or named: |extra= and |extra2=; mixing can be problematic
<extra> is rendered as presented preceeded with <comma><space>
<extra2> is rendered as presented preceeded with <space>
<post> is positional or named: |post= is a postscript character preceding the <ref>..</ref> tag (after <English>)
|lead=: takes one value 'yes'; renders language name same as {{lang-ja}} but also adds [[Hepburn romanization|Hepburn]]:<space> ahead of the romanization;
TODO: in Module:Lang, turnoff tooltip for transl when |lead=yes
in the live template |lead= also adds the Help:Installing Japanese character sets link; this is not supported in this code (nihongo nor nihongo3 have this support)
|group=: the group attribute in <ref group="..."> and in {{reflist}}
]=]
local function nihongo_foot (frame)
local lang_module = require ('Module:Lang');
local args = require ('Module:Arguments').getArgs (frame);
local english = args[1]; -- meaningful names
local japanese = args[2];
local romaji = args[3];
local extra = args[4] or args.extra;
local extra2 = args[5] or args.extra2;
local post = args[6] or args.post;
local group = args.group;
local lead = 'yes' == args.lead; -- make boolean
if japanese then
japanese = lead and lang_module._lang_xx_inherit ({['code']='ja', japanese}) or lang_module._lang ({'ja', japanese}); -- add ja script with/without language prefix
end
if romaji then
romaji = (lead and '[[Hepburn romanization|Hepburn]]: ' or '') .. lang_module._transl ({'ja', 'hepburn', romaji}) or nil;
end
local formatting = {
{'%s', {extra}}, -- 1 - extra
{'%s', {romaji}}, -- 2 - romaji
{'%s, %s', {romaji, extra}}, -- 3 - romaji, extra
{'%s', {japanese}}, -- 4 - japanese
{'%s, %s', {japanese, extra}}, -- 5 - japanese, extra
{'%s %s', {japanese, romaji}}, -- 6 - japanese romaji
{'%s %s, %s', {japanese, romaji, extra}}, -- 7 - japanese romaji, extra
-- from here english is used in the mapping but not rendered by nihongo_renderer so not included in the table
{'', {''}}, -- 8 - english
{'%s', {extra}}, -- 9 - extra
{'%s', {romaji}}, -- 10 - romaji
{'%s, %s', {romaji, extra}}, -- 11 - romaji, extra
{'%s', {japanese}}, -- 12 - japanese
{'%s, %s', {japanese, extra}}, -- 13 - japanese, extra
{'%s %s', {japanese, romaji}}, -- 14 - japanese romaji
{'%s %s, %s', {japanese, romaji, extra}}, -- 15 - japanese romaji, extra
}
if english and post then -- rewrite english to include |post=
english = english .. post; -- if english has a value append post else just post
elseif post then
english = post; -- english not set, use post
elseif not english then -- neither are set
english = ''; -- make english an empty string for concatenation
end
if japanese or romaji or extra or extra2 then -- no ref tag when none of these are set (it would be empty)
return english .. frame:extensionTag ({name='ref', args={group=group}, content=nihongo_renderer (args, formatting, extra2)});
else
return;
end
end
--[[--------------------------< E X P O R T E D F U N C T I O N S >------------------------------------------
return {
in_lang = in_lang, -- module entry from {{#invoke:}}
native_name_lang = native_name_lang, -- experimental code; may not be retained
nihongo = nihongo,
_in_lang = _in_lang, -- module entry from another module
nihongo3 = nihongo3,
nihongo_foot = nihongo_foot,
cat_test = cat_test, -- temporary test code to be deleted
set_italics = set_italics,
}
| 