Module:Cite/sandbox - Revision history

Ahecht: move up a line to make comments clearer

2025-05-14T20:12:36Z

move up a line to make comments clearer

← Previous revision		Revision as of 20:12, 14 May 2025
Line 65:		Line 65:
	]]		]]

	return setmetatable({}, { -- returns an empty TABLE whose metatable has the __index set so that, for any given KEY, it returns		return setmetatable({}, {__index = -- returns an empty TABLE whose metatable has the __index set so that, for any given KEY, it returns
	~~__index =~~ function(_, template) -- this anonymous function called as function(TABLE, KEY)		function(_, template) -- this anonymous function called as function(TABLE, KEY)
	return function (frame) return cite (frame, template) end; -- which in turn return a function which calls cite() with the KEY name		return function (frame) return cite (frame, template) end; -- which in turn return a function which calls cite() with the KEY name
	end		end

Ahecht: tweak comment

2025-05-14T20:11:27Z

tweak comment

← Previous revision		Revision as of 20:11, 14 May 2025
Line 65:		Line 65:
	]]		]]

	return setmetatable({}, { -- returns a ~~table~~ ~~that~~ ~~is empty,~~ ~~but~~ has the __index set so that, for any given ~~key~~, it returns		return setmetatable({}, { -- returns an empty TABLE whose metatable has the __index set so that, for any given KEY, it returns
	__index = function(_, template) -- this anonymous function called as function(~~table~~, ~~key~~)		__index = function(_, template) -- this anonymous function called as function(TABLE, KEY)
	return function (frame) return cite (frame, template) end; -- which in turn return a function which calls cite() with the ~~key~~ name		return function (frame) return cite (frame, template) end; -- which in turn return a function which calls cite() with the KEY name
	end		end
	})		})

Ahecht: simplify

2025-05-14T20:08:15Z

simplify

← Previous revision		Revision as of 20:08, 14 May 2025
Line 65:		Line 65:
	]]		]]

			return setmetatable({}, { -- returns a table that is empty, but has the __index set so that, for any given key, it returns
	local p = {};
			__index = function(_, template) -- this anonymous function called as function(table, key)

	~~local~~ function ~~index~~ (_, template) -- ~~This~~ ~~function~~ ~~gets~~ ~~called~~ by ~~the~~ ~~metatable~~ as ~~index~~(~~table,~~ key)		return function (frame) return cite (frame, template) end; -- which in turn return a function which calls cite() with the key name
		⚫	end
	return function (frame) return cite (frame, template) end; -- Return a function which calls cite() with the key name
			})
⚫	end

	local metatable = {['__index'] = index} -- Set __index, which is returned if table[key] is nil, to the index function

	setmetatable (p, metatable) -- Assign the metatable to the returned table

	return p

Ahecht: config no longer requires aliases

2025-04-29T18:59:57Z

config no longer requires aliases

← Previous revision		Revision as of 18:59, 29 April 2025
Line 1:		Line 1:
	require ('strict');		require ('strict');

	local cfg = mw.loadData ('Module:Cite/config/sandbox'); ~~-- Sandbox includes aliases with alternative capitalization (e.g. arXiv)~~		local cfg = mw.loadData ('Module:Cite/config/sandbox');

Trappist the monk at 19:56, 23 April 2025

2025-04-23T19:56:41Z

← Previous revision		Revision as of 19:56, 23 April 2025
Line 9:		Line 9:
	<data_t> not nil; returns <message> else.		<data_t> not nil; returns <message> else.

	TODO: this function goes away if positinal parameter use goes away
	]]		]]

Line 21:		Line 20:
	Assembles an error message from module name, message text, help link, and error category.		Assembles an error message from module name, message text, help link, and error category.

	TODO: this function goes away if positinal parameter use goes away
	]]		]]

	local function make_error_msg (frame, msg~~, nocat~~)		local function make_error_msg (frame, msg)
	local module_name = frame:getTitle(); -- get the module name for prefix and help-link label		local module_name = frame:getTitle(); -- get the module name for prefix and help-link label
	local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization		local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization

	local category_link = ((0 == namespace~~) and not nocat~~) and substitute ('[[Category:$1]]', {cfg.settings_t.err_category}) or '';		local category_link = (0 == namespace) and substitute ('[[Category:$1]]', {cfg.settings_t.err_category}) or '';
	return substitute ('<span style="color:#d33">Error: {{[[$1\|#invoke:$2]]}}: $3 ([[:$4\|$5]])</span>$6',		return substitute ('<span style="color:#d33">Error: {{[[$1\|#invoke:$2]]}}: $3 ([[:$4\|$5]])</span>$6',
	{		{
Line 36:		Line 34:
	cfg.settings_t.help_text_link, -- help wikilink to text at help page		cfg.settings_t.help_text_link, -- help wikilink to text at help page
	cfg.settings_t.help, -- help wikilink display text		cfg.settings_t.help, -- help wikilink display text
	category_link -- link to error category (main namespace only)		category_link -- link to error category (for main namespace errors only)
	})		})
	end		end
