Difference between revisions of "Module:Road data/parser"

From blackwiki
Jump to navigation Jump to search
blackwiki>Imzadi1979
(Reverted to revision 719942056 by Happy5214 (talk): Rolling back update in attempt to fix a large number of breakages. (TW))
blackwiki>Fredddie
(sync to main)
Line 1: Line 1:
-- Export package
+
local p = {} -- Package to be exported
local p = {}
+
 
 +
-- Change to "" upon deployment.
 +
local moduleSuffix = ""
 +
 
 +
local parserHooksModuleName = "Module:Road data/parser/hooks" .. moduleSuffix
  
 
-- Local library aliases
 
-- Local library aliases
 
local format = string.format
 
local format = string.format
 
local gsub = mw.ustring.gsub
 
local gsub = mw.ustring.gsub
local trim = mw.text.trim
 
 
local upper = mw.ustring.upper
 
local upper = mw.ustring.upper
  
-- Regex substitution patterns
+
---
local prepattern = "%[(%w+)%|(.*)%|(.*)%|(.*)%]" -- [arg|equal to (blank for existence)|if true|if false]
+
-- Substitution pattern based on passed arguments
local pattern = "%%(%w+)%%" -- %arg%
+
-- Syntax: [param|value|match|mismatch]
 +
-- where
 +
--  param is the parameter name to be tested
 +
--  value is the value to test against argument; if empty, the argument is
 +
--    tested for existence
 +
--  match is the string to be substituted if the argument matches value
 +
--  mismatch is the string to be substituted if the argument does not match
 +
--    the value
 +
-- These arguments may not contain "[", "|", or "]".
 +
local prepattern = "%[(%w+)%|([^%[|%]]*)%|([^%[|%]]*)%|([^%[|%]]*)%]"
 +
---
 +
-- Parameter substitution pattern
 +
-- Syntax: %param%
 +
-- where param is the name of the parameter whose value is to be substituted
 +
-- in place of %param%.
 +
local pattern = "%%(%w+)%%"
  
local function parser(formatStr, args, form)
+
---
local function ifexists(name)
+
-- Perform substitutions.
-- Check whether a page or file named name exists
+
-- @param #string formatStr The string the be substituted
if name == '' then return false end -- Page doesn't exist if name is blank
+
-- @param #table args The arguments passed to this module
local title -- mw.title object
+
local function subst(formatStr, args)
if form == 'shield' then
+
---
title = mw.title.new(name, 'Media') -- Shields are in the Media namespace
+
-- Perform a substitution based on passed argument.
 +
-- @param #string param The parameter name to be tested
 +
-- @param #string value The value to test against argument; if empty,
 +
-- the argument is tested for existence
 +
-- @param #string ifmatch The resulting string if the argument matches
 +
-- `value`
 +
-- @param #string ifmismatch The resulting string if the argument does not
 +
-- match `value`
 +
-- @return #string either `ifmatch` or `ifmismatch`, based on the test
 +
local function testArgs(param, value, ifmatch, ifmismatch)
 +
local arg = args[param] or ''
 +
if value ~= '' then
 +
return arg == value and ifmatch or ifmismatch
 
else
 
else
title = mw.title.new(name, 0) -- Links are in the mainspace
+
return arg ~= '' and ifmatch or ifmismatch
 
end
 
end
return title.exists -- A boolean for whether the page exists
 
 
end
 
end
local function testArgs(test, equals, ifexists, ifnot)
+
-- argument-test substitutions
-- Implement the if test
+
local preprocessed = gsub(formatStr, prepattern, testArgs)
if equals ~= '' then -- Argument equals something
+
-- parameter substitutions
if args[test] == equals then return ifexists else return ifnot end
+
return (gsub(preprocessed, pattern, args))
else -- Existence of argument
+
-- gsub returns number of matches as second value.
if args[test] and args[test] ~= '' then return ifexists else return ifnot end
+
-- The enclosing parens discards it.
 +
end
 +
 
 +
---
 +
-- Determine whether a given title exists on Wikipedia.
 +
-- @param #string name The title, e.g., article name and file name,
 +
-- without namespace prefix
 +
-- @param #string key The name of the entry being translated.
 +
-- @return #boolean `true` if the title exists, false otherwise
 +
local function titleExists(name, key)
 +
if name == '' then return false end
 +
local namespaceModule = mw.loadData('Module:Road data/parser/namespace')
 +
