Module:Mw lang

require('Module:No globals');


--[[--------------------------< _ _ N O R M A L I Z E _ A R G S >----------------------------------------------

normalize frame.args[1] and frame.args[2] to lowercase and trimmed of leading and trailing whitespace

because frame.args[1] can be either a language code or a language name, first is used instead.  frame.args[2]
is always used for the target language code so we use target_lang_code as is used by the other functions in this
module

]]

local function __normalize_args (first, target_lang_code)
	if not first or '' == first then
		return nil;																-- empty or missing so not a language code
	end
	
	first = first:lower():gsub ('%s*(.-)%s*', '%1');							-- lowercase trimmed

	if target_lang_code and '' ~= target_lang_code then
		target_lang_code = target_lang_code:lower():gsub ('%s*(.-)%s*', '%1');	-- lowercase trimmed
	else
		target_lang_code = nil;
	end
	
	return first, target_lang_code;
end


--[[--------------------------< E R R _ M S G _ M A K E >------------------------------------------------------
]]

local function err_msg_make (msg)
	return '<span class="error" style="font-size:100%">error: ' .. msg .. ' not recognized</span>'
end


--[[--------------------------< _ I S _ C O D E >--------------------------------------------------------------

local or require()d entry point

return true if code is a mediawiki recognized code; false else

code - language code to validate; expected to be lowercase without leading/trailing whitespace
target_lang_code - language code for target language; expected to be lowercase without leading/trailing whitespace

specifying target_lang_code may be a pointless exercise because of cldr fallback.  For example,
	mw.language.fetchLanguageName (crh, sq) -> Crimean Turkish
because the Albanian language definitions do not have an Albanian-language version of the language name

]]

local function _is_code (code, target_lang_code)
	code = mw.language.fetchLanguageName (code, target_lang_code or mw.getContentLanguage():getCode());
	return '' ~= code;
end


--[[--------------------------< I S _ C O D E >----------------------------------------------------------------

module entry point

return true if code is a mediawiki recognized code; empty string else

]]

local function is_code (frame)
	local code, target_lang_code = __normalize_args (frame.args[1], frame.args[2])

	if not code then
		return '';																-- empty or missing so not a language code
	else
		return _is_code (code, target_lang_code) and true or '';
	end
end


--[[--------------------------< _ _ V A L I D A T E _ T A R G E T _ L A N G _ C O D E >------------------------

validates target_lang_code as a know language code; returns two values
	when target_lang_code is valid, first return value holds target_lang_code; second return value is nil
	when target_lang_code is invalid, first retrun value is nil; second return value has error message

if target_lang_code argument is nil, (missing or empty in the invoke) use local wiki's language code

]]

local function __validate_target_lang_code (target_lang_code)
	local msg;
	
	if target_lang_code then													-- not missing or empty
		if not _is_code (target_lang_code) then									-- validate target_lang_code
			msg = err_msg_make ('target language code: ' .. target_lang_code);
			target_lang_code = nil;												-- unset as invalid
		end
	else
		target_lang_code = mw.getContentLanguage():getCode();					-- not set so use local wiki's language code
	end

	return target_lang_code, msg;												-- target_lang_code is valid or nil; msg is nil or has an error message
end


--[[--------------------------< N A M E _ F R O M _ C O D E >--------------------------------------------------

module entry point

args[1]: language code
args[2]: optional target language code; same as <target lang code> in {{#language:<code>|<target lang code>}}; defaults to the local wiki language

return language-name if language-code is a mediawiki recognized code; error message string else

returned language name not guarenteed to be in target_lang_code (if specified), because mw language lists are incomplete

]]

local function name_from_code (frame)
	local code, target_lang_code = __normalize_args (frame.args[1], frame.args[2])
	local msg;
	
	if not code then
		return err_msg_make ('code: (empty)');
	end
	
	target_lang_code, msg = __validate_target_lang_code (target_lang_code);
	if msg then
		return msg;
	end

	local name = mw.language.fetchLanguageName (code, target_lang_code);		-- returns empty string if code not found
	return '' ~= name and name or err_msg_make ('language code: ' .. code);		-- return language name or error message
end


--[[--------------------------< C O D E _ F R O M _ N A M E >--------------------------------------------------

module entry point

args[1]: language name
args[2]: optional target language code; instruct this function to fetch language name list in 'this' language

return language-code if language-name is a mediawiki recognized name; error message string else

]]

local function code_from_name (frame)
	local name, target_lang_code = __normalize_args (frame.args[1], frame.args[2]);
	local msg;

	if not name then
		return err_msg_make ('name: (empty)');
	end

	target_lang_code, msg = __validate_target_lang_code (target_lang_code);
	if msg then
		return msg;
	end

	local code_name_list = mw.language.fetchLanguageNames (target_lang_code, 'all');	-- get language code / name list in target_lang_code language indexed by language code
	local name_code_list = {};													-- to hold language name / code list indexed by name

	for k, v in pairs (code_name_list) do										-- spin through the code / name list and
		name_code_list[v:lower()] = k;											-- make a name / code list
	end

	return name_code_list[name] or err_msg_make ('language name: ' .. name);	-- returns code when name is found; error message else
end


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

return {
	name_from_code = name_from_code,											-- switching to names more like those function names used in Module:Lang
	is_code = is_code,
	code_from_name = code_from_name,

	_is_code = _is_code,														-- entry point from another module
	}