Line 46:		Line 44:
	post-expand include size limit.		post-expand include size limit.

	{{#invoke:~~cite\|~~cite\|book\|title=Title}}		{{#invoke:cite\|book\|title=Title}}

	]]		]]

	local function cite (frame, ~~t) -- if positional parameter use goes away, <t> renames to <~~template>		local function cite (frame, template)
	local args_t = require ('Module:Arguments').getArgs (frame, {frameOnly=true}); ~~-- simplify if positional parameter not used?~~		local args_t = require ('Module:Arguments').getArgs (frame, {frameOnly=true});

		⚫	template = template:lower(); -- lowercase for table indexes
	-- <start> all of this goes away if positional parameter not used; after fixes to various templates that use this module
	-- this goes away because we can't get here without we already know that the calling function exists
	if t then args_t[1] = t end -- override args_t[1] if called using template name as function
	if not args_t[1] then -- this is the template name; we must have a template name
⚫	return make_error_msg (frame, cfg.~~error_messages_t~~.~~missing~~); -- ~~no template name~~; abandon with error message
	end

		⚫	if not cfg.known_templates_t[template] then -- do we recognize this template name?
⚫	~~local~~ template = ~~args_t[1]~~:lower(); -- lowercase for table indexes
		⚫	return make_error_msg (frame, substitute (cfg.settings_t.unknown_name, {template})); -- nope; abandon with error message
	args_t[1] = nil; -- unset, no longer needed (and would break the cs1\|2 template)

⚫	if not cfg.~~known_templates_lower_case_t~~[template] then -- do we recognize this template name?
	return make_error_msg (frame, substitute (cfg.error_messages_t.unknown, {template})); -- nope; abandon with error message
	end		end

	-- <end>all of this goes away if positional parameter not used
		⚫	local config_t = {['CitationClass'] = cfg.citation_classes_t[template] or template}; -- set CitationClass value
	-- template = template:lower(); -- add this line if positional parameter use goes away -- lowercase for table indexing
⚫	local config_t = {['CitationClass'] = cfg.citation_classes_t[template] or template};
	return require ('Module:Citation/CS1')._citation (nil, args_t, config_t); -- go render the citation		return require ('Module:Citation/CS1')._citation (nil, args_t, config_t); -- go render the citation
	end		end
Line 76:		Line 65:
	]]		]]

	local p = {		local p = {};
	cite = cite, -- these go away if we adopt the code below !after necessary
	Cite = cite, -- edits to the various templates that already use this module
	}

	local function index(_, template) -- This function gets called by the metatable as index(table, key)		local function index (_, template) -- This function gets called by the metatable as index(table, key)
	return function (frame) return cite (frame, template) end; -- Return a function which calls cite() with the key name		return function (frame) return cite (frame, template) end; -- Return a function which calls cite() with the key name
	end		end
Line 87:		Line 73:
	local metatable = {['__index'] = index} -- Set __index, which is returned if table[key] is nil, to the index function		local metatable = {['__index'] = index} -- Set __index, which is returned if table[key] is nil, to the index function

	setmetatable(p, metatable) -- Assign the metatable to the returned table		setmetatable (p, metatable) -- Assign the metatable to the returned table

	return p		return p

Ahecht: document

2025-04-23T17:23:30Z

document

← Previous revision		Revision as of 17:23, 23 April 2025
Line 81:		Line 81:
	}		}

	local function index(_, template)		local function index(_, template) -- This function gets called by the metatable as index(table, key)
	return function (frame) return cite (frame, template) end;		return function (frame) return cite (frame, template) end; -- Return a function which calls cite() with the key name
	end		end

	local metatable = {['__index'] = index}		local metatable = {['__index'] = index} -- Set __index, which is returned if table[key] is nil, to the index function

	setmetatable(p, metatable)		setmetatable(p, metatable) -- Assign the metatable to the returned table

	return p		return p

Ahecht: Use metatable instead of dynamically generated functions

2025-04-23T17:17:20Z

Use metatable instead of dynamically generated functions

