Module:Weather box/row: Difference between revisions

Module documentation[create] [purge]

You might want to create a documentation page for this Scribunto module.
Editors can experiment in this module's sandbox (edit | diff) and testcases (edit) pages.
Add categories to the /doc subpage. Subpages of this module.

local w = {}
local math_mod = require( "Module:Math" )
local wbc = require( "Module:WeatherBoxColors" )

local function checkFlag( flag )
	if flag == nil then
		return nil
	elseif type( flag ) == 'boolean' then
		return flag
	elseif type( flag ) == 'string' then
		flag = flag:lower()
		if flag == '0' or flag == 'false' or
				flag == '' or flag == 'no' or
				flag == 'n' then
			return false
		else
			return true
		end
	else
		return error( 'Flag type not valid' )
	end
end

local function makeLine( label, first_value_string, second_value_string, color_values, color_scheme )
	local result, color_str, value_str

	result = {'|- style="text-align: center;"\n! scope="row" style="height: 16px;" | ', label,  "\n"}
	for i = 1,13 do
		color_str = color_values[i]

		if i == 13 then
			table.insert( result, table.concat( {'|style="', color_str, ' border-left-width:medium" | '} ) )
		else
			table.insert( result, table.concat( {'|style="', color_str, '" | '} ) )
		end

		value_str = first_value_string[i]
		if value_str ~= '' and value_str ~= nil then
			table.insert( result, value_str )
			if second_value_string ~= nil then
				value_str = second_value_string[i]
				if value_str ~= '' and value_str ~= nil then
					table.insert( result, "<br /> (" .. value_str .. ")" )
				end
			end
		else
			table.insert( result, '—' )
		end

		table.insert( result, "\n" )
	end

	return table.concat( result )
end

