Module:Citation/CS1/Date validation: Difference between revisions

Line 3:

]]

local is_set, in_array; -- imported functions from selected Module:Citation/CS1/Utilities

local add_prop_cat, is_set, in_array, wrap_style; -- imported functions from selected Module:Citation/CS1/Utilities

local cfg; -- table of tables imported from selected Module:Citation/CS1/Configuration

Line 23:

Wikipedia start date is 2001-01-15T00:00:00 UTC which is 979516800 seconds after 1970-01-01T00:00:00 UTC (the start of Unix time)

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

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

today is the current date at time 00:00:00 UTC plus 48 hours

if today is 2015-01-01T00:00:00 then

Line 30:

This function does not work if it is fed month names for languages other than English. Wikimedia #time: parser

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

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

contains a non-English month name because good1 is false after the call to lang.formatDate(). To get around that

call this function with YYYY-MM-DD format dates.

Line 38:

local function is_valid_accessdate (accessdate)

local good1, good2;

local access_ts, tomorrow_ts; -- to hold ~~unix~~ time stamps representing the dates

local access_ts, tomorrow_ts; -- to hold Unix time stamps representing the dates

good1, access_ts = pcall (lang_object.formatDate, lang_object, 'U', accessdate ); -- convert accessdate value to ~~unix timesatmp~~

good1, access_ts = pcall (lang_object.formatDate, lang_object, 'U', accessdate ); -- convert accessdate value to Unix timestamp

good2, tomorrow_ts = pcall (lang_object.formatDate, lang_object, 'U', 'today + 2 days' ); -- today midnight + 2 days is one second more than all day tomorrow

Line 47:

tomorrow_ts = tonumber (tomorrow_ts) or lang_object:parseFormattedNumber (tomorrow_ts);

else

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

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

end

Line 62:

returns true and date value if that value has proper dmy, mdy, ymd format.

returns false and 9999 (embargoed forever) when date value is not proper format; assumes that when |embargo= is

returns false and 9999 (embargoed forever) when date value is not proper format; assumes that when |pmc-embargo-date= is

set, the editor intended to embargo a ~~pmc~~ but |embargo= does not hold a single date.

set, the editor intended to embargo a PMC but |pmc-embargo-date= does not hold a single date.

]]

Line 99:

returns 0 when <param> is not |date=

Season numbering is defined by Extended Date/Time Format (EDTF) ~~Specification~~ (https://www.loc.gov/standards/datetime/)

Season 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 using

numbers 21-41. cs1|2 only supports generic seasons. EDTF does support the distinction between north and south

Line 131:

returns 0 when <param> is not |date=

Quarter numbering is defined by Extended Date/Time Format (EDTF) ~~Specification~~ (https://www.loc.gov/standards/datetime/)

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 using

numbers 21-41. cs1|2 only supports generic seasons and quarters.

Line 228:

month = tonumber(month); -- required for YYYY-MM-DD dates

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

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

month_length = 28; -- then 28 days unless

if 1582 > tonumber(year) then -- Julian calendar

if 0==(year%4) then -- is a leap year?

if 0 == (year%4) then -- is a leap year?

month_length = 29; -- if leap year then 29 days in February

end

else -- Gregorian calendar

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

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

month_length = 29; -- if leap year then 29 days in February

end

else

month_length=days_in_month[month];

month_length = days_in_month[month];

end

Line 264:

if len1 == len2 then

return true; -- both months are short form so return true

elseif 'May' == month1 or 'May'== month2 then

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

return true; -- both months are long form so return true

elseif 3 == len1 or 3 == len2 then

Line 280:

Month pairs are expected to be left to right, earliest to latest in time.

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

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

]]

Line 292:

range_end_number = get_season_number (range_end, param); -- get end season number

if (0 ~= range_start_number) and (0 ~= range_end_number) then

if (0 ~= range_start_number) and (0 ~= range_end_number) and (range_start_number ~= range_end_number) then

return true; -- any season pairing is accepted

return true; -- any season pairing is accepted except when both are the same

end

return false; -- range_start and/or range_end is not a season

Line 331:

the output table receives:

rftdate: an ~~IS8601~~ formatted date

rftdate: an ISO 8601 formatted date

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

rftssn: one of four season keywords: winter, spring, summer, fall (lowercase)

Line 346:

local day = tonumber (input.day);

if (0 ~= day) and -- day must have a value for this to be a whole date

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

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