-- Retrieve the namespace for `key`.
 +
local namespace = namespaceModule[key] or 0
 +
local title = mw.title.new(name, namespace);
 +
return title.exists
 +
end
 +
 
 +
---
 +
-- Determine whether titles exist on Wikipedia.
 +
-- @param value A string or a table containing strings of titles to be checked
 +
-- against
 +
-- @param #string key The name of the entry being translated.
 +
-- @return #boolean `true` if all titles exist, false otherwise
 +
local function ifexists(value, key)
 +
local valueType = type(value)
 +
if valueType == "table" then
 +
-- If `value` is a table, recursively check the existence
 +
-- for each element within the table.
 +
for _,entry in pairs(value) do
 +
if not ifexists(entry, key) then return false end
 
end
 
end
 +
return true
 
end
 
end
local formatTable = {} -- Table with definitions
+
-- Otherwise, `value` is a string, so check the existence for that string.
-- Recursively dig into tables that could be parser hooks or argument tables.
+
return titleExists(value, key)
local function formatStrInTable(formatStr)
+
end
if type(formatStr) ~= "table" then return formatStr end -- formatStr is a scalar
+
 
formatTable = formatStr
+
---
local hook = formatStr.hook -- Possible hook
+
-- Perform a translation on a given entry.
local both = formatStr[2] -- Second shield
+
-- @param entry An entry to be translated; may be any non-function type.
if both then
+
-- A table may be a parser hook specification, a switch table, or an
local first = formatStrInTable(formatStr[1])
+
-- ordinary value table.  Translations are applied recursively.
local second = formatStrInTable(both)
+
-- @param #table args The arguments passed to this module
return {first, second} -- First and second shield
+
-- @param #string key The name of the entry being translated.
elseif hook then
+
-- @return The translated entry
local hooksModule = require "Module:Road data/parser/hooks"
+
local function translate(entry, args, key)
local hookFunction = hooksModule[hook] or error("Hook '" .. hook .. "' does not exist", 0)
+
if type(entry) == "string" then
return formatStrInTable(hookFunction(formatStr, args)) -- Call hook
+
return subst(entry, args) -- Substitute arguments as necessary.
else -- Switch on an argument
+
elseif type(entry) ~= "table" then
local arg = args[formatStr.arg or "route"]
+
return entry
return formatStrInTable(formatStr[arg] or formatStr.default)
+
elseif entry.hook then
 +
-- This entry is a parser hook.
 +
-- Requires: Parser hook must have hook field.
 +
local hook = entry.hook
 +
local parserHooksModule = require(parserHooksModuleName)
 +
local hookFunction = parserHooksModule[hook]
 +
or error("Hook '" .. hook .. "' does not exist", 0)
 +
return translate(hookFunction(entry, args), args, key)
 +
elseif entry.arg or entry.undefined or entry.default then
 +
-- This entry is a switch table.
 +
-- Requires: Switch table must have
 +
--          arg, undefined, or default fields
 +
--          but not hook field.
 +
local arg = args[entry.arg or "route"]
 +
if entry[arg] then return translate(entry[arg], args, key) end
 +
if arg == nil and entry.undefined ~= nil then
 +
-- result for unspecified argument
 +
return translate(entry.undefined, args, key)
 
end
 
end
end
+
-- default result for mismatch
local function parse(formatStr)
+
local defaultValue = translate(entry.default, args, key)
local preprocessed = gsub(formatStr, prepattern, testArgs) -- If statements
+
if defaultValue and entry.ifexists then
local parsedStr = gsub(preprocessed, pattern, args) -- Variable interpolation
+
-- Check existence.
local final = trim(parsedStr) -- Trim extra spaces
+
if ifexists(defaultValue, key) then return defaultValue end
if formatTable.ifexists then -- Existence test
+
-- Failed existence check results in fallback value (default to nil).
local exists = ifexists(final)
+
return entry.otherwise and translate(entry.otherwise, args, key) or nil
if exists then
+
else
return final
+
return defaultValue
else
 
return parser(formatTable.otherwise, args, form)
 
end
 
 
end
 
end
return final
 
end
 
formatStr = formatStrInTable(formatStr) -- Get formatStr
 
if not formatStr or formatStr == '' then return '' end -- Return empty string for empty formatStr
 
if type(formatStr) == 'table' then -- Dual shields
 
