Module:Ref info
MyWikiBiz, Author Your Legacy — Sunday September 08, 2024
Jump to navigationJump to searchImplements {{Ref info}}
-- This module counts the number of times that various reference tags and cs1|2 templates appear. -- {{#invoke:ref_info|ref_info}} -- {{ref info}} -- {{ref info|aristotle}} require('Module:No globals'); local data = mw.loadData ('Module:Ref info/data'); --mw.logObject (data.cs12_stripped_list, 'data.cs12_stripped_list') local collapsible_tables = { ['cs1'] = '', -- collapsible wiki-tables of names and counts ['cs2'] = '', ['cs1_like'] = '', ['vcite'] = '', ['sfn'] = '', ['harv'] = '', } --[[--------------------------< T E M P L A T E _ N A M E _ T A B L E _ M A K E >------------------------------ makes a collapsed html table that holds a list of cs1 or cs2 template used in an article. The list occupies a single row of the parent table. ]] local function template_name_table_make (name_list, group) local name_table = {}; local function comp (a, b) -- used in following table.sort() return a:lower() < b:lower(); -- case-insensitive ascending alpha sort end table.insert (name_table, '\n|-\n|scope="row" colspan="2" style="vertical-align:top;text-align:left" |\n'); -- create a blank row in parent table for this table table.insert (name_table, '{| class="mw-collapsible mw-collapsed nowrap" style="margin: 0.2em auto auto; width:100%;"\n') -- open the collapsed list table; style aligns show/hide toggle table.insert (name_table, '| List of '); -- begin simple header row always displays table.insert (name_table, group); -- template group (cs1, cs2 TODO: vcite? harv?) table.insert (name_table, ' templates \n'); -- end of simple heading table.insert (name_table, '|-\n|\n<hr /><ul>\n'); -- new row, row content begins with <hr />; open unordered list local t = {}; for k, v in pairs (name_list) do -- spin through the list table.insert (t, string.format ('<li>%s (%s)</li>', k, v)) -- make pretty unordered list of name with count end if not t[1] then return ''; -- nothing in the list so abandon end table.sort (t, comp); -- case-insensitive ascending alpha sort table.insert (t, '</ul>\n'); -- close unordered list table.insert (name_table, table.concat (t, '\n')); -- make a string and add to main table table.insert (name_table, '\n|}'); -- close the table return table.concat (name_table); -- return html table as a string end --[[--------------------------< C O U N T _ P A T T E R N >---------------------------------------------------- this is a general purpose function used to count occurrences of <pattern> in <text> ]] local function count_pattern (text, pattern) local _; local count; _, count = mw.ustring.gsub (text, pattern, '%1'); return count; end --[[--------------------------< C O U N T _ C S 1 _ L A S T >-------------------------------------------------- makes a count of those cs1|2 templates that use |last= or |last1= (or any of the selected aliases of these). ]] local function count_cs1_last (template, count) local _, tally; for _, param in ipairs (data.last_param_patterns) do _, tally = mw.ustring.gsub (template, '|%s*' .. param .. '%s*=%s*[^}|]', '%1'); -- count occurences of that pattern count = count + tally; -- accumulate a total end return count; end --[[--------------------------< C O U N T _ C S 1 _ A U T H O R >---------------------------------------------- makes a count of those cs1|2 templates that use |author= or |author1= (or any of the selected aliases of these). ]] local function count_cs1_author (template, count) local _, tally; for _, param in ipairs (data.author_param_patterns) do _, tally = mw.ustring.gsub (template, '|%s*' .. param .. '%s*=%s*[^}|]', '%1'); -- count occurences of that pattern count = count + tally; -- accumulate a total end return count; end --[[--------------------------< C O U N T _ C S 1 _ A U T H O R S >-------------------------------------------- makes a count of those cs1|2 templates that use |authors= (or any of the selected aliases). ]] local function count_cs1_authors (template, count) local _, tally; for _, param in ipairs (data.authors_param_patterns) do _, tally = mw.ustring.gsub (template, '|%s*' .. param .. '%s*=%s*[^}|]', '%1'); -- count occurences of that pattern count = count + tally; -- accumulate a total end return count; end --[[--------------------------< C O U N T _ C S 1 _ V A U T H O R S >------------------------------------------ makes a count of those cs1|2 templates that use |vauthors=. ]] local function count_cs1_vauthors (template, count) local _, tally; _, tally = mw.ustring.gsub (template, '|%s*vauthors%s*=%s*[^}|]', '%1'); -- count occurences of that pattern count = count + tally; -- accumulate a total return count; end --[[--------------------------< C O U N T _ C S 1 _ D A T E S _ D M Y >---------------------------------------- Using the lists of cs1|2 templates, make a count of just those templates that have |date=DD Month YYYY where DD is one or two digits or a range DD-DD Month YYYY ]] local function count_cs1_dates_dmy (template, count) local _, tally; _, tally = mw.ustring.gsub (template, '|%s*date%s*=%s*%d?%d%s+%a+%s+%d%d%d%d', '%1'); -- dd Month yyyy count = count + tally; -- accumulate a total _, tally = mw.ustring.gsub (template, '|%s*date%s*=%s*%d?%d[%-–]%d?%d%s+%a+%s+%d%d%d%d', '%1'); -- dd-dd Month yyyy count = count + tally; -- accumulate a total return count; end --[[--------------------------< C O U N T _ C S 1 _ D A T E S _ M D Y >---------------------------------------- Using the lists of cs1|2 templates, make a count of just those templates that have |date=Month DD, YYYY where DD is one or two digits or a range Month DD-DD, YYYY ]] local function count_cs1_dates_mdy (template, count) local _, tally; _, tally = mw.ustring.gsub (template, '|%s*date%s*=%s*%a+%s+%d?%d%s*,%s+%d%d%d%d', '%1'); -- Month dd, yyyy count = count + tally; -- accumulate a total _, tally = mw.ustring.gsub (template, '|%s*date%s*=%s*%a+%s+%d?%d[%-–]%d?%d%s*,%s+%d%d%d%d', '%1'); -- Month dd-dd, yyyy count = count + tally; -- accumulate a total return count; end --[[--------------------------< C O U N T _ C S 1 _ D A T E S _ Y M D >---------------------------------------- Using the lists of cs1|2 templates, make a count of just those templates that have |date=YYYY-MM-DD ]] local function count_cs1_dates_ymd (template, count) local _, tally; _, tally = mw.ustring.gsub (template, '|%s*date%s*=%s*%d%d%d%d%-%d%d%-%d%d', '%1'); -- yyyy-mm-dd count = count + tally; -- accumulate a total return count; end --[[--------------------------< C O U N T _ C S 1 _ D F _ D M Y >---------------------------------------------- Using the lists of cs1|2 templates, make a count of just those templates that have |df=xxx (with a value) ]] local function count_cs1_df_dmy (template, count) local _, tally; _, tally = mw.ustring.gsub (template, '|%s*df%s*=%s*dmy%-?a?l?l?', '%1'); -- |df=dmy |df=dmy-all count = count + tally; -- accumulate a total return count; end --[[--------------------------< C O U N T _ C S 1 _ D F _ M D Y >---------------------------------------------- Using the lists of cs1|2 templates, make a count of just those templates that have |df=xxx (with a value) ]] local function count_cs1_df_mdy (template, count) local _, tally; _, tally = mw.ustring.gsub (template, '|%s*df%s*=%s*mdy%-?a?l?l?', '%1'); -- |df=mdy |df=mdy-all count = count + tally; -- accumulate a total return count; end --[[--------------------------< C O U N T _ C S 1 _ D F _ Y M D >---------------------------------------------- Using the lists of cs1|2 templates, make a count of just those templates that have |df=xxx (with a value) ]] local function count_cs1_df_ymd (template, count) local _, tally; _, tally = mw.ustring.gsub (template, '|%s*df%s*=%s*ymd%-?a?l?l?', '%1'); -- |df=ymd |df=ymd-all count = count + tally; -- accumulate a total return count; end --[[--------------------------< C O U N T _ C S 1 2 _ M O D E >-------------------------------------------------- make a count of those cs1|2 templates that have |mode=cs1 or |mode=cs2 ]] local function count_cs12_mode (template, count, mode) local _, tally; mode = 1 == mode and 'cs1' or 'cs2'; _, tally = mw.ustring.gsub (template, '|%s*mode%s*=%s*' .. mode, '%1'); -- |mode=cs1 or |mode=cs2 count = count + tally; -- accumulate a total return count; end --[[--------------------------< C S 1 _ C S 2 _I N F O _ G E T >----------------------------------------------- Using the list of cs1|2 templates, make a count of those templates. Make lists of cs1|2 templates used. Count different author-name styles, date styles. ]] local function cs1_cs2_info_get (Article_content, pattern, template_name_list, object) local tstart, tend = Article_content:find (pattern); -- find the first cs1 template local total = 0; while tstart do -- nil when cs1|2 template not found local template = Article_content:match ('%b{}', tstart); -- get the whole template if template then -- necessary? local name = template:match ('{{%s*([^|}]+)'); -- get template name name=mw.text.trim (name); -- trim whitespace if not template_name_list[name] then -- if not already saved template_name_list[name] = 1; -- save it else -- here when this name already saved template_name_list[name] = template_name_list[name] + 1; -- to indicate that there are multiple same name templates end total = total + 1; -- tally total number of cs1 templates -- count various date properties object['cs1_dmy_dates']['count'] = count_cs1_dates_dmy (template, object['cs1_dmy_dates']['count']); -- count of |date=dmy object['cs1_mdy_dates']['count'] = count_cs1_dates_mdy (template, object['cs1_mdy_dates']['count']); -- count of |date=mdy object['cs1_ymd_dates']['count'] = count_cs1_dates_ymd (template, object['cs1_ymd_dates']['count']); -- count of |date=ymd object['cs1_dates_df_dmy']['count'] = count_cs1_df_dmy (template, object['cs1_dates_df_dmy']['count']); -- count of |df=dmy object['cs1_dates_df_mdy']['count'] = count_cs1_df_mdy (template, object['cs1_dates_df_mdy']['count']); -- count of |df=dmy object['cs1_dates_df_ymd']['count'] = count_cs1_df_ymd (template, object['cs1_dates_df_ymd']['count']); -- count of |df=dmy -- count various author-name properties object['cs1_last']['count'] = count_cs1_last (template, object['cs1_last']['count']); -- count of |lastn= object['cs1_author']['count'] = count_cs1_author (template, object['cs1_author']['count']); -- count of |authorn= object['cs1_authors']['count'] = count_cs1_authors (template, object['cs1_authors']['count']); -- count of |authors= object['cs1_vauthors']['count'] = count_cs1_vauthors (template, object['cs1_vauthors']['count']); -- count of |vauthors= object['cs1_mode']['count'] = count_cs12_mode (template, object['cs1_mode']['count'], 1); -- count of |mode=cs1 object['cs2_mode']['count'] = count_cs12_mode (template, object['cs2_mode']['count'], 2); -- count of |mode=cs2 end tstart = tend; -- reset the search starting index tstart, tend = Article_content:find (pattern, tstart); -- search for another cs1|2 template end return total; end --[[--------------------------< C O U N T _ C S 1 >------------------------------------------------------------ Using the list of cs1 templates, make a count of just those templates as dictated by base_pattern. makes a list of cs1 templates in the article ]] local function count_cs1 (Article_content, base_pattern, object) local _; local pattern; local total = 0; local cs1_template_name_list = {}; for i, cs1_template in ipairs (data.cs1_template_patterns) do pattern = string.format (base_pattern, cs1_template); -- make a pattern for the selected cs1 template total = total + cs1_cs2_info_get (Article_content, pattern, cs1_template_name_list, object); end collapsible_tables.cs1 = template_name_table_make (cs1_template_name_list, 'cs1'); --mw.logObject (cs1_template_name_list, 'cs1_template_name_list') return total; end --[[--------------------------< C O U N T _ C S 1 _ R E F S >-------------------------------------------------- Using the list of cs1 templates, make a count of just those references as dictated by base_pattern. ]] local function count_cs1_refs (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.cs1_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected cs1 template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< C O U N T _ C S 1 _ L I K E _ T E M P L A T E S >------------------------------ make a count of cs1-like templates as dictated by <pattern>. ]] local function count_cs1_like_templates (Article_content, pattern) local tstart, tend = Article_content:find (pattern); -- find the first cs1-like template local total = 0; local template_name_list = {}; while tstart do -- nil when cs1-like template not found local template = Article_content:match ('%b{}', tstart); -- get the template in the ref if template then -- necessary? local name = template:match ('{{%s*([^|}]+)'); -- get template name name = mw.text.trim (name); -- trim whitespace name = name:gsub (' +', ' '); -- replace multiple space chars with a single char if not data.cs12_stripped_list[name] then -- if not a cs1|2 template if not template_name_list[name] then -- if not already saved template_name_list[name] = 1; -- save it else -- here when this name already saved template_name_list[name] = template_name_list[name] + 1; -- to indicate that there are multiple same name templates end total = total + 1; -- tally total number of cs1-like templates end end tstart = tend; -- reset the search starting index tstart, tend = Article_content:find (pattern, tstart); -- search for another cs1|2 template end collapsible_tables.cs1_like = template_name_table_make (template_name_list, 'cs1-like'); return total; end --[[--------------------------< C O U N T _ C S 1 _ L I K E _ R E F S >---------------------------------------- make a count of cs1-like references as dictated by <pattern>. ]] local function count_cs1_like_refs (Article_content, pattern) local tstart, tend = Article_content:find (pattern); -- find the first cs1-like template local total = 0; while tstart do -- nil when cs1-like reference not found local template = Article_content:match ('%b{}', tstart); -- get the template in the ref if template then -- necessary? local name = template:match ('{{%s*([^|}]+)'); -- get template name name = mw.text.trim (name); -- trim whitespace name = name:gsub (' +', ' '); -- replace multiple space chars with a single char if not data.cs12_stripped_list[name] then -- if not a cs1|2 template total = total + 1; -- tally total number of cs1-like references end end tstart = tend; -- reset the search starting index tstart, tend = Article_content:find (pattern, tstart); -- search for another cs1|2 template end return total; end --[[--------------------------< C O U N T _ C S 2 >------------------------------------------------------------ Using the list of cs2 templates, make a count of those templates as dictated by base_pattern. make a list of cs2 templates in the article ]] local function count_cs2 (Article_content, base_pattern, object) local _; local pattern; local count, total = 0, 0; local cs2_template_name_list = {}; for i, cs2_template in ipairs (data.cs2_template_patterns) do pattern = string.format (base_pattern, cs2_template); -- make a pattern for the selected cs2 template total = total + cs1_cs2_info_get (Article_content, pattern, cs2_template_name_list, object); end collapsible_tables.cs2 = template_name_table_make (cs2_template_name_list, 'cs2'); --mw.logObject (cs2_template_name_list, 'cs2_template_name_list') return total; end --[[--------------------------< C O U N T _ C S 2 _ R E F S >-------------------------------------------------- Using the list of cs2 templates, make a count of those references as dictated by base_pattern. ]] local function count_cs2_refs (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.cs2_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected cs1 template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< C O U N T _ V C I T E >-------------------------------------------------------- Using the list of vcite templates, make a count of just those templates as dictated by base_pattern. makes a list of vcite templates in the article ]] local function count_vcite (Article_content, base_pattern, object) local _; local pattern; local total = 0; local vcite_template_name_list = {}; for i, vcite_template in ipairs (data.vcite_template_patterns) do pattern = string.format (base_pattern, vcite_template); -- make a pattern for the selected vcite template local tstart, tend = Article_content:find (pattern); -- find the first vcite template while tstart do -- nil when vcite template not found local template = Article_content:match ('%b{}', tstart); -- get the whole template if template then -- necessary? local name = template:match ('{{%s*([^|}]+)'); -- get template name name=mw.text.trim (name); -- trim whitespace if not vcite_template_name_list[name] then -- if not already saved vcite_template_name_list[name] = 1; -- save it else -- here when this name already saved vcite_template_name_list[name] = vcite_template_name_list[name] + 1; -- to indicate that there are multiple same name templates end total = total + 1; -- tally total number of vcite templates end tstart = tend; -- reset the search starting index tstart, tend = Article_content:find (pattern, tstart); -- search for another vcite template end end collapsible_tables.vcite = template_name_table_make (vcite_template_name_list, 'vcite'); --mw.logObject (vcite_template_name_list, 'vcite_template_name_list') return total; end --[[--------------------------< C O U N T _ V C I T E _ R E F S >---------------------------------------------- Using the list of cs1 templates, make a count of just those references as dictated by base_pattern. ]] local function count_vcite_refs (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.vcite_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected vcite template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< S F N _ H A R V _I N F O _ G E T >--------------------------------------------- Using the list of sfn and harv templates, make a count of those templates. Make lists of sfn and harv templates used. ]] local function sfn_harv_info_get (Article_content, pattern, template_name_list, object) local tstart, tend = Article_content:find (pattern); -- find the first cs1 template local total = 0; while tstart do -- nil when the template not found local template = Article_content:match ('%b{}', tstart); -- get the whole template if template then -- necessary? local name = template:match ('{{%s*([^|}]+)'); -- get template name name=mw.text.trim (name); -- trim whitespace if not template_name_list[name] then -- if not already saved template_name_list[name] = 1; -- save it else -- here when this name already saved template_name_list[name] = template_name_list[name] + 1; -- to indicate that there are multiple same name templates end total = total + 1; -- tally total number of templates end tstart = tend; -- reset the search starting index tstart, tend = Article_content:find (pattern, tstart); -- search for another template end return total; end --[[--------------------------< C O U N T _ S F N >------------------------------------------------------------ Using the list of sfn templates, make a count of just those templates as dictated by base_pattern. makes a list of sfn templates in the article ]] local function count_sfn (Article_content, base_pattern, object) local _; local pattern; local total = 0; local sfn_template_name_list = {}; for i, sfn_template in ipairs (data.sfn_template_patterns) do pattern = string.format (base_pattern, sfn_template); -- make a pattern for the selected template total = total + sfn_harv_info_get (Article_content, pattern, sfn_template_name_list, object); end collapsible_tables.sfn = template_name_table_make (sfn_template_name_list, 'sfn'); --mw.logObject (sfn_template_name_list, 'sfn_template_name_list') return total; end --[[--------------------------< C O U N T _ H A R V >---------------------------------------------------------- Using the list of harv templates, make a count of just those templates as dictated by base_pattern. makes a list of harv templates in the article ]] local function count_harv (Article_content, base_pattern, object) local _; local pattern; local total = 0; local harv_template_name_list = {}; for i, harv_template in ipairs (data.harv_template_patterns) do pattern = string.format (base_pattern, harv_template); -- make a pattern for the selected template total = total + sfn_harv_info_get (Article_content, pattern, harv_template_name_list, object); end collapsible_tables.harv = template_name_table_make (harv_template_name_list, 'harv'); --mw.logObject (harv_template_name_list, 'harv_template_name_list') return total; end --[[--------------------------< C O U N T _ H A R V _ R E F S >------------------------------------------------ Using the list of harv templates, make a count of those references as dictated by base_pattern. ]] local function count_harv_refs (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.harv_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected cs1 template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< C O U N T _ R E F B E G I N >-------------------------------------------------- Using the list of cleanup templates, make a count of those templates as dictated by base_pattern. ]] local function count_refbegin (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.refbegin_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected cleanup template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< C O U N T _ R P >-------------------------------------------------------------- Using the list of cleanup templates, make a count of those templates as dictated by base_pattern. ]] local function count_rp (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.rp_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected cleanup template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< C O U N T _ C L E A N U P >---------------------------------------------------- Using the list of cleanup templates, make a count of those templates as dictated by base_pattern. ]] local function count_cleanup (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.cleanup_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected cleanup template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< C O U N T _ D E A D _ L I N K S >---------------------------------------------- Using the list of dead link templates, make a count of those templates as dictated by base_pattern. ]] local function count_dead_links (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.dead_link_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected cleanup template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< C O U N T _ W E B A R C H I V E >---------------------------------------------- Using the list of webarchive aliases, make a count of those templates as dictated by base_pattern. ]] local function count_webarchive (text, base_pattern) local _; local pattern; local count, total = 0, 0; for i, template in ipairs (data.webarchive_template_patterns) do pattern = string.format (base_pattern, template); -- make a pattern for the selected webarchive template _, count = mw.ustring.gsub (text, pattern, '%1'); -- count occurences of that pattern total = total + count; -- accumulate a total end return total; end --[[--------------------------< H A S _ L D R >---------------------------------------------------------------- returns a string set to 'yes' if the article uses list defined references. ldr uses {{reflist |refs=...}} or <references>...</references>. Here we do simple 'find's to make the determination. It is also possible to do ldr with {{refbegin}} ... {{refend}} the pattern value is passed to this function but ignored ]] local function has_ldr (text) local pattern; for i, template in ipairs (data.reflist_template_patterns) do pattern = string.format ('{{%%s*%s[^}]*|%%s*refs%%s*=%%s*[^}|]+', template); -- make a pattern using the selected reflist template if mw.ustring.find (text, '{{%s*[Rr]eflist[^}]*|%s*refs%s*=%s*[^}|]+') then -- does page use {{Reflist |refs=...}}? return 'yes' end end if mw.ustring.find (text, '<references>[^<]+') then -- no reflist template, does page use <references>...</references>? return 'yes' else return 'no'; end end --[[--------------------------< H A S _ U S E _ X X X _ D A T E S >-------------------------------------------- returns string set to either of 'dmy' or 'mdy' TODO: needs companion |cs1-dates= support somehow ... 2 separate tests? one detects {{use xxx dates |cs1-dates=xx}} the other detects {{use xxx dates}}? Also, detect conflicting |df= parameters? ]] local global_df; local function has_use_xxx_dates (text, pattern) local ret_val = 'no'; -- presume not found local df_template_patterns = { -- table of redirects to {{Use dmy dates}} and {{Use mdy dates}} '{{ *[Uu]se (dmy) dates *[|}]', -- 915k -- sorted by approximate transclusion count '{{ *[Uu]se *(mdy) *dates *[|}]', -- 161k '{{ *[Uu]se (DMY) dates *[|}]', -- 2929 '{{ *[Uu]se *(dmy) *[|}]', -- 250 + 34 '{{ *([Dd]my) *[|}]', -- 272 '{{ *[Uu]se (MDY) dates *[|}]', -- 173 '{{ *[Uu]se *(mdy) *[|}]', -- 59 + 12 '{{ *([Mm]dy) *[|}]', -- 9 '{{ *[Uu]se (MDY) *[|}]', -- 3 '{{ *([Dd]MY) *[|}]', -- 2 '{{ *([Mm]DY) *[|}]', -- 0 -- '{{ *[Uu]se(mdy) *[|}]', -- '{{ *[Uu]se(mdy)dates *[|}]', -- '{{ *[Uu]se(dmy) *[|}]', } for _, pattern in ipairs (df_template_patterns) do -- loop through the patterns looking for {{Use dmy dates}} or {{Use mdy dates}} or any of their redirects local start, _, match = text:find(pattern); -- match is the three letters indicating desired date format if match then ret_val = match; -- set return value to the global date format global_df = match; -- save for |df= tests text = text:match ('%b{}', start); -- get the whole use xxx dates template if text:match ('| *cs1%-dates *= *[lsy][sy]?') then -- look for |cs1-dates=publication date length access-/archive-date length ret_val = ret_val .. ' [' .. text:match ('| *cs1%-dates *= *([lsy][sy]?)') .. ']'; end break; -- loop escape end end return ret_val; end --[[--------------------------< O B J E C T S T A B L E >---------------------------------------------------- Here we define various properties and values necessary to the counting of referencing objects ]] local objects = { ['unnamed_refs'] = { -- count unnamed ref tags ['func'] = count_pattern, -- the function that does the work for this object ['pattern'] = '(<ref>)', -- a pattern that the function uses to find and count this object ['count'] = 0, -- the returned result (called count because that is the most common but can be 'yes' or 'no' etc ['label'] = 'unnamed refs' -- a label and markup for displaying the result; used with string.format() }, ['named_refs'] = { -- count named ref tags ['func'] = count_pattern, ['pattern'] = '(<ref%s+name%s*=%s*[%a%d%p ]+>)', ['count'] = 0, ['label'] = 'named refs' }, ['self_closed_refs'] = { -- count self closed ref tags ['func'] = count_pattern, ['pattern'] = '(<ref%s*name%s*=%s*["%a%d%p ]+/>)', ['count'] = 0, ['label'] = 'self closed' }, ['r_templates'] = { -- count R templates (wrapper for self closed refs) ['func'] = count_pattern, ['pattern'] = '({{%s*[Rr]%s*|)', ['count'] = 0, ['label'] = 'R templates' }, ['refn_templates'] = { -- count Refn templates ['func'] = count_pattern, ['pattern'] = '({{%s*[Rr]efn%s*|)', ['count'] = 0, ['label'] = 'Refn templates' }, ['bare_url_refs'] = { -- count bare url refs ['func'] = count_pattern, -- TODO: separate function to detect protocol relative urls? ['pattern'] = '(<ref[^>]*>%s*http[^<%s]+%s*</ref>)', ['count'] = 0, ['label'] = '<span style="font-size:inherit" class="error">bare url refs</span>' }, ['ext_link_refs'] = { -- count unlabeled external link refs ['func'] = count_pattern, -- TODO: separate function to detect protocol relative urls? ['pattern'] = '(<ref[^>]*>%[%s*http[^%]<%s]+%][^<]*</ref>)', ['count'] = 0, ['label'] = '<span style="font-size:inherit" class="error">bare ext link refs</span>' }, ['cs1_like_refs'] = { -- count cs1 refs and refs that look like cs1 (cite something) ['func'] = count_cs1_like_refs, ['pattern'] = '(<ref[^>]*>[^<{]*{{%s*[Cc]ite%s+[^|]+)', ['count'] = 0, ['label'] = 'cs1-like refs' }, ['cs1_refs'] = { -- count cs1 refs only ['func'] = count_cs1_refs, ['pattern'] = '(<ref[^>]*>[^<{]*{{%%s*%s%%s*|)', -- will be modified in the func by string.format() ['count'] = 0, ['label'] = 'cs1 refs' }, ['cs1_like_templates'] = { -- count templates that look like cs1 ['func'] = count_cs1_like_templates, ['pattern'] = '({{%s*[Cc]ite%s+[^|]+)', ['count'] = 0, ['label'] = 'cs1-like templates' }, ['cs1_templates'] = { -- count cs1 templates only ['func'] = count_cs1, ['pattern'] = '({{%%s*%s%%s*|)', -- will be modified in the func by string.format() ['count'] = 0, ['label'] = 'cs1 templates' }, ['cs2_refs'] = { -- count cs2 refs ['func'] = count_cs2_refs, ['pattern'] = '(<ref[^>]*>[^<{]*{{%%s*%s%%s*|)', -- will be modified in the func by string.format() ['count'] = 0, ['label'] = 'cs2 refs' }, ['cs2_templates'] = { -- count cs2 templates ['func'] = count_cs2, ['pattern'] = '{{%%s*%s%%s*|', ['count'] = 0, ['label'] = 'cs2 templates' }, ['vcite_refs'] = { -- count vancite, vcite, and vcite2 refs -- ['func'] = count_pattern, -- ['pattern'] = '(<ref[^>]*>[^<{]*{{%s*[Vv]a?n?cite2?%s+[^|]+)', ['func'] = count_vcite_refs, ['pattern'] = '(<ref[^>]*>[^<{]*{{%%s*%s%%s*|)', ['count'] = 0, ['label'] = 'vcite refs' }, ['vcite_templates'] = { -- count vancite templates ['func'] = count_vcite, ['pattern'] = '{{%%s*%s%%s*|', -- ['func'] = count_pattern, -- ['pattern'] = '({{%s*[Vv]a?n?cite2?%s+[^|]+)', ['count'] = 0, ['label'] = 'vcite templates' }, ['wikicite_templates'] = { -- count wikicite templates ['func'] = count_pattern, ['pattern'] = '({{%s*[Ww]ikicite%s*|)', ['count'] = 0, ['label'] = 'wikicite templates' }, ['harv_refs'] = { -- count harv refs ['func'] = count_harv_refs, ['pattern'] = '(<ref[^>]*>[^<{]*{{%%s*%s%%s*|)', -- will be modified in the func by string.format() ['count'] = 0, ['label'] = 'harv refs' }, ['harv_templates'] = { -- count harv templates ['func'] = count_harv, ['pattern'] = '({{%%s*%s%%s*|)', ['count'] = 0, ['label'] = 'harv templates' }, ['sfn_templates'] = { -- count sfn templates ['func'] = count_sfn, ['pattern'] = '({{%%s*%s%%s*|)', ['count'] = 15, ['label'] = 'sfn templates' }, ['rp_templates'] = { -- count rp templates ['func'] = count_rp, ['pattern'] = '({{%%s*%s%%s*[|}])', ['count'] = 0, ['label'] = 'rp templates' }, ['ldr'] = { -- does this article use list defined references? ['func'] = has_ldr, ['pattern'] = '', -- uses multiple patterns which are defined in the function ['count'] = 'no', ['label'] = 'uses ldr' }, ['refbegin_templates'] = { -- count refbegin templates - bibliography lists ['func'] = count_refbegin, ['pattern'] = '({{%%s*%s%%s*[|}])', ['count'] = 0, ['label'] = 'refbegin templates' }, ['cleanup_templates'] = { -- count cleanup templates ['func'] = count_cleanup, ['pattern'] = '({{%%s*%s%%s*[|}])', -- will be modified in the func by string.format() ['count'] = 0, ['label'] = 'cleanup templates' }, ['dead_link_templates'] = { -- count deadlink templates (includes redirects) ['func'] = count_dead_links, ['pattern'] = '({{%%s*%s%%s*[|}])', -- will be modified in the func by string.format() ['count'] = 0, ['label'] = 'dead link templates' }, ['webarchive_templates'] = { -- count webarchive templates (includes redirects) ['func'] = count_webarchive, ['pattern'] = '({{%%s*%s%%s*|)', -- will be modified in the func by string.format() ['count'] = 0, ['label'] = 'webarchive templates' }, ['use_xxx_dates'] = { -- does this article use list defined references? ['func'] = has_use_xxx_dates, ['pattern'] = nil, -- uses multiple patterns that are defined in the function ['count'] = 'no', ['label'] = 'use xxx dates' }, ['cs1_dates_df_dmy'] = { -- count ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 df dmy' }, ['cs1_dates_df_mdy'] = { -- count ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 df mdy' }, ['cs1_dates_df_ymd'] = { -- count ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 df ymd' }, ['cs1_dmy_dates'] = { -- count cs1 templates only ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 dmy dates' }, ['cs1_mdy_dates'] = { -- count cs1 templates only ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 mdy dates' }, ['cs1_ymd_dates'] = { -- count cs1 templates only ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 ymd dates' }, ['cs1_last'] = { -- count cs1 templates only ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 last/first' }, ['cs1_author'] = { -- count cs1 templates only ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 author' }, ['cs1_authors'] = { -- count cs1 templates only ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 authors' }, ['cs1_vauthors'] = { ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1|2 vauthors' }, ['cs1_mode'] = { ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs1 mode' }, ['cs2_mode'] = { ['func'] = nil, -- handled by cs1_cs2_info_get() ['pattern'] = nil, ['count'] = 0, ['label'] = 'cs2 mode' }, } -- here we set the order in which the objects are processed local order = {'unnamed_refs', 'named_refs', 'self_closed_refs', -- these three are always output 'r_templates', -- this and the others only produce output when ... 'refn_templates', -- ... their count is not 0 or not 'no' 'bare_url_refs', 'ext_link_refs', 'cs1_refs', 'cs1_templates', 'cs1_like_refs', 'cs1_like_templates', 'cs2_refs', 'cs2_templates', 'vcite_refs', 'vcite_templates', 'wikicite_templates', 'harv_refs', 'harv_templates', 'sfn_templates', 'rp_templates', 'ldr', 'refbegin_templates', 'cleanup_templates', 'dead_link_templates', 'webarchive_templates', 'use_xxx_dates', 'cs1_dates_df_dmy', 'cs1_dates_df_mdy', 'cs1_dates_df_ymd', 'cs1_dmy_dates', 'cs1_mdy_dates', 'cs1_ymd_dates', 'cs1_last', 'cs1_author', 'cs1_authors', 'cs1_vauthors', 'cs1_mode', 'cs2_mode', }; --[[--------------------------< R E F _ I N F O >-------------------------------------------------------------- the working part of Template:Ref info ]] local function ref_info (frame) local text; -- unparsed page content local title; -- page title without namespace or interwiki references local nstitle; -- page title with namespace and interwiki references local page_title_object; -- local output = {}; local i=1; local style = frame.args.style or ''; -- styling css for output table if frame.args[1] then page_title_object = mw.title.new(frame.args[1]); -- title object for the page specified in the template call else page_title_object = mw.title.getCurrentTitle(); -- title object for the current page end text = page_title_object:getContent(); -- the unparsed content of the selected page text = text:gsub ('<nowiki>.-</nowiki>', ''); -- remove nowiki tags and their content; less constrained text = text:gsub ('<!%-%-.-%-%->', ''); -- remove html comments and their content text = text:gsub ('<pre>.-</pre>', ''); -- remove pre tags and their content nstitle = page_title_object.prefixedText; -- the title of the page (with namespace) title = page_title_object.text; -- the title of the page (without namespace) if nil == text then return string.format ('<span style="font-size:100%%" class="error">{{ref info}} – page is empty or does not exist: %s</span>', frame.args[1] or 'no page'); end for i, object in ipairs (order) do -- loop through order and search for the related objects if objects[object].func then objects[object].count = objects[object].func (text, objects[object].pattern, objects) -- do the search and store the result end end -- for those that count duplicates remove the duplicates from the counts objects['named_refs'].count = objects['named_refs'].count - objects['self_closed_refs'].count; table.insert (output, string.format ('{| class="wikitable" style="text-align:right; %s"\n|+reference info for [[%s|%s]]', style, nstitle, title)); -- output table header for i, object in ipairs (order) do -- loop through order and search for the related objects if i<=3 then -- first three (reference tags) are always output table.insert (output, string.format ('%s\n|%s', objects[object].label, objects[object].count)); elseif 'string' == type (objects[object].count) then -- objects[object].count can be a string or a number if 'no' ~= objects[object].count then -- if a string and not 'no' ... table.insert (output, string.format ('%s\n|%s', objects[object].label, objects[object].count)); -- output the result end elseif 'number' == type (objects[object].count) then -- if a number ... if 0 < objects[object].count then -- ... and count is greater than zero ... table.insert (output, string.format ('%s\n|%s', objects[object].label, objects[object].count)); -- ... output the result end end end output = {table.concat (output,'\n|-\n! scope="row" | ')}; -- concat an intermediate result table.insert (output, collapsible_tables.cs1); -- add the collapsible tables table.insert (output, collapsible_tables.cs2); table.insert (output, collapsible_tables.cs1_like); table.insert (output, collapsible_tables.vcite); table.insert (output, collapsible_tables.sfn); table.insert (output, collapsible_tables.harv); table.insert (output, '\n|-\n|scope="row" colspan="2" style="text-align:center"|[[Template:Ref_info#Output_meanings|explanations]]\n|-\n|}'); return table.concat (output); end --[[--------------------------< E X P O R T E D F U N C T I O N S >------------------------------------------ ]] return { ref_info = ref_info, }