Changes

local is_set, in_arraylang_object = mw.getContentLanguage(); -- imported functions from selected Moduleused by is_valid_accessdate(), is_valid_year(), date_name_xlate(); TODO:Citationmove to ~/CS1/UtilitiesConfiguration?local cfgyear_limit; -- table of tables imported from slected Module:Citation/CS1/Configurationused by is_valid_year() 

accessdate is the date provided in |accessdateaccess-date= at time 00:00:00 UTC

apparently doesn't understand non-Engish English date month names. This function will always return false when the date

local access_ts, tomorrow_ts; -- to hold unix Unix time stamps representing the dates good1, access_ts = pcall( langlang_object.formatDate, langlang_object, 'U', accessdate ); -- convert accessdate value to unix timesatmp Unix timestamp good2, tomorrow_ts = pcall( langlang_object.formatDate, langlang_object, 'U', 'today + 2 days' ); -- today midnight + 2 days is one second more than all day tomorrow

access_ts = tonumber (access_ts) or langlang_object:parseFormattedNumber (access_ts); -- convert to numbers for the comparison; tomorrow_ts = tonumber (tomorrow_ts) or langlang_object:parseFormattedNumber (tomorrow_ts);

return false; -- one or both failed to convert to unix Unix time stamp

returns false and 9999 (embargoed forever) when date value is not proper format; assumes that when |pmc-embargo-date= isset, the editor intended to embargo a pmc PMC but |pmc-embargo-date= does not hold a single date.

returns a number according to the sequence of seasons in a year: 1 21 for WinterSpring, etc. Capitalization and spelling must be correct. If not a valid season, returns 0. 21-24 = Spring, Summer, Autumn, Winter, independent of “Hemisphere” returns 0 when <param> is not |date=