local first = parse(formatStr[1])
 
local second = parse(formatStr[2])
 
return first, second
 
 
else
 
else
return parse(formatStr)
+
-- This entry is a value table.
 +
-- Process each table element.
 +
local result = {}
 +
for key,elem in pairs(entry) do
 +
result[key] = translate(elem, args, key)
 +
end
 +
return result
 
end
 
end
 
end
 
end
  
local function formatString(args, form)
+
---
-- Get format string/table from module based on jurisdiction and type
+
-- Retrieve an entry from a data module based on a given type and key.
local function getTypeData(module, type)
+
-- @param #string module The name of the data module to be fetched
-- Get data from module for particular type
+
-- @param type The key for the type table within the loaded table
local success, moduleData = pcall(mw.loadData, module)
+
-- @param key The key for the entry within the type table
if not success then return '' end -- Empty string if module cannot be loaded
+
-- @return fetchedTable[type][key] if specified, where `fetchedTable` is the
local typeTable = moduleData[type] or moduleData[''] -- Type table or empty string default table
+
-- table fetched from `module`, nil otherwise
local defaultTable = moduleData[''] or {} -- Default table
+
local function getTypeData(module, type, key)
if typeTable then
+
-- Attempt to fetch the given data module.
local alias = typeTable.alias
+
local success, moduleData = pcall(mw.loadData, module)
if alias then -- Type is an alias to another module
+
if not success then return false, moduleData end -- Module could not be loaded
local aliasedModule = "Module:Road data/strings/" .. alias.module
+
-- The type table defaults to empty-key table if undefined.
local aliasedType = alias.type
+
local typeTable = moduleData[type] or moduleData['']
return getTypeData(aliasedModule, aliasedType)
+
-- Fallback table is the empty-key table, with the empty table as default.
end
+
local defaultTable = moduleData[''] or {}
return typeTable[form] or defaultTable[form] or ''
+
if typeTable then
else
+
local alias = typeTable.alias
return ''
+
if alias and alias.module and alias.type then
 +
-- The type table is an alias table.
 +
-- Recursively fetch the aliased type data.
 +
local aliasedModule = "Module:Road data/strings/" .. alias.module
 +
local aliasedType = alias.type
 +
return getTypeData(aliasedModule, aliasedType, key)
 
end
 
end
 +
return true, typeTable[key] or defaultTable[key] or nil
 +
else
 +
return true, nil
 
end
 
end
+
end
local stateCountries = {USA = true, CAN = true} -- These countries have state/province modules
+
 
 +
---
 +
-- Determine the module name for the lookup by country and state.
 +
-- @param #table args The arguments passed to this module
 +
-- @return #string The module name to be fetched
 +
local function getModuleName(args)
 +
-- countries with submodules for states or provinces
 +
local stateCountries = {USA = true, CAN = true}
 
local state = upper(args.state or '')
 
local state = upper(args.state or '')
 
local country
 
local country
 
if args.country then
 
if args.country then
 
country = upper(args.country)
 
country = upper(args.country)
else -- Find country via a mask
+
else
 +
-- Recover the country from the given state or province.
 
local countryModule = mw.loadData("Module:Road data/countrymask")
 
local countryModule = mw.loadData("Module:Road data/countrymask")
 
country = countryModule[state] or 'UNK'
 
country = countryModule[state] or 'UNK'
 
end
 
end
local typeArg = args.type
 
local module
 
 
if stateCountries[country] and state ~= '' then
 
if stateCountries[country] and state ~= '' then
module = format("Module:Road data/strings/%s/%s", country, state)
+
-- Submodule within the country exists.
else
+
return format("Module:Road data/strings/%s/%s", country, state)
module = format("Module:Road data/strings/%s", country)
 
 
end
 
end
return getTypeData(module, typeArg)
+
return format("Module:Road data/strings/%s", country)
 
end
 
end
  
function p.parser(passedArgs, form)
+
---
local args = {state = passedArgs.state, type = passedArgs.type, route = passedArgs.route,
+
-- Fetch the entry from the appropriate module, and return that entry
              denom = passedArgs.denom, county = passedArgs.county, dab = passedArgs.dab,
+
-- substituted with appropriate values.
              country = passedArgs.country, township = passedArgs.township}