local function getInputs( frame, group_name, suffix, include_space )
	local month_names = { 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
		'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'year' }
	local str, str2, val

	local output_string = {}
	local output_value = {}
	local variant = {}
	if suffix == nil then
		for _, mon in ipairs( month_names ) do
			if include_space then
				str = ( frame.args[ mon .. ' ' .. group_name ] or '' )
			else
				str = ( frame.args[ mon .. group_name ] or '' )
			end
			val, str2 = math_mod._cleanNumber( str )
			if val ~= nil then
				table.insert( output_string, str2 )
				table.insert( output_value, val )
			else
				table.insert( output_string, str )
				table.insert( output_value, -9999 )
			end
		end
	else
		local updated = false
		for _, mon in ipairs( month_names ) do
			updated = false
			for i, suf in ipairs( suffix ) do
				if include_space then
					str = frame.args[ mon .. ' ' .. group_name .. ' ' .. suf ]
				else
					str = frame.args[ mon .. group_name .. ' ' .. suf ]
				end
				if str ~= nil and str ~= '' then
					val, str2 = math_mod._cleanNumber( str )
					if val ~= nil then
						table.insert( output_string, str2 )
						table.insert( output_value, val )
					else
						table.insert( output_string, str )
						table.insert( output_value, -9999 )
					end
					table.insert( variant, i )
					updated = true
					break
				end
			end
			if not updated then
				table.insert( output_string, '' )
				table.insert( output_value, -9999 )
				table.insert( variant, 0 )
			end
		end
	end

	return output_string, output_value, variant
end

local function getAnnualValue( values, mode )
	local total = 0
	local val = 0

	if mode == 'avg' or mode == 'sum' then
		local p1, p2
		p1 = 0
		for i = 1, 12 do
			val = values[i]
			if val == -9999 then
				return '', -9999
			end

			p2 = math_mod._precision( val )
			if p2 > p1 then
				p1 = p2
			end

			total = total + val
		end
		if mode == 'avg' then
			total = math_mod._round( total / 12, p1 )
		end
		return tostring( total ), total
	elseif mode == 'min' then
		local min_val = nil
		for i = 1, 12 do
			val = values[i]
			if val ~= -9999 then
				if min_val == nil or val < min_val then
					min_val = val
				end
			end
		end
		return tostring( min_val ), min_val
	elseif mode == 'max' then
		local max_val = nil
		for i = 1, 12 do
			val = values[i]
			if val ~= -9999 then
				if max_val == nil or val > max_val then
					max_val = val
				end
			end
		end
		return tostring(max_val), max_val
	else
		error( 'Unrecognized Annual Mode' )
	end
end

local function reconcileTemperature( C_degree_strings, C_degree_values, F_degree_strings, F_degree_values )
	local p
	for i = 1,13 do
		if C_degree_strings[i] == '' then
			if F_degree_values[i] ~= -9999 then
				p = math.max( 0, math_mod._precision( F_degree_strings[i] ) )
				C_degree_values[i] = math_mod._round( (F_degree_values[i] - 32)*5/9, p )
				C_degree_strings[i] = tostring( C_degree_values[i] )
			end
		elseif F_degree_strings[i] == '' then
			if C_degree_values[i] ~= -9999 then
				p = math.max( 0, math_mod._precision( C_degree_strings[i] ) )
				F_degree_values[i] = math_mod._round( C_degree_values[i]*9/5 + 32, p )
				F_degree_strings[i] = tostring( F_degree_values[i] )
			end
		end
	end
	return C_degree_strings, C_degree_values, F_degree_strings, F_degree_values
end

local function reconcilePrecipitation( M_degree_strings, M_degree_values,
		I_degree_strings, I_degree_values, variant, prefer_cm )
	local p

	local v_class = 0
	for i = 1,13 do
		if variant[i] == 1 then
			v_class = 1
		elseif variant[i] == 2 then
			v_class = 2
		end
	end
	if v_class == 0 then
		if prefer_cm then
			v_class = 1
		else
			v_class = 2
		end
	end
	for i = 1,13 do
		if M_degree_strings[i] == '' then
			if I_degree_values[i] ~= -9999 then
				if v_class == 1 then
					p = math.max( 0, math_mod._precision( I_degree_strings[i] ) ) - 1
					M_degree_values[i] = math_mod._round( I_degree_values[i]*2.54, p )
					variant[i] = v_class
				else
					p = math.max( 0, math_mod._precision( I_degree_strings[i] ) ) - 2
					M_degree_values[i] = math_mod._round( I_degree_values[i]*25.4, p )
					variant[i] = v_class
				end
				M_degree_strings[i] = tostring( M_degree_values[i] )
			end
		elseif I_degree_strings[i] == '' then
			if M_degree_values[i] ~= -9999 then
				if variant[i] == 1 then
					p = math.max( 0, math_mod._precision( M_degree_strings[i] ) )
					I_degree_values[i] = M_degree_values[i]/2.54
				else
					p = math.max( 0, math_mod._precision( M_degree_strings[i] ) ) + 1
					I_degree_values[i] = M_degree_values[i]/25.4
				end
				I_degree_values[i] = math_mod._round( I_degree_values[i], p )
				I_degree_strings[i] = tostring( I_degree_values[i] )
			end
		end
	end
	return M_degree_strings, M_degree_values, I_degree_strings, I_degree_values, variant
end

function w.buildRow( frame )
	local mode = (frame.args.mode or 'basic'):lower()
	local group_name = frame.args.group_name
	local first_value_string, second_value_string
	local first_value_number, second_value_number, color_values
	local color_scheme = frame.args.color_scheme or 't'
	local scale_factor = math_mod._cleanNumber( frame.args.scale_factor) or 1
	local date_mode = checkFlag( frame.args.date_mode or false )
	local label = frame.args.label or ''
	local annual_mode = (frame.args.annual_mode or 'avg'):lower()
	local include_space = checkFlag( frame.args.include_space or true )
	local second_line = checkFlag( frame.args.second_line ) or false
	local prefer_cm = checkFlag( frame.args.prefer_cm ) or false
	local result
	local variant

	local pframe = frame:getParent()
	local imperial_first = checkFlag( frame.args['imperial first'] )
	if imperial_first == nil then imperial_first = checkFlag( pframe.args['imperial first'] ) end

	local metric_first = checkFlag( frame.args['metric first'] )
	if metric_first == nil then metric_first = checkFlag( pframe.args['metric first'] ) end

	local single_line = checkFlag( frame.args['single line'] )
	if single_line == nil then single_line = checkFlag( pframe.args['single line'] ) end

	if imperial_first == nil and metric_first ~= nil then
		imperial_first = not metric_first
	else
		imperial_first = true
	end

	if mode == 'basic' then
		first_value_string, first_value_number = getInputs( pframe, group_name,
			nil, include_space )
		second_value_string = nil
		second_value_number = nil
	elseif mode == 'temperature' then
		first_value_string, first_value_number = getInputs( pframe, group_name,
			{'C'}, include_space )
		second_value_string, second_value_number = getInputs( pframe, group_name,
			{'F'}, include_space )
		first_value_string, first_value_number, second_value_string, second_value_number =
			reconcileTemperature( first_value_string, first_value_number,
				second_value_string, second_value_number )
	elseif mode == "precipitation" then
		first_value_string, first_value_number, variant = getInputs( pframe, group_name,
			{'cm', 'mm'}, include_space )
		second_value_string, second_value_number = getInputs( pframe, group_name,
			{'inch'}, include_space )
		first_value_string, first_value_number, second_value_string, second_value_number,
			variant =
			reconcilePrecipitation( first_value_string, first_value_number,
				second_value_string, second_value_number, variant, prefer_cm )
	else
		error( 'Requested mode not recognized' )
	end

	local good = false
	for i = 1,13 do
		if first_value_string[i] ~= nil and first_value_string[i] ~= '' then
			good = true
			break
		end
	end
	if not good then
		return ''
	end

	if first_value_string[13] == nil or first_value_string[13] == '' then
		first_value_string[13], first_value_number[13] = getAnnualValue( first_value_number, annual_mode )
	end
	if second_value_string ~= nil then
		if second_value_string[13] == nil or second_value_string[13] == '' then
			second_value_string[13], second_value_number[13] = getAnnualValue( second_value_number, annual_mode )
		end
		if mode == 'precipitation' then
			for i = 1,12 do
				if variant[i] ~= 0 then
					variant[13] = variant[i]
					break
				end
			end
		end
	end

	color_scheme = wbc.interpret_color_code( color_scheme )

	color_values = {}
	local month_adj = { 31/30, 28.25/30, 31/30, 1, 31/30, 1,
		31/30, 31/30, 1, 31/30, 1, 31/30, 12.175 }
	local adj
	for i = 1,13 do
		if first_value_number[i] ~= nil and first_value_number[i] ~= -9999 then
			adj = scale_factor
			if date_mode then
				adj = adj / month_adj[i]
			end
			if mode == "precipitation" then
				if variant[i] == 1 then
					adj = adj * 10
				end
			end
			table.insert( color_values, color_scheme( first_value_number[i] * adj ) )
		else
			table.insert( color_values, color_scheme( nil ) )
		end
	end

	local lang = mw.getContentLanguage()
	local function formatNumber(number, number_string)
		if number ~= nil and number ~= -9999 then
			if math.abs(number) >= 1000 then
				number_string = lang:formatNum( math.abs(number) )
				if number < 0 then
					number_string = '−' .. number_string
				end
			elseif number < 0 then
				number_string = '−' .. number_string:sub(2)
			end
		end
		return number_string
	end
	for i = 1,13 do
		first_value_string[i] = formatNumber(first_value_number[i], first_value_string[i])
		if second_value_number ~= nil then
			second_value_string[i] = formatNumber(second_value_number[i], second_value_string[i])
		end
	end

	if imperial_first and second_value_string ~= nil then
		local t = first_value_string
		first_value_string = second_value_string
		second_value_string = t
	end

	if not single_line then
		if second_line and second_value_string ~= nil then
			first_value_string = second_value_string
		end
		second_value_string = nil
	end

	return makeLine( label, first_value_string, second_value_string, color_values, color_scheme )
end

return w