Module:In lang/sandbox: Difference between revisions

Revision as of 17:06, 13 June 2019

Latest revision as of 06:11, 22 July 2023

(41 intermediate revisions by 4 users not shown)

Line 1:

require ('Module:No globalsstrict');

local is_latn = require ("Module:Unicode data").is_Latin;

--[[--------------------------< _ 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

|template=<template name> - customizes error messages created by Module:lang

|list-cats=yes - documentation tool returns language-category names of cats populated by this template

<span class="languageicon">(in <language>)</span>

]]

local function is_cjk_code_in_lang (codeargs)

local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code

local cjk =

local list_cats = 'yes' == args['list-cats']; -- make a boolean

{

local list = {};

['zh'] = true, ['cdo'] = true, ['cjy'] = true, ['cmn'] = true, -- Chinese language codes

local cats = {};

['cpi'] = true, ['cpx'] = true, ['czh'] = true, ['czo'] = true,

local maint_msgs = {};

['gan'] = true, ['hak'] = true, ['hsn'] = true, ['ltc'] = true,

['lzh'] = true, ['mnp'] = true, ['nan'] = true, ['och'] = true,

if not args[1] then

['wuu'] = true, ['yue'] = true, ['zhx'] = true,

local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template)

['ja'] = true, ['jpx'] = true, ['ojp'] = true, -- Japanese language codes

return table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: ', template, 'missing language tag</span>'});

['ko'] = true, ['okm'] = true, ['oko'] = true, -- Korean language codes

end

}

local module = 'Module:Lang' .. (mw.getCurrentFrame():getTitle():match ('/sandbox') or ''); -- if this module is the sandbox,

return cjk[code] or false;

end

local name_from_tag = require (module)._name_from_tag; -- use Module:Lang/sandbox; Module:Lang else

local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization

--[[--------------------------< S E T _ I T A L I C S >--------------------------------------------------------

local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language code

for i, lang in ipairs (args) do

Created for use with Template:Infobox book and Template:Infobox document and perhaps others to replace hard-coded

local code = args[i]:lower();

italic markup in the call to {{lang}}. This module attempts to make sure that {{lang}} correctly applies italic

local t = {code, ['link'] = args['link'], ['template'] = args['template']}; -- build an 'args' table

markup according to MOS:FOREIGNITALIC.

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

]]

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

end

if synonym_table[code] then -- if 639-2/639-2T code has a 639-1 synonym

if (0 == namespace) and not list_cats then -- when listing cats don't include this cat; TODO: right choice?

table.insert (cats, table.concat ({'[[Category:Lang and lang-xx code promoted to ISO 639-1|', code ..']]'}));

end

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

local function set_italics (frame)

if lang:find ('error') then -- add error category (message provided by Module:Lang)

local code = frame.args[1] or frame.args['code'] or ''; -- empty string causes 'yes' return; {{lang}} will handle the missing code error

if not list_cats then -- don't include this cat when listin cats; TODO: right choice?

local text = frame.args[2] or frame.args['text'] or ''; -- empty string causes 'yes' return; {{lang}} will handle the missing text error

table.insert (cats, '[[Category:in lang template 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

if is_cjk_code (code) and not is_latn (text) then -- is_latn() is in Module:Lang

local cats = table.concat (cats, ', '):gsub ('[%[%]]', ''); -- make a string of categories and then strip wikilink markup

return 'no'; -- only case for 'no'

return cats

end

return 'yes'; -- everything else is yes

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 concatenate 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

Line 46 ⟶ 93:

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

implements {{in lang}}

written to support multiple language codes in {{link language}}

Module entry point from an {{#invoke:lang/utilities/sanbox|in_lang|<code>|<code2>|<code3>|<code...>|link=yes|template=Linkin languagelang|list-cats=yes}}

<span class="languageicon">(in <language>)</span>

]]

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

|native_name_lang= parameter.

if {{{1}}} is a valid ietf language tag, returns that tag;

if {{{1}}} is a properly spelled (case agnostic) language name, returns the ietf language tag associated with that name

error messages else

entry point from an {{#invoke:Lang/utilities/sandbox|native_name_lang|<language name or tag>|template=<template name>}}

]]

local function native_name_lang (frame)

local lang_module = require ('Module:Lang/sandbox');

local getArgs = require ('Module:Arguments').getArgs;

local args = getArgs(frame);

local list = {};

local cats = {};

if notlang_module._is_ietf_tag (args[1]) then

return args[1]; -- if a tag, return the tag

local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template)

else

return table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: ', template, 'missing language tag</span>'});

return lang_module._tag_from_name (args); -- not a tag, attempt to get a tag from the args[1] input value; return tag or error message

end

end

local name_from_code = require ('Module:Lang/sandbox')._name_from_code

--[[--------------------------< C A T _ T E S T >--------------------------------------------------------------

local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization

local this_wiki_lang = mw.getCurrentFrame():preprocess('{{int:lang}}');

if '⧼lang⧽' == this_wiki_lang then

this_wiki_lang = mw.language.getContentLanguage().code; -- not at a MediaWiki site that supports interface language; get this wiki's language code

end

temporary test code to be deleted

for i, lang in ipairs (args) do

local t = {args[i], ['link'] = args['link'], ['template'] = args['template']};

lang = name_from_code (t)

table.insert (list, lang)

support for {{Category articles containing non-English-language text}} that tests the language parameters provided

if lang:find ('error') or (this_wiki_lang == args[i]) or (0 ~= namespace) then -- for these, no categorization

to that template against the category name.

else

if lang:match ('%[%[.-|.-%]%]') then

{{#invoke:Lang/utilities/sandbox|cat_test}}

lang = lang:match ('%[%[.-|(.-)%]%]');

elseif lang:match ('%[%[.-%]%]') then

]]

lang = lang:match ('%[%[(.-)%]%]');

local function cat_test (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)

if 'number' == type (i) and args[i] then -- only positional parameters and only when they have a value

if lang_module._is_ietf_tag (v) then -- see if this thing 'v' is an ietf tag

local t = {v}; -- it is so make an args table for _name_from_tag()

lang_name = lang_module._name_from_tag (t); -- get the language name

else

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

table.insert (cats, '[[Category:Articles with ' .. lang .. '-language external links]]')

not mw.ustring.find (lc_title, lc_lang_name_col, 1, true) then

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

return err and table.concat ({

local count = #list;

'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: language: ',

local ret_string;

lang_name, -- the thing that we think is the language name

if 2 >= count then

' from {{{',

ret_string = table.concat (list, ' and '); -- insert '<space>and<space>' between two language names

index, -- the positional parameter index: 1 in {{{1}}}

elseif 2 < count then

'}}} (',

ret_string = table.concat (list, ', '); -- concatenate with '<comma><space>' separators

args[index], -- the content of the positional parameter

ret_string = ret_string:gsub (', ([^,]+)$', ', and ' .. '%1'); -- replace last '<comma><space>' separator with '<comma><space>and<space>' separator

') does not match category title.</span>[[Category:Lang and lang-xx template errors]]'

end

}) or nil;

return table.concat ({'<span class="languageicon">(in ', ret_string, ')</span>', table.concat (cats)});

-- return ret_string .. table.concat (cats);

end

--[[--------------------------< E X P O R T E D F U N C T I O N S >------------------------------------------

Line 107 ⟶ 202:

return {

in_lang = in_lang, -- module entry from {{#invoke:}}

native_name_lang = native_name_lang, -- experimental code; may not be retained

set_italics = set_italics,

_in_lang = _in_lang, -- module entry from another module

cat_test = cat_test, -- temporary test code to be deleted

}