Module:Params/sandbox - Revision history

Grufo: The directives ‘with_pattern_isep’, ‘with_plain_isep’, ‘with_pattern_psep’ and ‘with_plain_psep’ have been renamed to ‘splitter_pattern’, ‘splitter_string’, ‘setter_pattern’, and ‘setter_string’ respectively

2025-04-22T02:32:24Z

The directives ‘with_pattern_isep’, ‘with_plain_isep’, ‘with_pattern_psep’ and ‘with_plain_psep’ have been renamed to ‘splitter_pattern’, ‘splitter_string’, ‘setter_pattern’, and ‘setter_string’ respectively

← Previous revision		Revision as of 02:32, 22 April 2025
Line 188:		Line 188:
	-- `reinterpreting` modifiers		-- `reinterpreting` modifiers
	local isep_parse_opts = {		local isep_parse_opts = {
	~~with_pattern_isep~~ = false,		splitter_pattern = false,
	~~with_plain_isep~~ = true		splitter_string = true
	}		}

Line 196:		Line 196:
	-- `reinterpreting` modifiers		-- `reinterpreting` modifiers
	local psep_parse_opts = {		local psep_parse_opts = {
	~~with_pattern_psep~~ = false,		setter_pattern = false,
	~~with_plain_psep~~ = true		setter_string = true
	}		}

Line 217:		Line 217:
	-- guarantee that they will make their own (modified) copy available		-- guarantee that they will make their own (modified) copy available
	local refpipe = {		local refpipe = {
		⚫	call_for_each_group = true,
		⚫	coins = true,
	count = true,		count = true,
	~~value_of~~ = true,		for_each = true,
	list = true,		list = true,
	list_values = true,		list_values = true,
	~~coins~~ = true,		value_of = true
	for_each = true,
⚫	call_for_each_group = true
	}		}

Line 232:		Line 232:
	-- (modified) copy available		-- (modified) copy available
	local refparams = {		local refparams = {
	~~--inserting~~ = true,		call_for_each_group = true,
	with_name_matching = true,
⚫	grouping_by_calling = true,
	combining_by_calling = true,		combining_by_calling = true,
⚫	~~count~~ = true,
	concat_and_call = true,		concat_and_call = true,
	concat_and_invoke = true,		concat_and_invoke = true,
	concat_and_magic = true,		concat_and_magic = true,
		⚫	count = true,
			--inserting = true,
		⚫	grouping_by_calling = true,
	value_of = true,		value_of = true,
	~~call_for_each_group~~ = true		with_name_matching = true
	}		}

Grufo: Add the `excluding_non-numeric_names` and `excluding_numeric_names` modifiers to the module; code review

2025-04-16T17:54:08Z

Add the `excluding_non-numeric_names` and `excluding_numeric_names` modifiers to the module; code review

Show changes

Grufo: Better names for some of the arguments in the `parsing` and `reinterpreting` modifiers

2025-04-14T17:37:01Z

Better names for some of the arguments in the `parsing` and `reinterpreting` modifiers

← Previous revision		Revision as of 17:37, 14 April 2025
Line 185:		Line 185:


	-- Possible string modes for the iteration separator in the `parsing` ~~modifier~~		-- Possible string modes for the iteration separator in the `parsing` and
			-- `reinterpreting` modifiers
	local isep_parse_opts = {		local isep_parse_opts = {
	~~let_isep_pattern~~ = false,		with_pattern_isep = false,
	~~let_isep_plain~~ = true		with_plain_isep = true
	}		}


	-- Possible string modes for the key-value separator in the `parsing` ~~modifier~~		-- Possible string modes for the key-value separator in the `parsing` and
			-- `reinterpreting` modifiers
	local psep_parse_opts = {		local psep_parse_opts = {
	~~let_psep_pattern~~ = false,		with_pattern_psep = false,
	~~let_psep_plain~~ = true		with_plain_psep = true
	}		}