+
-- @param #table args The arguments to be used for lookup and substitutions
local formatStr = formatString(args, form)
+
-- @param #string key The key for the entry within the type table
if not formatStr or formatStr == '' then return nil end
+
-- @param #string type (optional) The key for the type table within the fetched
return parser(formatStr, args, form)
+
-- module; defaults to args.type
 +
-- @param #string moduleName (optional) The name of the module to be fetched;
 +
-- defaults to the module determined by country and state
 +
-- @return The substituted entry
 +
function p.parser(args, key, type, moduleName)
 +
-- Determine module name, if not given.
 +
local dataModuleName = moduleName or getModuleName(args)
 +
-- Fetch the entry from the module.
 +
local success, formatStr = getTypeData(dataModuleName, type or args.type, key)
 +
if not success then return false, formatStr end
 +
-- Translate the entry.
 +
return translate(formatStr, args, key)
 
end
 
end
  
 
return p
 
return p

Revision as of 02:57, 7 August 2019

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

local p = {} -- Package to be exported

-- Change to "" upon deployment.
local moduleSuffix = ""

local parserHooksModuleName = "Module:Road data/parser/hooks" .. moduleSuffix

-- Local library aliases
local format = string.format
local gsub = mw.ustring.gsub
local upper = mw.ustring.upper

---
-- Substitution pattern based on passed arguments
-- Syntax: [param|value|match|mismatch]
-- where
--  param is the parameter name to be tested
--  value is the value to test against argument; if empty, the argument is
--    tested for existence
--  match is the string to be substituted if the argument matches value
--  mismatch is the string to be substituted if the argument does not match
--    the value
-- These arguments may not contain "[", "|", or "]".
local prepattern = "%[(%w+)%|([^%[|%]]*)%|([^%[|%]]*)%|([^%[|%]]*)%]"
---
-- Parameter substitution pattern
-- Syntax: %param%
-- where param is the name of the parameter whose value is to be substituted
-- in place of %param%.
local pattern = "%%(%w+)%%"

---
-- Perform substitutions.
-- @param #string formatStr The string the be substituted
-- @param #table args The arguments passed to this module
local function subst(formatStr, args)
	---
	-- Perform a substitution based on passed argument.
	-- @param #string param The parameter name to be tested
	-- @param #string value The value to test against argument; if empty,
	-- 		the argument is tested for existence
	-- @param #string ifmatch The resulting string if the argument matches
	-- 		`value`
	-- @param #string ifmismatch The resulting string if the argument does not
	-- 		match `value`
	-- @return #string either `ifmatch` or `ifmismatch`, based on the test
	local function testArgs(param, value, ifmatch, ifmismatch)
		local arg = args[param] or ''
		if value ~= '' then
			return arg == value and ifmatch or ifmismatch
		else
			return arg ~= '' and ifmatch or ifmismatch
		end
	end
	-- argument-test substitutions
	local preprocessed = gsub(formatStr, prepattern, testArgs)
	-- parameter substitutions
	return (gsub(preprocessed, pattern, args))
	-- gsub returns number of matches as second value.
	-- The enclosing parens discards it.
end

---
-- Determine whether a given title exists on Wikipedia.
-- @param #string name The title, e.g., article name and file name,
-- 		without namespace prefix
-- @param #string key The name of the entry being translated.
-- @return #boolean `true` if the title exists, false otherwise
local function titleExists(name, key)
	if name == '' then return false end
	local namespaceModule = mw.loadData('Module:Road data/parser/namespace')
	-- Retrieve the namespace for `key`.
	local namespace = namespaceModule[key] or 0
	local title = mw.title.new(name, namespace);
	return title.exists
end

---
-- Determine whether titles exist on Wikipedia.
-- @param value A string or a table containing strings of titles to be checked
-- 		against
-- @param #string key The name of the entry being translated.
-- @return #boolean `true` if all titles exist, false otherwise
local function ifexists(value, key)
	local valueType = type(value)
	if valueType == "table" then
		-- If `value` is a table, recursively check the existence
		-- for each element within the table.
		for _,entry in pairs(value) do
			if not ifexists(entry, key) then return false end
		end
		return true
	end
	-- Otherwise, `value` is a string, so check the existence for that string.
	return titleExists(value, key)
end

