தமிழர்விக்கி

Module:Citation/CS1/Date validation: திருத்தங்களுக்கு இடையிலான வேறுபாடு

← முந்திய தொகுப்பு
உள்ளடக்கம் நீக்கப்பட்டது உள்ளடக்கம் சேர்க்கப்பட்டது
sync from sandbox;
imported>Info-farmer
en:Module:Citation/CS1/Date_validation இலிருந்து திருத்தங்கள் இறக்குமதி செய்யப்பட்டன
 
(4 பயனர்களால் செய்யப்பட்ட 5 இடைப்பட்ட திருத்தங்கள் காட்டப்படவில்லை.)
வரிசை 185:
end
 
year = tonumber (year) or lang_object:parseFormattedNumber (year); -- convert to number for the comparison;
if year and (100 > year) then -- years less than 100 not supported
return false;
end
if 'pmc-embargo-date' == param then -- special case for |pmc-embargo-date=
வரி 321 ⟶ 324:
local date; -- one date or first date in a range
local date2 = ''; -- end of range date
input.year = tonumber (input.year) or lang_object:parseFormattedNumber (input.year); -- language-aware tonumber()
-- start temporary Julian / Gregorian calendar uncertainty detection
input.year2 = tonumber (input.year2) or lang_object:parseFormattedNumber (input.year2); -- COinS dates are pseudo-ISO 8601 so convert to Arabic numerals
local year = tonumber(input.year); -- this temporary code to determine the extent of sources dated to the Julian/Gregorian
 
