Module:Footnotes/anchor id list/sandbox: Difference between revisions

Revision as of 21:24, 18 August 2023

Latest revision as of 10:15, 24 May 2025

(33 intermediate revisions by 2 users not shown)

Line 2:

local data = mw.loadData ('Module:Footnotes/anchor id list/data');

local whitelist = mw.loadData ('Module:Footnotes/whitelist/sandbox');

local Lang_obj = mw.language.getContentLanguage(); -- used by template_list_addtemplate_name_get() to uppercase first letter of template name TODO: better way to do that?

local redirects_date = {

Line 60:

'|%s*date%s*=%s*',

'|%s*publication%-?date%s*=%s*',

'|%s*air%-?date%s*=%s*',

}

local alias_patterns_harvc_date = { -- normal lua patterns for harvc template

Line 72 ⟶ 73:

}

local patterns_date = { -- normal lua patterns

-- '(%d%d%d%d–%d%d%d%d%l?)$', -- YYYY–YYYY four-digit year range at end (Season YYYY–YYYY); with or without dab

'(%d%d%d%d)%D+(%d%d%d%d%l?)$', -- any range with four-digit years; with or without dab; not two captures

'^(%d%d%d%d–%d%d%l?)$', -- YYYY–YY two-digit year range; with or without dab

'^(c%. %d%d%d%d?%l?)$', -- three- or four-digit circa year; with or without dab

Line 90 ⟶ 92:

['Citation-attribution'] = true,

}

local global_article_content = nil

local Article_content;

local global_anchor_id_list = nil -- exported tables

local global_template_list = nil

local global_article_whitelist = nil

local anchor_id_list = {}; -- exported tables

local template_list = {};

local article_whitelist = {};

Line 105 ⟶ 108:

local function article_content_get ()

if global_article_content then return global_article_content end

if not Article_content then

Article_content local article_content = mw.title.getCurrentTitle():getContent() or ''; -- get the content of the article or ''; new pages edited w/ve do not have 'content' until saved; ve does not preview; phab:T221625

for _, tag in ipairs (patterns_tags) do

Article_content article_content = Article_contentarticle_content:gsub (tag, ''); -- remove certain html-like tags and their content

end

end

global_article_content = article_content

return article_content

end

Line 156 ⟶ 160:

local function date_get (template, aliases)

local date;

local rvalue;

Line 185 ⟶ 188:

if rvalue then

for _, pattern in ipairs (patterns_date) do -- spin through the recognized date formats

-- date = rvalue:match (pattern); -- attempt to extract year portion according to the pattern

local date, date2 = rvalue:match (pattern); -- attempt to extract year portion according to the pattern; <date2> gets second year in any range

if date then

if date2 then -- when a second year

date = table.concat ({date, '–', date2}); -- build a date range

end

return date; -- matched so return;

end

Line 324 ⟶ 331:

local function template_strip (template)

template = template:gsub ('^{{%s*', ''):gsub ('%s*}}$', '', 1); -- remove outer {{ and }} (cs1|2 template delimiters with trailing/leading whitespace)

template = template:gsub ('%b{}', ''); -- remove any templates from the cs1|2 template

return template;

Line 367 ⟶ 374:

end

