Module:Road data/parser

Documentation for this module may be created at Module:Road data/parser/doc

local p = {}
local format = mw.ustring.format
local gsub = mw.ustring.gsub
local trim = mw.text.trim
local upper = mw.ustring.upper

local prepattern = "%[(%w+)%|(.*)%|(.*)%|(.*)%]"
local pattern = "%%(%w+)%%"

local function parser(formatStr, args)
	local function testArgs(test, equals, ifexists, ifnot)
		if equals ~= '' then
			if args[test] == equals then return ifexists else return ifnot end
		else
			if args[test] and args[test] ~= '' then return ifexists else return ifnot end
		end
	end
	-- Recursively dig into tables that could be parser hooks or argument tables.
	local function formatStrInTable(formatStr)
		if type(formatStr) ~= "table" then return formatStr end
		local hook = formatStr.hook
		if hook then
			local hooksModule = require "Module:Road data/parser/hooks"
			local hookFunction = hooksModule[hook] or error("Hook '" .. hook .. "' does not exist", 0)
			return formatStrInTable(hookFunction(formatStr, args))
		else
			local arg = args[formatStr.arg or "route"]
			return formatStrInTable(formatStr[arg] or formatStr.default)
		end
	end
	formatStr = formatStrInTable(formatStr)
	if formatStr == '' then return '' end
	local preprocessed = gsub(formatStr, prepattern, testArgs)
	local final = gsub(preprocessed, pattern, args)
	return trim(final)
end

local function formatString(args, form, part)
	local formatStringData = mw.loadData("Module:Road data/strings")
	local state = upper(args.state or args.province or '')
	local country
	if args.country then
		country = upper(args.country)
	else
		local countryModule = mw.loadData("Module:Road data/countrymask")
		country = countryModule[state] or 'UNK'
	end
	local typeArg = args.type
	local module
	local countryData = formatStringData[country] or ''
	if state and (type(countryData) == 'table') then
		module = countryData[state]
	else
		module = countryData
	end
	if module == '' then return '' end
	local moduleData = mw.loadData(module)
	local typeTable = moduleData[typeArg]
	if typeTable then
		return part and typeTable[form][part] or typeTable[form]
	else
		return ''
	end
end

function p.parser(passedArgs, form, part)
	local args = {state = passedArgs.state, type = passedArgs.type, route = passedArgs.route, 
	              denom = passedArgs.denom, county = passedArgs.county, dab = passedArgs.dab,
	              country = passedArgs.country}
	local formatStr = formatString(args, form, part)
	return (formatStr ~= '') and parser(formatStr, args) or nil
end

return p