Module:Sensitive IP addresses/blocktext: 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 (create | mirror) and testcases (edit | run) pages.
Add categories to the /doc subpage. Subpages of this module.

-- This module creates a warning about sensitive IP addresses that is intended
-- to be placed in [[Special:Block]] via the [[Mediawiki:Blockiptext]] message.

local querySensitiveIPs = require('Module:Sensitive IP addresses').query
local mIP = require('Module:IP')
local IPAddress = mIP.IPAddress
local Subnet = mIP.Subnet

local function normalizeIPOrSubnet(ipOrSubnet)
	-- Normalize an IP address or subnet.
	-- If ipOrSubnet is not a valid IP address or subnet, returns nil.
	local ipSuccess, ipObj = pcall(IPAddress.new, ipOrSubnet)
	if ipSuccess and ipObj then
		return tostring(ipObj)
	end
	local subnetSuccess, subnetObj = pcall(Subnet.new, ipOrSubnet)
	if subnetSuccess and subnetObj then
		return tostring(subnetObj)
	end
	return nil
end

local function parseTitle(title)
	-- Parse a title. If the subpage(s) of the root page are a valid IP
	-- address or subnet, then return the normalized IP address or subnet.
	local ipOrSubnet = title.text:gsub('^.-/', '')
	return normalizeIPOrSubnet(ipOrSubnet)
end

local function fetchSensitivityData(ipOrSubnet)
	return querySensitiveIPs{test = {ipOrSubnet}}
end

local function parseSensitivityData(sensitivityData)
	-- Parse the data from the sensitive IP API call, and return a table with
	-- information about the first match that we can use as arguments to a
	-- template call.
	local function parse(sensitivityData)
		sensitivityData = sensitivityData.sensitiveips
		if #sensitivityData.matches == 0 then
			return nil
		end
		local ret = {}
		ret.type = sensitivityData.matches[1].type
		if ret.type == 'ip' then
			ret.ip = sensitivityData.matches[1].ip
		elseif ret.type == 'range' then
			ret.range = sensitivityData.matches[1].range
		else
			return nil
		end
		ret['entity-id'] = sensitivityData.matches[1]['entity-id']
		ret['matches-range'] = sensitivityData.matches[1]['matches-range']
		ret['entity-name'] = sensitivityData.entities[ret['entity-id']].name
		ret['entity-description'] = sensitivityData.entities[ret['entity-id']].description
		ret.reason = sensitivityData.entities[ret['entity-id']].reason
		return ret
	end

	local success, ret = pcall(parse, sensitivityData)
	if success and ret then
		return ret
	else
		return nil
	end
end

local function renderMessage(rawMessage, messageArgs)
	if rawMessage then
		message = mw.message.newRawMessage(rawMessage)
	else
		message = mw.message.new('sensitive-ip-block-text')
	end
	wikitext = message:params(
		messageArgs.type,
		messageArgs.type == 'ip' and messageArgs.ip or messageArgs.range,
		messageArgs['matches-range'],
		messageArgs['entity-id'],
		messageArgs['entity-name'],
		messageArgs['entity-description'],
		messageArgs.reason
	):plain()
	local frame = mw.getCurrentFrame()
	return frame:preprocess(wikitext)
end

local p = {}

function p._main(args, title)
	args = args or {}
	title = title or mw.title.getCurrentTitle()
	local ipOrSubnet = parseTitle(title)
	if not ipOrSubnet then
		return nil
	end
	local sensitivityData = fetchSensitivityData(ipOrSubnet)
	if not sensitivityData then
		return nil
	end
	messageArgs = parseSensitivityData(sensitivityData)
	return renderMessage(args.message, messageArgs)
end

function p.main(frame)
	local args = require('Module:Arguments').getArgs(frame)
	return p._main(args)
end

function p._exportFunctions()
	return {
		parseTitle = parseTitle,
		fetchSensitivityData = fetchSensitivityData,
		parseSensitivityData = parseSensitivityData,
		renderMessage = renderMessage,
	}
end

return p