((1926 == year) and (1 == month) and (1 == input.day)) or -- 1 January 1926 or

((1582 < year) and (1925 >= year))) then -- any date 1 January 1583 – 31 December 1925

tCOinS_date.inter_cal_cat = true; -- set category flag true

end

-- end temporary Julian / ~~Gergorian~~ calendar uncertainty detection

-- end temporary Julian / Gregorian calendar uncertainty detection

if 1582 > tonumber(input.year) or 20 < tonumber(input.month) then -- Julian calendar or season so &rft.date gets year only

Line 359:

end

if 20 < tonumber(input.month) then -- if season or 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

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 0 == input.month2 then -- single season date

if 40 <tonumber(input.month) then

if 40 < tonumber(input.month) then

tCOinS_date.rftchron = season[input.month]; -- proper-name dates

elseif 30 <tonumber(input.month) then

elseif 30 < tonumber(input.month) then

tCOinS_date.rftquarter = season[input.month]; -- quarters

else

Line 446:

-- month/season range year; months separated by endash

['M-My'] = {'^(%D-)[%-–](%D-) +((%d%d%d%d)%a?)$', 'm', 'm2', 'a', 'y'},

-- month/season year or proper-name year; quarter year when First Quarter YYYY etc

-- month/season year or proper-name year; quarter year when First Quarter YYYY etc.

['My'] = {'^([^%d–]-) +((%d%d%d%d)%a?)$', 'm', 'a', 'y'}, -- this way because endash is a member of %D; %D- will match January–March 2019 when it shouldn't

-- these date formats cannot be converted

~~-- ['Q,y'] = {'^(Q%a* +[1-4]), +((%d%d%d%d)%a?)$'}, -- Quarter n, yyyy~~

['Sy4-y2'] = {'^(%D-) +((%d%d)%d%d)[%-–]((%d%d)%a?)$'}, -- special case Winter/Summer year-year (YYYY-YY); year separated with unspaced endash

['Sy-y'] = {'^(%D-) +(%d%d%d%d)[%-–]((%d%d%d%d)%a?)$'}, -- special case Winter/Summer year-year; year separated with unspaced endash

Line 468:

Line 466:

If the date fails the format tests, this function returns false and does not return values for anchor_year and

COinS_date. When this happens, the date parameter is used in the COinS metadata and the CITEREF identifier gets

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

its year from the year parameter if present otherwise CITEREF does not get a date value.

Inputs:

date_string - date string from date-holding parameters (date, year, ~~accessdate~~, embargo, ~~archivedate~~, ~~etc.~~)

date_string - date string from date-holding parameters (date, year, publication-date, access-date, pmc-embargo-date, archive-date, lay-date)

Returns:

Line 484:

Line 482:

local function check_date (date_string, param, tCOinS_date)

local year; -- assume that year2, months, and days are not used;

local year2=0; -- second year in a year range

local year2 = 0; -- second year in a year range

local month=0;

local month = 0;

local month2=0; -- second month in a month range

local month2 = 0; -- second month in a month range

local day=0;

local day = 0;

local day2=0; -- second day in a day range

local day2 = 0; -- second day in a day range

local anchor_year;

local coins_date;

if date_string:match (patterns['ymd'][1]) then -- year-initial numerical year month day format

year, month, day=date_string:match (patterns['ymd'][1]);

year, month, day = date_string:match (patterns['ymd'][1]);

if 12 < tonumber(month) or 1 > tonumber(month) or 1582 > tonumber(year) or 0 == tonumber(day) then return false; end -- month or day number not valid or not Gregorian calendar

anchor_year = year;

~~-- elseif mw.ustring.match(date_string, patterns['Q,y'][1]) then -- quarter n, year; here because much the same as Mdy~~

~~-- month, anchor_year, year=mw.ustring.match(date_string, patterns['Q,y'][1]);~~

~~-- if not is_valid_year(year) then return false; end~~

~~-- month = get_quarter_number (month, param); -- get quarter number or nil~~

~~-- if not month then return false; end -- not valid whatever it is~~

elseif mw.ustring.match(date_string, patterns['Mdy'][1]) then -- month-initial: month day, year

month, day, anchor_year, year=mw.ustring.match(date_string, patterns['Mdy'][1]);

month, day, anchor_year, year = mw.ustring.match(date_string, patterns['Mdy'][1]);

month = get_month_number (month);

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, patterns['Md-dy'][1]) 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, patterns['Md-dy'][1]);

