Editing Module:Citation/CS1/Utilities
The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.
Latest revision | Your text | ||
Line 1: | Line 1: | ||
local u = {} | |||
local z = { | local z = { | ||
Line 13: | Line 14: | ||
local cfg; -- table of tables imported from selected Module:Citation/CS1/Configuration | local cfg; -- table of tables imported from selected Module:Citation/CS1/Configuration | ||
Line 43: | Line 22: | ||
]] | ]] | ||
local function is_set (var) | local function is_set( var ) | ||
return not (var == nil or var == ''); | return not (var == nil or var == ''); | ||
end | end | ||
Line 54: | Line 33: | ||
]] | ]] | ||
local function in_array (needle, haystack) | local function in_array( needle, haystack ) | ||
if needle == nil then | if needle == nil then | ||
return false; | return false; | ||
end | end | ||
for n, v in ipairs (haystack) do | for n,v in ipairs( haystack ) do | ||
if v == needle then | if v == needle then | ||
return n; | return n; | ||
Line 73: | Line 52: | ||
]] | ]] | ||
local function substitute (msg, args) | local function substitute( msg, args ) | ||
return args and mw.message.newRawMessage (msg, args):plain() or msg; | return args and mw.message.newRawMessage( msg, args ):plain() or msg; | ||
end | end | ||
Line 80: | Line 59: | ||
--[[--------------------------< E R R O R _ C O M M E N T >---------------------------------------------------- | --[[--------------------------< E R R O R _ C O M M E N T >---------------------------------------------------- | ||
Wraps error messages with | Wraps error messages with css markup according to the state of hidden. | ||
]] | ]] | ||
local function error_comment (content, hidden) | local function error_comment( content, hidden ) | ||
return substitute (hidden and cfg.presentation['hidden-error'] or cfg.presentation['visible-error'], content); | return substitute( hidden and cfg.presentation['hidden-error'] or cfg.presentation['visible-error'], content ); | ||
end | end | ||
Line 91: | Line 70: | ||
--[=[-------------------------< M A K E _ W I K I L I N K >---------------------------------------------------- | --[=[-------------------------< M A K E _ W I K I L I N K >---------------------------------------------------- | ||
Makes a wikilink; when | Makes a wikilink; when bot link and display text is provided, returns a wikilink in the form [[L|D]]; if only | ||
link is provided | link is provided, returns a wikilink in the form [[L]]; if neither are provided or link is omitted, returns an | ||
provided or link is omitted, returns an empty string. | empty string. | ||
]=] | ]=] | ||
local function make_wikilink (link, display) | local function make_wikilink (link, display) | ||
if | if is_set (link) then | ||
if is_set (display) then | |||
return table.concat ({'[[', link, '|', display, ']]'}); | |||
else | |||
return table.concat ({'[[', link, ']]'}); | |||
end | |||
else | else | ||
return | return ''; | ||
end | end | ||
end | end | ||
--[[--------------------------< S E T _ | --[[--------------------------< S E T _ E R R O R >-------------------------------------------------------------- | ||
Sets an error condition and returns the appropriate error message. The actual placement of the error message in the output is | Sets an error condition and returns the appropriate error message. The actual placement of the error message in the output is | ||
the responsibility of the calling function. | the responsibility of the calling function. | ||
]] | ]] | ||
local function | local function set_error( error_id, arguments, raw, prefix, suffix ) | ||
local error_state = cfg.error_conditions[error_id]; | local error_state = cfg.error_conditions[ error_id ]; | ||
prefix = prefix or | prefix = prefix or ""; | ||
suffix = suffix or | suffix = suffix or ""; | ||
if error_state == nil then | if error_state == nil then | ||
error (cfg.messages['undefined_error'] | error( cfg.messages['undefined_error'] ); -- because missing error handler in Module:Citation/CS1/Configuration | ||
elseif is_set( error_state.category ) then | |||
elseif is_set (error_state.category) then | table.insert( z.error_categories, error_state.category ); | ||
end | end | ||
local message = substitute (error_state.message, arguments); | local message = substitute( error_state.message, arguments ); | ||
message = table.concat ( | message = table.concat ( | ||
Line 156: | Line 125: | ||
}); | }); | ||
-- message = table.concat ({message, ' (', substitute (cfg.presentation['wikilink'], | |||
-- {cfg.messages['help page link'] .. '#' .. error_state.anchor, cfg.messages['help page label']}), ')'}); | |||
-- message = message .. " ([[" .. cfg.messages['help page link'] .. | |||
-- "#" .. error_state.anchor .. "|" .. | |||
-- cfg.messages['help page label'] .. "]])"; | |||
z.error_ids[ error_id ] = true; | |||
if in_array( error_id, { 'bare_url_missing_title', 'trans_missing_title' } ) | |||
and z.error_ids['citation_missing_title'] then | |||
return '', false; | |||
end | end | ||
message = table.concat ({prefix, message, suffix}); | message = table.concat({ prefix, message, suffix }); | ||
if raw == true then | if raw == true then | ||
return message, error_state.hidden; | return message, error_state.hidden; | ||
end | end | ||
return error_comment (message, error_state.hidden); | return error_comment( message, error_state.hidden ); | ||
end | end | ||
Line 181: | Line 156: | ||
alias – one of the list of possible aliases in the aliases lists from Module:Citation/CS1/Configuration | alias – one of the list of possible aliases in the aliases lists from Module:Citation/CS1/Configuration | ||
index – for enumerated parameters, identifies which one | index – for enumerated parameters, identifies which one | ||
enumerated – true/false flag used | enumerated – true/false flag used choose how enumerated aliases are examined | ||
value – value associated with an alias that has previously been selected; nil if not yet selected | value – value associated with an alias that has previously been selected; nil if not yet selected | ||
selected – the alias that has previously been selected; nil if not yet selected | selected – the alias that has previously been selected; nil if not yet selected | ||
Line 199: | Line 174: | ||
end | end | ||
if is_set (args[alias]) then -- alias is in the template's argument list | if is_set(args[alias]) then -- alias is in the template's argument list | ||
if value ~= nil and selected ~= alias then -- if we have already selected one of the aliases | if value ~= nil and selected ~= alias then -- if we have already selected one of the aliases | ||
local skip; | local skip; | ||
for _, v in ipairs (error_list) do -- spin through the error list to see if we've added this alias | for _, v in ipairs(error_list) do -- spin through the error list to see if we've added this alias | ||
if v == alias then | if v == alias then | ||
skip = true; | skip = true; | ||
Line 209: | Line 184: | ||
end | end | ||
if not skip then -- has not been added so | if not skip then -- has not been added so | ||
table.insert (error_list, alias); -- add error alias to the error list | table.insert( error_list, alias ); -- add error alias to the error list | ||
end | end | ||
else | else | ||
Line 227: | Line 202: | ||
]] | ]] | ||
local added_maint_cats = {} -- list of maintenance categories that have been added to z.maintenance_cats | |||
local function add_maint_cat (key, arguments) | local function add_maint_cat (key, arguments) | ||
if not added_maint_cats [key] then | if not added_maint_cats [key] then | ||
added_maint_cats [key] = true; -- note that we've added this category | added_maint_cats [key] = true; -- note that we've added this category | ||
table.insert (z.maintenance_cats, substitute (cfg.maint_cats | table.insert( z.maintenance_cats, substitute (cfg.maint_cats [key], arguments)); -- make name then add to table | ||
end | end | ||
end | end | ||
Line 267: | Line 221: | ||
]] | ]] | ||
local function safe_for_italics (str) | local function safe_for_italics( str ) | ||
if not is_set (str) then return str | if not is_set(str) then | ||
return str; | |||
else | |||
if str:sub(1,1) == "'" then str = "<span></span>" .. str; end | |||
if str:sub(-1,-1) == "'" then str = str .. "<span></span>"; end | |||
-- Remove newlines as they break italics. | |||
return str:gsub( '\n', ' ' ); | |||
end | |||
end | end | ||
Line 288: | Line 243: | ||
local function wrap_style (key, str) | local function wrap_style (key, str) | ||
if not is_set (str) then | if not is_set( str ) then | ||
return ""; | return ""; | ||
elseif in_array (key, {'italic-title', 'trans-italic-title'}) then | elseif in_array( key, { 'italic-title', 'trans-italic-title' } ) then | ||
str = safe_for_italics (str); | str = safe_for_italics( str ); | ||
end | end | ||
return substitute (cfg.presentation[key], {str}) | return substitute( cfg.presentation[key], {str} ); | ||
end | end | ||
Line 343: | Line 266: | ||
]] | ]] | ||
local function select_one (args, aliases_list, error_condition, index) | local function select_one( args, aliases_list, error_condition, index ) | ||
local value = nil; -- the value assigned to the selected parameter | local value = nil; -- the value assigned to the selected parameter | ||
local selected = ''; -- the name of the parameter we have chosen | local selected = ''; -- the name of the parameter we have chosen | ||
Line 350: | Line 273: | ||
if index ~= nil then index = tostring(index); end | if index ~= nil then index = tostring(index); end | ||
for _, alias in ipairs (aliases_list) do -- for each alias in the aliases list | for _, alias in ipairs( aliases_list ) do -- for each alias in the aliases list | ||
if alias:match ('#') then -- if this alias can be enumerated | if alias:match ('#') then -- if this alias can be enumerated | ||
if '1' == index then -- when index is 1 test for enumerated and non-enumerated aliases | if '1' == index then -- when index is 1 test for enumerated and non-enumerated aliases | ||
value, selected = is_alias_used (args, alias, index, false, value, selected, error_list); -- first test for non-enumerated alias | value, selected = is_alias_used (args, alias, index, false, value, selected, error_list); -- first test for non-enumerated alias | ||
end | end | ||
value, selected = is_alias_used (args, alias, index, true, value, selected, error_list); -- test for enumerated alias | value, selected = is_alias_used (args, alias, index, true, value, selected, error_list); -- test for enumerated alias | ||
else | else | ||
value, selected = is_alias_used (args, alias, index, false, value, selected, error_list); -- test for non-enumerated alias | value, selected = is_alias_used (args, alias, index, false, value, selected, error_list); --test for non-enumerated alias | ||
end | end | ||
end | end | ||
if #error_list > 0 and 'none' ~= error_condition then -- for cases where this code is used outside of extract_names() | if #error_list > 0 and 'none' ~= error_condition then -- for cases where this code is used outside of extract_names() | ||
for | local error_str = ""; | ||
for _, k in ipairs( error_list ) do | |||
if error_str ~= "" then error_str = error_str .. cfg.messages['parameter-separator'] end | |||
error_str = error_str .. wrap_style ('parameter', k); | |||
end | |||
if #error_list > 1 then | |||
error_str = error_str .. cfg.messages['parameter-final-separator']; | |||
else | |||
error_str = error_str .. cfg.messages['parameter-pair-separator']; | |||
end | end | ||
error_str = error_str .. wrap_style ('parameter', selected); | |||
table.insert (z.message_tail, { | table.insert( z.message_tail, { set_error( error_condition, {error_str}, true ) } ); | ||
end | end | ||
Line 379: | Line 309: | ||
The str:gsub() returns either A|B froma [[A|B]] or B from [[B]] or B from B (no wikilink markup). | The str:gsub() returns either A|B froma [[A|B]] or B from [[B]] or B from B (no wikilink markup). | ||
In l(), l:gsub() removes the link and pipe (if they exist); the second :gsub() trims | In l(), l:gsub() removes the link and pipe (if they exist); the second :gsub() trims white space from the label | ||
if str was wrapped in wikilink markup. Presumably, this is because without wikimarkup in str, there is no match | if str was wrapped in wikilink markup. Presumably, this is because without wikimarkup in str, there is no match | ||
in the initial gsub, the replacement function l() doesn't get called. | in the initial gsub, the replacement function l() doesn't get called. | ||
Line 386: | Line 316: | ||
local function remove_wiki_link (str) | local function remove_wiki_link (str) | ||
return (str:gsub ("%[%[([^%[%]]*)%]%]", function(l) | return (str:gsub( "%[%[([^%[%]]*)%]%]", function(l) | ||
return l:gsub ("^[^|]*|(.*)$", "%1" ):gsub ("^%s*(.-)%s*$", "%1"); | return l:gsub( "^[^|]*|(.*)$", "%1" ):gsub("^%s*(.-)%s*$", "%1"); | ||
end)); | end)); | ||
end | end | ||
Line 394: | Line 324: | ||
--[=[-------------------------< I S _ W I K I L I N K >-------------------------------------------------------- | --[=[-------------------------< I S _ W I K I L I N K >-------------------------------------------------------- | ||
Determines if str is a wikilink, extracts, and returns the wikilink type, link text, and display text parts. | Determines if str is a wikilink, extracts, and returns the the wikilink type, link text, and display text parts. | ||
If str is a complex wikilink ([[L|D]]): | If str is a complex wikilink ([[L|D]]): | ||
returns wl_type 2 and D and L from [[L|D]]; | returns wl_type 2 and D and L from [[L|D]]; | ||
Line 402: | Line 332: | ||
returns wl_type 0, str as D, and L as empty string. | returns wl_type 0, str as D, and L as empty string. | ||
trims leading and trailing | trims leading and trailing white space and pipes from L and D ([[L|]] and [[|D]] are accepted by MediaWiki and | ||
treated like [[D]]; while [[|D|]] is not accepted by MediaWiki, here, we accept it and return D without the pipes). | treated like [[D]]; while [[|D|]] is not accepted by MediaWiki, here, we accept it and return D without the pipes). | ||
Line 411: | Line 341: | ||
local wl_type = 2; -- assume that str is a complex wikilink [[L|D]] | local wl_type = 2; -- assume that str is a complex wikilink [[L|D]] | ||
L, D = str:match ('%[%[([^|]+)|([^%]]+)%]%]'); -- get L and D from [[L|D]] | |||
if not is_set (D) then -- if no separate link | |||
D = str:match ('%[%[([^%]]*)|*%]%]'); -- get D from [[D]] | |||
wl_type = 1; | |||
end | end | ||
if not is_set (D) then -- no wikilink markup | |||
D = str; -- return the string as D | |||
if not is_set (D) then -- | wl_type = 0; -- but say that it is not a wikilink | ||
D = str | |||
wl_type = | |||
end | end | ||
D = mw.text.trim (D, '%s|'); -- trim white space and pipe characters | D = mw.text.trim (D, '%s|'); -- trim white space and pipe characters | ||
L = L and mw.text.trim (L, '%s|'); | |||
return wl_type, D, L or ''; | return wl_type, D, L or ''; | ||
end | end | ||
Line 479: | Line 372: | ||
return { | return { -- return exported functions and tables | ||
is_set = is_set, | |||
in_array = in_array, | |||
substitute = substitute, | |||
error_comment = error_comment, | error_comment = error_comment, | ||
set_error = set_error, | |||
select_one = select_one, | |||
add_maint_cat = add_maint_cat, | |||
wrap_style = wrap_style, | |||
safe_for_italics = safe_for_italics, | |||
remove_wiki_link = remove_wiki_link, | |||
is_wikilink = is_wikilink, | is_wikilink = is_wikilink, | ||
make_wikilink = make_wikilink, | make_wikilink = make_wikilink, | ||
set_selected_modules = set_selected_modules, | set_selected_modules = set_selected_modules, | ||
z = z, | |||
z = z, | |||
} | } |