← Previous revision		Revision as of 17:17, 23 April 2025
Line 81:		Line 81:
	}		}

			local function index(_, template)
	for _, templates_t in ipairs ({cfg.known_templates_lower_case_t, cfg.known_templates_mixed_case_t}) do
			return function (frame) return cite (frame, template) end;
	for template, _ in pairs (templates_t) do -- iterate over known template names and aliases
	p[template] = function (frame) return cite (frame, template) end; -- create a function for each template (e.g. {{#invoke:cite\|book\|title=Title}})
	p[template:gsub("^%l", string.upper)] = function (frame) return cite (frame, template) end; -- create a function for first letter capitalized (e.g. {{#invoke:cite\|Book\|title=Title}})
	end
	end		end

			local metatable = {['__index'] = index}

			setmetatable(p, metatable)

	return p		return p

Ahecht: If we're not grabbing classes, this is no longer needed

2025-04-23T16:00:12Z

If we're not grabbing classes, this is no longer needed

← Previous revision		Revision as of 16:00, 23 April 2025
Line 83:		Line 83:
	for _, templates_t in ipairs ({cfg.known_templates_lower_case_t, cfg.known_templates_mixed_case_t}) do		for _, templates_t in ipairs ({cfg.known_templates_lower_case_t, cfg.known_templates_mixed_case_t}) do
	for template, _ in pairs (templates_t) do -- iterate over known template names and aliases		for template, _ in pairs (templates_t) do -- iterate over known template names and aliases
	~~local funct_name~~ = template; -- function ~~name~~ is template ~~name~~ ~~or class name~~		p[template] = function (frame) return cite (frame, template) end; -- create a function for each template (e.g. {{#invoke:cite\|book\|title=Title}})
	p[~~funct_name~~] = function (frame) return cite (frame, template) end; -- create a function for ~~each~~ ~~template~~ (e.g. {{#invoke:cite\|~~book~~\|title=Title}})		p[template:gsub("^%l", string.upper)] = function (frame) return cite (frame, template) end; -- create a function for first letter capitalized (e.g. {{#invoke:cite\|Book\|title=Title}})
	p[funct_name:gsub("^%l", string.upper)] = function (frame) return cite (frame, template) end; -- create a function for first letter capitalized (e.g. {{#invoke:cite\|Book\|title=Title}})
	end		end
	end		end

Trappist the monk at 22:07, 22 April 2025

2025-04-22T22:07:51Z

← Previous revision		Revision as of 22:07, 22 April 2025
Line 54:		Line 54:

	-- <start> all of this goes away if positional parameter not used; after fixes to various templates that use this module		-- <start> all of this goes away if positional parameter not used; after fixes to various templates that use this module
			-- this goes away because we can't get here without we already know that the calling function exists
	if t then args_t[1] = t end -- override args_t[1] if called using template name as function		if t then args_t[1] = t end -- override args_t[1] if called using template name as function
	if not args_t[1] then -- this is the template name; we must have a template name		if not args_t[1] then -- this is the template name; we must have a template name
Line 62:		Line 63:
	args_t[1] = nil; -- unset, no longer needed (and would break the cs1\|2 template)		args_t[1] = nil; -- unset, no longer needed (and would break the cs1\|2 template)

	if not cfg.~~known_templates_t~~[template] then -- do we recognize this template name?		if not cfg.known_templates_lower_case_t[template] then -- do we recognize this template name?
	return make_error_msg (frame, substitute (cfg.error_messages_t.unknown, {template})); -- nope; abandon with error message		return make_error_msg (frame, substitute (cfg.error_messages_t.unknown, {template})); -- nope; abandon with error message
	end		end
Line 76:		Line 77:

	local p = {		local p = {
	cite = cite, -- these ~~can~~ go away if we adopt the code below after necessary		cite = cite, -- these go away if we adopt the code below !after necessary
	Cite = cite, -- edits to the various templates that already use this module		Cite = cite, -- edits to the various templates that already use this module
	}		}

Trappist the monk: rename tables;

2025-04-22T22:02:01Z

rename tables;

← Previous revision		Revision as of 22:02, 22 April 2025
Line 79:		Line 79:
	Cite = cite, -- edits to the various templates that already use this module		Cite = cite, -- edits to the various templates that already use this module
	}		}

	-- TODO: rename tables? one for canonical lowercase; one for canonical mixed case?
	for _, templates_t in ipairs({cfg.~~known_templates_t~~, cfg.~~known_template_aliases_t~~}) do		for _, templates_t in ipairs ({cfg.known_templates_lower_case_t, cfg.known_templates_mixed_case_t}) do
	for template, _ in pairs(templates_t) do -- iterate over known template names and aliases		for template, _ in pairs (templates_t) do -- iterate over known template names and aliases
	local funct_name = template; -- function name is template name or class name		local funct_name = template; -- function name is template name or class name
	p[funct_name] = function (frame) return cite (frame, template) end; -- create a function for each template (e.g. {{#invoke:cite\|book\|title=Title}})		p[funct_name] = function (frame) return cite (frame, template) end; -- create a function for each template (e.g. {{#invoke:cite\|book\|title=Title}})
	p[funct_name:gsub("^%l", string.upper)] = function (frame) return cite (frame, template) end; -- create an ~~alias~~ ~~with the~~ first letter capitalized (e.g. {{#invoke:cite\|Book\|title=Title}})		p[funct_name:gsub("^%l", string.upper)] = function (frame) return cite (frame, template) end; -- create a function for first letter capitalized (e.g. {{#invoke:cite\|Book\|title=Title}})
	end		end
	end		end