month, day, day2, anchor_year, year = mw.ustring.match(date_string, patterns['Md-dy'][1]);

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;

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]);

day, month, anchor_year, year = mw.ustring.match(date_string, patterns['dMy'][1]);

month = get_month_number (month);

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

Line 523:

Line 515:

--[[ NOT supported at en.wiki

elseif mw.ustring.match(date_string, patterns['yMd'][1]) then -- year-initial: year month day; day: 1 or 2 two digits, leading zero allowed

anchor_year, year, month, day=mw.ustring.match(date_string, patterns['yMd'][1]);

anchor_year, year, month, day = mw.ustring.match(date_string, patterns['yMd'][1]);

month = get_month_number (month);

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

Line 529:

Line 521:

elseif mw.ustring.match(date_string, patterns['d-dMy'][1]) 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-dMy'][1]);

day, day2, month, anchor_year, year = mw.ustring.match(date_string, patterns['d-dMy'][1]);

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

month2 = month; -- for metadata

year2=year;

year2 = year;

elseif mw.ustring.match(date_string, patterns['dM-dMy'][1]) 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, patterns['dM-dMy'][1]);

day, month, day2, month2, anchor_year, year = mw.ustring.match(date_string, patterns['dM-dMy'][1]);

if (not is_valid_month_season_range(month, month2)) or not is_valid_year(year) then return false; end -- date range order is left to right: earlier to later;

month = get_month_number (month); -- for metadata

month2 = get_month_number (month2);

year2=year;

year2 = year;

elseif mw.ustring.match(date_string, patterns['Md-Mdy'][1]) 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, patterns['Md-Mdy'][1]);

month, day, month2, day2, anchor_year, year = mw.ustring.match(date_string, patterns['Md-Mdy'][1]);

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

month2 = get_month_number (month2);

year2=year;

year2 = year;

elseif mw.ustring.match(date_string, patterns['dMy-dMy'][1]) 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, patterns['dMy-dMy'][1]);

day, month, year, day2, month2, anchor_year, year2 = mw.ustring.match(date_string, patterns['dMy-dMy'][1]);

if tonumber(year2) <= tonumber(year) then return false; end -- must be sequential years, left to right, earlier to later

if not is_valid_year(year2) or not is_valid_month_range_style(month, month2) then return false; end -- year2 no more than one year in the future; months same style

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, patterns['Mdy-Mdy'][1]) 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, patterns['Mdy-Mdy'][1]);

month, day, year, month2, day2, anchor_year, year2 = mw.ustring.match(date_string, patterns['Mdy-Mdy'][1]);

if tonumber(year2) <= tonumber(year) then return false; end -- must be sequential years, left to right, earlier to later

if not is_valid_year(year2) or not is_valid_month_range_style(month, month2) then return false; end -- year2 no more than one year in the future; months same style

month = get_month_number (month); -- for metadata

month2 = get_month_number (month2);

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, patterns['Sy4-y2'][1]) then -- special case Winter/Summer year-year (YYYY-YY); year separated with unspaced endash

local century;

month, year, century, anchor_year, year2=mw.ustring.match(date_string, patterns['Sy4-y2'][1]);

month, year, century, anchor_year, year2 = mw.ustring.match(date_string, patterns['Sy4-y2'][1]);

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

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);

month = get_season_number(month, param);

elseif mw.ustring.match(date_string, patterns['Sy-y'][1]) then -- special case Winter/Summer year-year; year separated with unspaced endash

month, year, anchor_year, year2=mw.ustring.match(date_string, patterns['Sy-y'][1]);

month, year, anchor_year, year2 = mw.ustring.match(date_string, patterns['Sy-y'][1]);

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

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

Line 583:

Line 577:

elseif mw.ustring.match(date_string, patterns['My-My'][1]) then -- month/season year - month/season year; separated by spaced endash

month, year, month2, anchor_year, year2=mw.ustring.match(date_string, patterns['My-My'][1]);

month, year, month2, anchor_year, year2 = mw.ustring.match(date_string, patterns['My-My'][1]);

anchor_year=year..'–'..anchor_year; -- assemble anchor_year from both years

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

Line 598:

Line 592:

elseif mw.ustring.match(date_string, patterns['M-My'][1]) then -- month/season range year; months separated by endash

month, month2, anchor_year, year=mw.ustring.match(date_string, patterns['M-My'][1]);

