Module:Sandbox/trappist the monk/Parameters

--[[--------------------------< F O R W A R D D E C L A R A T I O N S >--------------------------------------

]]

local in_array, is_set, is_wikilink, make_sep_list, select_one, set_message,

substitute, wrap_style; -- functions in Module:Citation/CS1/Utilities

local z; -- table of tables defined in Module:Citation/CS1/Utilities

local cfg; -- table of configuration tables that are defined in Module:Citation/CS1/Configuration

local suggestions;

local 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_vanc_errs; -- boolean flag so we only emit one Vancouver error / category

local Frame; -- holds the module's frame table

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

!!! TODO : MOVE from main to TO UTILITIES !!!

used here by namelists_get()

This function is used to validate a parameter's assigned value for those parameters that have only a limited number

of allowable values (yes, y, true, live, dead, etc.). When the parameter value has not been assigned a value (missing

or empty in the source template) the function returns the value specified by ret_val. If the parameter value is one

of the list of allowed values returns the translated value; else, emits an error message and returns the value

specified by ret_val.

]]

local function is_valid_parameter_value (value, name, possible, ret_val)

if not is_set (value) then

return ret_val; -- an empty parameter is ok

elseif in_array (value, possible) then

return cfg.keywords_xlate[value]; -- return translation of parameter keyword

else

table.insert( z.message_tail, {set_message ('err_invalid_param_val', {name, value}, true)}); -- not an allowed value so add error message

return ret_val;

end

--[[--------------------------< S E L E C T _ A U T H O R _ E D I T O R _ S O U R C E >------------------------

Select one of |authors=, |authorn= / |lastn / firstn=, or |vauthors= as the source of the author name list or

select one of |editorn= / editor-lastn= / |editor-firstn= or |veditors= as the source of the editor name list.

Only one of these appropriate three will be used. The hierarchy is: |authorn= (and aliases) highest and |authors= lowest;

|editorn= (and aliases) highest and |veditors= lowest (support for |editors= withdrawn)

When looking for |authorn= / |editorn= parameters, test |xxxxor1= and |xxxxor2= (and all of their aliases); stops after the second

test which mimicks the test used in extract_names() when looking for a hole in the author name list. There may be a better

way to do this, I just haven't discovered what that way is.

Emits an error message when more than one xxxxor name source is provided.

In this function, vxxxxors = vauthors or veditors; xxxxors = authors as appropriate.

]]

local function select_author_editor_source (vxxxxors, xxxxors, args, list_name)

local lastfirst = false;

if select_one ( args, cfg.aliases[list_name .. '-Last'], 'none', 1 ) or -- do this twice in case we have a |first1= without a |last1=; this ...

select_one ( args, cfg.aliases[list_name .. '-First'], 'none', 1 ) or -- ... also catches the case where |first= is used with |vauthors=

select_one ( args, cfg.aliases[list_name .. '-Last'], 'none', 2 ) or

select_one ( args, cfg.aliases[list_name .. '-First'], 'none', 2 ) then

lastfirst = true;

end

if (is_set (vxxxxors) and true == lastfirst) or -- these are the three error conditions

(is_set (vxxxxors) and is_set (xxxxors)) or

(true == lastfirst and is_set (xxxxors)) then

local err_name;

if 'AuthorList' == list_name then -- figure out which name should be used in error message

err_name = 'author';

else

err_name = 'editor';

end

table.insert( z.message_tail, {set_message ( 'err_redundant_parameters',

{err_name .. '-name-list parameters'}, true ) } ); -- add error message

end

if true == lastfirst then return 1 end; -- return a number indicating which author name source to use

if is_set (vxxxxors) then return 2 end;

if is_set (xxxxors) then return 3 end;

return 1; -- no authors so return 1; this allows missing author name test to run in case there is a first without last

end

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

]]

local function namelists_get (params)

local author_etal;

local a = {}; -- authors list from |lastn= / |firstn= pairs or |vauthors=

local Authors;

local NameListStyle = is_valid_parameter_value (params['NameListStyle'].value, params['NameListStyle'].origin, cfg.keywords_lists['name-list-style'], '');

do -- to limit scope of selected