local month = tonumber(input.month); -- interstice 1 October 1582 – 1 January 1926
if ((1582 == input.year) and (10 > tonumber(input.month))) or (1582 > input.year) then -- if a Julian calendar date
local day = tonumber (input.day);
tCOinS_date.rftdate = tostring (input.year); -- &rft.date gets year only
if (0 ~= day) and -- day must have a value for this to be a whole date
return; -- done
(((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
-- here for all forms of Gregorian dates
-- end temporary Julian / Gregorian calendar uncertainty detection
if 20 < tonumber (input.month) then -- if season, quarter, or proper-name date
if 1582 date >= tonumber(input.year) or 20 < tonumber(input.month) then; -- Julian calendar or season so &rft.date gets year only
date = input.year;
if 0 ~= input.year2 and input.year ~= input.year2 then -- if a range, only the second year portion when not the same as range start year
date = string.format ('%.4d/%.4d', tonumber(input.year), tonumber(input.year2)) -- assemble the date range
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
if 0 == input.month2 then -- single season, quarter, or proper-name date
if 40 < tonumber(input.month) then
tCOinS_date.rftchron = season[input.month]; -- proper-name datesdate; used in journal metadata only
elseif 30 < tonumber(input.month) then
tCOinS_date.rftquarter = season[input.month]; -- quartersquarter date; used in journal metadata only
else
tCOinS_date.rftssn = season[input.month]; -- seasonsseason date; used in journal metadata only
end
else -- season rangeranges withare alumped secondinto season&rft.chron; &rft.ssn and &rft.quarter are left specifiedblank
if input.year ~= input.year2 then -- season year – season year range or season year–year
if 0 ~= input.month2 then
tCOinS_date.rftssn = season[input.month]; -- start of range season; keep this?
tCOinS_date.rftchron = string.format ('%s %s – %s %s', season[input.month], input.year, season[input.month2], input.year2); -- used in journal metadata only
if 0~= input.month2 then
tCOinS_date.rftchron = string.format ('%s %s – %s %s', season[input.month], input.year, season[input.month2], input.year2);
end
else -- season–season year range
tCOinS_date.rftssn = season[input.month]; -- start of range season; keep this?
tCOinS_date.rftchron = season[input.month] .. '–' .. season[input.month2]; -- season–season year range
end
else -- season–season year range
tCOinS_date.rftchron = season[input.month] .. '–' .. season[input.month2]; -- season–season year range; used in journal metadata only
end
end
 
tCOinS_date.rftdate = date;
tCOinS_date.rftdate = tostring (date);
return; -- done
end
-- here for gregorian calendar dates
if 0 ~= input.day then
date = string.format ('%s-%.2d-%.2d', input.year, tonumber(input.month), tonumber(input.day)); -- whole date
வரி 387 ⟶ 384:
 
 
--[[--------------------------< P A T T E R N S _ T >--------------------------------------------------------------
 
this is the list of patterns for date formats that this module recognizes. Approximately the first half of these
வரி 399 ⟶ 396:
]]
 
local patternspatterns_t = {
-- year-initial numerical year-month-day
['ymd'] = {'^(%d%d%d%d)%-(%d%d)%-(%d%d)$', 'y', 'm', 'd'},
வரி 448 ⟶ 445:
 
local function is_valid_embargo_date (v)
if v:match (patternspatterns_t['ymd'][1]) or -- ymd
v:match (patternspatterns_t['Mdy'][1]) or -- dmy
v:match (patternspatterns_t['dMy'][1]) then -- mdy
return true, v;
end
வரி 489 ⟶ 486:
local coins_date;
 
if date_string:match (patternspatterns_t['ymd'][1]) then -- year-initial numerical year month day format
year, month, day = date_string:match (patternspatterns_t['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, patternspatterns_t['Mdy'][1]) then -- month-initial: month day, year
month, day, anchor_year, year = mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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, patternspatterns_t['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);
வரி 507 ⟶ 504:
year2 = year;
 
elseif mw.ustring.match(date_string, patternspatterns_t['dMy'][1]) then -- day-initial: day month year
day, month, anchor_year, year = mw.ustring.match(date_string, patternspatterns_t['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
 
--[[ NOT supported at en.wiki
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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
-- end NOT supported at en.wiki ]]
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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);
வரி 527 ⟶ 524:
year2 = year;
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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
வரி 534 ⟶ 531:
year2 = year;
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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
வரி 541 ⟶ 538:
year2 = year;
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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
வரி 549 ⟶ 546:
if 0 == month or 0 == month2 then return false; end -- both must be valid
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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
வரி 557 ⟶ 554:
if 0 == month or 0 == month2 then return false; end -- both must be valid
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['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
வரி 567 ⟶ 564:
month = get_season_number(month, param);
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['Sy-y'][1]);
month = get_season_number (month, param); -- <month> can only be winter or summer; also for metadata
if (month ~= cfg.date_names['en'].season['Winter']) and (month ~= cfg.date_names['en'].season['Summer']) then
வரி 577 ⟶ 574:
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, patternspatterns_t['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, patternspatterns_t['My-My'][1]);
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
வரி 592 ⟶ 589:
end
 
elseif mw.ustring.match(date_string, patternspatterns_t['M-My'][1]) then -- month/season range year; months separated by endash
month, month2, anchor_year, year = mw.ustring.match(date_string, patternspatterns_t['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
வரி 605 ⟶ 602:
year2 = year;
elseif mw.ustring.match(date_string, patternspatterns_t['My'][1]) then -- month/season/quarter/proper-name year
month, anchor_year, year = mw.ustring.match(date_string, patternspatterns_t['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
if not month then return false; end -- not valid whatever it is
 
elseif mw.ustring.match(date_string, patternspatterns_t['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, patternspatterns_t['y-y'][1]);
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 mw.ustring.match(date_string, patternspatterns_t['y4-y2'][1]) then -- Year range: YYYY–YY; separated by unspaced endash
local century;
year, century, anchor_year, year2 = mw.ustring.match(date_string, patternspatterns_t['y4-y2'][1]);
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
வரி 631 ⟶ 624:
if not is_valid_year(year2) then return false; end -- no year farther in the future than next year
 
if in_array (param, {'date', 'publication-date', 'year'}) then -- here when 'valid' abbreviated year range; if one of these parameters
elseif mw.ustring.match(date_string, patterns['y'][1]) then -- year; here accept either YYY or YYYY
add_prop_cat ('year-range-abbreviated'); -- add properties cat
anchor_year, year = mw.ustring.match(date_string, patterns['y'][1]);
end
 
elseif mw.ustring.match(date_string, patterns_t['y'][1]) then -- year; here accept either YYY or YYYY
anchor_year, year = mw.ustring.match(date_string, patterns_t['y'][1]);
if false == is_valid_year(year) then
return false;
வரி 647 ⟶ 644:
end
 
if 'access-date' == param then -- test accessdateaccess-date here because we have numerical date parts
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; accessdateaccess-date must not be a range
if not is_valid_accessdate(year .. '-' .. month .. '-' .. day) then
return false; -- return false when accessdateaccess-date out of bounds
end
else
return false; -- return false when accessdateaccess-date is a range of two dates
end
end
 
if 'archive-date' == param then -- test archive-date here because we have numerical date parts
if not (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; archive-date must not be a range
return false; -- return false when archive-date is a range of two dates
end
end
வரி 739 ⟶ 743:
end
return anchor_year, embargo_date; -- and done
end
 
 
--[[--------------------------< Y E A R _ C H E C K >----------------------------------------------------------
 
Temporary function to test |year= for acceptable values:
YYY, YYYY, year-only ranges, their circa forms, with or without CITEREF disambiguators.
 
When |year= holds some form of date that is not one of these year-only dates, emit a maintenance message.
 
This function necessary because many non-cs1|2 templates have a |year= parameter so cirrus searches are more-or-
less useless
 
]]
 
local function year_check (year)
year = year:gsub ('c%. *', ''); -- remove circa annotation (if present) before testing <year>
for _, index in ipairs ({'y-y', 'y4-y2', 'y'}) do -- spin through these indexes into patterns_t
if mw.ustring.match (year, patterns_t[index][1]) then
return; -- if a match then |year= holds a valid 'year'
end
end
 
set_message ('maint_year'); -- if here, |year= value is not an accepted value; add a maint cat
end
 
வரி 812 ⟶ 841:
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 patternspatterns_t[pattern_idx][1]
 
Items in patternspatterns_t{} have the general form:
['ymd'] = {'^(%d%d%d%d)%-(%d%d)%-(%d%d)$', 'y', 'm', 'd'}, where:
['ymd'] is pattern_idx
patternspatterns_t['ymd'][1] is the match pattern with captures for mw.ustring.match()
patternspatterns_t['ymd'][2] is an indicator letter identifying the content of the first capture
patternspatterns_t['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
வரி 828 ⟶ 857:
format_param set to the desired format. This function loads table t{} as described and then calls string.format()
with the format string specified by re_format[pattern_idx][format_param][1] using values taken from t{} according
to the capture identifier letters specified by patternspatterns_t[pattern_idx][format_param][n] where n is 2..
 
]]
வரி 893 ⟶ 922:
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 patternspatterns_t then not a reformattable date
end
வரி 910 ⟶ 939:
end
local c1, c2, c3, c4, c5, c6, c7; -- these hold the captures specified in patternspatterns_t[pattern_idx][1]
c1, c2, c3, c4, c5, c6, c7 = mw.ustring.match (date, patternspatterns_t[pattern_idx][1]); -- get the captures
 
local t = { -- table that holds k/v pairs of date parts from the captures and patternspatterns_t[pattern_idx][2..]
[patternspatterns_t[pattern_idx][2]] = c1; -- at minimum there is always one capture with a matching indicator letter
[patternspatterns_t[pattern_idx][3] or 'x'] = c2; -- patternspatterns_t can have a variable number of captures; each capture requires an indicator letter;
[patternspatterns_t[pattern_idx][4] or 'x'] = c3; -- where there is no capture, there is no indicator letter so n in patternspatterns_t[pattern_idx][n] will be nil;
[patternspatterns_t[pattern_idx][5] or 'x'] = c4; -- the 'x' here spoofs an indicator letter to prevent 'table index is nil' error
[patternspatterns_t[pattern_idx][6] or 'x'] = c5;
[patternspatterns_t[pattern_idx][7] or 'x'] = c6;
[patternspatterns_t[pattern_idx][8] or 'x'] = c7;
};
 
வரி 1,020 ⟶ 1,049:
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 -- skip access- or archive-date unless format is xxx-all; yeah, ugly; TODO: find a better way
for pattern_idx, pattern in pairs (patternspatterns_t) do
if mw.ustring.match (param_val.val, pattern[1]) then
if all and in_array (param_name, {'access-date', 'archive-date'}) then -- if this date is an access- or archive-date
வரி 1,031 ⟶ 1,060:
date_parameters_list[param_name].val = new_date; -- update date in date list
result = true; -- and announce that changes have been made
break;
end
end -- if
வரி 1,055 ⟶ 1,085:
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) and
not mw.ustring.match (param_val.val, patternspatterns_t.ymd[1]) 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
வரி 1,142 ⟶ 1,172:
 
cfg = cfg_table_ptr; -- import tables from selected Module:Citation/CS1/Configuration
end
 
 
--[[--------------------------< A R C H I V E _ D A T E _ C H E C K >------------------------------------------
 
Compare value in |archive-date= with the timestamp in Wayback machine urls. Emits an error message with suggested
date from the |archive-url= timestamp in an appropriate format when the value in |archive-date= does not match
the timestamp.
 
this function never called when any date in a cs1|2 template has errors
 
error message suggests new |archive-date= value in an appropriate format specified by <df>. <df> is either
|df= or cfg.global_df in that order. If <df> is nil, suggested date has format from |archive-date=. There is
a caveat: when |df=dmy or |df=mdy, the reformatter leaves |access-date= and |archive-date= formats as they are.
The error message suggested date is passed to the formatter as YYYY-MM-DD so when |df=dmy or |df=mdy, the format
is not changed.
 
]]
 
local function archive_date_check (archive_date, archive_url_timestamp, df)
local archive_date_format = 'dmy-y'; -- holds the date format of date in |archive-date; default to ymd; 'dmy' used here to spoof reformat_dates()
for _, v_t in ipairs ({{'dMy', 'dmy-all'}, {'Mdy', 'mdy-all'}}) do -- is |archive-date= format dmy or mdy?
if archive_date:match (patterns_t[v_t[1]][1]) then -- does the pattern match?
archive_date_format = cfg.keywords_xlate[v_t[2]]; -- get appropriate |df= supported keyword from the i18n translator table
break;
end
end
local dates_t = {};
dates_t['archive-date'] = {val=archive_date, name=''}; -- setup to call reformat_dates(); never called when errors so <name> unset as not needed
reformat_dates (dates_t, 'dmy-y'); -- reformat |archive-date= to ymd; 'dmy' used here to spoof reformat_dates()
local archive_url_date = archive_url_timestamp:gsub ('(%d%d%d%d)(%d%d)(%d%d)%d*', '%1-%2-%3'); -- make ymd format date from timestamp
 
if dates_t['archive-date'].val == archive_url_date then -- are the two dates the same
return; -- yes, done
else
dates_t['archive-date'] = {val=archive_url_date, name=''}; -- setup to call reformat_dates() with the timestamp date
reformat_dates (dates_t, df or archive_date_format); -- reformat timestamp to format specified by <df> or format used in |archive-date=
archive_url_date = dates_t['archive-date'].val;
set_message ('err_archive_date_url_ts_mismatch', archive_url_date); -- emit an error message
end
end
 
வரி 1,149 ⟶ 1,221:
 
return { -- return exported functions
archive_date_check = archive_date_check,
dates = dates,
year_date_check = year_date_check,
reformat_dates = reformat_dates,
date_hyphen_to_dash = date_hyphen_to_dash,
date_name_xlate = date_name_xlate,
dates = dates,
set_selected_modules = set_selected_modules
reformat_dates = reformat_dates,
set_selected_modules = set_selected_modules,
year_check = year_check,
year_date_check = year_date_check,
}
"https://tamilar.wiki/w/Module:Citation/CS1/Date_validation" இலிருந்து மீள்விக்கப்பட்டது