month, month2, anchor_year, year = mw.ustring.match(date_string, patterns['M-My'][1]);

if (not is_valid_month_season_range(month, month2, param)) or (not is_valid_year(year)) 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 month or season

month = get_month_number(month);

month2 = get_month_number(month2);

if 0 == month or 0 == month2 then return false; end

else

month = get_season_number(month, param);

month2 = get_season_number(month2, param);

end

year2=year;

year2 = year;

elseif mw.ustring.match(date_string, patterns['My'][1]) then -- month/season/quarter/proper-name year

month, anchor_year, year=mw.ustring.match(date_string, patterns['My'][1]);

month, anchor_year, year = mw.ustring.match(date_string, patterns['My'][1]);

if not is_valid_year(year) then return false; end

month = get_element_number (month, param); -- get month season quarter proper-name number or nil

month = get_element_number(month, param); -- get month season quarter proper-name number or nil

if not month then return false; end -- not valid whatever it is

elseif mw.ustring.match(date_string, patterns['y-y'][1]) 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, patterns['y-y'][1]);

year, anchor_year, year2 = mw.ustring.match(date_string, patterns['y-y'][1]);

anchor_year=year..'–'..anchor_year; -- assemble anchor year from both years

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

Line 623:

Line 618:

elseif mw.ustring.match(date_string, patterns['y4-y2'][1]) then -- Year range: YYYY–YY; separated by unspaced endash

local century;

year, century, anchor_year, year2=mw.ustring.match(date_string, patterns['y4-y2'][1]);

year, century, anchor_year, year2 = mw.ustring.match(date_string, patterns['y4-y2'][1]);

anchor_year=year..'–'..anchor_year; -- assemble anchor year from both years

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

if 13 > tonumber(year2) then return false; end -- don't allow 2003-05 which might be May 2003

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

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

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 mw.ustring.match (date_string, patterns['y'][1]) then -- year; here accept either YYY or YYYY

elseif mw.ustring.match(date_string, patterns['y'][1]) then -- year; here accept either YYY or YYYY

anchor_year, year=mw.ustring.match (date_string, patterns['y'][1]);

anchor_year, year = mw.ustring.match(date_string, patterns['y'][1]);

if false == is_valid_year(year) then

return false;

Line 643:

if 0 ~= year and 0 ~= month and 0 ~= day and -- all parts of a single date required

0 == year2 and 0 == month2 and 0 == day2 then -- none of these; accessdate must not be a range

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

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

return false; -- return false when accessdate out of bounds

end

Line 653:

local result=true; -- check whole dates for validity; assume true because not all dates will go through this test

if 0 ~= year and 0 ~= month and 0 ~= day and 0 == year2 and 0 == month2 and 0 == day2 then -- YMD (simple whole date)

result=is_valid_date(year,month,day);

result = is_valid_date(year, month, day);

elseif 0 ~= year and 0 ~= month and 0 ~= day and 0 == year2 and 0 == month2 and 0 ~= day2 then -- YMD-d (day range)

result=is_valid_date(year,month,day);

result = is_valid_date(year, month, day);

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

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

elseif 0 ~= year and 0 ~= month and 0 ~= day and 0 == year2 and 0 ~= month2 and 0 ~= day2 then -- YMD-md (day month range)

result=is_valid_date(year,month,day);

result = is_valid_date(year, month, day);

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

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

elseif 0 ~= year and 0 ~= month and 0 ~= day and 0 ~= year2 and 0 ~= month2 and 0 ~= day2 then -- YMD-ymd (day month year range)

result=is_valid_date(year,month,day);

result = is_valid_date(year, month, day);

result=result and is_valid_date(year2,month2,day2);

result = result and is_valid_date(year2, month2, day2);

end

Line 671:

if nil ~= tCOinS_date then -- this table only passed into this function when testing |date= parameter values

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

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

end

Line 685:

Unlike most error messages created in this module, only one error message is created by this function. Because all of the date holding parameters are processed serially,

~~a single error message is created~~ as the dates are tested.

parameters with errors are added to the <error_list> sequence table as the dates are tested.

]]

local function dates(date_parameters_list, tCOinS_date)

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=

local embargo_date; -- if embargo date is a good dmy, mdy, ymd date then holds original value else reset to 9999

~~local error_message = "";~~

local good_date = false;

for k, v in pairs(date_parameters_list) do -- for each date-holding parameter in the list

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

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=

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

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

