This module is a rewrite of the existing wikitext template . The primary purpose of
the rewrite is to bring the non-English text into the template so that it can be marked up by .

To accomodate the variety of uses of the template, news parameters are introduced to allow variable styling.

supported parameters (original)

supported parameters (new)
		'none' – omit left and right parens around ''
		'left' – includes left paren, omits right paren
		'right' – includes right paren, omits left paren

because this template now calls properly, it also supports the parameters:
	
basic rendering
	')

multiple terms
	')

	'

	')

	')

	')

]=]

require ('strict');
local get_args = require ('Module:Arguments').getArgs;
local lang_mod = require ('Module:Lang');

--------------------------------------------------------------------------------

render an error message with help-text link and category.


local function error_message (message)
	local err_msg_t = {'');	-- the help link

	local namespace = mw.title.getCurrentTitle.namespace;						-- namespace number
	if 0 == namespace or 10 == namespace then
		table.insert ;	-- categorize in main and template namespaces
	end

	return table.concat (err_msg_t);											-- make a big string and done
end

--termn= parameters. Return a string where each term is in
single quotes. If more than one |termn= parameter, separate each term with . Apply italic markup
when |itlaic-term=yes


local function terms_get (args_t)
	local function render_term 								-- local function to do the rendering
		if is_italic then
			term = term:gsub ;								-- apply italic markup; html to avoid converting '' to ** when quoted
		end
		if is_italic or term:match ('[^\']\'\'$') then
			term = term:gsub ;
		else
			term = term:gsub ;								-- quote using &#39; in case term uses italic or bold wikimarkup
		end
		return term;															-- done this was to avoid second string.gsub return value
	end

	local is_italic = 'yes' == args_t['italic-term'];							-- make boolean
	
	if args_t[3] then															-- if } has a value
		return render_term ;
	end
	
	local terms = {};															-- a table to hold one or more non-English terms
	
	for k, v in pairs (args_t) do
		if 'string' == type (k) and k:match ('term%d') then						-- string parameter names only
			table.insert (terms, k:match ('term(%d+)') .. '=' .. v);			-- convert k/v pairs to a sequence that can be sorted by |termn= enumerator (enum=term)
		end
	end
	
	table.sort (terms, function 											-- sort the sequence using local sort function
		local enum_a = a:match ('^%d+');										-- make numbers for the comparison
		local enum_b = b:match ('^%d+');
		return tonumber(enum_a) < tonumber(enum_b)								-- and compare
		end
		);
	
	for i, v in ipairs (terms) do												-- rewrite the sequence to be sorted sequence of terms
		terms[i] = render_term (v:gsub ('%d+=(.+)', '%1'), is_italic);			-- extract term; italicize as required, and quote
	end

	return table.concat ;											-- form a string and done
end

--lang-name= has a
value, override any value that might be in } with 'mis' (uncoded languages) 

TODO: error condition when both of } and |lang-name= have values?


local function text_make (lang_params_t)
	if not lang_params_t[2] then
		return '';
	end

	return lang_mod._lang (lang_params_t);
end

--lang-name= overrides }. Language name links to language
article through ' language' redirect except when |links=no


local function lang_make 
	if args_t['lang-name'] then
		if 'no' == args_t.links then
			return args_t['lang-name'];
		end
		
		local lang_t = {};														-- holds component parts of language name link when using |lang-name=
		table.insert ;											-- open wikilink
		table.insert ;								-- add the name from |lang-name=
		table.insert ;									-- add ' languge' for redirect and pipe for link label
		table.insert ;								-- add language name as label for wikilink
		table.insert ;											-- close wikilink
		return table.concat (lang_t);											-- and make a big string and done
	end
		
	return lang_mod._name_from_tag (lang_params_t);								-- get language name (linked or not) from 
end

--------------------------------------------------------------------------------------------

entry point from another module


local function _langnf (args_t)
	if not (args_t[1] or args_t['lang-name']) then
		return error_message ('missing language tag or language name');
	end

	if (args_t[1] and args_t['lang-name']) then
		return error_message ('only one of  allowed');
	end

	if not (args_t[3] or args_t.term1) then
		return error_message ('missing English translation');
	end

	local lang_params_t = {														-- build a table of parameters to be used by 
		link = args_t.links or 'yes', ['rtl']=args_t.rtl,						-- used by 
		[1] = args_t['lang-name'] and 'mis' or args_t[1],						-- used by and by 
		[2] = args_t[2],														-- the rest of these are parameters used only by 
		rtl = args_t.rtl,														-- right-to-left; not normally needed
		i = args_t.i,															-- |italic= alias
		italic = args_t.italic,
		italics = args_t.italics,												-- |italic= alias
		size = args_t.size,
		cat = args_t.cat,
		nocat = args_t.nocat,
		template = 'Language with name/for',

	local out_t = {};															-- components of the rendering go here
	local left_paren = ('none' == args_t.paren or 'right' == args_t.paren) and '' or '(';
	local right_paren = (not args_t[2] or 'none' == args_t[2] or 'left' == args_t.paren or 'none' == args_t.paren) and '' or ')';
	
	if args_t[2] and ('none' ~= args_t[2]) then									-- optional; } may be omitted; keyword 'none' prevents categorization; used in 
		table.insert (out_t, text_make (lang_params_t));						-- the non-English text marked up by 
		table.insert (out_t, 'yes' == args_t['break'] and ' else
		table.insert ;										-- omit left paren around '' when |paren=none or |paren=right
	end
	table.insert (out_t, lang_make );					-- language name; linked unless |links=no
	table.insert ;												-- the 'for' static text
	table.insert (out_t, terms_get (args_t));									-- and the term(s) italicized as appropriate and quoted
	table.insert ;											-- omit right paren around '' when |paren=none or |paren=left or } omitted
	
	if not args_t[2] then														-- if this template doesn't use } for the non-English text
		table.insert ;	-- add this category
	end
	
	return table.concat (out_t);												-- make a big string and done
end

----------------------------------------------------------------------------------------------

implements 



local function langnf (frame)
	local args_t = get_args (frame);
	return _langnf (args_t)
end

--------------------------------------------------------------------------------------------

return {
	langnf = langnf,															-- entry point from a template
	
	_langnf = _langnf,															-- entry point from another module