Line 433:		Line 435:


	-- Load the optional arguments of the `parsing` ~~modifier~~		-- Load the optional arguments of the `parsing` and `reinterpreting` modifiers
	local function load_parse_opts (opts, start_from)		local function load_parse_opts (opts, start_from)
	local argc = start_from		local argc = start_from

Grufo: Testing the next version

2025-04-13T01:09:37Z

Testing the next version

Show changes

Grufo at 18:50, 1 October 2024

2024-10-01T18:50:24Z

← Previous revision		Revision as of 18:50, 1 October 2024
Line 950:		Line 950:
	local key = ctx.pipe[1]:match'^%s(.-)%s$'		local key = ctx.pipe[1]:match'^%s(.-)%s$'
	key = tonumber(key) or key		key = tonumber(key) or key
	if ctx.params[key] ~= nil then ctx.params[key] = ctx.pipe[2] end		if ctx.params[key] == nil then ctx.params[key] = ctx.pipe[2] end
	return context_iterate(ctx, 3)		return context_iterate(ctx, 3)
	end		end

Grufo: Add ‘providing’

2024-10-01T18:45:12Z

Add ‘providing’

@@ Line 940: / Line 940: @@
 	local key = ctx.pipe[1]:match'^%s*(.-)%s*$'
 	ctx.params[tonumber(key) or key] = ctx.pipe[2]
 	return context_iterate(ctx, 3)
 end

Grufo: Code organization, no changes

2024-10-01T09:22:23Z

Code organization, no changes