local selected = select_author_editor_source (A['Vauthors'], A['Authors'], args, 'AuthorList');

if 1 == selected then

elseif 2 == selected then

NameListStyle = 'vanc'; -- override whatever |name-list-style= might be

a, author_etal = parse_vauthors_veditors (args, args.vauthors, 'AuthorList'); -- fetch author list from |vauthors=, |author-linkn=, and |author-maskn=

elseif 3 == selected then

Authors = A['Authors']; -- use content of |authors=

if 'authors' == A:ORIGIN('Authors') then -- but add a maint cat if the parameter is |authors=

set_message ('maint_authors'); -- because use of this parameter is discouraged; what to do about the aliases is a TODO:

end

if is_set (params['Collaboration'].value) then

author_etal = true; -- so that |display-authors=etal not required

end

local Others = A['Others'];

local editor_etal;

local e = {}; -- editors list from |editor-lastn= / |editor-firstn= pairs or |veditors=

local Editors;

do -- to limit scope of selected

local selected = select_author_editor_source (A['Veditors'], nil, args, 'EditorList'); -- support for |editors= withdrawn

if 1 == selected then

elseif 2 == selected then

NameListStyle = 'vanc'; -- override whatever |name-list-style= might be

e, editor_etal = parse_vauthors_veditors (args, args.veditors, 'EditorList'); -- fetch editor list from |veditors=, |editor-linkn=, and |editor-maskn=

end

local translator_etal;

local t = {}; -- translators list from |translator-lastn= / translator-firstn= pairs

local Translators; -- assembled translators name list

t = extract_names (args, 'TranslatorList'); -- fetch translator list from |translatorn= / |translator-lastn=, -firstn=, -linkn=, -maskn=

local interviewer_etal;

local interviewers_list = {};

local Interviewers; -- used later

interviewers_list = extract_names (args, 'InterviewerList'); -- process preferred interviewers parameters

local contributor_etal;

local c = {}; -- contributors list from |contributor-lastn= / contributor-firstn= pairs

local Contributors; -- assembled contributors name list

local Chapter = A['Chapter']; -- done here so that we have access to |contribution= from |chapter= aliases

local Chapter_origin = A:ORIGIN ('Chapter');

local Contribution; -- because contribution is required for contributor(s)

if 'contribution' == A:ORIGIN ('Chapter') then

Contribution = A['Chapter']; -- get the name of the contribution

end

if in_array (config.CitationClass, {"book", "citation"}) and not is_set (A['Periodical']) then -- |contributor= and |contribution= only supported in book cites

c = extract_names (args, 'ContributorList'); -- fetch contributor list from |contributorn= / |contributor-lastn=, -firstn=, -linkn=, -maskn=

if 0 < #c then

if not is_set (Contribution) then -- |contributor= requires |contribution=