good_date = is_valid_year(year);

elseif 'year'==k then

elseif 'year' == k then

good_date = is_valid_year(year);

end

elseif 'date'==k then -- if the parameter is |date=

elseif 'date' == k then -- if the parameter is |date=

if v.val:match("^n%.d%.%a?$") then -- if |date=n.d. with or without a CITEREF disambiguator

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?)"); --"n.d."; no error when date parameter is set to no date

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 -- if |date=nd with or without a CITEREF disambiguator

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?)"); --"nd"; no error when date parameter is set to no date

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

else

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

end

elseif 'year'==k then -- if the parameter is |year= it should hold only a year value

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

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?)");

end

elseif 'embargo'==k then -- if the parameter is |embargo=

elseif 'pmc-embargo-date' == k then -- if the parameter is |pmc-embargo-date=

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

if true == good_date then -- if the date is a valid date

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

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

end

else -- any other date-holding parameter

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

end

if false==good_date then -- assemble one error message so we don't add the tracking category multiple times

if false == good_date then -- assemble one error message so we don't add the tracking category multiple times

~~if is_set~~(~~error_message) then -- once we~~'~~ve added the first portion of the error message ...~~

table.insert (error_list, wrap_style ('parameter', v.name)); -- make parameter name suitable for error message list

~~error_message=error_message .. "~~, ~~"; -- ... add a comma space separator~~

~~end~~

~~error_message=error_message .. "|" ..~~ v.name ~~.. "="~~; -- ~~add the failed~~ parameter

end

return anchor_year, embargo_date~~, error_message~~; -- and done

return anchor_year, embargo_date; -- and done

end

Line 796:

Line 792:

reformatted. Does the grunt work for reformat_dates().

The table re_formats maps ~~patern_idx~~ (current format) and format_param (desired format) to a table that holds:

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

Line 806:

Line 802:

patterns['ymd'][1] is the match pattern with captures for mw.ustring.match()

patterns['ymd'][2] is an indicator letter identifying the content of the first capture

patterns['ymd'][3] ... the second capture etc

patterns['ymd'][3] ... the second capture etc.

when a pattern matches a date, the captures are loaded into table t{} in capture order using the idemtifier

Line 891:

Line 887:

end

-- if 'yMd' == format_param and in_array (pattern_idx, {'yMd', 'Md-dy', 'd-dMy', 'dM-dMy', 'Md-Mdy', 'dMy-dMy', 'Mdy-Mdy'}) then -- not supported at en.wiki

-- yMd is not supported at en.wiki

if 'yMd' == format_param then -- 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

Line 1,036:

Line 1,035:

for param_name, param_val in pairs(date_parameters_list) do -- for each date-holding parameter in the list

if is_set (param_val.val) then

if not 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~~)

if not 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

Line 1,054:

Line 1,053:

date parser function. This is simple name-for-name replacement and may not work for all languages.

if xlat_dig is true, this function will also translate ~~western~~ (English) digits to the local language's digits.

if xlat_dig is true, this function will also translate Western (English) digits to the local language's digits.

This will also translate ymd dates.

]]

local function date_name_xlate (date_parameters_list, xlt_dig)

local xlate;

local mode; -- long or short month names

Line 1,086:

Line 1,085:

if xlt_dig then -- shall we also translate digits?

date = date:gsub ('%d', cfg.date_names.xlate_digits); -- translate digits from ~~western~~ to 'local digits'

date = date:gsub ('%d', cfg.date_names.xlate_digits); -- translate digits from Western to 'local digits'

date_parameters_list[param_name].val = date; -- save the translated date

modified = true;

Line 1,104:

Line 1,103:

local function set_selected_modules (cfg_table_ptr, utilities_page_ptr)

~~is_set~~ = utilities_page_ptr.~~is_set~~; -- import functions from selected Module:Citation/CS1/Utilities module

add_prop_cat = utilities_page_ptr.add_prop_cat ; -- import functions from selected Module:Citation/CS1/Utilities module

in_array = utilities_page_ptr.in_array; -- ~~import functions from selected Module:Citation/CS1/Utilities module~~

is_set = utilities_page_ptr.is_set;

in_array = utilities_page_ptr.in_array;

-- set_message = utilities_page_ptr.set_message;

wrap_style = utilities_page_ptr.wrap_style;

cfg = cfg_table_ptr; -- import tables from selected Module:Citation/CS1/Configuration

end