@@ Line 182: / Line 182: @@
 	--[[ Module's private environment ]]--
 	--------------------------------------
@@ Line 412: / Line 441: @@
--- Map parameters' values using a custom callback and a referenced table
+-- Map parameters' names using a custom callback and a referenced table
 local function map_names (tbl, rargs, karg, varg, looptype, fn)
 	local cache = {}
@@ Line 1,757: / Line 1,786: @@
 	--[[ First-position-only functions ]]--
 	---------------------------------------
@@ Line 1,769: / Line 1,797: @@
 	--[[ Public metatable of functions ]]--
 	---------------------------------------
@@ Line 1,780: / Line 1,807: @@
 		if library[fname] == nil then error(ctx.luaname ..
 			': The function ‘' .. fname .. '’ does not exist', 0) end
 		return function (frame)
 			ctx.frame = frame:getParent()
-			ctx.pipe = copy_or_ref_table(frame.args, refpipe[fname])
+			ctx.pipe = copy_or_ref_table(frame.args,
-			ctx.params = copy_or_ref_table(ctx.frame.args, refparams[fname])
+			ctx.params = copy_or_ref_table(ctx.frame.args,
 			main_loop(ctx, func)
 			return ctx.text

Grufo: Performance only, no changes

2024-10-01T07:08:43Z

Performance only, no changes

← Previous revision		Revision as of 07:08, 1 October 2024
Line 357:		Line 357:

	-- Map parameters' values using a custom callback and a referenced table		-- Map parameters' values using a custom callback and a referenced table
		⚫	local value_maps = {
⚫	local function ~~map_values~~ (tbl, ~~margs~~, karg, varg, looptype, fn)
			[0] = function (tbl, margs, karg, varg, fn)
	if looptype == 1 then
		⚫	for key in pairs(tbl) do tbl[key] = fn() end
		⚫	end,
			[1] = function (tbl, margs, karg, varg, fn)
	for key, val in pairs(tbl) do		for key, val in pairs(tbl) do
	margs[varg] = val		margs[varg] = val
	tbl[key] = fn()		tbl[key] = fn()
	end		end
		⚫	end,
	elseif looptype == 3 then
			[2] = function (tbl, margs, karg, varg, fn)
⚫	for key, val in pairs(tbl) do
		⚫	for key in pairs(tbl) do
	margs[karg] = key		margs[karg] = key
⚫	~~margs~~[varg] = val
	tbl[key] = fn()		tbl[key] = fn()
	end		end
			end,
	elseif looptype == 2 then
			[3] = function (tbl, margs, karg, varg, fn)
⚫	for key in pairs(tbl) do
		⚫	for key, val in pairs(tbl) do
	margs[karg] = key		margs[karg] = key
	~~tbl~~[~~key~~] = ~~fn()~~		margs[varg] = val
⚫	end
	elseif looptype == 0 then
⚫	for key in pairs(tbl) do
	tbl[key] = fn()		tbl[key] = fn()
	end		end
	end		end
			}
⚫	end


			-- Private table for `map_names()`
⚫	-- Map parameters' ~~names~~ using a custom callback and a referenced table
			local name_thieves_maps = {
	~~local~~ function ~~map_names~~ (tbl, rargs, karg, varg~~, looptype~~, fn)		[0] = function (cache, tbl, rargs, karg, varg, fn)
⚫	local ~~cache~~ = {}
	if looptype == 2 then
	for key, val in pairs(tbl) do		for key, val in pairs(tbl) do
⚫	rargs[karg] = key
	steal_if_renamed(val, tbl, key, cache, fn())		steal_if_renamed(val, tbl, key, cache, fn())
	end		end
			end,
	elseif looptype == 3 then
			[1] = function (cache, tbl, rargs, karg, varg, fn)
	for key, val in pairs(tbl) do		for key, val in pairs(tbl) do
	rargs[karg] = key
	rargs[varg] = val		rargs[varg] = val
	steal_if_renamed(val, tbl, key, cache, fn())		steal_if_renamed(val, tbl, key, cache, fn())
	end		end
			end,
	elseif looptype == 1 then
			[2] = function (cache, tbl, rargs, karg, varg, fn)
	for key, val in pairs(tbl) do		for key, val in pairs(tbl) do
	rargs[~~varg~~] = ~~val~~		rargs[karg] = key
	steal_if_renamed(val, tbl, key, cache, fn())		steal_if_renamed(val, tbl, key, cache, fn())
	end		end
			end,
	elseif looptype == 0 then
			[3] = function (cache, tbl, rargs, karg, varg, fn)
	for key, val in pairs(tbl) do		for key, val in pairs(tbl) do
		⚫	rargs[karg] = key
		⚫	rargs[varg] = val
	steal_if_renamed(val, tbl, key, cache, fn())		steal_if_renamed(val, tbl, key, cache, fn())
	end		end
	end		end
			}


		⚫	-- Map parameters' values using a custom callback and a referenced table
		⚫	local function map_names (tbl, rargs, karg, varg, looptype, fn)
			local cache = {}
			name_thieves_maps[looptype](cache, tbl, rargs, karg, varg, fn)
	for key, val in pairs(cache) do tbl[key] = val end		for key, val in pairs(cache) do tbl[key] = val end
	end		end
Line 1,053:		Line 1,063:
	mapping_styles.values_only)		mapping_styles.values_only)
	local model = { title = tname, args = margs }		local model = { title = tname, args = margs }
	~~map_values~~(ctx.params, margs, karg, varg~~, looptype~~, function ()		value_maps[looptype](ctx.params, margs, karg, varg, function ()
	return ctx.frame:expandTemplate(model)		return ctx.frame:expandTemplate(model)
	end)		end)
Line 1,080:		Line 1,090:
	', ‘mapping_by_invoking’: The function ‘' .. fname ..		', ‘mapping_by_invoking’: The function ‘' .. fname ..
	'’ does not exist', 0) end		'’ does not exist', 0) end
	~~map_values~~(ctx.params, margs, karg, varg~~, looptype~~, function ()		value_maps[looptype](ctx.params, margs, karg, varg, function ()
	return mfunc(ctx.frame:newChild(model))		return mfunc(ctx.frame:newChild(model))
	end)		end)
