Module:Citation/CS1: Difference between revisions

sync from sandbox;
m (1 revision imported)
(sync from sandbox;)
Line 1:
require('strict');
 
require('Module:No globals');
 
--[[--------------------------< F O R W A R D D E C L A R A T I O N S >--------------------------------------
 
each of these counts against the Lua upvalue limit
 
]]
 
Line 9 ⟶ 10:
 
local utilities; -- functions in Module:Citation/CS1/Utilities
local z = {}; -- table of tables in Module:Citation/CS1/Utilities
 
local identifiers; -- functions and tables in Module:Citation/CS1/Identifiers
Line 15 ⟶ 16:
local cfg = {}; -- table of configuration tables that are defined in Module:Citation/CS1/Configuration
local whitelist = {}; -- table of tables listing valid template parameter names; defined in Module:Citation/CS1/Whitelist
 
 
--[[------------------< P A G E S C O P E V A R I A B L E S >---------------
 
declare variables here that have page-wide scope that are not brought in from
other modules; that are created here and used here
 
]]
 
local added_deprecated_cat; -- Boolean flag so that the category is added only once
local added_discouraged_cat; -- Boolean flag so that the category is added only once
local added_vanc_errs; -- Boolean flag so we only emit one Vancouver error / category
local added_generic_name_errs; -- Boolean flag so we only emit one generic name error / category and stop testing names once an error is encountered
local Frame; -- holds the module's frame table
local is_preview_mode; -- true when article is in preview mode; false when using 'Preview page with this template' (previewing the module)
local is_sandbox; -- true when using sandbox modules to render citation
 
 
--[[--------------------------< F I R S T _ S E T >------------------------------------------------------------
Line 60 ⟶ 68:
added_vanc_errs = true; -- note that we've added this category
table.insert( z.message_tail, { utilities.set_message ( 'err_vancouver', {source, position}, true ) } );
end
 
Line 146 ⟶ 154:
end
 
for _, d in ipairs ({'cash', 'company', 'today', 'org'}cfg.single_letter_2nd_lvl_domains_t) do -- look for single letter second level domain names for these top level domains
if domain:match ('%f[%w][%w]%.' .. d) then
return true
Line 257 ⟶ 265:
 
local function link_title_ok (link, lorig, title, torig)
local orig;
if utilities.is_set (link) then -- don't bother if <param>-link doesn't have a value
if not link_param_ok (link) then -- check |<param>-link= markup
Line 274 ⟶ 282:
if utilities.is_set (orig) then
link = ''; -- unset
table.insert( z.message_tail, { utilities.set_message ( 'err_bad_paramlink', orig)}); -- URL or wikilink in |title= with |title-link=;
end
Line 349 ⟶ 357:
]]
 
local function check_for_url (parameter_list, error_list)
local error_message = '';
for k, v in pairs (parameter_list) do -- for each parameter in the list
if is_parameter_ext_wikilink (v) then -- look at the value; if there is a URL add an error message
table.insert (error_list, utilities.wrap_style ('parameter', k));
if utilities.is_set(error_message) then -- once we've added the first portion of the error message ...
error_message = error_message .. ", "; -- ... add a comma space separator
end
error_message = error_message .. "&#124;" .. k .. "="; -- add the failed parameter
end
end
if utilities.is_set (error_message) then -- done looping, if there is an error message, display it
table.insert( z.message_tail, { utilities.set_message ( 'err_param_has_ext_link', {error_message}, true ) } );
end
end
Line 373 ⟶ 374:
local function safe_for_url( str )
if str:match( "%[%[.-%]%]" ) ~= nil then
table.insert( z.message_tail, { utilities.set_message ( 'err_wikilink_in_url', {}, true ) } );
end
Line 389 ⟶ 390:
]]
 
