มอดูล:In lang/sandbox

require ('Module:No globals');
--list-cats=yes - documentation tool returns language-category names of cats populated by this template
(in )
local function _in_lang (args)
	local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms');			-- ISO 639-2/639-2T code translation to 639-1 code
	local list_cats = 'yes' == args'list-cats';								-- make a boolean
	local list = {};
	local cats = {};
	local maint_msgs = {};
	
	if not args1 then
		local template = (args'template' and table.concat ({': '})) or ;	-- make template name (if provided by the template)
		return table.concat ({'error: ', template, 'missing language tag'});
	end
	local module = 'Module:Lang' .. (mw.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
	local namespace = mw.title.getCurrentTitle().namespace;						-- used for categorization
	local this_wiki_lang = mw.language.getContentLanguage().code;				-- get this wiki's language code
	for i, lang in ipairs (args) do
		local code = argsi: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
			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_tablecode 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 ({}));
			end
			table.insert (maint_msgs, ' ')
			table.insert (maint_msgs, table.concat ({'code: ', code, ' promoted to code: ', synonym_tablecode}));
			table.insert (maint_msgs, ';');
			code = synonym_tablecode;											-- use the synonym
		end
		if (0 == namespace) or list_cats then												-- when in article space
			if lang:find ('error') then											-- add error category (message provided by Module:Lang)
				if not list_cats then											-- don't include this cat when listin cats; TODO: right choice?
					table.insert (cats, );
				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 ({}));
				else
					table.insert (cats, table.concat ({}));
				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 = {'('};							-- 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 ');											-- 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
--------------------------------------------------------------------------------------------
implements 
Module entry point from an list-cats=yes
local function in_lang (frame)
	local args = require ('Module:Arguments').getArgs (frame);
	return _in_lang (args);
	end
--------------------------------------------------------------------------
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  is a valid ietf language tag, returns that tag;
if  is a properly spelled (case agnostic) language name, returns the ietf language tag associated with that name
error messages else
entry point from an template=
local function native_name_lang (frame)
	local lang_module = require ('Module:Lang/sandbox');
	local getArgs = require ('Module:Arguments').getArgs;
	local args = getArgs(frame);
	
	if lang_module._is_ietf_tag (args1) then
		return args1;															-- if a tag, return the tag
	else
		return lang_module._tag_from_name (args);								-- not a tag, attempt to get a tag from the args1 input value; return tag or error message
	end
end
------------------------------------------------------------------------------------------
temporary test code to be deleted
support for  that tests the language parameters provided
to that template against the category name.
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 argsi 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
				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 ({
		'error: language: ',
		lang_name,																-- the thing that we think is the language name
		' from  (',
		argsindex,															-- the content of the positional parameter
		') does not match category title.'
		}) or nil;
end
----------------------------------------------------------------------
return {
	in_lang = in_lang,															-- module entry from 
	native_name_lang = native_name_lang,										-- experimental code; may not be retained
	
	_in_lang = _in_lang,														-- module entry from another module
	cat_test = cat_test,														-- temporary test code to be deleted
	}