Line 1,098:		Line 1,108:
	local margs, argc, looptype, karg, varg = parse_callback_args(opts, 1,		local margs, argc, looptype, karg, varg = parse_callback_args(opts, 1,
	mapping_styles.values_only)		mapping_styles.values_only)
	~~map_values~~(ctx.params, margs, karg, varg~~, looptype~~, function ()		value_maps[looptype](ctx.params, margs, karg, varg, function ()
	return ctx.frame:callParserFunction(magic, margs)		return ctx.frame:callParserFunction(magic, margs)
	end)		end)

Grufo: Comment out unused function

2024-09-30T13:13:01Z

Comment out unused function

← Previous revision		Revision as of 13:13, 30 September 2024
Line 75:		Line 75:

	-- Make an expanded copy of a table (shifting in both directions if necessary)		-- Make an expanded copy of a table (shifting in both directions if necessary)
			--[[
	local function copy_table_expanded (tbl, idx, len)		local function copy_table_expanded (tbl, idx, len)
	local ret = {}		local ret = {}
Line 100:		Line 101:
	return ret		return ret
	end		end
			]]--


Line 1,223:		Line 1,225:
	-- 1]\|[argument 2]\|[...]\|[argument N]\|pipe to		-- 1]\|[argument 2]\|[...]\|[argument N]\|pipe to
	library.grouping_by_calling = function (ctx)		library.grouping_by_calling = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!		-- NOTE: `ctx.params` might be the original metatable! As a modifier,
			-- this function MUST create a copy of it before returning
	local opts = ctx.pipe		local opts = ctx.pipe
	local tmp		local tmp

Grufo: Nomenclature only, no changes

2024-09-30T07:18:56Z

Nomenclature only, no changes

← Previous revision		Revision as of 07:18, 30 September 2024
Line 923:		Line 923:


	-- Syntax: #invoke:params\|with_name_matching\|~~pattern~~ 1\|[plain flag 1]\|[or]		-- Syntax: #invoke:params\|with_name_matching\|target 1\|[plain flag 1]\|[or]
	-- \|[~~pattern~~ 2]\|[plain flag 2]\|[or]\|[...]\|[~~pattern~~ N]\|[plain flag		-- \|[target 2]\|[plain flag 2]\|[or]\|[...]\|[target N]\|[plain flag
	-- N]\|pipe to		-- N]\|pipe to
	library.with_name_matching = function (ctx)		library.with_name_matching = function (ctx)
	local tbl = ctx.params		local tbl = ctx.params
	local ~~patterns~~, argc = parse_pattern_args(ctx, ~~patterns~~,		local targets, argc = parse_pattern_args(ctx, targets,
	'with_name_matching')		'with_name_matching')
	local nomatch		local nomatch
	for key in pairs(tbl) do		for key in pairs(tbl) do
	nomatch = true		nomatch = true
	for _, ptn in ipairs(~~patterns~~) do		for _, ptn in ipairs(targets) do
	if not ptn[3] then		if not ptn[3] then
	if string.find(key, ptn[1], 1, ptn[2]) then		if string.find(key, ptn[1], 1, ptn[2]) then
Line 950:		Line 950:


	-- Syntax: #invoke:params\|with_name_not_matching\|~~pattern~~ 1\|[plain flag 1]		-- Syntax: #invoke:params\|with_name_not_matching\|target 1\|[plain flag 1]
	-- \|[and]\|[~~pattern~~ 2]\|[plain flag 2]\|[and]\|[...]\|[~~pattern~~ N]\|[plain		-- \|[and]\|[target 2]\|[plain flag 2]\|[and]\|[...]\|[target N]\|[plain
	-- flag N]\|pipe to		-- flag N]\|pipe to
	library.with_name_not_matching = function (ctx)		library.with_name_not_matching = function (ctx)
	local tbl = ctx.params		local tbl = ctx.params
	local ~~patterns~~, argc = parse_pattern_args(ctx, ~~patterns~~,		local targets, argc = parse_pattern_args(ctx, targets,
	'with_name_not_matching')		'with_name_not_matching')
	local yesmatch		local yesmatch
	for key in pairs(tbl) do		for key in pairs(tbl) do
	yesmatch = true		yesmatch = true
	for _, ptn in ipairs(~~patterns~~) do		for _, ptn in ipairs(targets) do
	if ptn[3] then		if ptn[3] then
	if key ~= ptn[1] then		if key ~= ptn[1] then