local function external_link( (URL, label, source, access)
local error_strerr_msg = ""'';
local domain;
local path;
local base_url;
 
if not utilities.is_set ( label ) then
label = URL;
if utilities.is_set ( source ) then
error_str = utilities.set_message ( 'err_bare_url_missing_title', { utilities.wrap_style ('parameter', source) }, false, " " );
else
error( (cfg.messages["bare_url_no_origin"] ); -- programmer error; valid parameter name does not have matching meta-parameter
end
end
if not check_url ( URL ) then
error_str = utilities.set_message ( 'err_bad_url', {utilities.wrap_style ('parameter', source)}, false, " " ) .. error_str;
end
Line 413 ⟶ 414:
end
 
base_url = table.concat ({ "[", URL, " ", safe_for_url (label), "]" }); -- assemble a wiki-markup URL
 
if utilities.is_set (access) then -- access level (subscription, registration, limited)
base_url = utilities.substitute (cfg.presentation['ext-link-access-signal'], {cfg.presentation[access].class, cfg.presentation[access].title, base_url}); -- add the appropriate icon
end
 
return table.concat ({base_url, error_str});
end
 
Line 436 ⟶ 437:
if not added_deprecated_cat then
added_deprecated_cat = true; -- note that we've added this category
table.insert( z.message_tail, { utilities.set_message ( 'err_deprecated_params', {name}, true ) } ); -- add error message
end
end
 
 
--[[--------------------------< D I S C O U R A G E D _ P A R A M E T E R >------------------------------------
 
Categorize and emit an maintenance message when the citation contains one or more discouraged parameters. Only
one error message is emitted regardless of the number of discouraged parameters in the citation.
 
added_discouraged_cat is a Boolean declared in page scope variables above
 
]]
 
local function discouraged_parameter(name)
if not added_discouraged_cat then
added_discouraged_cat = true; -- note that we've added this category
table.insert( z.message_tail, { utilities.set_message ( 'maint_discouraged', {name}, true ) } ); -- add maint message
end
end
Line 477 ⟶ 461:
local function kern_quotes (str)
local cap = '';
local cap2 = '';
local wl_type, label, link;
 
Line 484 ⟶ 467:
if 1 == wl_type then -- [[D]] simple wikilink with or without quote marks
if mw.ustring.match (str, '%[%[[\"“”\'‘’].+[\"“”\'‘’]%]%]') then -- leading and trailing quote marks
str = utilities.substitute (cfg.presentation['kern-wl-bothleft'], str);
str = utilities.substitute (cfg.presentation['kern-right'], str);
elseif mw.ustring.match (str, '%[%[[\"“”\'‘’].+%]%]') then -- leading quote marks
str = utilities.substitute (cfg.presentation['kern-wl-left'], str);
elseif mw.ustring.match (str, '%[%[.+[\"“”\'‘’]%]%]') then -- trailing quote marks
str = utilities.substitute (cfg.presentation['kern-wl-right'], str);
end
 
Line 495 ⟶ 479:
label = mw.ustring.gsub (label, '[‘’]', '\''); -- replace ‘’ (U+2018 & U+2019) with ' (typewriter single quote mark)
 
cap, cap2 = mw.ustring.match (label, "^([\"\'])([^\'].+)"); -- match leading double or single quote but not doubled single quotes (italic markup)
if utilities.is_set (cap) then
label = utilities.substitute (cfg.presentation['kern-left'], {cap, cap2});
end
cap, cap2 = mw.ustring.match (label, "^(.+[^\'])([\"\'])$") -- match trailing double or single quote but not doubled single quotes (italic markup)
if utilities.is_set (cap) then
label = utilities.substitute (cfg.presentation['kern-right'], {cap, cap2});
end
Line 545 ⟶ 529:
lang = script_value:match('^(%l%l%l?)%s*:%s*%S.*'); -- get the language prefix or nil if there is no script
if not utilities.is_set (lang) then
table.insert( z.message_tail, { utilities.set_message ( 'err_script_parameter', {script_param, cfg.err_msg_supl['missing title part']}, true ) } ); -- prefix without 'title'; add error message
return ''; -- script_value was just the prefix so return empty string
end
Line 554 ⟶ 538:
-- is prefix one of these language codes?
if utilities.in_array (lang, cfg.script_lang_codes) then
utilities.add_prop_cat ('script_with_namescript', {name, lang})
else
table.insert( z.message_tail, { utilities.set_message ( 'err_script_parameter', {script_param, cfg.err_msg_supl['unknown language code']}, true ) } ); -- unknown script-language; add error message
end
lang = ' lang="' .. lang .. '" '; -- convert prefix into a lang attribute
else
table.insert( z.message_tail, { utilities.set_message ( 'err_script_parameter', {script_param, cfg.err_msg_supl['invalid language code']}, true ) } ); -- invalid language code; add error message
lang = ''; -- invalid so set lang to empty string
end
else
table.insert( z.message_tail, { utilities.set_message ( 'err_script_parameter', {script_param, cfg.err_msg_supl['missing prefix']}, true ) } ); -- no language code prefix; add error message
end
script_value = utilities.substitute (cfg.presentation['bdi'], {lang, script_value}); -- isolate in case script is RTL
Line 574 ⟶ 558:
--[[--------------------------< S C R I P T _ C O N C A T E N A T E >------------------------------------------
 
Initially for |title= and |script-title=, this function concatenates those two parameter values after the script value has been
value has been wrapped in <bdi> tags.
 
]]
 
Line 673 ⟶ 658:
 
local function format_periodical (script_periodical, script_periodical_source, periodical, trans_periodical)
local periodical_error = '';
 
if not utilities.is_set (periodical) then
Line 689 ⟶ 673:
else -- here when trans-periodical without periodical or script-periodical
periodical = trans_periodical;
periodical_error = ' ' .. utilities.set_message ('err_trans_missing_title', {'periodical'});
end
end
 
return periodical .. periodical_error;
end
 
Line 706 ⟶ 690:
 
local function format_chapter_title (script_chapter, script_chapter_source, chapter, chapter_source, trans_chapter, trans_chapter_source, chapter_url, chapter_url_source, no_quotes, access)
local chapter_error = '';
 
local ws_url, ws_label, L = wikisource_url_make (chapter); -- make a wikisource URL and label from a wikisource interwiki link
if ws_url then
Line 739 ⟶ 721:
chapter = trans_chapter;
chapter_source = trans_chapter_source:match ('trans%-?(.+)'); -- when no chapter, get matching name from trans-<param>
chapter_error = ' ' .. utilities.set_message ('err_trans_missing_title', {chapter_source});
end
end
 
return chapter .. chapter_error;
end
 
Line 782 ⟶ 764:
if mw.ustring.find (v, cfg.indic_script) then -- it's ok if one of the Indic scripts
position = nil; -- unset position
elseif cfg.emojiemoji_t[mw.ustring.codepoint (v, position+1)] then -- is zwj followed by a character listed in emoji{}?
position = nil; -- unset position
end
Line 801 ⟶ 783:
end
 
table.insert (z.message_tail, {utilities.set_message ('err_invisible_char', {err_msg, utilities.wrap_style ('parameter', param), position}, true)}); -- add error message
return; -- and done with this parameter
end
Line 904 ⟶ 886:
 
return cfg.title_types [cite_class] or ''; -- set template's default title type; else empty string for concatenation
end
 
 
--[[--------------------------< H Y P H E N _ T O _ D A S H >--------------------------------------------------
 
Converts a hyphen to a dash under certain conditions. The hyphen must separate
like items; unlike items are returned unmodified. These forms are modified:
letter - letter (A - B)
digit - digit (4-5)
digit separator digit - digit separator digit (4.1-4.5 or 4-1-4-5)
letterdigit - letterdigit (A1-A5) (an optional separator between letter and
digit is supported – a.1-a.5 or a-1-a-5)
digitletter - digitletter (5a - 5d) (an optional separator between letter and
digit is supported – 5.a-5.d or 5-a-5-d)
 
any other forms are returned unmodified.
 
str may be a comma- or semicolon-separated list
 
]]
 
local function hyphen_to_dash( str )
if not utilities.is_set (str) then
return str;
end
 
local accept; -- Boolean
 
str = str:gsub ('&[nm]dash;', {['&ndash;'] = '–', ['&mdash;'] = '—'}); -- replace &mdash; and &ndash; entities with their characters; semicolon mucks up the text.split
str = str:gsub ('&#45;', '-'); -- replace HTML numeric entity with hyphen character
 
str = str:gsub ('&nbsp;', ' '); -- replace &nbsp; entity with generic keyboard space character
local out = {};
local list = mw.text.split (str, '%s*[,;]%s*'); -- split str at comma or semicolon separators if there are any
 
for _, item in ipairs (list) do -- for each item in the list
item, accept = utilities.has_accept_as_written (item); -- remove accept-this-as-written markup when it wraps all of item
if not accept and mw.ustring.match (item, '^%w*[%.%-]?%w+%s*[%-–—]%s*%w*[%.%-]?%w+$') then -- if a hyphenated range or has endash or emdash separators
if item:match ('^%a+[%.%-]?%d+%s*%-%s*%a+[%.%-]?%d+$') or -- letterdigit hyphen letterdigit (optional separator between letter and digit)
item:match ('^%d+[%.%-]?%a+%s*%-%s*%d+[%.%-]?%a+$') or -- digitletter hyphen digitletter (optional separator between digit and letter)
item:match ('^%d+[%.%-]%d+%s*%-%s*%d+[%.%-]%d+$') or -- digit separator digit hyphen digit separator digit
item:match ('^%d+%s*%-%s*%d+$') or -- digit hyphen digit
item:match ('^%a+%s*%-%s*%a+$') then -- letter hyphen letter
item = item:gsub ('(%w*[%.%-]?%w+)%s*%-%s*(%w*[%.%-]?%w+)', '%1–%2'); -- replace hyphen, remove extraneous space characters
else
item = mw.ustring.gsub (item, '%s*[–—]%s*', '–'); -- for endash or emdash separated ranges, replace em with en, remove extraneous whitespace
end
end
table.insert (out, item); -- add the (possibly modified) item to the output table
end
 
local temp_str = ''; -- concatenate the output table into a comma separated string
temp_str, accept = utilities.has_accept_as_written (table.concat (out, ', ')); -- remove accept-this-as-written markup when it wraps all of concatenated out
if accept then
temp_str = utilities.has_accept_as_written (str); -- when global markup removed, return original str; do it this way to suppress boolean second return value
return temp_str;
else
return temp_str; -- else, return assembled temp_str
end
end
 
Line 1,053 ⟶ 975:
--[[--------------------------< I S _ S U F F I X >-----------------------------
 
returns true isif suffix is properly formed Jr, Sr, or ordinal in the range 1–9.
Puncutation not allowed.
 
Line 1,183 ⟶ 1,105:
return table.concat(initials) -- Vancouver format does not include spaces.
end
 
 
--[[--------------------------< I N T E R W I K I _ P R E F I X E N _ G E T >----------------------------------
 
extract interwiki prefixen from <value>. Returns two one or two values:
false – no prefixen
nil – prefix exists but not recognized
project prefix, language prefix – when value has either of:
:<project>:<language>:<article>
:<language>:<project>:<article>
project prefix, nil – when <value> has only a known single-letter prefix
nil, language prefix – when <value> has only a known language prefix
 
accepts single-letter project prefixen: 'd' (wikidata), 's' (wikisource), and 'w' (wikipedia) prefixes; at this
writing, the other single-letter prefixen (b (wikibook), c (commons), m (meta), n (wikinews), q (wikiquote), and
v (wikiversity)) are not supported.
 
]]
 
local function interwiki_prefixen_get (value, is_link)
if not value:find (':%l+:') then -- if no prefix
return false; -- abandon; boolean here to distinguish from nil fail returns later
end
 
local prefix_patterns_linked_t = { -- sequence of valid interwiki and inter project prefixen
'^%[%[:([dsw]):(%l%l+):', -- wikilinked; project and language prefixes
'^%[%[:(%l%l+):([dsw]):', -- wikilinked; language and project prefixes
'^%[%[:([dsw]):', -- wikilinked; project prefix
'^%[%[:(%l%l+):', -- wikilinked; language prefix
}
local prefix_patterns_unlinked_t = { -- sequence of valid interwiki and inter project prefixen
'^:([dsw]):(%l%l+):', -- project and language prefixes
'^:(%l%l+):([dsw]):', -- language and project prefixes
'^:([dsw]):', -- project prefix
'^:(%l%l+):', -- language prefix
}
local cap1, cap2;
for _, pattern in ipairs ((is_link and prefix_patterns_linked_t) or prefix_patterns_unlinked_t) do
cap1, cap2 = value:match (pattern);
if cap1 then
break; -- found a match so stop looking
end
end
if cap1 and cap2 then -- when both then :project:language: or :language:project: (both forms allowed)
if 1 == #cap1 then -- length == 1 then :project:language:
if cfg.inter_wiki_map[cap2] then -- is language prefix in the interwiki map?
return cap1, cap2; -- return interwiki project and interwiki language
end
else -- here when :language:project:
if cfg.inter_wiki_map[cap1] then -- is language prefix in the interwiki map?
return cap2, cap1; -- return interwiki project and interwiki language
end
end
return nil; -- unknown interwiki language
elseif not (cap1 or cap2) then -- both are nil?
return nil; -- we got something that looks like a project prefix but isn't; return fail
elseif 1 == #cap1 then -- here when one capture
return cap1, nil; -- length is 1 so return project, nil language
else -- here when one capture and its length it more than 1
if cfg.inter_wiki_map[cap1] then -- is language prefix in the interwiki map?
return nil, cap1; -- return nil project, language
end
end
end
 
Line 1,253 ⟶ 1,242:
one = utilities.make_wikilink (person.link, one); -- link author/editor
end
 
if one then -- if <one> has a value (name, mdash replacement, or mask text replacement)
local proj, tag = interwiki_prefixen_get (one, true); -- get the interwiki prefixen if present
 
if 'w' == proj and ('Wikipedia' == mw.site.namespaces.Project['name']) then
proj = nil; -- for stuff like :w:de:<article>, :w is unnecessary TODO: maint cat?
end
if proj then
proj = ({['d'] = 'Wikidata', ['s'] = 'Wikisource', ['w'] = 'Wikipedia'})[proj]; -- :w (wikipedia) for linking from a non-wikipedia project
if proj then
one = one .. utilities.wrap_style ('interproj', proj); -- add resized leading space, brackets, static text, language name
tag = nil; -- unset; don't do both project and language
end
end
if tag == cfg.this_wiki_code then
tag = nil; -- stuff like :en:<article> at en.wiki is pointless TODO: maint cat?
end
if tag then
local lang = cfg.lang_code_remap[tag] or cfg.mw_languages_by_tag_t[tag];
if lang then -- error messaging done in extract_names() where we know parameter names
one = one .. utilities.wrap_style ('interwiki', lang); -- add resized leading space, brackets, static text, language name
end
end
 
table.insert (name_list, one); -- add it to the list of names
table.insert (name_list, sep_one); -- add the proper name-list separator
Line 1,283 ⟶ 1,295:
return result, count; -- return name-list string and count of number of names (count used for editor names only)
end
 
 
--[[--------------------< M A K E _ C I T E R E F _ I D >-----------------------
Line 1,307 ⟶ 1,320:
return ''; -- return an empty string; no reason to include CITEREF id in this citation
end
end
 
 
--[[--------------------------< C I T E _ C L A S S _A T T R I B U T E _M A K E >------------------------------
 
construct <cite> tag class attribute for this citation.
 
<cite_class> – config.CitationClass from calling template
<mode> – value from |mode= parameter
 
]]
 
local function cite_class_attribute_make (cite_class, mode)
local class_t = {};
table.insert (class_t, 'citation'); -- required for blue highlight
if 'citation' ~= cite_class then
table.insert (class_t, cite_class); -- identify this template for user css
table.insert (class_t, utilities.is_set (mode) and mode or 'cs1'); -- identify the citation style for user css or javascript
else
table.insert (class_t, utilities.is_set (mode) and mode or 'cs2'); -- identify the citation style for user css or javascript
end
for _, prop_key in ipairs (z.prop_keys_t) do
table.insert (class_t, prop_key); -- identify various properties for user css or javascript
end
 
return table.concat (class_t, ' '); -- make a big string and done
end
 
Line 1,332 ⟶ 1,371:
etal = true; -- set flag (may have been set previously here or by |display-<names>=etal)
if not nocat then -- no categorization for |vauthors=
table.insert( z.message_tail, {utilities.set_message ('err_etal', {param})}); -- and set an error if not added
end
end
Line 1,356 ⟶ 1,395:
if mw.ustring.match (name, '^[%A]+$') then -- when name does not contain any letters
utilities.set_message ('maint_numeric_names', cfg.special_case_translation [list_name]); -- add a maint cat for this template
end
end
end
 
 
--[[-------------------< N A M E _ H A S _ E D _ M A R K U P >------------------
 
Evaluates the content of author and editor parameters for extraneous editor annotations:
ed, ed., eds, (Ed.), etc. These annotations do not belong in author parameters and
are redundant in editor parameters. If found, the function adds the editor markup
maintenance category.
 
returns nothing
 
]]
 
local function name_has_ed_markup (name, list_name)
local patterns = cfg.editor_markup_patterns; -- get patterns from configuration
 
if utilities.is_set (name) then
for _, pattern in ipairs (patterns) do -- spin through patterns table and
if name:match (pattern) then
utilities.set_message ('maint_extra_text_names', cfg.special_case_translation [list_name]); -- add a maint cat for this template
break;
end
end
end
Line 1,419 ⟶ 1,433:
 
 
--[=[-------------------------< NI AS M_ G E _N CE HR EI C K S >----------------------------------------------------------
 
Compares values assigned to various parameters according to the string provided as <item> in the function call.
This function calls various name checking functions used to validate the content
<item> can have on of two values:
of the various name-holding parameters.
'generic_names' – for name-holding parameters: |last=, |first=, |editor-last=, etc
'generic_titles' – for |title=
 
There are two types of generic tests. The 'accept' tests look for a pattern that should not be rejected by the
'reject' test. For example,
|author=[[John Smith (author)|Smith, John]]
would be rejected by the 'author' reject test. But piped wikilinks with 'author' disambiguation should not be
rejected so the 'accept' test prevents that from happening. Accept tests are always performed before reject
tests.
 
Each of the 'accept' and 'reject' sequence tables hold tables for en.wiki (['en']) and local.wiki (['local'])
that each can hold a test sequence table The sequence table holds, at index [1], a test pattern, and, at index
[2], a boolean control value. The control value tells string.find() or mw.ustring.find() to do plain-text search (true)
or a pattern search (false). The intent of all this complexity is to make these searches as fast as possible so
that we don't run out of processing time on very large articles.
 
Returns
true when a reject test finds the pattern or string
false when an accept test finds the pattern or string
nil else
 
]=]
 
local function is_generic (item, value, wiki)
local test_val;
local str_lower = { -- use string.lower() for en.wiki (['en']) and use mw.ustring.lower() or local.wiki (['local'])
['en'] = string.lower,
['local'] = mw.ustring.lower,
}
local str_find = { -- use string.find() for en.wiki (['en']) and use mw.ustring.find() or local.wiki (['local'])
['en'] = string.find,
['local'] = mw.ustring.find,
}
 
local function test (val, test_t, wiki) -- local function to do the testing; <wiki> selects lower() and find() functions
val = test_t[2] and str_lower[wiki](value) or val; -- when <test_t[2]> set to 'true', plaintext search using lowercase value
return str_find[wiki] (val, test_t[1], 1, test_t[2]); -- return nil when not found or matched
end
local test_types_t = {'accept', 'reject'}; -- test accept patterns first, then reject patterns
local wikis_t = {'en', 'local'}; -- do tests for each of these keys; en.wiki first, local.wiki second
 
for _, test_type in ipairs (test_types_t) do -- for each test type
for _, generic_value in pairs (cfg.special_case_translation[item][test_type]) do -- spin through the list of generic value fragments to accept or reject
for _, wiki in ipairs (wikis_t) do
if generic_value[wiki] then
if test (value, generic_value[wiki], wiki) then -- go do the test
return ('reject' == test_type); -- param value rejected, return true; false else
end
end
end
end
end
end
 
 
--[[--------------------------< N A M E _ I S _ G E N E R I C >------------------------------------------------
 
calls is_generic() to determine if <name> is a 'generic name' listed in cfg.generic_names; <name_alias> is the
parameter name used in error messaging
 
]]
 
local function name_is_generic (name, name_alias)
if not added_generic_name_errs and is_generic ('generic_names', name) then
utilities.set_message ('err_generic_name', name_alias); -- set an error message
added_generic_name_errs = true;
end
end
 
 
--[[--------------------------< N A M E _ C H E C K S >--------------------------------------------------------
 
This function calls various name checking functions used to validate the content of the various name-holding parameters.
 
]]
 
local function name_checks (last, first, list_name, last_alias, first_alias)
local accept_name;
 
if utilities.is_set (last) then
last, accept_name = utilities.has_accept_as_written (last); -- remove accept-this-as-written markup when it wraps all of <last>
 
if not accept_name then -- <last> not wrapped in accept-as-written markup
name_has_mult_names (last, list_name); -- check for multiple names in the parameter (last only)
name_has_ed_markup (last, list_name); -- check for extraneous 'editor' annotation
name_is_numeric (last, list_name); -- check for names that are composed of digits and punctuation
name_is_generic (last, last_alias); -- check for names found in the generic names list
end
end
Line 1,443 ⟶ 1,531:
 
if not accept_name then -- <first> not wrapped in accept-as-written markup
name_has_ed_markup (first, list_name); -- check for extraneous 'editor' annotation
name_is_numeric (first, list_name); -- check for names that are composed of digits and punctuation
name_is_generic (first, first_alias); -- check for names found in the generic names list
end
local wl_type, D = utilities.is_wikilink (first);
if 0 ~= wl_type then
first = D;
utilities.set_message ('err_bad_paramlink', first_alias);
end
end
Line 1,453 ⟶ 1,546:
 
--[[----------------------< E X T R A C T _ N A M E S >-------------------------
 
Gets name list from the input arguments
 
Line 1,490 ⟶ 1,584:
link, link_alias = utilities.select_one ( args, cfg.aliases[list_name .. '-Link'], 'err_redundant_parameters', i );
mask = utilities.select_one ( args, cfg.aliases[list_name .. '-Mask'], 'err_redundant_parameters', i );
 
if last then -- error check |lastn= alias for unknown interwiki link prefix; done here because this is where we have the parameter name
local project, language = interwiki_prefixen_get (last, true); -- true because we expect interwiki links in |lastn= to be wikilinked
if nil == project and nil == language then -- when both are nil
utilities.set_message ('err_bad_paramlink', last_alias); -- not known, emit an error message -- TODO: err_bad_interwiki?
last = utilities.remove_wiki_link (last); -- remove wikilink markup; show display value only
end
end
if link then -- error check |linkn= alias for unknown interwiki link prefix
local project, language = interwiki_prefixen_get (link, false); -- false because wiki links in |author-linkn= is an error
if nil == project and nil == language then -- when both are nil
utilities.set_message ('err_bad_paramlink', link_alias); -- not known, emit an error message -- TODO: err_bad_interwiki?
link = nil; -- unset so we don't link
link_alias = nil;
end
end
last, etal = name_has_etal (last, etal, false, last_alias); -- find and remove variations on et al.
first, etal = name_has_etal (first, etal, false, first_alias); -- find and remove variations on et al.
last, first = name_checks (last, first, list_name, last_alias, first_alias); -- multiple names, extraneous annotation, etc. checks
 
if first and not last then -- if there is a firstn without a matching lastn
local alias = first_alias:find ('given', 1, true) and 'given' or 'first'; -- get first or given form of the alias
table.insert (z.message_tail, { utilities.set_message ( 'err_first_missing_last', {
first_alias, -- param name of alias missing its mate
first_alias:gsub (alias, {['first'] = 'last', ['given'] = 'surname'}), -- make param name appropriate to the alias form
}, true ) } ); -- add this error message
elseif not first and not last then -- if both firstn and lastn aren't found, are we done?
count = count + 1; -- number of times we haven't found last and first
Line 1,509 ⟶ 1,620:
local result;
link = link_title_ok (link, link_alias, last, last_alias); -- check for improper wiki-markup
 
if first then
link = link_title_ok (link, link_alias, first, first_alias); -- check for improper wiki-markup
Line 1,516 ⟶ 1,628:
n = n + 1; -- point to next location in the names table
if 1 == count then -- if the previous name was missing
table.insert( z.message_tail, { utilities.set_message ( 'err_missing_name', {list_name:match ("(%w+)List"):lower(), i - 1}, true ) } ); -- add this error message
end
count = 0; -- reset the counter, we're looking for two consecutive missing names
Line 1,527 ⟶ 1,639:
 
 
--[[--------------------------< GN A M E T _ IT SA O 6 3 9G _ CG OE D ET >------------------------------------------------------
 
attempt to decode |language=<lang_param> and return language name and matching tag; nil else.
Validates language names provided in |language= parameter if not an ISO639-1 or 639-2 code.
 
This function looks for:
Returns the language name and associated two- or three-character code. Because
<lang_param> as a tag in cfg.lang_code_remap{}
case of the source may be incorrect or different from the case that WikiMedia uses,
<lang_param> as a name in cfg.lang_name_remap{}
the name comparisons are done in lower case and when a match is found, the Wikimedia
version (assumed to be correct) is returned along with the code. When there is no
<lang_param> as a name in cfg.mw_languages_by_name_t
match, we return the original language name string.
<lang_param> as a tag in cfg.mw_languages_by_tag_t
when those fail, presume that <lang_param> is an IETF-like tag that MediaWiki does not recognize. Strip all
script, region, variant, whatever subtags from <lang_param> to leave just a two or three character language tag
and look for the new <lang_param> in cfg.mw_languages_by_tag_t{}
 
on success, returns name (in properly capitalized form) and matching tag (in lowercase); on failure returns nil
mw.language.fetchLanguageNames(<local wiki language>, 'all') returns a list of
languages that in some cases may include extensions. For example, code 'cbk-zam'
and its associated name 'Chavacano de Zamboanga' (MediaWiki does not support
code 'cbk' or name 'Chavacano'. Most (all?) of these languages are not used a
'language' codes per se, rather they are used as sub-domain names: cbk-zam.wikipedia.org.
A list of language names and codes supported by fetchLanguageNames() can be found
at Template:Citation Style documentation/language/doc
 
]]
Names that are included in the list will be found if that name is provided in the
|language= parameter. For example, if |language=Chavacano de Zamboanga, that name
will be found with the associated code 'cbk-zam'. When names are found and the
associated code is not two or three characters, this function returns only the
WikiMedia language name.
 
local function name_tag_get (lang_param)
Some language names have multiple entries under different codes:
local lang_param_lc = mw.ustring.lower (lang_param); -- use lowercase as an index into the various tables
Aromanian has code rup and code roa-rup
local name;
When this occurs, this function returns the language name and the 2- or 3-character code
local tag;
 
name = cfg.lang_code_remap[lang_param_lc]; -- assume <lang_param_lc> is a tag; attempt to get remapped language name
Adapted from code taken from Module:Check ISO 639-1.
if name then -- when <name>, <lang_param> is a tag for a remapped language name
return name, lang_param_lc; -- so return <name> from remap and <lang_param_lc>
end
 
tag = lang_param_lc:match ('^(%a%a%a?)%-.*'); -- still assuming that <lang_param_lc> is a tag; strip script, region, variant subtags
]]
name = cfg.lang_code_remap[tag]; -- attempt to get remapped language name with language subtag only
if name then -- when <name>, <tag> is a tag for a remapped language name
return name, tag; -- so return <name> from remap and <tag>
end
 
if cfg.lang_name_remap[lang_param_lc] then -- not a tag, assume <lang_param_lc> is a name; attempt to get remapped language tag
local function get_iso639_code (lang, this_wiki_code)
return cfg.lang_name_remap[lang_param_lc][1], cfg.lang_name_remap[lang_param_lc][2]; -- for this <lang_param_lc>, return a (possibly) new name and appropriate tag
if cfg.lang_name_remap[lang:lower()] then -- if there is a remapped name (because MediaWiki uses something that we don't think is correct)
return cfg.lang_name_remap[lang:lower()][1], cfg.lang_name_remap[lang:lower()][2]; -- for this language 'name', return a possibly new name and appropriate code
end
 
tag = cfg.mw_languages_by_name_t[lang_param_lc]; -- assume that <lang_param_lc> is a language name; attempt to get its matching tag
local ietf_code; -- because some languages have both IETF-like codes and ISO 639-like codes
local ietf_name;
if tag then
local langlc = mw.ustring.lower (lang); -- lower-case version for comparisons
return cfg.mw_languages_by_tag_t[tag], tag; -- <lang_param_lc> is a name so return the name from the table and <tag>
end
 
for code, name in pairs= (cfg.languages) do mw_languages_by_tag_t[lang_param_lc]; -- scanassume thethat list<lang_param_lc> tois seea iftag; weattempt canto findget ourits matching language name
if langlc == mw.ustring.lower (name) then
if name then
if 2 == #code or 3 == #code then -- two- or three-character codes only; IETF extensions not supported
return name, codelang_param_lc; -- <lang_param_lc> is a tag so return the nameit and the code<name>
end
ietf_code = code; -- remember that we found an IETF-like code and save its name
tag = lang_param_lc:match ('^(%a%a%a?)%-.*'); -- is <lang_param_lc> an IETF-like tag that MediaWiki doesn't recognize? <tag> gets the language subtag; nil else
ietf_name = name; -- but keep looking for a 2- or 3-char code
 
if tag then
name = cfg.mw_languages_by_tag_t[tag]; -- attempt to get a language name using the shortened <tag>
if name then
return name, tag; -- <lang_param_lc> is an unrecognized IETF-like tag so return <name> and language subtag
end
end
-- didn't find name with 2- or 3-char code; if IETF-like code found return
return ietf_code and ietf_name or lang; -- associated name; return original language text else
end
 
Line 1,605 ⟶ 1,722:
 
local function language_parameter (lang)
local codetag; -- thesome two-form orof threeIETF-characterlike language codetag; language subtag with optional region, sript, vatiant, etc subtags
local lang_subtag; -- ve populates |language= with mostly unecessary region subtags the MediaWiki does not recognize; this is the base language subtag
local name; -- the language name
local language_list = {}; -- table of language names to be rendered
local names_tablenames_t = {}; -- table made from the value assigned to |language=
 
local this_wiki_name = mw.language.fetchLanguageName (cfg.this_wiki_code, cfg.this_wiki_code); -- get this wiki's language name
 
names_tablenames_t = mw.text.split (lang, '%s*,%s*'); -- names should be a comma separated list
 
for _, lang in ipairs (names_tablenames_t) do -- reuse lang here because we don't yet know if lang is a language name or a language tag
name, tag = cfg.lang_code_remap[lang:lowername_tag_get (lang)]; -- firstattempt seeto ifget thisname/tag ispair afor code<lang>; that<name> ishas notproper supportedcapitalization; by MediaWiki but<tag> is in remaplowercase
 
if utilities.is_set (tag) then
if name then -- there was a remapped code so
iflang_subtag not= langtag:matchgsub ('^(%a%a%a?)%-x%-.*', '%a+$1') then ; -- iffor notcategorization, astrip privateany IETF-like tags from language tag
lang = lang:gsub ('^(%a%a%a?)%-.*', '%1'); -- strip IETF tags from code
end
else
lang = lang:gsub ('^(%a%a%a?)%-.*', '%1'); -- strip any IETF-like tags from code
if 2 == lang:len() or 3 == lang:len() then -- if two-or three-character code
name = mw.language.fetchLanguageName (lang:lower(), cfg.this_wiki_code); -- get language name if |language= is a proper code
end
end
 
if utilities.is_set (name) then -- if |language= specified a valid code
code = lang:lower(); -- save it
else
name, code = get_iso639_code (lang, cfg.this_wiki_code); -- attempt to get code from name (assign name here so that we are sure of proper capitalization)
end
if utilities.is_set (code) then -- only 2- or 3-character codes
name = cfg.lang_code_remap[code] or name; -- override wikimedia when they misuse language codes/names
 
if cfg.this_wiki_code ~= codelang_subtag then -- when the language is not the same as this wiki's language
if 2 == codelang_subtag:len() then -- and is a two-character codetag
utilities.add_prop_cat ('foreign_lang_sourceforeign-lang-source' .. code, {name, codetag}, lang_subtag); -- categorize it; codetag appended to allow for multiple language categorization
else -- or is a recognized language (but has a three-character codetag)
utilities.add_prop_cat ('foreign_lang_source_2foreign-lang-source-2' .. code, {codelang_subtag}, lang_subtag); -- categorize it differently TODO: support multiple three-character codetag categories per cs1|2 template?
end
elseif cfg.local_lang_cat_enable then -- when the language and this wiki's language are the same and categorization is enabled
utilities.add_prop_cat ('local_lang_sourcelocal-lang-source', {name, codelang_subtag}); -- categorize it
end
else
name = lang; -- return whatever <lang> has so that we show something
utilities.set_message ('maint_unknown_lang'); -- add maint category if not already added
end
Line 1,655 ⟶ 1,757:
name = utilities.make_sep_list (#language_list, language_list);
if (1 == #language_list) and (lang_subtag == cfg.this_wiki_code) then -- when only one language, find lang name in this wiki lang name; for |language=en-us, 'English' in 'American English'
 
if this_wiki_name == name then
return ''; -- if one language and that language is this wiki's return an empty string (no annotation)
end
Line 1,664 ⟶ 1,765:
]]
end
 
 
--[[-----------------------< S E T _ C S _ S T Y L E >--------------------------
 
Gets the default CS style configuration for the given mode.
Returns default separator and either postscript as passed in or the default.
In CS1, the default postscript and separator are '.'.
In CS2, the default postscript is the empty string and the default separator is ','.
 
]]
 
local function set_cs_style (postscript, mode)
if utilities.is_set(postscript) then
Line 1,683 ⟶ 1,788:
return cfg.presentation['sep_' .. mode], postscript;
end
 
 
--[[--------------------------< S E T _ S T Y L E >-----------------------------
 
Sets the separator and postscript styles. Checks the |mode= first and the
#invoke CitationClass second. Removes the postscript if postscript == none.
 
]]
 
local function set_style (mode, postscript, cite_class)
local sep;
Line 1,711 ⟶ 1,820:
return sep, postscript
end
 
 
--[=[-------------------------< I S _ P D F >-----------------------------------
Line 1,742 ⟶ 1,852:
format = utilities.wrap_style ('format', format); -- add leading space, parentheses, resize
if not utilities.is_set (url) then
format = format .. ' ' .. utilities.set_message ( 'err_format_missing_url', {fmt_param, url_param} ); -- add an error message
end
elseif is_pdf (url) then -- format is not set so if URL is a PDF file then
Line 1,784 ⟶ 1,894:
max = tonumber (max); -- make it a number
if max >= count then -- if |display-xxxxors= value greater than or equal to number of authors/editors
table.insert( z.message_tail, {utilities.set_message ('err_disp_name', {param, max}, true)}); -- add error message
max = nil;
end
else -- not a valid keyword or number
table.insert( z.message_tail, {utilities.set_message ('err_disp_name', {param, max}, true)}); -- add error message
max = nil; -- unset; as if |display-xxxxors= had not been set
end
Line 1,813 ⟶ 1,923:
for _, pattern in ipairs (cfg.vol_iss_pg_patterns.bad_ppatterns) do -- spin through the selected sequence table of patterns
if val:match (pattern) then -- when a match, error so
table.insert (z.message_tail, {utilities.set_message ('err_extra_text_pages', {name}, true)}); -- add error message
return; -- and done
end
Line 1,856 ⟶ 1,966:
for _, pattern in ipairs (patterns) do -- spin through the selected sequence table of patterns
if val:match (pattern) then -- when a match, error so
table.insert (z.message_tail, {utilities.set_message (handler, {name}, true)}); -- add error message
return; -- and done
end
Line 2,028 ⟶ 2,138:
err_name = 'editor';
end
table.insert( z.message_tail, { utilities.set_message ( 'err_redundant_parameters', err_name .. '-name-list parameters'); -- add error message
{err_name .. '-name-list parameters'}, true ) } ); -- add error message
end
 
Line 2,046 ⟶ 2,155:
of the list of allowed values returns the translated value; else, emits an error message and returns the value
specified by ret_val.
 
TODO: explain <invert>
 
]]
 
local function is_valid_parameter_value (value, name, possible, ret_val, invert)
if not utilities.is_set (value) then
return ret_val; -- an empty parameter is ok
end
elseif utilities.in_array (value, possible) then
 
if (not invert and utilities.in_array (value, possible)) then -- normal; <value> is in <possible> table
return cfg.keywords_xlate[value]; -- return translation of parameter keyword
elseif invert and not utilities.in_array (value, possible) then -- invert; <value> is not in <possible> table
return value; -- return <value> as it is
else
table.insert( z.message_tail, { utilities.set_message ( 'err_invalid_param_val', {name, value}, true ) } ); -- not an allowed value so add error message
return ret_val;
end
Line 2,081 ⟶ 2,196:
 
 
--[[-------------------------< F O R M A T _ V O L U M E _ I S S U E >-----------------------------------------
 
returns the concatenation of the formatted volume and issue parameters(or asjournal aarticle singlenumber) string;parameters oras formatteda volumesingle
string; or formatted volume or formatted issue, or an empty string if neither are set.
 
]]
local function format_volume_issue (volume, issue, article, cite_class, origin, sepc, lower)
if not utilities.is_set (volume) and not utilities.is_set (issue) and not utilities.is_set (article) then
return '';
end
 
-- same condition as in format_pages_sheets()
local is_journal = 'journal' == cite_class or (utilities.in_array (cite_class, {'citation', 'map', 'interview'}) and 'journal' == origin);
 
local is_numeric_vol = volume and (volume:match ('^[MDCLXVI]+$') or volume:match ('^%d+$')); -- is only uppercase roman numerals or only digits?
local is_long_vol = volume and (4 < mw.ustring.len(volume)); -- is |volume= value longer than 4 characters?
if volume and (not is_numeric_vol and is_long_vol) then -- when not all digits or Roman numerals, is |volume= longer than 4 characters?
if 'magazine' == cite_class or (utilities.in_array (cite_class, {'citation', 'map'}) and 'magazine' == origin) then
if utilities.is_setadd_prop_cat (volume'long-vol'); -- andyes, utilities.is_setadd (issue)properties thencat
return wrap_msg ('vol-no', {sepc, hyphen_to_dash (volume), issue}, lower);
elseif utilities.is_set (volume) then
return wrap_msg ('vol', {sepc, hyphen_to_dash (volume)}, lower);
else
return wrap_msg ('issue', {sepc, issue}, lower);
end
end
 
if is_journal then -- journal-style formatting
local vol = '';
 
if utilities.is_set (volume) then
if is_numeric_vol then -- |volume= value all digits or all uppercase Roman numerals?
vol = utilities.substitute (cfg.presentation['vol-bold'], {sepc, volume}); -- render in bold face
elseif is_long_vol then -- not all digits or Roman numerals; longer than 4 characters?
vol = utilities.substitute (cfg.messages['j-vol'], {sepc, utilities.hyphen_to_dash (volume)}); -- not bold
else -- four or fewer characters
vol = utilities.substitute (cfg.presentation['vol-bold'], {sepc, utilities.hyphen_to_dash (volume)}); -- bold
end
end
vol = vol .. (utilities.is_set (issue) and utilities.substitute (cfg.messages['j-issue'], issue) or '')
vol = vol .. (utilities.is_set (article) and utilities.substitute (cfg.messages['j-article-num'], article) or '')
return vol;
end
if 'podcast' == cite_class and utilities.is_set (issue) then
return wrap_msg ('issue', {sepc, issue}, lower);
end
 
if 'conference' == cite_class and utilities.is_set (article) then -- |article-number= supported only in journal and conference cites
local vol = ''; -- here for all cites except magazine
if utilities.is_set (volume) and utilities.is_set (article) then -- both volume and article number
if return wrap_msg ('vol-art', {sepc, utilities.is_sethyphen_to_dash (volume), thenarticle}, lower);
elseif utilities.is_set (article) then -- article number alone; when volume alone, handled below
if volume:match ('^[MDCLXVI]+$') or volume:match ('^%d+$') then -- volume value is all digits or all uppercase Roman numerals
return wrap_msg ('art', {sepc, article}, lower);
vol = utilities.substitute (cfg.presentation['vol-bold'], {sepc, volume}); -- render in bold face
elseif (4 < mw.ustring.len(volume)) then -- not all digits or Roman numerals and longer than 4 characters
vol = utilities.substitute (cfg.messages['j-vol'], {sepc, hyphen_to_dash (volume)}); -- not bold
utilities.add_prop_cat ('long_vol');
else -- four or less characters
vol = utilities.substitute (cfg.presentation['vol-bold'], {sepc, hyphen_to_dash (volume)}); -- bold
end
end
 
if utilities.is_set (issue) then
-- all other types of citation
return vol .. utilities.substitute (cfg.messages['j-issue'], issue);
if utilities.is_set (volume) and utilities.is_set (issue) then
return wrap_msg ('vol-no', {sepc, utilities.hyphen_to_dash (volume), issue}, lower);
elseif utilities.is_set (volume) then
return wrap_msg ('vol', {sepc, utilities.hyphen_to_dash (volume)}, lower);
else
return wrap_msg ('issue', {sepc, issue}, lower);
end
return vol;
end
 
Line 2,243 ⟶ 2,375:
if utilities.is_set (archive) then
if archive == url or archive == c_url then
table.insert (z.message_tail, {utilities.set_message ('err_bad_url', {utilities.wrap_style ('parameter', source)}, true)}); -- add error message
return '', ''; -- unset |archive-url= and |archive-date= because same as |url= or |chapter-url=
end
Line 2,300 ⟶ 2,432:
else
path, timestamp, flag = url:match('//web%.archive%.org/([^%d]*)(%d+)([^/]*)/'); -- split out some of the URL parts for evaluation
if not path then -- malformed in some way; pattern did not match
err_msg = cfg.err_msg_supl.timestamp;
if not utilities.is_set (timestamp) or 14 ~= timestamp:len() then -- path and flag optional, must have 14-digit timestamp here
elseif 14 ~= timestamp:len() then -- path and flag optional, must have 14-digit timestamp here
err_msg = cfg.err_msg_supl.timestamp;
if '*' ~= flag then
urllocal replacement =url timestamp:gsubmatch ('(//web%.archive%.org/[^%d]*%d?%d?%d?%d?%d?%d?)[^/]*',) or timestamp:match ('^%1*d%d%d%d', 1); -- forget preview,the modifyfirst ts6 to(YYYYMM) beor yearmo*first max (0-64 digits plus splat(YYYY)
if replacement then -- nil if there aren't at least 4 digits (year)
replacement = replacement .. string.rep ('0', 14 - replacement:len()); -- year or yearmo (4 or 6 digits) zero-fill to make 14-digit timestamp
url=url:gsub ('(//web%.archive%.org/[^%d]*)%d[^/]*', '%1' .. replacement .. '*', 1) -- for preview, modify ts to 14 digits plus splat for calendar display
end
end
elseif utilities.is_set (path) and 'web/' ~= path then -- older archive URLs do not have the extra 'web/' path element
Line 2,317 ⟶ 2,454:
end
-- if here, something not right so
table.insert( z.message_tail, { utilities.set_message ( 'err_archive_url', {err_msg}, true ) } ); -- add error message and
 
if utilities.is_set (Frame:preprocess('{{REVISIONID}}')) then
if is_preview_mode then
return '', ''; -- return empty strings for ArchiveURL and ArchiveDate
else
return url, date; -- preview mode so return ArchiveURL and ArchiveDate
else
return '', ''; -- return empty strings for ArchiveURL and ArchiveDate
end
end
Line 2,345 ⟶ 2,483:
return param_val; -- and done
end
 
 
--[[--------------------------< I S _ G E N E R I C _ T I T L E >----------------------------------------------
 
compares |title= value against list of known generic title patterns. Returns true when pattern matches; nil else
 
the k/v pairs in 'generic_titles' each contain two tables, one for English and one for another 'local' language
Each of those tables contain another table that holds the string or pattern (whole title or title fragment) in
index [1]. index [2] is a Boolean that tells string.find() or mw.ustring.find() to do plain-text search (true)
or a pattern search (false). The intent of all this complexity is to make these searches as fast as possible so
that we don't run out of processing time on very large articles.
 
]]
 
local function is_generic_title (title)
title = mw.ustring.lower(title); -- switch title to lower case
for _, generic_title in ipairs (cfg.special_case_translation['generic_titles']) do -- spin through the list of known generic title fragments
if title:find (generic_title['en'][1], 1, generic_title['en'][2]) then
return true; -- found English generic title so done
elseif generic_title['local'] then -- to keep work load down, generic_title['local'] should be nil except when there is a local version of the generic title
if mw.ustring.find (title, generic_title['local'][1], 1, generic_title['local'][2]) then -- mw.ustring() because might not be Latin script
return true; -- found local generic title so done
end
end
end
end
 
Line 2,459 ⟶ 2,571:
if 0 < #c then
if not utilities.is_set (Contribution) then -- |contributor= requires |contribution=
table.insert( z.message_tail, { utilities.set_message ( 'err_contributor_missing_required_param', 'contribution')}); -- add missing contribution error message
c = {}; -- blank the contributors' table; it is used as a flag later
end
if 0 == #a then -- |contributor= requires |author=
table.insert( z.message_tail, { utilities.set_message ( 'err_contributor_missing_required_param', 'author')}); -- add missing author error message
c = {}; -- blank the contributors' table; it is used as a flag later
end
Line 2,469 ⟶ 2,581:
else -- if not a book cite
if utilities.select_one (args, cfg.aliases['ContributorList-Last'], 'err_redundant_parameters', 1 ) then -- are there contributor name list parameters?
table.insert( z.message_tail, { utilities.set_message ( 'err_contributor_ignored')}); -- add contributor ignored error message
end
Contribution = nil; -- unset
Line 2,479 ⟶ 2,591:
local auto_select = ''; -- default is auto
local accept_link;
TitleLink, accept_link = utilities.has_accept_as_written (TitleLink, true); -- test for accept-this-as-written markup
if (not accept_link) and utilities.in_array (TitleLink, {'none', 'pmc', 'doi'}) then -- check for special keywords
auto_select = TitleLink; -- remember selection for later
Line 2,500 ⟶ 2,612:
Periodical, i = utilities.strip_apostrophe_markup (Periodical); -- strip apostrophe markup so that metadata isn't contaminated
if i then -- non-zero when markup was stripped so emit an error message
table.insert( z.message_tail, {utilities.set_message ('err_apostrophe_markup', {Periodical_origin}, true)});
end
end
 
if 'mailinglist' == config.CitationClass then -- special case for {{cite mailing list}}
if utilities.is_set (Periodical) and utilities.is_set (A ['MailingList']) then -- both set emit an error TODO: make a function for this and similar?
table.insert( z.message_tail, {utilities.set_message ('err_redundant_parameters', {utilities.wrap_style ('parameter', Periodical_origin) .. cfg.presentation[' and sep_list_pair'] .. utilities.wrap_style ('parameter', 'mailinglist')}, true )});
end
 
Line 2,521 ⟶ 2,633:
local p = {['journal'] = 'journal', ['magazine'] = 'magazine'}; -- for error message
if p[config.CitationClass] then
table.insert( z.message_tail, {utilities.set_message ('err_missing_periodical', {config.CitationClass, p[config.CitationClass]}, true)});
end
end
Line 2,529 ⟶ 2,641:
if 'citation' == config.CitationClass then
if utilities.is_set (Periodical) then
if not utilities.in_array (Periodical_origin, {'website', 'mailinglist'}cfg.citation_no_volume_t) then -- {{citation}} does not render |volume= forwhen these 'periodicals'parameters are used
Volume = A['Volume']; -- but does for all other 'periodicals'
end
Line 2,546 ⟶ 2,658:
local Issue;
if 'citation' == config.CitationClass then
if utilities.is_set (Periodical) and utilities.in_array (Periodical_origin, {'journal', 'magazine', 'newspaper', 'periodical', 'work'}cfg.citation_issue_t) orthen -- {{citation}} rendersmay render |issue= forwhen these 'periodicals'parameters are used
Issue = utilities.hyphen_to_dash (A['Issue']);
utilities.is_set (ScriptPeriodical) and utilities.in_array (ScriptPeriodical_origin, {'script-journal', 'script-magazine', 'script-newspaper', 'script-periodical', 'script-work'}) then -- and these 'script-periodicals'
Issue = hyphen_to_dash (A['Issue']);
end
elseif utilities.in_array (config.CitationClass, cfg.templates_using_issue) then -- conference & map books do not support issue; {{citation}} listed here because included in settings table
if not (utilities.in_array (config.CitationClass, {'conference', 'map', 'citation'}) and not (utilities.is_set (Periodical) or utilities.is_set (ScriptPeriodical))) then
Issue = utilities.hyphen_to_dash (A['Issue']);
end
end
local ArticleNumber;
 
if utilities.in_array (config.CitationClass, {'journal', 'conference'}) or ('citation' == config.CitationClass and utilities.is_set (Periodical) and 'journal' == Periodical_origin) then
ArticleNumber = A['ArticleNumber'];
end
 
extra_text_in_vol_iss_check (Issue, A:ORIGIN ('Issue'), 'i');
 
Line 2,560 ⟶ 2,678:
local Pages;
local At;
local QuotePage;
if not utilities.in_array (config.CitationClass, cfg.templates_not_using_page) then
local QuotePages;
if not utilities.in_array (config.CitationClass, cfg.templates_not_using_page) then -- TODO: rewrite to emit ignored parameter error message?
Page = A['Page'];
Pages = utilities.hyphen_to_dash (A['Pages']);
At = A['At'];
QuotePage = A['QuotePage'];
QuotePages = utilities.hyphen_to_dash (A['QuotePages']);
end
 
Line 2,576 ⟶ 2,698:
PublisherName, i = utilities.strip_apostrophe_markup (PublisherName); -- strip apostrophe markup so that metadata isn't contaminated; publisher is never italicized
if i then -- non-zero when markup was stripped so emit an error message
table.insert( z.message_tail, {utilities.set_message ('err_apostrophe_markup', {PublisherName_origin}, true)});
end
end
Line 2,585 ⟶ 2,707:
if 'newsgroup' == config.CitationClass then
if utilities.is_set (PublisherName) then -- general use parameter |publisher= not allowed in cite newsgroup
local error_text, error_state = utilities.set_message ('err_parameter_ignored', {PublisherName_origin}, true);
if utilities.is_set (error_text) then
table.insert( z.message_tail, {error_text, error_state} );
end
end
 
Line 2,594 ⟶ 2,713:
end
 
local URL = A['URL']; -- TODO: better way to do this for URL, ChapterURL, and MapURL?
local UrlAccess = is_valid_parameter_value (A['UrlAccess'], A:ORIGIN('UrlAccess'), cfg.keywords_lists['url-access'], nil);
if not utilities.is_set (URL) and utilities.is_set (UrlAccess) then
UrlAccess = nil;
table.insert( z.message_tail, { utilities.set_message ( 'err_param_access_requires_param', {'url'}, true ) } );
end
Line 2,606 ⟶ 2,725:
if not utilities.is_set (ChapterURL) and utilities.is_set (ChapterUrlAccess) then
ChapterUrlAccess = nil;
table.insert( z.message_tail, { utilities.set_message ( 'err_param_access_requires_param', {A:ORIGIN('ChapterUrlAccess'):gsub ('%-access', '')}, true ) } );
end
 
Line 2,612 ⟶ 2,731:
if not utilities.is_set (A['MapURL']) and utilities.is_set (MapUrlAccess) then
MapUrlAccess = nil;
table.insert( z.message_tail, { utilities.set_message ( 'err_param_access_requires_param', {'map-url'}, true ) } );
end
 
Line 2,620 ⟶ 2,739:
-- check this page to see if it is in one of the namespaces that cs1 is not supposed to add to the error categories
if not utilities.is_set (no_tracking_cats) then -- ignore if we are already not going to categorize this page
if cfg.uncategorized_namespaces[this_page.namespace] then -- is this page's namespace id one of the uncategorized namespace ids?
if utilities.in_array (this_page.nsText, cfg.uncategorized_namespaces) then
no_tracking_cats = "true"; -- set no_tracking_cats
end
Line 2,640 ⟶ 2,759:
 
if utilities.is_set (PublicationPlace) and utilities.is_set (Place) then -- both |publication-place= and |place= (|location=) allowed if different
utilities.add_prop_cat ('location -test'); -- add property cat to evaluate how often PublicationPlace and Place are used together
if PublicationPlace == Place then
Place = ''; -- unset; don't need both if they are the same
Line 2,678 ⟶ 2,797:
if utilities.is_set (Encyclopedia) then -- emit error message when Encyclopedia set but template is other than {{cite encyclopedia}} or {{citation}}
if 'encyclopaedia' ~= config.CitationClass and 'citation' ~= config.CitationClass then
table.insert (z.message_tail, {utilities.set_message ('err_parameter_ignored', {A:ORIGIN ('Encyclopedia')}, true)});
Encyclopedia = nil; -- unset because not supported by this template
end
Line 2,684 ⟶ 2,803:
 
if ('encyclopaedia' == config.CitationClass) or ('citation' == config.CitationClass and utilities.is_set (Encyclopedia)) then
if utilities.is_set (Periodical) and utilities.is_set (Encyclopedia) then -- when both set emit an error TODO: make a function for this and similar?
table.insert (z.message_tail, {utilities.set_message ('err_redundant_parameters', {utilities.wrap_style ('parameter', A:ORIGIN ('Encyclopedia')) .. cfg.presentation[' and sep_list_pair'] .. utilities.wrap_style ('parameter', Periodical_origin)}, true )});
end
 
Line 2,717 ⟶ 2,836:
ScriptTitle = '';
end
elseif utilities.is_set (Chapter) or utilities.is_set (ScriptChapter) then -- |title= not set
Title = Periodical; -- |encyclopedia= set and |article= set so map |encyclopedia= to |title=
Periodical = ''; -- redundant so unset
Line 2,731 ⟶ 2,850:
ID = A['Number']; -- yes, use it
else -- ID has a value so emit error message
table.insert( z.message_tail, { utilities.set_message ('err_redundant_parameters', {utilities.wrap_style ('parameter', 'id') .. cfg.presentation[' and sep_list_pair'] .. utilities.wrap_style ('parameter', 'number')}, true )});
end
end
Line 2,776 ⟶ 2,895:
local Sheets = A['Sheets'] or '';
if config.CitationClass == "map" then
if utilities.is_set (Chapter) then --TODO: make a function for this and similar?
table.insert( z.message_tail, { utilities.set_message ( 'err_redundant_parameters', {utilities.wrap_style ('parameter', 'map') .. cfg.presentation[' and sep_list_pair'] .. utilities.wrap_style ('parameter', Chapter_origin)}, true ) } ); -- add error message
end
Chapter = A['Map'];
Line 2,819 ⟶ 2,938:
local SeriesNumber = A['SeriesNumber'];
 
if utilities.is_set (Season) and utilities.is_set (SeriesNumber) then -- these are mutually exclusive so if both are set TODO: make a function for this and similar?
table.insert( z.message_tail, { utilities.set_message ( 'err_redundant_parameters', {utilities.wrap_style ('parameter', 'season') .. cfg.presentation[' and sep_list_pair'] .. utilities.wrap_style ('parameter', 'seriesno')}, true ) } ); -- add error message
SeriesNumber = ''; -- unset; prefer |season= over |seriesno=
end
Line 2,837 ⟶ 2,956:
ChapterUrlAccess = UrlAccess;
ChapterURL_origin = URL_origin;
ChapterFormat = Format;
 
Title = Series; -- promote series to title
TitleLink = SeriesLink;
Line 2,850 ⟶ 2,970:
TransTitle = '';
ScriptTitle = '';
Format = '';
else -- now oddities that are cite serial
Line 2,865 ⟶ 2,986:
local TitleType = A['TitleType'];
local Degree = A['Degree'];
if utilities.in_array (config.CitationClass, {"'AV-media-notes"', "'interview"', "'mailinglist"', "'map"', "'podcast"', "'pressrelease"', "'report"', "'speech', 'techreport"', "'thesis"'}) then
TitleType = set_titletype (config.CitationClass, TitleType);
if utilities.is_set (Degree) and "Thesis" == TitleType then -- special case for cite thesis
Line 2,946 ⟶ 3,067:
-- start temporary Julian / Gregorian calendar uncertainty categorization
if COinS_date.inter_cal_cat then
utilities.add_prop_cat ('jul_greg_uncertaintyjul-greg-uncertainty');
end
-- end temporary Julian / Gregorian calendar uncertainty categorization
Line 2,957 ⟶ 3,078:
local modified = false; -- flag
if validation.edtf_transform (date_parameters_list) then -- edtf dates to MOS compliant format
modified = true;
end
 
if utilities.is_set (DF) then -- if we need to reformat dates
modified = validation.reformat_dates (date_parameters_list, DF); -- reformat to DF format, use long month names if appropriate
Line 2,970 ⟶ 3,087:
end
-- for those wikis that can and want to have English date names translated to the local language,; not supported at en.wiki
if cfg.date_name_auto_xlate_enable and validation.date_name_xlate (date_parameters_list, cfg.date_digit_auto_xlate_enable ) then
-- uncomment the next three lines. Not supported by en.wiki (for obvious reasons)
utilities.set_message ('maint_date_auto_xlated'); -- add maint cat
-- set validation.date_name_xlate() second argument to true to translate English digits to local digits (will translate ymd dates)
modified = true;
-- if validation.date_name_xlate (date_parameters_list, false) then
end
-- modified = true;
-- end
 
if modified then -- if the date_parameters_list values were modified
Line 2,986 ⟶ 3,102:
end
else
table.insert (z.message_tail, {utilities.set_message ('err_bad_date', {utilities.make_sep_list (#error_list, error_list)}, true)}); -- add this error message
end
end -- end of do
Line 3,003 ⟶ 3,119:
 
-- Account for the oddities that are {{cite arxiv}}, {{cite biorxiv}}, {{cite citeseerx}}, {{cite ssrn}}, before generation of COinS data.
if utilities.in_array (config.CitationClass, whitelist.preprint_template_list) then -- |arxiv= or |eprint= required for cite arxiv; |biorxiv=, |citeseerx=, |ssrn= required for their templates
if not utilities(args[cfg.is_set (ID_list_coinsid_handlers[config.CitationClass:upper()]).parameters[1]] thenor -- |arxiv=can't oruse |eprint= required for cite arxiv;ID_list_coins |biorxiv=k/v &table |citeseerx=here requiredbecause forinvalid theirparameters templatesomitted
args[cfg.id_handlers[config.CitationClass:upper()].parameters[2]]) then -- which causes unexpected parameter missing error message
table.insert (z.message_tail, {utilities.set_message ('err_' .. config.CitationClass .. '_missing', {}, true)}); -- add error message
utilities.set_message ('err_' .. config.CitationClass .. '_missing'); -- add error message
end
 
Line 3,027 ⟶ 3,144:
end
 
if utilities.is_set (URL) and utilities.is_set (AccessDate) then -- accessset datewhen requiresusing |url=;an identifier-created URL is not |url=
if utilities.is_set (AccessDate) then -- |access-date= requires |url=; identifier-created URL is not |url=
table.insert( z.message_tail, { utilities.set_message ( 'err_accessdate_missing_url', {}, true ) } ); -- add an error message
utilities.set_message ('err_accessdate_missing_url'); -- add an error message
AccessDate = ''; -- unset
AccessDate = ''; -- unset
end
 
if utilities.is_set (ArchiveURL) then -- |archive-url= requires |url=; identifier-created URL is not |url=
utilities.set_message ('err_archive_missing_url'); -- add an error message
ArchiveURL = ''; -- unset
end
end
end
Line 3,036 ⟶ 3,160:
-- Test if citation has no title
if not utilities.is_set (Title) and not utilities.is_set (TransTitle) and not utilities.is_set (ScriptTitle) then -- has special case for cite episode
table.insert( z.message_tail, { utilities.set_message ( 'err_citation_missing_title', {'episode' == config.CitationClass and 'series' or 'title'}, true ) } );
end
 
Line 3,046 ⟶ 3,170:
utilities.set_message ('maint_untitled'); -- add maint cat
end
 
check_for_url ({ -- add error message when any of these parameters hold a URL
['title'] = Title,
[A:ORIGIN('Chapter')] = Chapter,
[Periodical_origin] = Periodical,
[PublisherName_origin] = PublisherName
});
 
-- COinS metadata (see <http://ocoins.info/>) for automated parsing of citation information.
Line 3,072 ⟶ 3,189:
end
local QuotePage = A['QuotePage'];
local QuotePages = hyphen_to_dash (A['QuotePages']);
 
-- this is the function call to COinS()
local OCinSoutput = metadata.COinS({
['Periodical'] = utilities.strip_apostrophe_markup (Periodical), -- no markup in the metadata
['Encyclopedia'] = Encyclopedia, -- just a flag; content ignored by ~/COinS
['Chapter'] = metadata.make_coins_title (coins_chapter, ScriptChapter), -- Chapter and ScriptChapter stripped of bold / italic wiki/ accept-as-written markup
['Degree'] = Degree; -- cite thesis only
['Title'] = metadata.make_coins_title (coins_title, ScriptTitle), -- Title and ScriptTitle stripped of bold / italic wiki/ accept-as-written markup
['PublicationPlace'] = PublicationPlace,
['Date'] = COinS_date.rftdate, -- COinS_date has correctly formatted date if Date is valid;
Line 3,090 ⟶ 3,204:
['Volume'] = Volume,
['Issue'] = Issue,
['ArticleNumber'] = ArticleNumber,
['Pages'] = coins_pages or metadata.get_coins_pages (first_set ({Sheet, Sheets, Page, Pages, At, QuotePage, QuotePages}, 7)), -- pages stripped of external links
['Edition'] = Edition,
Line 3,188 ⟶ 3,303:
if utilities.in_array (config.CitationClass, {"web", "podcast", "mailinglist"}) or -- |url= required for cite web, cite podcast, and cite mailinglist
('citation' == config.CitationClass and ('website' == Periodical_origin or 'script-website' == ScriptPeriodical_origin)) then -- and required for {{citation}} with |website= or |script-website=
table.insert( z.message_tail, { utilities.set_message ( 'err_cite_web_url', {}, true ) } );
end
-- do we have |accessdate= without either |url= or |chapter-url=?
if utilities.is_set (AccessDate) and not utilities.is_set (ChapterURL) then -- ChapterURL may be set when URL is not set;
table.insert( z.message_tail, { utilities.set_message ( 'err_accessdate_missing_url', {}, true ) } );
AccessDate = '';
end
Line 3,228 ⟶ 3,343:
UrlAccess = nil; -- restricted access levels do not make sense for archived URLs
end
end
elseif utilities.is_set (UrlStatus) then -- if |url-status= is set when |archive-url= is not set
utilities.set_message ('maint_url_status'); -- add maint cat
end
 
Line 3,247 ⟶ 3,364:
 
if utilities.is_set (chap_param) then -- if we found one
table.insert( z.message_tail, { utilities.set_message ( 'err_chapter_ignored', {chap_param}, true ) } ); -- add error message
Chapter = ''; -- and set them to empty string to be safe with concatenation
TransChapter = '';
Line 3,287 ⟶ 3,404:
end
 
if not accept_title then -- <Title> not wrapped in accept-as-written markup
if '...' == Title:sub (-3) then -- if ellipsis is the last three characters of |title=
Title = Title:gsub ('(%.%.%.)%.+$', '%1'); -- limit the number of dots to three
Line 3,299 ⟶ 3,416:
end
 
if is_generic_titleis_generic ('generic_titles', Title) then
table.insert (z.message_tail, {utilities.set_message ( 'err_generic_title', {}, true ) } ); -- set an error message
end
end
Line 3,311 ⟶ 3,428:
Title = script_concatenate (Title, ScriptTitle, 'script-title'); -- <bdi> tags, lang attribute, categorization, etc.; must be done after title is wrapped
TransTitle = utilities.wrap_style ('trans-quoted-title', TransTitle );
elseif plain_title or ('report' == config.CitationClass) then -- no styling for cite report and descriptive titles (otherwise same as above)
Title = script_concatenate (Title, ScriptTitle, 'script-title'); -- <bdi> tags, lang attribute, categorization, etc.; must be done after title is wrapped
TransTitle = utilities.wrap_style ('trans-quoted-title', TransTitle ); -- for cite report, use this form for trans-title
else
Title = utilities.wrap_style ('italic-title', Title);
Line 3,320 ⟶ 3,437:
end
 
local TransError = "";
if utilities.is_set (TransTitle) then
if utilities.is_set (Title) then
TransTitle = " " .. TransTitle;
else
TransError = " " .. utilities.set_message ( 'err_trans_missing_title', {'title'} );
end
end
Line 3,331 ⟶ 3,447:
if utilities.is_set (Title) then -- TODO: is this the right place to be making Wikisource URLs?
if utilities.is_set (TitleLink) and utilities.is_set (URL) then
table.insert( z.message_tail, { utilities.set_message ( 'err_wikilink_in_url', {}, true ) } ); -- set an error message because we can't have both
TitleLink = ''; -- unset
end
if not utilities.is_set (TitleLink) and utilities.is_set (URL) then
Title = external_link (URL, Title, URL_origin, UrlAccess) .. TransTitle .. TransError .. Format;
URL = ''; -- unset these because no longer needed
Format = "";
Line 3,345 ⟶ 3,461:
Title = external_link (ws_url, Title .. '&nbsp;', 'ws link in title-link'); -- space char after Title to move icon away from italic text; TODO: a better way to do this?
Title = utilities.substitute (cfg.presentation['interwiki-icon'], {cfg.presentation['class-wikisource'], TitleLink, Title});
Title = Title .. TransTitle .. TransError;
else
Title = utilities.make_wikilink (TitleLink, Title) .. TransTitle .. TransError;
end
else
Line 3,356 ⟶ 3,472:
Title = external_link (ws_url, Title .. '&nbsp;', 'ws link in title'); -- space char after Title to move icon away from italic text; TODO: a better way to do this?
Title = utilities.substitute (cfg.presentation['interwiki-icon'], {cfg.presentation['class-wikisource'], L, Title});
Title = Title .. TransTitle .. TransError;
else
Title = Title .. TransTitle .. TransError;
end
end
else
Title = TransTitle .. TransError;
end
 
Line 3,385 ⟶ 3,501:
 
if utilities.is_set (Minutes) then
if utilities.is_set (Time) then --TODO: make a function for this and similar?
table.insert( z.message_tail, { utilities.set_message ( 'err_redundant_parameters', {utilities.wrap_style ('parameter', 'minutes') .. cfg.presentation[' and sep_list_pair'] .. utilities.wrap_style ('parameter', 'time')}, true ) } );
end
Position = " " .. Minutes .. " " .. cfg.messages['minutes'];
Line 3,448 ⟶ 3,564:
if utilities.is_set (Edition) then
if Edition:match ('%f[%a][Ee]d%n?%.?$') or Edition:match ('%f[%a][Ee]dition$') then -- Ed, ed, Ed., ed., Edn, edn, Edn., edn.
table.insert( z.message_tail, { utilities.set_message ( 'err_extra_text_edition')}); -- add error message
end
Edition = " " .. wrap_msg ('edition', Edition);
Line 3,458 ⟶ 3,574:
local Agency = A['Agency'];
Agency = utilities.is_set (Agency) and wrap_msg ('agency', {sepc, Agency}) or "";
Volume = format_volume_issue (Volume, Issue, ArticleNumber, config.CitationClass, Periodical_origin, sepc, use_lowercase);
 
if utilities.is_set (AccessDate) then
Line 3,494 ⟶ 3,610:
end
end
 
Quote = kern_quotes (Quote); -- kern if needed
Quote = utilities.wrap_style ('quoted-text', Quote ); -- wrap in <q>...</q> tags
Line 3,542 ⟶ 3,659:
-- TODO: Should we check a specific pattern?
if utilities.is_set(PostScript) and mw.ustring.len(PostScript) > 1 then
utilities.set_message ('maint_postscript')
end
local Archived;
if utilities.is_set (ArchiveURL) then
local arch_text;
if not utilities.is_set (ArchiveDate) then
ArchiveDate = utilities.set_message ('err_archive_missing_date');
ArchiveDate = ''; -- empty string for concatenation
end
if "live" == UrlStatus then
arch_text = cfg.messages['archived'];
if sepc ~= "." then arch_text = arch_text:lower() end
if utilities.is_set (ArchiveDate) then
Archived = sepc .. " " .. utilities.substitute ( cfg.messages['archived-live'],
Archived = sepc .. ' ' .. utilities.substitute ( cfg.messages['archived-live'],
{ external_link( ArchiveURL, arch_text, A:ORIGIN('ArchiveURL'), nil ) .. ArchiveFormat, ArchiveDate } );
{external_link( ArchiveURL, arch_text, A:ORIGIN('ArchiveURL'), nil) .. ArchiveFormat, ArchiveDate } );
else
Archived = '';
end
if not utilities.is_set (OriginalURL) then
Archived = Archived .. " " .. utilities.set_message ('err_archive_missing_url');
Archived = ''; -- empty string for concatenation
end
elseif utilities.is_set (OriginalURL) then -- UrlStatus is empty, 'dead', 'unfit', 'usurped', 'bot: unknown'
Line 3,563 ⟶ 3,686:
arch_text = cfg.messages['archived-unfit'];
if sepc ~= "." then arch_text = arch_text:lower() end
Archived = sepc .. "' "' .. arch_text .. ArchiveDate; -- format already styled
if 'bot: unknown' == UrlStatus then
utilities.set_message ('maint_bot_unknown'); -- and add a category if not already added
Line 3,572 ⟶ 3,695:
arch_text = cfg.messages['archived-dead'];
if sepc ~= "." then arch_text = arch_text:lower() end
Archived = sepc .. " " ..if utilities.substituteis_set (ArchiveDate) arch_text,then
Archived = sepc .. " " .. utilities.substitute ( arch_text,
{ external_link( OriginalURL, cfg.messages['original'], OriginalURL_origin, OriginalAccess ) .. OriginalFormat, ArchiveDate } ); -- format already styled
{ external_link( OriginalURL, cfg.messages['original'], OriginalURL_origin, OriginalAccess ) .. OriginalFormat, ArchiveDate } ); -- format already styled
else
Archived = ''; -- unset for concatenation
end
end
else -- OriginalUrl not set
arch_text = cfg.messages['archived-missing'];
if sepc ~= "." then arch_text = arch_text:lower() end
utilities.set_message ('err_archive_missing_url');
Archived = sepc .. " " .. utilities.substitute ( arch_text,
Archived = ''; -- empty string for concatenation
{ utilities.set_message ('err_archive_missing_url'), ArchiveDate } );
end
elseif utilities.is_set (ArchiveFormat) then
Archived = ArchiveFormat; -- if set and ArchiveURL not set ArchiveFormat has error message
else
Archived = ""'';
end
Line 3,664 ⟶ 3,791:
]]
if "speech" == config.CitationClass then -- cite speech only
TitleNote = " (Speech)"TitleType; -- annotatemove TitleType to TitleNote so that it renders ahead theof citation|event=
TitleType = ''; -- and unset
 
if utilities.is_set (Periodical) then -- if Periodical, perhaps because of an included |website= or |journal= parameter
if utilities.is_set (Conference) then -- and if |event= is set
Line 3,680 ⟶ 3,809:
if utilities.in_array (config.CitationClass, {"journal", "citation"}) and utilities.is_set (Periodical) then
if not (utilities.is_set (Authors) or utilities.is_set (Editors)) then
Others = Others:gsub ('^' .. sepc .. ' ', ''); -- when no authors and no editors, strip leading sepc and space
end
if utilities.is_set (Others) then Others = safe_join ({Others, sepc .. " "}, sepc) end -- add terminal punctuation & space; check for dup sepc; TODO why do we need to do this here?
tcommon = safe_join( {Others, Title, TitleNote, Conference, Periodical, Format, TitleType, Series, Language, Edition, Publisher, Agency, Volume}, sepc );
Line 3,775 ⟶ 3,907:
if utilities.is_set (Date) then
if EditorCount <= 1 then
Editors = Editors .. ", "cfg.presentation['sep_name'] .. cfg.messages['editor'];
else
Editors = Editors .. ", "cfg.presentation['sep_name'] .. cfg.messages['editors'];
end
else
Line 3,803 ⟶ 3,935:
 
-- Now enclose the whole thing in a <cite> element
local optionsoptions_t = {};
options_t.class = cite_class_attribute_make (config.CitationClass, Mode);
 
if utilities.is_set (config.CitationClass) and config.CitationClass ~= "citation" then
local Ref = is_valid_parameter_value (A['Ref'], A:ORIGIN('Ref'), cfg.keywords_lists['ref'], nil, true); -- nil when |ref=harv; A['Ref'] else
options.class = string.format ('%s %s %s', 'citation', config.CitationClass, utilities.is_set (Mode) and Mode or 'cs1'); -- class=citation required for blue highlight when used with |ref=
else
options.class = string.format ('%s %s', 'citation', utilities.is_set (Mode) and Mode or 'cs2');
end
 
if 'none' ~= cfg.keywords_xlate[(Ref and Ref:lower()) or ''] then
local Ref = A['Ref'];
if local 'harv'namelist_t == Ref then {}; -- need toholds checkselected thiscontributor, beforeauthor, settingeditor toname defaultlist
utilities.set_message ('maint_ref_harv'); -- add maint cat to identify templates that have this now-extraneous param value
elseif not utilities.is_set (Ref) then
Ref = 'harv'; -- set as default when not set externally
end
if 'none' ~= cfg.keywords_xlate[Ref:lower()] then
local id = Ref
local namelist = {}; -- holds selected contributor, author, editor name list
local year = first_set ({Year, anchor_year}, 2); -- Year first for legacy citations and for YMD dates that require disambiguation
 
if #c > 0 then -- if there is a contributor list
namelistnamelist_t = c; -- select it
elseif #a > 0 then -- or an author list
namelistnamelist_t = a;
elseif #e > 0 then -- or an editor list
namelistnamelist_t = e;
end
local citeref_id;
if #namelistnamelist_t > 0 then -- if there are names in namelistnamelist_t
citeref_id = make_citeref_id (namelistnamelist_t, year); -- go make the CITEREF anchor
if mw.uri.anchorEncode (citeref_id) == ((Ref and mw.uri.anchorEncode (Ref)) or '') then -- Ref may already be encoded (by {{sfnref}}) so citeref_id must be encoded before comparison
utilities.set_message ('maint_ref_duplicates_default');
end
else
citeref_id = ''; -- unset
end
if citeref_idoptions_t.id == Ref thenor citeref_id;
utilities.set_message ('maint_ref_duplicates_default');
end
if 'harv' == Ref then
id = citeref_id
end
options.id = id;
end
 
if string.len (text:gsub("<span[^>/]*>(.-)</span>", "%1"):gsub("'%b<>"', ""'')) <= 2 then -- remove <span> tagshtml and other HTMLhtml-like markuptags; then get length of what remains;
z.error_cats_t = {}; -- blank the categories list
z.error_categories = {};
z.error_msgs_t = {}; -- blank the error messages list
text = utilities.set_message ('err_empty_citation');
OCinSoutput = nil; -- blank the metadata string
z.message_tail = {};
text = ''; -- blank the the citation
utilities.set_message ('err_empty_citation'); -- set empty citation message and category
end
local renderrender_t = {}; -- here we collect the final bits for concatenation into the rendered citation
 
if utilities.is_set (optionsoptions_t.id) then -- here we wrap the rendered citation in <cite ...>...</cite> tags
table.insert (renderrender_t, utilities.substitute (cfg.presentation['cite-id'], {mw.uri.anchorEncode(optionsoptions_t.id), mw.text.nowiki(optionsoptions_t.class), text})); -- when |ref= is set or when there is a namelist
else
table.insert (renderrender_t, utilities.substitute (cfg.presentation['cite'], {mw.text.nowiki(optionsoptions_t.class), text})); -- allwhen other|ref=none casesor when namelist_t empty and |ref= is missing or is empty
end
 
if OCinSoutput then -- blanked when citation is 'empty' so don't bother to add boilerplate metadata span
table.insert (render, utilities.substitute (cfg.presentation['ocins'], {OCinSoutput})); -- append metadata to the citation
table.insert (render_t, utilities.substitute (cfg.presentation['ocins'], OCinSoutput)); -- format and append metadata to the citation
end
 
local template_name = ('citation' == config.CitationClass) and 'citation' or 'cite ' .. (cfg.citation_class_map_t[config.CitationClass] or config.CitationClass);
if 0 ~= #z.message_tail then
local template_link = '[[Template:' .. template_name .. '|' .. template_name .. ']]';
table.insert (render, ' ');
local msg_prefix = '<code class="cs1-code">{{' .. template_link .. '}}</code>: ';
for i,v in ipairs( z.message_tail ) do
 
if utilities.is_set (v[1]) then
if i0 =~= #z.message_tailerror_msgs_t then
tablemw.insertaddWarning (render, utilities.error_commentsubstitute ( v[1]cfg.messages.warning_msg_e, v[2] template_link));
 
else
table.insert (render_t, ' '); -- insert a space between citation and its error messages
table.insert (render, utilities.error_comment ( v[1] .. "; ", v[2] ));
table.sort (z.error_msgs_t); -- sort the error messages list; sorting includes wrapping <span> and <code> tags; hidden-error sorts ahead of visible-error
end
 
local hidden = true; -- presume that the only error messages emited by this template are hidden
for _, v in ipairs (z.error_msgs_t) do -- spin through the list of error messages
if v:find ('cs1-visible-error', 1, true) then -- look for the visible error class name
hidden = false; -- found one; so don't hide the error message prefix
break; -- and done because no need to look further
end
end
 
z.error_msgs_t[1] = table.concat ({utilities.error_comment (msg_prefix, hidden), z.error_msgs_t[1]}); -- add error message prefix to first error message to prevent extraneous punctuation
table.insert (render_t, table.concat (z.error_msgs_t, '; ')); -- make a big string of error messages and add it to the rendering
end
 
if 0 ~= #z.maintenance_catsmaint_cats_t then
mw.addWarning (utilities.substitute (cfg.messages.warning_msg_m, template_link));
local maint_msgs = {}; -- here we collect all of the maint messages
 
for _, v in ipairs( z.maintenance_cats ) do -- append maintenance categories
local maint =table.sort {}(z.maint_cats_t); -- here wesort assemblethe amaintenance maintenencemessages messagelist
 
table.insert (maint, v); -- maint msg is the category name
table.insertlocal (maint,maint_msgs_t '= ('){}; -- openhere we collect all of the linkmaint textmessages
 
table.insert (maint, utilities.substitute (cfg.messages[':cat wikilink'], {v})); -- add the link
table.insertif (maint,0 ')');== #z.error_msgs_t then -- andif no closeerror itmessages
table.insert (maint_msgsmaint_msgs_t, table.concat (maint)msg_prefix); -- assemble new maintinsert message andprefix addin itmaint to the maint_msgsmessage tablelivery
end
table.insert (render, utilities.substitute (cfg.presentation['hidden-maint'], table.concat (maint_msgs, ' '))); -- wrap the group of maint message with proper presentation and save
for _, v in ipairs( z.maint_cats_t ) do -- append maintenance categories
table.insert (maint_msgs_t, -- assemble new maint message and add it to the maint_msgs_t table
table.concat ({v, ' (', utilities.substitute (cfg.messages[':cat wikilink'], v), ')'})
);
end
table.insert (render_t, utilities.substitute (cfg.presentation['hidden-maint'], table.concat (maint_msgs_t, ' '))); -- wrap the group of maint messages with proper presentation and save
end
 
if not no_tracking_cats then
for _, v in ipairs ( z.error_categories error_cats_t) do -- append error categories
table.insert (renderrender_t, utilities.substitute (cfg.messages['cat wikilink'], {v}));
end
for _, v in ipairs ( z.maintenance_cats maint_cats_t) do -- append maintenance categories
table.insert (renderrender_t, utilities.substitute (cfg.messages['cat wikilink'], {v}));
end
for _, v in ipairs ( z.properties_cats prop_cats_t) do -- append properties categories
table.insert (renderrender_t, utilities.substitute (cfg.messages['cat wikilink'], {v}));
end
end
 
return table.concat (renderrender_t); -- make a big string and done
end
 
Line 3,924 ⟶ 4,062:
return true;
end
if 'discouragedtracked' == state then
discouraged_parameterlocal base_name = (name:gsub ('%d', ''); -- strip enumerators from parameter isnames discouragedthat buthave stillthem supportedto get the base name
utilities.add_prop_cat ('tracked-param', {base_name}, base_name); -- add a properties category; <base_name> modifies <key>
return true;
end
Line 3,983 ⟶ 4,122:
if prefix and cfg.inter_wiki_map[prefix:lower()] then -- if prefix is in the map, needs preceding colon so
table.insert( z.message_tail, {utilities.set_message ('err_bad_paramlink', parameter)}); -- emit an error message
_, value, _ = utilities.is_wikilink (value); -- extract label portion from wikilink
end
Line 4,010 ⟶ 4,149:
capture = value:match ('%s+(%a[%w%-]+)%s*=') or value:match ('^(%a[%w%-]+)%s*='); -- find and categorize parameters with possible missing pipes
if capture and validate (capture) then -- if the capture is a valid parameter name
table.insert( z.message_tail, {utilities.set_message ('err_missing_pipe', parameter)});
end
end
Line 4,033 ⟶ 4,172:
if value:match ('[,;:]$') then
utilities.set_message ('maint_extra_punct'); -- has extraneous punctuation; add maint cat
end
if value:match ('^=') then -- sometimes an extraneous '=' character appears ...
utilities.set_message ('maint_extra_punct'); -- has extraneous punctuation; add maint cat
end
end
 
 
--[[--------------------------< H A S _ E X T R A N E O U S _ U R L >------------------------------------------
 
look for extraneous url parameter values; parameters listed in skip table are not checked
 
]]
 
local function has_extraneous_url (url_param_t)
local url_error_t = {};
check_for_url (url_param_t, url_error_t); -- extraneous url check
if 0 ~= #url_error_t then -- non-zero when there are errors
table.sort (url_error_t);
utilities.set_message ('err_param_has_ext_link', {utilities.make_sep_list (#url_error_t, url_error_t)}); -- add this error message
end
end
Line 4,045 ⟶ 4,204:
local function citation(frame)
Frame = frame; -- save a copy in case we need to display an error message in preview mode
 
local config = {}; -- table to store parameters from the module {{#invoke:}}
for k, v in pairs( frame.args ) do -- get parameters from the {{#invoke}} frame
config[k] = v;
-- args[k] = v; -- crude debug support that allows us to render a citation from module {{#invoke:}}; skips parameter validation; TODO: keep?
end
-- i18n: set the name that your wiki uses to identify sandbox subpages from sandbox template invoke (or can be set here)
local sandbox = ((config.SandboxPath and '' ~= config.SandboxPath) and config.SandboxPath) or '/sandbox'; -- sandbox path from {{#invoke:Citation/CS1/sandbox|citation|SandboxPath=/...}}
is_sandbox = nil ~= string.find (frame:getTitle(), sandbox, 1, true); -- is this invoke the sandbox module?
sandbox = is_sandbox and sandbox or ''; -- use i18n sandbox to load sandbox modules when this module is the sandox; live modules else
 
local pframe = frame:getParent()
local styles;
cfg = mw.loadData ('Module:Citation/CS1/Configuration' .. sandbox); -- load sandbox versions of support modules when {{#invoke:Citation/CS1/sandbox|...}}; live modules else
if nil ~= string.find (frame:getTitle(), 'sandbox', 1, true) then -- did the {{#invoke:}} use sandbox version?
cfg whitelist = mw.loadData ('Module:Citation/CS1/Configuration/sandboxWhitelist'); -- load.. sandbox versions of support modules);
whitelist utilities = mw.loadDatarequire ('Module:Citation/CS1/Whitelist/sandboxUtilities' .. sandbox);
utilities validation = require ('Module:Citation/CS1/Utilities/sandboxDate_validation' .. sandbox);
validation identifiers = require ('Module:Citation/CS1/Date_validation/sandboxIdentifiers' .. sandbox);
identifiers metadata = require ('Module:Citation/CS1/Identifiers/sandboxCOinS' .. sandbox);
metadata styles = require ('Module:Citation/CS1/COinS/' .. sandbox .. '/styles.css');
styles = 'Module:Citation/CS1/sandbox/styles.css';
else -- otherwise
cfg = mw.loadData ('Module:Citation/CS1/Configuration'); -- load live versions of support modules
whitelist = mw.loadData ('Module:Citation/CS1/Whitelist');
utilities = require ('Module:Citation/CS1/Utilities');
validation = require ('Module:Citation/CS1/Date_validation');
identifiers = require ('Module:Citation/CS1/Identifiers');
metadata = require ('Module:Citation/CS1/COinS');
styles = 'Module:Citation/CS1/styles.css';
end
 
utilities.set_selected_modules (cfg); -- so that functions in Utilities can see the selected cfg tables
Line 4,073 ⟶ 4,232:
 
z = utilities.z; -- table of error and category tables in Module:Citation/CS1/Utilities
 
is_preview_mode = not utilities.is_set (frame:preprocess ('{{REVISIONID}}'));
 
local args = {}; -- table where we store all of the template's arguments
local suggestions = {}; -- table where we store suggestions if we need to loadData them
local error_text, error_state; -- used as a flag
 
local config = {}; -- table to store parameters from the module {{#invoke:}}
for k, v in pairs( frame.args ) do -- get parameters from the {{#invoke}} frame
config[k] = v;
-- args[k] = v; -- crude debug support that allows us to render a citation from module {{#invoke:}}; skips parameter validation; TODO: keep?
end
 
local capture; -- the single supported capture when matching unknown parameters using patterns
Line 4,093 ⟶ 4,248:
end
if not validate( k, config.CitationClass ) then
if type (k) ~= 'string' then -- exclude empty numbered parameters
error_text = "";
if type( k ) ~= 'string' then
-- exclude empty numbered parameters
if v:match("%S+") ~= nil then
error_text, error_state = utilities.set_message ( 'err_text_ignored', {v}, true );
end
elseif validate ( k:lower(), config.CitationClass ) then
error_text, error_state = utilities.set_message ( 'err_parameter_ignored_suggest', {k, k:lower()}, true ); -- suggest the lowercase version of the parameter
else
if nil == suggestions.suggestions then -- if this table is nil then we need to load it
suggestions = mw.loadData ('Module:Citation/CS1/Suggestions' .. sandbox); --load sandbox version of suggestion module when {{#invoke:Citation/CS1/sandbox|...}}; live module else
if nil ~= string.find (frame:getTitle(), 'sandbox', 1, true) then -- did the {{#invoke:}} use sandbox version?
suggestions = mw.loadData( 'Module:Citation/CS1/Suggestions/sandbox' ); -- use the sandbox version
else
suggestions = mw.loadData( 'Module:Citation/CS1/Suggestions' ); -- use the live version
end
end
for pattern, param in pairs (suggestions.patterns) do -- loop through the patterns to see if we can suggest a proper parameter
Line 4,114 ⟶ 4,263:
param = utilities.substitute (param, capture); -- add the capture to the suggested parameter (typically the enumerator)
if validate (param, config.CitationClass) then -- validate the suggestion to make sure that the suggestion is supported by this template (necessary for limited parameter lists)
error_text, error_state = utilities.set_message ('err_parameter_ignored_suggest', {k, param}, true); -- set the suggestion error message
else
error_text, error_state = utilities.set_message ( 'err_parameter_ignored', {k}, true ); -- suggested param not supported by this template
v = ''; -- unset
end
Line 4,123 ⟶ 4,272:
if not utilities.is_set (error_text) then -- couldn't match with a pattern, is there an explicit suggestion?
if (suggestions.suggestions[ k:lower() ] ~= nil) and validate (suggestions.suggestions[ k:lower() ], config.CitationClass) then
error_text, error_state = utilities.set_message ( 'err_parameter_ignored_suggest', {k, suggestions.suggestions[ k:lower() ]}, true );
else
error_text, error_state = utilities.set_message ( 'err_parameter_ignored', {k}, true );
v = ''; -- unset value assigned to unrecognized parameters (this for the limited parameter lists)
end
end
end
if error_text ~= '' then
table.insert( z.message_tail, {error_text, error_state} );
end
end
 
Line 4,149 ⟶ 4,295:
 
if 0 ~= #empty_unknowns then -- create empty unknown error message
table.insert (z.message_tail, {utilities.set_message ('err_param_unknown_empty', {
1 == #empty_unknowns and '' or 's',
utilities.make_sep_list (#empty_unknowns, empty_unknowns)
}, true )});
end
 
local url_param_t = {};
 
for k, v in pairs( args ) do
Line 4,162 ⟶ 4,310:
missing_pipe_check (k, v); -- do we think that there is a parameter that is missing a pipe?
args[k] = inter_wiki_check (k, v); -- when language interwiki-linked parameter missing leading colon replace with wiki-link label
 
if 'string' == type (k) and not cfg.url_skip[k] then -- when parameter k is not positional and not in url skip table
url_param_t[k] = v; -- make a parameter/value list for extraneous url check
end
end
 
has_extraneous_url (url_param_t); -- look for url in parameter values where a url does not belong
 
return table.concat ({
Line 4,169 ⟶ 4,323:
});
end
 
 
--[[--------------------------< E X P O R T E D F U N C T I O N S >------------------------------------------