Linguifex

Module:string: Difference between revisions

Module Discussion

Module:string (view source)

Revision as of 16:14, 22 January 2025

2,743 bytes removed ,  22 January 2025
no edit summary
No edit summary
No edit summary
 
Line 1: Line 1:
local m_string_utils = require("Module:string utilities")
local str = {}
local str = {}


-- Cannot include null byte.
local decode_uri = m_string_utils.decode_uri
local UTF8_char = "[\1-\127\194-\244][\128-\191]*"
local gsub = string.gsub
 
local pattern_escape = m_string_utils.pattern_escape
--[[
local process_params = require("Module:parameters").process
ulen
local replacement_escape = m_string_utils.replacement_escape
 
local reverse = string.reverse
Counts UTF-8 characters. Faster than mw.ustring.len.
local ufind = m_string_utils.find
 
local ugmatch = m_string_utils.gmatch
Assumes that the encoding is correct. Unlike mw.ustring.len, does not return nil
local ugsub = m_string_utils.gsub
if encoding is invalid.
local ulen = m_string_utils.len
 
local ulower = m_string_utils.lower
Does not count the bytes 192, 193, and 245-255. They are not used in UTF-8 and
local umatch = m_string_utils.match
will not occur if the string is valid. They are replaced with the replacement
local unpack = unpack
character (U+FFFD) on MediaWiki pages.
local usub = m_string_utils.sub
--]]
function str.ulen(text)
local _, length = string.gsub(text, UTF8_char, "")
return length
end


--[[
--[[
Line 38: Line 35:
]]
]]
function str.len(frame)
function str.len(frame)
local new_args = str._getParameters(frame.args, { 's' });
return ulen(str._getParameters(frame.args, {"s"}).s or "")
local s = new_args['s'] or '';
return mw.ustring.len(s)
end
end


Line 51: Line 46:
]]
]]
function str.len_visible(frame)
function str.len_visible(frame)
local new_args = str._getParameters(frame.args, { 's' });
return ulen(ugsub(str._getParameters(frame.args, {"s"}).s or "", "<[^<>]+>", ""))
local s = new_args['s'] or '';
return mw.ustring.len(mw.ustring.gsub(s, "<[^<>]+>", ""))
end
end


Line 80: Line 73:
]]
]]
function str.sub(frame)
function str.sub(frame)
local new_args = str._getParameters(frame.args, { 's', 'i', 'j' });
local new_args = str._getParameters(frame.args, {"s", "i", "j"});
local s = new_args['s'] or '';
local s = new_args["s"] or "";
local i = tonumber(new_args['i']) or 1;
local i = tonumber(new_args["i"]) or 1;
local j = tonumber(new_args['j']) or -1;
local j = tonumber(new_args["j"]) or -1;
local len = mw.ustring.len(s);
local len = ulen(s);
-- Convert negatives for range checking
-- Convert negatives for range checking
Line 95: Line 88:
end
end
if i > len or j > len or i < 1 or j < 1 then
if i > len or j > len then
return str._error('String subset index out of range');
return str._error('String subset index out of range');
end
end
Line 102: Line 95:
end
end
return mw.ustring.sub(s, i, j)
return usub(s, i, j)
end
end


Line 112: Line 105:
local i = tonumber(frame.args.i) or 0
local i = tonumber(frame.args.i) or 0
local len = tonumber(frame.args.len)
local len = tonumber(frame.args.len)
return mw.ustring.sub(frame.args.s, i + 1, len and (i + len))
return usub(frame.args.s, i + 1, len and (i + len))
end
end


Line 172: Line 165:
return str._error('Pattern string is empty');
return str._error('Pattern string is empty');
end
end
if math.abs(start) < 1 or math.abs(start) > mw.ustring.len(s) then
if math.abs(start) < 1 or math.abs(start) > ulen(s) then
return str._error('Requested start is out of range');
return str._error('Requested start is out of range');
end
end
Line 179: Line 172:
end
end
if plain_flag then
if plain_flag then
pattern = str.pattern_escape(pattern);
pattern = pattern_escape(pattern);
end
end
Line 185: Line 178:
if match_index == 1 then
if match_index == 1 then
-- Find first match is simple case
-- Find first match is simple case
result = mw.ustring.match(s, pattern, start)
result = umatch(s, pattern, start)
else
else
if start > 1 then
if start > 1 then
s = mw.ustring.sub(s, start);
s = usub(s, start);
end
end
local iterator = mw.ustring.gmatch(s, pattern);
local iterator = ugmatch(s, pattern);
if match_index > 0 then
if match_index > 0 then
-- Forward search
-- Forward search
Line 255: Line 248:
local pos = tonumber(new_args['pos']) or 0;
local pos = tonumber(new_args['pos']) or 0;
if pos == 0 or math.abs(pos) > mw.ustring.len(target_str) then
if pos == 0 or math.abs(pos) > ulen(target_str) then
return str._error('String index out of range');
return str._error('String index out of range');
end
end
return mw.ustring.sub(target_str, pos, pos);
return usub(target_str, pos, pos);
end
end