Line 977:		Line 977:


	-- Syntax: #invoke:params\|with_value_matching\|~~pattern~~ 1\|[plain flag 1]\|[or]		-- Syntax: #invoke:params\|with_value_matching\|target 1\|[plain flag 1]\|[or]
	-- \|[~~pattern~~ 2]\|[plain flag 2]\|[or]\|[...]\|[~~pattern~~ N]\|[plain flag		-- \|[target 2]\|[plain flag 2]\|[or]\|[...]\|[target N]\|[plain flag
	-- N]\|pipe to		-- N]\|pipe to
	library.with_value_matching = function (ctx)		library.with_value_matching = function (ctx)
	local tbl = ctx.params		local tbl = ctx.params
	local ~~patterns~~, argc = parse_pattern_args(ctx, ~~patterns~~,		local targets, argc = parse_pattern_args(ctx, targets,
	'with_value_matching')		'with_value_matching')
	local nomatch		local nomatch
	for key, val in pairs(tbl) do		for key, val in pairs(tbl) do
	nomatch = true		nomatch = true
	for _, ptn in ipairs(~~patterns~~) do		for _, ptn in ipairs(targets) do
	if ptn[3] then		if ptn[3] then
	if val == ptn[1] then		if val == ptn[1] then
Line 1,004:		Line 1,004:


	-- Syntax: #invoke:params\|with_value_not_matching\|~~pattern~~ 1\|[plain flag 1]		-- Syntax: #invoke:params\|with_value_not_matching\|target 1\|[plain flag 1]
	-- \|[and]\|[~~pattern~~ 2]\|[plain flag 2]\|[and]\|[...]\|[~~pattern~~ N]\|[plain		-- \|[and]\|[target 2]\|[plain flag 2]\|[and]\|[...]\|[target N]\|[plain
	-- flag N]\|pipe to		-- flag N]\|pipe to
	library.with_value_not_matching = function (ctx)		library.with_value_not_matching = function (ctx)
	local tbl = ctx.params		local tbl = ctx.params
	local ~~patterns~~, argc = parse_pattern_args(ctx, ~~patterns~~,		local targets, argc = parse_pattern_args(ctx, targets,
	'with_value_not_matching')		'with_value_not_matching')
	local yesmatch		local yesmatch
	for key, val in pairs(tbl) do		for key, val in pairs(tbl) do
	yesmatch = true		yesmatch = true
	for _, ptn in ipairs(~~patterns~~) do		for _, ptn in ipairs(targets) do
	if ptn[3] then		if ptn[3] then
	if val ~= ptn[1] then		if val ~= ptn[1] then
Line 1,103:		Line 1,103:


	-- Syntax: #invoke:params\|mapping_by_replacing\|~~pattern~~\|replace\|[count]\|[plain		-- Syntax: #invoke:params\|mapping_by_replacing\|target\|replace\|[count]\|[plain
	-- flag]\|pipe to		-- flag]\|pipe to
	library.mapping_by_replacing = function (ctx)		library.mapping_by_replacing = function (ctx)
Line 1,191:		Line 1,191:


	-- Syntax: #invoke:params\|renaming_by_replacing\|~~pattern~~\|replace\|[count]\|[plain		-- Syntax: #invoke:params\|renaming_by_replacing\|target\|replace\|[count]\|[plain
	-- flag]\|pipe to		-- flag]\|pipe to
	library.renaming_by_replacing = function (ctx)		library.renaming_by_replacing = function (ctx)