---
-- Perform a translation on a given entry.
-- @param entry An entry to be translated; may be any non-function type.
-- 		A table may be a parser hook specification, a switch table, or an
-- 		ordinary value table.  Translations are applied recursively.
-- @param #table args The arguments passed to this module
-- @param #string key The name of the entry being translated.
-- @return The translated entry
local function translate(entry, args, key)
	if type(entry) == "string" then
		return subst(entry, args) -- Substitute arguments as necessary.
	elseif type(entry) ~= "table" then
		return entry
	elseif entry.hook then
		-- This entry is a parser hook.
		-- Requires: Parser hook must have hook field.
		local hook = entry.hook
		local parserHooksModule = require(parserHooksModuleName)
		local hookFunction = parserHooksModule[hook]
			or error("Hook '" .. hook .. "' does not exist", 0)
		return translate(hookFunction(entry, args), args, key)
	elseif entry.arg or entry.undefined or entry.default then
		-- This entry is a switch table.
		-- Requires: Switch table must have
		--           arg, undefined, or default fields
		--           but not hook field.
		local arg = args[entry.arg or "route"]
		if entry[arg] then return translate(entry[arg], args, key) end
		if arg == nil and entry.undefined ~= nil then
			-- result for unspecified argument
			return translate(entry.undefined, args, key)
		end
		-- default result for mismatch
		local defaultValue = translate(entry.default, args, key)
		if defaultValue and entry.ifexists then
			-- Check existence.
			if ifexists(defaultValue, key) then return defaultValue end
			-- Failed existence check results in fallback value (default to nil).
			return entry.otherwise and translate(entry.otherwise, args, key) or nil
		else
			return defaultValue
		end
	else
		-- This entry is a value table.
		-- Process each table element.
		local result = {}
		for key,elem in pairs(entry) do
			result[key] = translate(elem, args, key)
		end
		return result
	end
end

---
-- Retrieve an entry from a data module based on a given type and key.
-- @param #string module The name of the data module to be fetched
-- @param type The key for the type table within the loaded table
-- @param key The key for the entry within the type table
-- @return fetchedTable[type][key] if specified, where `fetchedTable` is the
-- 		table fetched from `module`, nil otherwise
local function getTypeData(module, type, key)
	-- Attempt to fetch the given data module.
	local success, moduleData = pcall(mw.loadData, module)
	if not success then return false, moduleData end -- Module could not be loaded
	-- The type table defaults to empty-key table if undefined.
	local typeTable = moduleData[type] or moduleData['']
	-- Fallback table is the empty-key table, with the empty table as default.
	local defaultTable = moduleData[''] or {}
	if typeTable then
		local alias = typeTable.alias
		if alias and alias.module and alias.type then
			-- The type table is an alias table.
			-- Recursively fetch the aliased type data.
			local aliasedModule = "Module:Road data/strings/" .. alias.module
			local aliasedType = alias.type
			return getTypeData(aliasedModule, aliasedType, key)
		end
		return true, typeTable[key] or defaultTable[key] or nil
	else
		return true, nil
	end
end

---
-- Determine the module name for the lookup by country and state.
-- @param #table args The arguments passed to this module
-- @return #string The module name to be fetched
local function getModuleName(args)
	-- countries with submodules for states or provinces
	local stateCountries = {USA = true, CAN = true}
	local state = upper(args.state or '')
	local country
	if args.country then
		country = upper(args.country)
	else
		-- Recover the country from the given state or province.
		local countryModule = mw.loadData("Module:Road data/countrymask")
		country = countryModule[state] or 'UNK'
	end
	if stateCountries[country] and state ~= '' then
		-- Submodule within the country exists.
		return format("Module:Road data/strings/%s/%s", country, state)
	end
	return format("Module:Road data/strings/%s", country)
end

---
-- Fetch the entry from the appropriate module, and return that entry
-- substituted with appropriate values.
-- @param #table args The arguments to be used for lookup and substitutions
-- @param #string key The key for the entry within the type table
-- @param #string type (optional) The key for the type table within the fetched
-- 		module; defaults to args.type
-- @param #string moduleName (optional) The name of the module to be fetched;
-- 		defaults to the module determined by country and state
-- @return The substituted entry
function p.parser(args, key, type, moduleName)
	-- Determine module name, if not given.
	local dataModuleName = moduleName or getModuleName(args)
	-- Fetch the entry from the module.
	local success, formatStr = getTypeData(dataModuleName, type or args.type, key)
	if not success then return false, formatStr end
	-- Translate the entry.
	return translate(formatStr, args, key)
end

return p