Line 285: Line 278:
end
end
local start = mw.ustring.find(source_str, target_str, 1, true)
local start = ufind(source_str, target_str, 1, true)
if start == nil then
if start == nil then
start = -1
start = -1
Line 323: Line 316:
]]
]]
function str.find(frame)
function str.find(frame)
local params = {
local main_param = {required = true, allow_empty = true}
[1] = { required = true, allow_empty = true },
return ufind(unpack(process_params(frame.args, {
[2] = { required = true, allow_empty = true },
[1] = main_param,
[3] = { type = "number" },
[2] = main_param,
[4] = { type = "boolean" },
[3] = {type = "number"},
}
[4] = {type = "boolean"},
})))
local args = require("Module:parameters").process(frame.args, params)
return mw.ustring.find(args[1], args[2], args[3], args[4])
end
end


Line 369: Line 359:
if plain then
if plain then
pattern = str.pattern_escape(pattern);
pattern = pattern_escape(pattern);
replace = mw.ustring.gsub(replace, "%%", "%%%%"); --Only need to escape replacement sequences.
replace = replacement_escape(replace);
end
end
local result;
local result;
result = mw.ustring.gsub(source_str, pattern, replace, count);
result = ugsub(source_str, pattern, replace, count);
return result;
return result;
Line 382: Line 372:


function str.gsub(frame)
function str.gsub(frame)
local params = {
local main_param = {required = true, allow_empty = true, no_trim = true}
[1] = { required = true, allow_empty = true, allow_whitespace = true},
return (ugsub(unpack(process_params(frame.args, {
[2] = { required = true, allow_empty = true, allow_whitespace = true},
[1] = main_param,
[3] = { required = true, allow_empty = true, allow_whitespace = true},
[2] = main_param,
[4] = { type = "number" },
[3] = main_param,
}
[4] = {type = "number"},
}))))
local args = require("Module:parameters").process(frame.args, params)
return (mw.ustring.gsub(args[1], args[2], args[3], args[4]))
end
end


Line 408: Line 395:


function str.lower(frame)
function str.lower(frame)
local text = frame.args[1] or ''
return ulower(frame.args[1] or "")
return mw.ustring.lower(text)
end
end
str.lc = str.lower
str.lc = str.lower


Line 512: Line 497:
end
end
return boolean_value
return boolean_value
end
--[[
Helper function that escapes all pattern characters – ().%+-*?[^$] – so that they will be treated
as plain text.
]]
function str.pattern_escape(pattern_str)
local invoked = false
local escape = require("Module:string/pattern_escape")
if type(pattern_str) == "table" then
if pattern_str.args then
local frame = pattern_str
invoked = true
if frame.args[1] then
pattern_str = frame.args[1]
else
pattern_str = frame:getParent().args[1]
end
else
error("First argument to pattern_escape should be a string, a number, or a frame object.")
end
elseif not (type(pattern_str) == "string" or type(pattern_str) == "number") then
error("First argument to pattern_escape should be a string or a number.")
end
if invoked then
return (escape(pattern_str)) -- only the first value
else
return escape(pattern_str)
end
end
end


Line 556: Line 509:
if plain then
if plain then
pattern = str.pattern_escape(pattern)
pattern = pattern_escape(pattern)
end
end
local _, count = mw.ustring.gsub(text, pattern, "")
local _, count = ugsub(text, pattern, "")
return count
return count
end
function str.plain_gsub(text, pattern, replacement)
local invoked = false
if type(text) == "table" then
invoked = true
if text.args then
local frame = text
local params = {
[1] = {},
[2] = {},
[3] = { allow_empty = true },
}
local args = require("Module:parameters").process(frame.args, params)
text = args[1]
pattern = args[2]
replacement = args[3]
else
error("If the first argument to plain_gsub is a table, it should be a frame object.")
end
else
if not (type(pattern) == "string" or type(pattern) == "number") then
error("The second argument to plain_gsub should be a string or a number.")
end
if not (type(replacement) == "string" or type(replacement) == "number") then
error("The third argument to plain_gsub should be a string or a number.")
end
end
pattern = str.pattern_escape(pattern)
if invoked then
text = mw.ustring.gsub(text, pattern, replacement)
return text
else
return mw.ustring.gsub(text, pattern, replacement)
end
end
end


Line 621: Line 531:
}
}
local args = require("Module:parameters").process(frame.args, params)
local args = process_params(frame.args, params)
text = args[1]
text = args[1]
Line 636: Line 546:
local matches = {}
local matches = {}
local i = 0
local i = 0
for match in mw.ustring.gmatch(text, pattern) do
for match in ugmatch(text, pattern) do
i = i + 1
i = i + 1
matches[i] = match
matches[i] = match
Line 689: Line 599:
pattern = "(" .. pattern .. ")"
pattern = "(" .. pattern .. ")"
end
end
local find = use_basic_Lua_function and string.find or mw.ustring.find
local find = use_basic_Lua_function and string.find or ufind
return function()
return function()
i = i + 1
i = i + 1
Line 702: Line 612:
end
end
end
end
end
function str.escapebytes(s)
return (string.gsub(s,
'.',
function(char)
return ('\\%03d'):format(string.byte(char))
end))
end
end


function str.URIdecode(frame)
function str.URIdecode(frame)
return mw.uri.decode(frame.args[1], frame.args[2] or "PATH")
return decode_uri(frame.args[1], frame.args[2] or "PATH")
end
end


--Reverses a UTF8 string; equivalent to string.reverse
function str:__index(k)
function str.reverse(s)
self[k] = package.loaders[2]("Module:string/" .. k)()
s = s:gsub(UTF8_char, function (c) return #c > 1 and c:reverse() end)
return self[k]
return s:reverse()
end
end


return str
return setmetatable(str, str)
Retrieved from "https://linguifex.com/wiki/Special:MobileDiff/433722"