--[[--------------------------< T E M P L A T E _ N A M E _ F R O M _ M O D U L E >----------------------------

if passed a module invocation, return the name of the template represented. Otherwise return the input.

{{#invoke:cite|foo|...}} or {{#invoke:cite bar||...}} will return "cite foo" and "cite bar", respectively.

]]

local function template_name_from_module (template, template_name)

if template_name and template_name:match ('^#invoke%s*:') then -- handle directly-invoked citation modules

template_name = template_name:match ('^#invoke%s*:%s*(.+)'); -- get module name

local func_name = template:match ('^{{[^|}]+%|%s*([^/|}]*)'); -- get function name

if template_name and func_name then -- valid module invocation

return template_name:gsub ('%s+$', '') .. ' ' .. func_name; -- ensure exactly one trailing whitespace between module and function name

end;

return nil -- could not get module and function name

end;

return template_name

end

--[[--------------------------< T E M P L A T E _ N A M E _ G E T >--------------------------------------------

Line 380 ⟶ 406:

local template_name = template:match ('^{{%s*([^/|}]+)'); -- get template name; ignore subpages ~/new, ~/sandbox; parser functions

template_name = template_name_from_module (template, template_name); -- if passed a module invocation, return the name of the template represented

if not template_name or template_name:match ('^#') then -- parser functions, magic words don't count as templates

return nil; -- could not get template name from (possibly corrupt) template; extraneous opening { mid template can cause this;

Line 395 ⟶ 423:

]]

local function template_params_get (template, paramsparams_t)

template = wikilink_strip (template); -- because piped wikilinks confuse code that builds paramsparams_t{} and because wikilinks not allowed in an anchor id

-- strip templates after getting |ref= value because |ref={{sfnref}} and |ref={{harvid}} are allowed

template = template_strip (template); -- because template markup can confuse code that builds paramsparams_t{} and because templates in name parameters are not allowed

templatelocal temp_t = mw.text.split (template:gsub, ('%s*|%s*|', '|'); --split when pipe follows pipe with or without white space, removeon extraneousthe pipe

for _, param in ipairs (temp_t) do

if param:find ('=', 1, true) then -- a named parameter?

for param, value in template:gmatch ('|%s*([^=]-)%s*=%s*([^|}]+)') do -- build a table of template parameters and their values

local k, v = param:match ('%s*([^=]-)%s*=%s*([^|}]+)');

if value then -- there must be a value

if v then -- there must be a value
if '' ~= valuev and not valuev:match ('^%s$') then -- skip when value is empty string or only whitespace

params params_t[paramk] = mw.text.trim (valuev); -- add trimmed value else

end

end

end

Line 493 ⟶ 523:

template_params_get (template, params); -- build a table of template parameters and their values

if local wrap_data = whitelist.wrapper_templates[template_name][1] then -- is this wrapper a simple-default wrapper?

name_default = whitelist.wrapper_templates[template_name][1]; -- get the default names

if wrap_data[1] then -- is this wrapper a simple-default wrapper?

date_default = whitelist.wrapper_templates[template_name][2]; -- get the default date

name_default = wrap_data[1]; -- get the default names

date_default = wrap_data[2]; -- get the default date

else

vol = params['volume'] or 'default';

local fascicle = params['fascicle'] -- some templates use "fascicle" to mean "subvolume"

if not whitelist.wrapper_templates[template_name][vol] then -- make sure this volume exists

if fascicle then

local subvol = vol..'/'..fascicle -- if fascicle is used, subvolume = "vol/fascicle"

if wrap_data[subvol] then -- if subvolume exists, use it, otherwise fall back to volume

vol = subvol

end

end

if not wrap_data[vol] then -- make sure this volume exists

vol = 'default'; -- doesn't exist, use default volume

end

name_default = whitelist.wrapper_templates[template_name]wrap_data[vol][1]; -- get the default names

date_default = whitelist.wrapper_templates[template_name]wrap_data[vol][2]; -- get the default date

end

Line 582 ⟶ 621:

template_params_get (template, params); -- build a table of template parameters and their values

if not ref then -- |ref= not set, might be cite LSA which doesn't support |ref=

if 'cite lsa' == template_name then

return 'CITEREF' .. (params.last or '') .. (params.year or ''); -- cite LSA always creates an anchor id using only |last= and |year= (no aliases)

end

end

if 'harv' == ref or not ref then -- |ref=harv specified or |ref= missing or empty

Line 676 ⟶ 709:

list_add (anchor_id, anchor_id_list, true); -- add anchor ID to the list

end

end

end

--[[--------------------------< T E M P L A T E _ L I S T _ A D D >--------------------------------------------

makes a list of templates use in the article.

]]

local function template_list_add (template)

local template = template:match ('{{%s*(.-)[|}]'); -- keep the case of the template - this is different from template_name_get()

if template and not template:match ('^#') then -- found a template or magic word; ignore magic words

template=mw.text.trim (template); -- trim whitespace

template = Lang_obj:ucfirst (template); -- first character in template name must be uppercase (same as canonical template name) TODO: better way to do this?

list_add (template, template_list); -- add to list with (unused) tally

end

end

Line 712 ⟶ 729:

local function anchor_id_list_make ()

local anchor_id_list = {}

article_content_get (); -- attempt to get this article's content

local template_list = {}

local article_whitelist = {}

local article_content = article_content_get (); -- attempt to get this article's content

if ''article_content == Article_content'' then -- when there is no article content

return ''; -- no point in continuing

end

Line 723 ⟶ 743:

local find_pattern = '%f[{]{{[^{]';

local tstart, tend = Article_contentarticle_content:find (find_pattern); -- find the first template; do not find template variables: {{{template var|}}}

while tstart do

template = Article_contentarticle_content:match ('%b{}', tstart); -- get the whole template

if not template then

break; -- template is nil for some reason (last template missing closing }} for example) so declare ourselves done

end

template_name = template_name_get (template); -- get first char uppercase trimmed template name; ignore subpages ~/new, ~/sandbox

template_list_addlist_add (templatetemplate_name, template_list); -- add this template's name to the list

--error (template_name)

if data.known_templates_cs12 [template_name] then

anchor_id = anchor_id_make_cs12 (template); -- extract an anchor id from this template

Line 793 ⟶ 812:

for _, anchor_id in ipairs (template) do -- spin through this template's parameter

if '' ~= anchor_id and not article_whitelist[anchor_id] then

anchor_id = mw.uri.anchorEncode (anchor_id)

article_whitelist[anchor_id] = 1; -- add to the whitelist

end

end

elseif template_name and whitelist.wrapper_templates[template_name] then

anchor_id = anchor_id_make_wrapper (template); -- extract an anchor id from this template if possible

list_add (anchor_id, anchor_id_list, true);

elseif template_name and template_name:match ('^Cit[ea]') then -- not known, not known wrapper; last gasp, try as cs1-like

anchor_id = anchor_id_make_cs12 (template); -- extract an anchor id from this template if possible

Line 806 ⟶ 827:

end

tstart, tend = Article_contentarticle_content:find (find_pattern, tend); -- search for another template; begin at end of last search

end

Line 813 ⟶ 834:

mw.logObject (article_whitelist, 'article_whitelist');

return anchor_id_list;

global_anchor_id_list = anchor_id_list

global_template_list = template_list

global_article_whitelist = article_whitelist

end

--[[--------------------------< C I T E R E F _ P A T T E R N S _ M A K E >--------------------------------------------

Scans template_list to look for wrapper templates that generate citerefs that require Lua patterns.

This scan is only done once per page load, to save time

]]

local function citeref_patterns_make()

if not global_template_list then return end

local citeref_patterns = {}

local template_patterns = whitelist.wrapper_template_patterns

for _, p in ipairs(template_patterns) do

for _, t in ipairs(p[1]) do -- loop through list of template wrappers

if global_template_list[t] then -- if wrapper is found in article, record corresponding patterns

for _, pat in ipairs(p[2]) do

table.insert(citeref_patterns, pat)

end

break

end

end

end

mw.logObject(citeref_patterns,'citeref_patterns')

return citeref_patterns

end

Line 820 ⟶ 870:

]]

-- First create global_anchor_id_list, global_template_list, global_article_whitelist

anchor_id_list_make()

-- Then stuff them (and derived tables) into return table

return {

anchor_id_list = anchor_id_list_make()global_anchor_id_list or {}, -- table of anchor ids available in this article

article_whitelist = article_whitelistglobal_article_whitelist or {}, -- table of anchor ids with false-positive error message to be suppressed

template_list = template_listglobal_template_list or {}, -- table of templates used in this article

citeref_patterns = citeref_patterns_make() or {}, -- table of Lua patterns to search for citeref from wrappers

}