Uses Season numbering is defined by Extended Date/Time Format (EDTF) specification (https://www.loc.gov/standards/datetime/)which became part of ISO DIS 8601 2016 part 2 §4in 2019.7 Divisions of a See '§Sub-year for hemishperegroupings'. The standard defines various divisions usingnumbers 21-independent 41. cs1|2 only supports generic seasons:. EDTF does support the distinction between north and south 21-24 = Spring, Summer, Autumn, Winter, independent of “Hemisphere”hemispere seasons but cs1|2 has no way to make that distinction.

local function get_season_number (season, param) if 'date' ~= param then return 0; -- season dates only supported by |date= end

--[[--------------------------< G E T _ Q U A R T E R _ N U M B E R >------------------------------------------ returns a number according to the sequence of quarters in a year: 33 for first quarter, etc. Capitalization and spellingmust be correct. If not a valid quarter, returns 0. 33-36 = Quarter 1, Quarter 2, Quarter 3, Quarter 4 (3 months each) returns 0 when <param> is not |date= Quarter numbering is defined by Extended Date/Time Format (EDTF) specification (https://www.loc.gov/standards/datetime/)which became part of ISO 8601 in 2019. See '§Sub-year groupings'. The standard defines various divisions usingnumbers 21-41. cs1|2 only supports generic seasons and quarters. These additional divisions not currently supported: 37-39 = Quadrimester 1, Quadrimester 2, Quadrimester 3 (4 months each) 40-41 = Semestral 1, Semestral-2 (6 months each) ]] local function get_quarter_number (quarter, param) if 'date' ~= param then return 0; -- quarter dates only supported by |date= end quarter = mw.ustring.gsub (quarter, ' +', ' '); -- special case replace multiple space chars with a single space char return cfg.date_names['local'].quarter[quarter] or -- look for local names first cfg.date_names['en'].quarter[quarter] or -- failing that, look for English names 0; -- not a recognized quarter nameend  --[[--------------------------< G E T _ P R O P E R _ N A M E _ N U M B E R >---------------------------------- returns a non-zero number if date contains a recognized proper -name. Capitalization and spelling must be correct. returns 0 when <param> is not |date=

local function is_proper_name get_proper_name_number (name, param) if 'date' ~= param then return 0; -- proper-name dates only supported by |date= end

--[[--------------------------< G E T _ E L E M E N T _ N U M B E R <------------------------------------------ returns true if month or season or quarter or proper name is valid (properly spelled, capitalized, abbreviated)

local function is_valid_month_or_season get_element_number (month_seasonelement, param) if 0 =local num; local funcs = {get_month_number , get_season_number, get_quarter_number, get_proper_name_number}; -- list of functions to execute in order for _, func in ipairs (month_seasonfuncs) then do -- if month text isn't one of spin through the twelve monthsfunction list num = func (element, might be a seasonparam); -- call the function and get the returned number if 0 ~== get_season_number (month_season) num then -- not a non-zero when valid month, is it a season?quarter return falsenum; -- return false not a month or one of the five seasonsthat number

return truenil; -- not valid

Function gets current year from the server and compares it to year from a citation parameter. Years more than one year in the future are not acceptable.

local year_limit;local function is_valid_year(year)

year_limit = tonumber(os.date("%Y"))+1; -- global variable so we only have to fetch it once

  return year = tonumber(year) <= year_limitor lang_object:parseFormattedNumber (year); -- false if convert to numbers for the comparison; return year is in the future more than one and (year<= year_limit) or false;

if (2==month) then -- if February

if 0==(year%4) then -- is a leap year? month_length = 29; -- if leap year then 29 days in February

if (0==(year%4) and (0~=(year%100) or 0==(year%400))) then -- is a leap year?

month_length=days_in_month[month];

elseif 'May' == month1 or 'May'== month2 then-- ToDo: I18N

All season ranges are accepted as valid because there are publishers out there who have published a Summer–Spring YYYY issue so ... , hence treat as ok

local function is_valid_month_season_range(range_start, range_end, param)

range_start_number = get_season_number (range_start, param); -- not a month; is it a season? get start season number range_end_number = get_season_number (range_end, param); -- get end season number

if (0 ~= range_start_number) and (0 ~= range_end_number) and (range_start_number ~= range_end_number) then return true; -- any season pairing is acceptedexcept when both are the same

rftdate: an IS8601 ISO 8601 formatted date rftchron: a free-form version of the date, usually without year which is in rftdate (season ranges and propername proper-name dates)

(((1582 == year) and (10 <= month) and (12 >= month)) or -- any whole 1582 date from 1 october October to 31 December or

-- end temporary Julian / Gergorian Gregorian calendar uncertainty detection

if 20 < tonumber(input.month) then -- if season or propername proper-name date local season = {[24]='winter', [21]='spring', [22]='summer', [23]='fall', [33] = '1', [34] = '2', [35] = '3', [36] = '4', [98] = 'Easter', [99]='Christmas'}; -- seasons lowercase, no autumn; proper -names use title case

if 30 40 <tonumber(input.month) then tCOinS_date.rftchron = season[input.month]; -- proper -name dates elseif 30 < tonumber(input.month) then tCOinS_date.rftquarter = season[input.month]; -- quarters

COinS_date. When this happens, the date parameter is (DEBUG: not?) used in the COinS metadata and the CITEREF identifier gets

date_string - date string from date-holding parameters (date, year, accessdatepublication-date, access-date, pmc-embargo-date, archivedatearchive-date, etc.lay-date)

local function check_date (date_string, param, tCOinS_date, test_accessdate) local year; -- assume that year2, months, and days are not used; local year2=0; -- second year in a year range local month=0; local month2=0; -- second month in a month range local day=0; local day2=0; -- second day in a day range

if date_string:match("^%d%d%d%d%-%d%d%-%d%d$"patterns['ymd'][1]) then -- year-initial numerical year month day format year, month, day=string.date_string:match(date_string, "(%d%d%d%d)%-(%d%d)%-(%d%d)"patterns['ymd'][1]);

elseif mw.ustring.match(date_string, "^%D- +patterns[1-9'Mdy']%d?, +[1-9]%d%d%d%a?$") then -- month-initial: month day, year month, day, anchor_year, year=mw.ustring.match(date_string, "(%D-) +(%d%d?),%s*((%d%d%d%d?)%a?)"patterns['Mdy'][1]);

if 0 == month then return false; end -- return false if month text isn't one of the twelve months

elseif mw.ustring.match(date_string, "^%D- +[1-9]%d?patterns[%'Md-–dy'][1-9]%d?, +[1-9]%d%d%d%a?$") then -- month-initial day range: month day–day, year; days are separated by endash month, day, day2, anchor_year, year=mw.ustring.match(date_string, "(%Dpatterns['Md-) +(%d%d?)dy'][%-–1](%d%d?), +((%d%d%d%d)%a?)"); if tonumber(day) >= tonumber(day2) then return false; end -- date range order is left to right: earlier to later; dates may not be the same; month = get_month_number (month); if 0 == month then return false; end -- return false if month text isn't one of the twelve months month2=month; -- for metadata year2 = year;  elseif mw.ustring.match(date_string, patterns['dMy'][1]) then -- day-initial: day month year day, month, anchor_year, year = mw.ustring.match(date_string, patterns['dMy'][1]);

if 0 == month then return false; end -- return false if month text isn't one of the twelve months month2=month; -- for metadata year2=year;

--[[ NOT supported at en.wiki elseif mw.ustring.match(date_string, "^patterns[1-9'yMd']%d? +%D- +[1-9]%d%d%d%a?$") then -- dayyear-initial: year month day month year; day: 1 or 2 two digits, leading zero allowed dayanchor_year, year, month, anchor_year, yearday =mw.ustring.match(date_string, "(%d%d*)%s*(%D-) +((%d%d%d%d?)%a?)"patterns['yMd'][1]);

if 0 == month then return false; end -- return false if month text isn't one of the twelve months-- end NOT supported at en.wiki ]]

elseif mw.ustring.match(date_string, "^patterns[1-9]%'d?[%-–dMy'][1-9]%d? +%D- +[1-9]%d%d%d%a?$") then -- day-range-initial: day–day month year; days are separated by endash day, day2, month, anchor_year, year=mw.ustring.match(date_string, "(%patterns['d%d?)-dMy'][%-–1](%d%d?) +(%D-) +((%d%d%d%d)%a?)"); if tonumber(day) >= tonumber(day2) then return false; end -- date range order is left to right: earlier to later; dates may not be the same;

if 0 == month then return false; end -- return false if month text isn't one of the twelve months month2=month; -- for metadata year2=year;

elseif mw.ustring.match(date_string, "^patterns[1-9]%d? +%D- +[%'dM-–dMy'] +[1-9]%d? +%D- +[1-9]%d%d%d%a?$") then -- day initial month-day-range: day month - day month year; uses spaced endash day, month, day2, month2, anchor_year, year=mw.ustring.match(date_string, "(%d%d?) +(%Dpatterns['dM-) +dMy'][%-–1] +(%d%d?) +(%D-) +((%d%d%d%d)%a?)");

month = get_month_number (month); -- for metadata

year2=year;

elseif mw.ustring.match(date_string, "^%D- +patterns[1'Md-9Mdy']%d? +[%-–] +%D- +[1-9]%d?, +[1-9]%d%d%d%a?$") then -- month initial month-day-range: month day – month day, year; uses spaced endash month, day, month2, day2, anchor_year, year=mw.ustring.match(date_string, "(%Dpatterns['Md-) +(%d%d?) +Mdy'][%-–1] +(%D-) +(%d%d?), +((%d%d%d%d)%a?)"); if (not is_valid_month_season_range(month, month2, param)) or not is_valid_year(year) then return false; end month = get_month_number (month); -- for metadata

year2=year;

elseif mw.ustring.match(date_string, "^patterns[1-9]%d? +%D- +[1-9]%d%d%d +[%'dMy-–dMy'] +[1-9]%d? +%D- +[1-9]%d%d%d%a?$") then -- day initial month-day-year-range: day month year - day month year; uses spaced endash day, month, year, day2, month2, anchor_year, year2=mw.ustring.match(date_string, "(%d%d?) +(%Dpatterns['dMy-) +(%d%d%d%d) +dMy'][%-–1] +(%d%d?) +(%D-) +((%d%d%d%d)%a?)"); if tonumber(year2) <= tonumber(year) then return false; end -- must be sequential years, left to right, earlier to later

month = get_month_number (month); -- for metadata

elseif mw.ustring.match(date_string, "^%D- +patterns[1'Mdy-9Mdy']%d?, +[1-9]%d%d%d +[%-–] +%D- +[1-9]%d?, +[1-9]%d%d%d%a?$") then -- month initial month-day-year-range: month day, year – month day, year; uses spaced endash month, day, year, month2, day2, anchor_year, year2=mw.ustring.match(date_string, "(%Dpatterns['Mdy-) +(%d%d?), +(%d%d%d%d) +Mdy'][%-–1] +(%D-) +(%d%d?), +((%d%d%d%d)%a?)"); if tonumber(year2) <= tonumber(year) then return false; end -- must be sequential years, left to right, earlier to later

month = get_month_number (month); -- for metadata month2 = get_month_number (month2); if 0 == month or 0 == month2 then return false; end -- both must be valid

elseif mw.ustring.match(date_string, "^%D- +patterns[1'Sy4-9y2']%d%d%d[%-–1]%d%d%a?$") then -- special case Winter/Summer year-year (YYYY-YY); year separated with unspaced endash

month, year, century, anchor_year, year2=mw.ustring.match(date_string, "(%Dpatterns['Sy4-) +((%d%d)%d%d)y2'][%-–1]((%d%d)%a?)"); if 'Winter' ~= month and 'Summer' ~= month then return false end; -- 'month' can only be Winter or Summer anchor_year=year..'–'..anchor_year; -- assemble anchor_year from both years year2 = century..year2; -- add the century to year2 for comparisons if 1 ~= tonumber(year2) - tonumber(year) then return false; end -- must be sequential years, left to right, earlier to later if not is_valid_year(year2) then return false; end -- no year farther in the future than next year month = get_season_number (month, param);

elseif mw.ustring.match(date_string, "^%D- +patterns[1'Sy-9]%d%d%d[%-–y'][1-9]%d%d%d%a?$") then -- special case Winter/Summer year-year; year separated with unspaced endash month, year, anchor_year, year2=mw.ustring.match(date_string, "(%Dpatterns['Sy-) +(%d%d%d%d)y'][%-–1]((%d%d%d%d)%a?)"); if 'Winter' ~= month and 'Summer' ~= month then return false end; -- 'month' can only be Winter or Summer anchor_year=year..'–'..anchor_year; -- assemble anchor_year from both years if 1 ~= tonumber(year2) - tonumber(year) then return false; end -- must be sequential years, left to right, earlier to later if not is_valid_year(year2) then return false; end -- no year farther in the future than next year month = get_season_number (month, param); -- for metadata

elseif mw.ustring.match(date_string, "^%D- +patterns[1'My-9My']%d%d%d +[%-–] +%D- +[1-9]%d%d%d%a?$") then -- month/season year - month/season year; separated by spaced endash month, year, month2, anchor_year, year2=mw.ustring.match(date_string, "(%Dpatterns['My-) +(%d%d%d%d) +My'][%-–1] +(%D-) +((%d%d%d%d)%a?)"); anchor_year=year..'–'..anchor_year; -- assemble anchor_year from both years if tonumber(year) >= tonumber(year2) then return false; end -- left to right, earlier to later, not the same if not is_valid_year(year2) then return false; end -- no year farther in the future than next year

elseif 0 ~= get_season_number(month, param) and 0 ~= get_season_number(month2, param) then -- both must be or season year, not mixed month = get_season_number(month, param); month2 = get_season_number(month2, param);

elseif mw.ustring.match(date_string, "^%D-patterns[%'M-–My']%D- +[1-9]%d%d%d%a?$") then -- month/season range year; months separated by endash month, month2, anchor_year, year=mw.ustring.match(date_string, "(%Dpatterns['M-)My'][%-–1](%D-)%s*((%d%d%d%d)%a?)"); if (not is_valid_month_season_range(month, month2, param)) or (not is_valid_year(year)) then return false; end

month = get_season_number(month, param); month2 = get_season_number(month2, param);

year2=year;

elseif mw.ustring.match(date_string, "^%D- +%d%d%d%d%a?$"patterns['My'][1]) then -- month/season year or /quarter/proper-name year month, anchor_year, year=mw.ustring.match(date_string, "(%D-)%s*((%d%d%d%d)%a?)"patterns['My'][1]);

if not is_valid_month_or_season (month) and 0 == is_proper_name get_element_number(month, param) then return false; end if 0 ~= get_month_number(month) then -- determined to be a valid range so just check this one to know if get month season quarter proper-name number or season month = get_month_number(month);nil elseif 0 ~= get_season_number(if not month) then month = get_season_number(month); else month = is_proper_name (month)return false; end -- must be proper name; not supported in COinS endvalid whatever it is

elseif mw.ustring.match(date_string, "^patterns[1-9]%d%d%d?[%'y-–y'][1-9]%d%d%d?%a?$") then -- Year range: YYY-YYY or YYY-YYYY or YYYY–YYYY; separated by unspaced endash; 100-9999 year, anchor_year, year2=mw.ustring.match(date_string, "(%d%d%d%d?)patterns[%'y-–y'][1]((%d%d%d%d?)%a?)"); anchor_year=year..'–'..anchor_year; -- assemble anchor year from both years

elseif mw.ustring.match(date_string, "^patterns[1'y4-9y2']%d%d%d[%-–1]%d%d%a?$") then -- Year range: YYYY–YY; separated by unspaced endash

year, century, anchor_year, year2=mw.ustring.match(date_string, "((%d%d)%d%d)patterns[%'y4-–y2'][1]((%d%d)%a?)"); anchor_year=year..'–'..anchor_year; -- assemble anchor year from both years  if in_array (param, {'date', 'publication-date', 'year'}) then add_prop_cat ('year_range_abbreviated'); end 

year2 = century..year2; -- add the century to year2 for comparisons

elseif date_string:mw.ustring.match("^date_string, patterns['y'][1-9]%d%d%d?%a?$") then -- year; here accept either YYY or YYYY anchor_year, year=date_string:mw.ustring.match("((%d%d%d%d?)%a?)"date_string, patterns['y'][1]);

if test_accessdate 'access-date' == param then -- test accessdate here because we have numerical date parts

if not is_valid_accessdate (year..'-'..month..'-'..day) then

result=is_valid_date(year,month,day);

result=is_valid_date(year,month,day); result=result and is_valid_date(year,month,day2);

result=is_valid_date(year,month,day); result=result and is_valid_date(year,month2,day2);

result=is_valid_date(year,month,day); result=result and is_valid_date(year2,month2,day2);

make_COinS_date ({year=year, month=month, day=day, year2=year2, month2=month2, day2=day2}, tCOinS_date); -- make an ISO 8601 date string for COinS

a single error message is created parameters with errors are added to the <error_list> sequence table as the dates are tested.

local function dates(date_parameters_list, tCOinS_date, error_list) local anchor_year; -- will return as nil if the date being tested is not |date= local COinS_date; -- will return as nil if the date being tested is not |date=

if is_set(v.val) then -- if the parameter has a value v.val = mw.ustring.gsub(v.val, '%d', cfg.date_names.local_digits); -- translate 'local' digits to Western 0-9 if v.val:match("^c%. [1-9]%d%d%d?%a?$") then -- special case for c. year or with or without CITEREF disambiguator - only |date= and |year= v = mw.ustring.gsub (v, '%d', cfg.date_names.local_digits); local year = v.val:match("c%. ([1-9]%d%d%d?)%a?"); -- get the year portion so it can be tested if 'date'==k then anchor_year, COinS_date = v.val:match("((c%. [1-9]%d%d%d?)%a?)"); -- anchor year and COinS_date only from |date= parameter

elseif 'year'==k then

elseif 'date'==k then -- if the parameter is |date= if v.val:match("^n%.d%.%a?$") then -- ToDo: I18N -- if |date=n.d. with or without a CITEREF disambiguator good_date, anchor_year, COinS_date = true, v.val:match("((n%.d%.)%a?)"); -- ToDo: I18N --"n.d."; no error when date parameter is set to no date elseif v.val:match("^nd%a?$") then -- ToDo: I18N -- if |date=nd with or without a CITEREF disambiguator good_date, anchor_year, COinS_date = true, v.val:match("((nd)%a?)"); -- ToDo: I18N --"nd"; no error when date parameter is set to no date

good_date, anchor_year, COinS_date = check_date (v.val, k, tCOinS_date); -- go test the date

elseif 'year'==k then -- if the parameter is |year= it should hold only a year value if v.val:match("^[1-9]%d%d%d?%a?$") then -- if |year= 3 or 4 digits only with or without a CITEREF disambiguator good_date, anchor_year, COinS_date = true, v.val:match("((%d+)%a?)");

elseif 'accesspmc-embargo-date'==k then -- if the parameter is |pmc-embargo-date= good_date = check_date (v.val, nil, true); -- go test the date; nil is a placeholder; true is the test_accessdate flag elseif 'embargo'==k then -- if the parameter is |embargo= good_date = check_date (v); -- go test the date

good_date, embargo_date = is_valid_embargo_date (v.val); -- is |pmc-embargo-date= date a single dmy, mdy, or ymd formatted date? yes:returns embargo; no: returns 9999

good_date = check_date (v.val, k); -- go test the date

if false==good_date then -- assemble one error message so we don't add the tracking category multiple times if is_settable.insert (error_list, wrap_style (error_message) then -- once we've added the first portion of the error message ... error_message=error_message .. "parameter', "; -- v... add a comma space separator end error_message=error_message .. "&#124name));" .. k .. "="; -- add the failed make parametername suitable for error message list

return anchor_year, embargo_date, error_message; -- and done

elseif mw.ustring.match(date_string, "%d%d%d%d[%-–]%d%d") then -- YYYY-YY date ranges

--[[--------------------------< R E F O R M A T T A B L E S R >--------------------------------------------------------

These table are used exclusively reformat 'date' into new format specified by format_param if pattern_idx (the current format of 'date') can bereformatted. Does the grunt work for reformatting datesreformat_dates().

The table re_formats maps pattern_idx (current format) and format_param (desired format) to a table that holds: format string used by string.format() identifier letters ('d', 'm', 'y', 'd2', 'm2', 'y2') that serve as indexes into a table t{} that holds captures from mw.ustring.match() for the various date parts specified by patterns[pattern_idx][1]

local source_patterns = Items in patterns{ -- this table holds patterns that match allowed date formats used to extract date components} have the general form: ['dmyymd'] = {'^(%d%d?)%s+(d%a+d)%s+-(%d%d)%-(%d%d)$', ['mdyy', '] = m'^(%a+)%s+(%d%d?),%s+(%d%d%'d%d)$'},where: ['ymd'] = is pattern_idx patterns['ymd'^][1] is the match pattern with captures for mw.ustring.match(%d%d%d%d)%-(%d%d)-(%d%d)$ patterns['ymd',][2] is an indicator letter identifying the content of the first capture } patterns['ymd'][3] ... the second capture etc.

local short_formats = when a pattern matches a date, the captures are loaded into table t{} in capture order using the idemtifiercharacters as indexes into t{ -- this table holds format strings used by os.} For the above, a ymd date() for short month namesis in t{} as: ['dmy'] t.y = '%e %b %Y'first capture (year), ['mdy'] t.m = '%b %esecond capture (month), %Y', ['ymd'] t.d = '%F', }third capture (day)

local long_formats = { -- To reformat, this function is called with the pattern_idx that matches the current format of the date and withformat_param set to the desired format. This function loads table holds t{} as described and then calls string.format strings used by os.date() for long month names with the format string specified by re_format['dmy'pattern_idx] = '%e %B %Y', ['mdy'format_param] = '%B %e, %Y', ['ymd'1] = '%F', using values taken from t{}according  --to the capture identifier letters specified by patterns[pattern_idx][format_param][-------------------------< G E T _ D M Y _ D A T E _ P A R T S >------------------------------------------ extracts year, month and day from DMY formatted date, places them in the source_date table, and returnsn] where n is 2..

local function get_dmy_date_parts (re_formats = { ['ymd'] = { -- dateformat is ymd; reformat to: ['mdy'] = {'%s %s, %s', 'm', source_date)'d', 'y'}, -- |df=mdy ['dmy'] = {'%s %s %s', 'd', 'm', 'y'}, -- |df=dmy-- source_date['yMd'] = {'%s %s %s', 'y', 'm', 'd'}, -- |df=yMd; not supported at en.daywiki }, ['Mdy'] = { -- date format is Mdy; reformat to: ['mdy'] = {'%s %s, %s', 'm', 'd', 'y'}, -- for long/short reformatting ['dmy'] = {'%s %s %s', 'd', 'm', 'y'}, -- |df=dmy ['ymd'] = {'%s-%s-%s', 'y', 'm', 'd'}, -- |df=ymd-- ['yMd'] = {'%s %s %s', 'y', 'm', source_date'd'}, -- |df=yMd; not supported at en.monthwiki }, ['dMy'] = { -- date format is dMy; reformat to: ['dmy'] = {'%s %s %s', 'd', 'm', 'y'}, -- for long/short reformatting ['mdy'] = {'%s %s, %s', 'm', 'd', source_date'y'}, -- |df=mdy ['ymd'] = {'%s-%s-%s', 'y', 'm', 'd'}, -- |df=ymd-- ['yMd'] = {'%s %s %s', 'y', 'm', 'd'}, -- |df=yMd; not supported at en.year wiki }, ['Md-dy'] = { -- dateformat is Md-dy; reformat to:match (source_patterns ['mdy'] = {'%s %s–%s, %s', 'm', 'd', 'd2', 'y'}, -- for long/short reformatting ['dmy'] = {'%s–%s %s %s', 'd', 'd2', 'm', 'y'}, -- |df=dmy-> d-dMy }, ['d-dMy'])= { -- date format is d-d>y; reformat to: ['dmy'] = {'%s–%s %s %s', 'd', 'd2', 'm', 'y'}, -- for long/short reformatting ['mdy'] = {'%s %s–%s, %s', 'm', 'd', 'd2', 'y'}, -- |df=mdy -> Md-dy }, ['dM-dMy'] = { -- get date components as stringsformat is dM-dMy; reformat to: ['dmy'] = {'%s %s – %s %s %s', 'd', 'm', 'd2', 'm2', 'y'}, -- for long/short reformatting ['mdy'] = {'%s %s – %s %s, %s', 'm', 'd', 'm2', 'd2', 'y'}, -- |df=mdy -> Md-Mdy }, ['Md-Mdy'] = { -- date format is Md-Mdy; reformat to: ['mdy'] = {'%s %s – %s %s, %s', 'm', 'd', 'm2', 'd2', 'y'}, -- for long/short reformatting ['dmy'] = {'%s %s – %s %s %s', 'd', 'm', 'd2', 'm2', 'y'}, -- |df=dmy -> dM-dMy }, ['dMy-dMy'] = { -- date format is dMy-dMy; reformat to: ['dmy'] = {'%s %s %s – %s %s %s', 'd', 'm', 'y', 'd2', 'm2', 'y2'}, -- for long/short reformatting ['mdy'] = {'%s %s, %s – %s %s, %s', 'm', 'd', 'y', 'm2', 'd2', 'y2'}, -- |df=mdy -> Mdy-Mdy }, source_date['Mdy-Mdy'] = { -- date format is Mdy-Mdy; reformat to: ['mdy'] = {'%s %s, %s – %s %s, %s', 'm', 'd', 'y', 'm2', 'd2', 'y2'}, -- for long/short reformatting ['dmy'] = {'%s %s %s – %s %s %s', 'd', 'm', 'y', 'd2', 'm2', 'y2'}, -- |df=dmy -> dMy-dMy }, ['My-My'] = { -- these for long/short reformatting ['any'] = {'%s %s – %s %s', 'm', 'y', 'm2', 'y2'}, -- dmy/mdy agnostic }, ['M-My'] = { -- these for long/short reformatting ['any'] = {'%s–%s %s', 'm', 'm2', 'y'}, -- dmy/mdy agnostic }, ['My'] = { -- these for long/short reformatting ['any'] = {'%s %s', 'm', 'y'}, -- dmy/mdy agnostic },-- ['yMd'] = { -- not supported at en.month wiki-- ['mdy'] = {'%s %s, %s', 'm', 'd', 'y'}, -- |df= get_month_number (source_date.month); mdy-- ['dmy'] = {'%s %s %s', 'd', 'm', 'y'}, -- |df=dmy-- ['ymd'] = {'%s-%s-%s', 'y', 'm', 'd'}, -- |df=ymd-- get month number },end }

local function reformatter (date, pattern_idx, format_param, mon_len) if not in_array (pattern_idx, {'ymd', 'Mdy', 'Md-dy', 'dMy', 'yMd', 'd-[[--dMy', 'dM-dMy', 'Md-Mdy', 'dMy-dMy', 'Mdy-Mdy', 'My-My', 'M-My', 'My'}) then return; --not in this set of date format patterns then not a reformattable date end if 'ymd' == format_param and in_array (pattern_idx, {'ymd', 'Md-dy', 'd-dMy', 'dM-dMy', 'Md-Mdy', 'dMy-dMy', 'Mdy-Mdy', 'My---------< G E T _ My', 'M D Y _ D A T E _ P A R T S >----------------------------------------My', 'My'}) then return; --ymd date ranges not supported at en.wiki; no point in reformatting ymd to ymd end

extracts year if in_array (pattern_idx, month and day from MDY formatted date{'My', places them in the source_date table'M-My', and returns.'My-My'}) then -- these are not dmy/mdy so can't be 'reformatted' into either format_param = 'any'; -- so format-agnostic end

-- yMd is not supported at en.wiki -- if yMd is supported at your wiki, uncomment the next line-- if 'yMd' == format_param and in_array (pattern_idx, {'yMd', 'Md-dy', 'd-dMy', 'dM-dMy', 'Md-Mdy', 'dMy-dMy', 'Mdy-Mdy'}) then -- these formats not convertable; yMd not supported at en.wiki -- if yMd is supported at your wiki, remove or comment-out the next line if 'yMd' == format_param then -- yMd not supported at en.wiki return; -- not a reformattable date end local c1, c2, c3, c4, c5, c6, c7; -- these hold the captures specified in patterns[pattern_idx][1] c1, c2, c3, c4, c5, c6, c7 = mw.ustring.match (date, patterns[pattern_idx][1]); -- get the captures

local function get_mdy_date_parts (t = { -- table that holds k/v pairs of date, source_date) source_dateparts from the captures and patterns[pattern_idx][2.month, source_date.day, source_date.year ] [patterns[pattern_idx][2]] = c1; -- at minimum there is always one capture with a matching indicator letter [patterns[pattern_idx][3] or 'x'] = date:match (source_patternsc2; -- patterns can have a variable number of captures; each capture requires an indicator letter; [patterns[pattern_idx][4] or 'mdyx'])= c3; -- get date components as stringswhere there is no capture, there is no indicator letter so n in patterns[pattern_idx][n] will be nil; source_date.month [patterns[pattern_idx][5] or 'x'] = get_month_number (source_date.month)c4; -- get month numberthe 'x' here spoofs an indicator letter to prevent 'table index is nil' error [patterns[pattern_idx][6] or 'x'] = c5; [patterns[pattern_idx][7] or 'x'] = c6; [patterns[pattern_idx][8] or 'x'] = c7;end };

if tonumber(t.m) then --if raw month is a number (converting from ymd) if 's' == mon_len then -- if we are to use abbreviated month names t.m = cfg.date_names['inv_local_s'][tonumber(t.m)]; --convert it to a month name else t.m = cfg.date_names['inv_local_l'][tonumber(t.m)]; --convert it to a month name end t.d = t.d:gsub ('0(%d)', '%1'); --strip leading '0' from day if present elseif 'ymd' == format_param then --when converting to ymd if 1582 > tonumber(t.y) then --ymd format dates not allowed before 1582 return; end t.m = string.format ('%02d', get_month_number (t.m)); --make sure that month and day are two digits t.d = string.format ('%02d', t.d); elseif mon_len then -------------< G E T if mon_len is set to either 'short' or 'long' for _ Y M D _ D A T E _ P A R T S >----------------------------------, mon in ipairs ({'m', 'm2'}) do --because there can be two month names, check both if t[mon] then t[mon] = get_month_number (t[mon]); --get the month number for this month (is length agnostic) if 0 == t[mon] then return; end --seasons and named dates can't be converted t[mon] = (('s' == mon_len) and cfg.date_names['inv_local_s'][t[mon]]) or cfg.date_names['inv_local_l'][t[mon]]; --fetch month name according to length end endextracts year, month and day from YMD formatted date, places them in the source_date table, and returns. end

local new_date = string.format (re_formats[pattern_idx][format_param][1], -- format string t[re_formats[pattern_idx][format_param][2]], -- named captures from t{} t[re_formats[pattern_idx][format_param][3]], t[re_formats[pattern_idx][format_param][4]], t[re_formats[pattern_idx][format_param][5]], t[re_formats[pattern_idx][format_param][6]], t[re_formats[pattern_idx][format_param][7]], t[re_formats[pattern_idx][format_param][8]] );

local function get_ymd_date_parts (date, source_date) source_date.year, source_date.month, source_date.day = date:match (source_patterns['ymd'])return new_date; -- get date components as strings

Reformats existing dates into the format specified by format and short.

format is one of several manual keywords: dmy, dmy-all, mdy, mdy-all, ymd, ymd-all. The -all version includes access- andarchive-dates; otherwise these dates are not reformatted.

Date rangesThis function allows automatic date formatting. In ~/Configuration, season the article source is searched for one ofthe {{use xxx dates}} templates. If found, proper name xxx becomes the global date format as xxx-all. If |cs1-dates= in{{use xxx dates}} has legitimate value then that value determines how cs1|2 dates will be rendered. Legitimatevalues for |cs1-dates= are: l - all dates are rendered with long month names ls - publication dates use long month names; access-/archive-dates use abbreviated month names ly - publication dates use long month names; access-/archive-dates rendered in ymd format s - all dates are not currently supported.rendered with abbreviated (short) month names sy - publication dates use abbreviated month names; access-/archive-dates rendered in ymd format y - all dates are rendered in ymd format

For i18n: This code works only at en.wiki because os.the format argument for automatic date() doesn't support any languages other than English.formatting will be the format specified by {{use xxx dates}} with themw.getContentLanguage()value supplied by |cs1-dates so one of:formatDate() will work at nonxxx-l, xxx-ls, xxx-ly, xxx-s, xxx-English wikis only when the date format is yyyysy, xxx-mmy, or simply xxx (|cs1-dd. This isdates=the same issue that plagues is_valid_accessdate(empty, omitted, or invalid)where xxx shall be either of dmy or mdy.

It dates are extracted from date_parameters_list, reformatted (if appropriate), and then written back into thelist in the new format. Dates in date_parameters_list are presumed here to be valid (no errors). This functionreturns true when a date has been reformatted, false else. Actual reformatting is possible that a solution like that written for ht:Module:Citation/CS1/Date_validation date_name_xlatedone by reformatter() could be applied to this problem.

local function reformat_dates (date_parameters_list, format, short)

local format_strlen_p = 'l'; -- default publication date length shall be long local len_a = 'l'; -- default access-/archive-date length shall be long local source_date result = {}false; local new_date;

if format:match('%a+%-all') then -- manual df keyword; auto df keyword when length not specified in {{use xxx dates}};

all = true; -- set to all dates are long format dates because this keyword doesn't specify length elseif format:match('%a+%-[lsy][sy]?') then -- auto df keywords; internal only all = true ; -- auto df applies to all dates; use length specified by capture len_p for all dates format, len_p, len_a = format:match('(%a+)%-([lsy])([sy]?)'); -- extract the format and length keywords if 'y' == len_p then -- because allowed by MOS:DATEUNIFY (sort of) range dates and My dates not reformatted format = 'ymd'; -- override {{use xxx dates}} elseif (not is_set(len_a)) or (len_p == len_a) then -- no access- and /archive-date length specified or same length as publication datesthen len_a = len_p; -- in case len_a not set end end -- else only publication dates and they are long

if is_set (param_val.val) then -- if the parameter has a value if not (not all and in_array (param_name, {'access-date', 'archive-date'})) then -- if skip access- or archive-date and unless format not is xxx-all; yeah, ugly; TODO: find a better way param_val = ''; -- set to empty string so we don't process this date end for sourcepattern_idx, pattern in pairs (source_patternspatterns) do if param_val:mw.ustring.match (param_val.val, pattern[1]) then if all and in_array (param_name, {'ymdaccess-date' == source then get_ymd_date_parts (param_val, source_date'archive-date'}); then -- if this date is an access-or archive- get the date parts into the source_date table elseif 'dmy' new_date == source then get_dmy_date_parts reformatter (param_val.val, pattern_idx, source_date); -- get the date parts into the source_date table elseif (('mdyy' == source then get_mdy_date_parts (param_val, source_datelen_a); -- get the date parts into the source_date table end  if and 'ymd' == ) or format and 1582 > tonumber(source_date.year, len_a) then ; -- choose ymd format dates not allowed before 1582or dmy/mdy according to len_a setting return false; else -- abandon reformattingall other dates end if short then format_str new_date = short_formats[reformatter (param_val.val, pattern_idx, format], len_p); else end format_str = long_formats[format]; end if new_date then -- convert set when date and save;was reformatted date_parameters_list[param_name] .val = mw.text.trim (os.new_date; -- update date in date (format_str, os.time(source_date)))list result = true; -- strip leading space when single digit day and %e is first formatannounce that changes have been made end end -- if end -- for end -- if end -- if end -- for return trueresult; -- declare success boolean result and done

if is_set (param_val.val) then if not param_val:mw.ustring.match (param_val.val, '%d%d%d%d%-%d%d%-%d%d') then -- for those that are not ymd dates(ustring because here digits may not be Western) param_val.val, n = param_val.val:gsub ('%-', '–'); -- replace any hyphen with ndash if 0 ~= n then date_parameters_list[param_name] .val = param_val.val; -- update the list result = true; end

local function date_name_xlate (date_parameters_list, xlt_dig)

if is_set(param_val.val) then -- if the parameter has a value date = param_val.val;

if mode then -- might be a season xlate = mw.getContentLanguage()lang_object:formatDate(mode, '1' .. month); -- translate the month name to this local language date = mw.ustring.gsub (date, month, xlate); -- replace the English with the translation date_parameters_list[param_name] .val = date; -- save the translated date

is_set add_prop_cat = utilities_page_ptr.is_setadd_prop_cat ; -- import functions from selected Module:Citation/CS1/Utilities module is_set = utilities_page_ptr.is_set; in_array = utilities_page_ptr.in_array; -- import functions from selected Module:Citation/CS1/Utilities moduleset_message = utilities_page_ptr.set_message; wrap_style = utilities_page_ptr.wrap_style;