table.insert( z.message_tail, {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, {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

else -- if not a book cite

if select_one (args, cfg.aliases['ContributorList-Last'], 'err_redundant_parameters', 1 ) then -- are there contributor name list parameters?

table.insert( z.message_tail, {set_message ( 'err_contributor_ignored')}); -- add contributor ignored error message

end

Contribution = nil; -- unset

end

--[[--------------------------< D E P R E C A T E D _ P A R A M E T E R >--------------------------------------

Categorize and emit an error message when the citation contains one or more deprecated parameters. The function includes the

offending parameter name to the error message. Only one error message is emitted regardless of the number of deprecated

parameters in the citation.

added_deprecated_cat is a Boolean declared in page scope variables above

]]

local function deprecated_parameter(name)

if not added_deprecated_cat then

added_deprecated_cat = true; -- note that we've added this category

table.insert (z.message_tail, {set_message ('err_deprecated_params', {name}, true)}); -- add error message

end

--[[--------------------------< B U I L D _ P A R A M _ L I S T >----------------------------------------------

builds a k/v table where k is the metaparameter name (same as key in aliases{} table) and v is a k/v table

where:

['value'] = value assigned to the parameter

['origin'] = original parameter name

['render'] = empty string that will later hold parameter rendered value

]]

local function build_param_list (args, params)

-- local params = {};

local val;

local selected;

for mparam, aliases in pairs (cfg.aliases) do -- spin through the aliases table (in ~/Configuration)

--error (mw.dumpObject (aliases))

if 'table' == type (aliases) then -- if there are multiple possible parameters

val, selected = select_one (args, aliases, 'err_redundant_parameters', 1); -- select one of them

if not selected then -- TODO: is this even possible?

selected = ''; -- Empty string, not nil

end

elseif aliases ~= nil then -- not nil so must be a single parameter name

val = args[aliases]; -- get the assigned value

selected = aliases; -- and the parameter name

else -- here when aliases is nil

error( cfg.messages['unknown_argument_map'] .. ': ' .. k); -- throw a major error because no key

end

if val then

params[mparam] = {value=val, origin=selected, render=''}; -- when parameter has a value, add it to params{} table

end

--error (mw.dumpObject (params))

return params;

end

--[[--------------------------< H A S _ I N V I S I B L E _ C H A R S >----------------------------------------

This function searches a parameter's value for non-printable or invisible characters. The search stops at the

first match.

This function will detect the visible replacement character when it is part of the Wikisource.

Detects but ignores nowiki and math stripmarkers. Also detects other named stripmarkers (gallery, math, pre, ref)

and identifies them with a slightly different error message. See also coins_cleanup().

Output of this function is an error message that identifies the character or the Unicode group, or the stripmarker

that was detected along with its position (or, for multi-byte characters, the position of its first byte) in the

parameter value.

]]

local function has_invisible_chars (param, v)

local position = ''; -- position of invisible char or starting position of stripmarker

local dummy; -- end of matching string; not used but required to hold end position when a capture is returned

local capture; -- used by stripmarker detection to hold name of the stripmarker

local i = 1;

local stripmarker, apostrophe;

capture = string.match (v, '[%w%p ]*'); -- test for values that are simple ASCII text and bypass other tests if true

if capture == v then -- if same there are no Unicode characters

return;

end

while cfg.invisible_chars[i] do

local char = cfg.invisible_chars[i][1] -- the character or group name

local pattern = cfg.invisible_chars[i][2] -- the pattern used to find it

position, dummy, capture = mw.ustring.find (v, pattern) -- see if the parameter value contains characters that match the pattern

if position and (char == 'zero width joiner') then -- if we found a zero-width joiner character

if mw.ustring.find (v, cfg.indic_script) then -- it's ok if one of the Indic scripts

position = nil; -- unset position

end

if position then

if 'nowiki' == capture or 'math' == capture or -- nowiki and math stripmarkers (not an error condition)

('templatestyles' == capture and in_array (param, {'id', 'quote'})) then -- templatestyles stripmarker allowed in these parameters

stripmarker = true; -- set a flag

elseif true == stripmarker and 'delete' == char then -- because stripmakers begin and end with the delete char, assume that we've found one end of a stripmarker

position = nil; -- unset

else

local err_msg;

if capture then

err_msg = capture .. ' ' .. char;

else

err_msg = char .. ' ' .. 'character';

end

table.insert (z.message_tail, {set_message ('err_invisible_char', {err_msg, wrap_style ('parameter', param), position}, true)}); -- add error message

return; -- and done with this parameter

end

i = i + 1; -- bump our index

end

--[[--------------------------< V A L I D A T E >--------------------------------------------------------------

Looks for a parameter's name in one of several whitelists.

Parameters in the whitelist can have three values:

true - active, supported parameters

false - deprecated, supported parameters

nil - unsupported parameters

]]

local function validate (name, cite_class, empty)

local name = tostring (name);

local enum_name; -- for enumerated parameters, is name with enumerator replaced with '#'

local state;

local function state_test (state, name) -- local function to do testing of state values

if true == state then return true; end -- valid actively supported parameter

if false == state then

if empty then return nil; end -- deprecated empty parameters are treated as unknowns

deprecated_parameter (name); -- parameter is deprecated but still supported

return true;

end

return nil;

end

if name:find ('#') then -- # is a cs1|2 reserved character so parameters with # not permitted

return nil;

end

if in_array (cite_class, whitelist.preprint_template_list) then -- limited parameter sets allowed for these templates

state = whitelist.limited_basic_arguments[name];