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

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

← முந்திய தொகுப்பு
உள்ளடக்கம் நீக்கப்பட்டது உள்ளடக்கம் சேர்க்கப்பட்டது
imported>Sukanthi
சி 55 திருத்தங்கள் இறக்குமதி செய்யப்பட்டன
imported>Info-farmer
en:Module:Citation/CS1/Date_validation இலிருந்து திருத்தங்கள் இறக்குமதி செய்யப்பட்டன
 
வரிசை 327:
input.year2 = tonumber (input.year2) or lang_object:parseFormattedNumber (input.year2); -- COinS dates are pseudo-ISO 8601 so convert to Arabic numerals
 
if ((1582 == input.year) and (10 > tonumber(input.month))) or (1582 > input.year) then -- if a Julian calendar date▼
-- start temporary Julian / Gregorian calendar uncertainty detection
local year = 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
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
((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 / Gregorian calendar uncertainty detection
▲ if ((1582 == year) and (10 > month)) or (1582 > year) then -- if a Julian calendar date
tCOinS_date.rftdate = tostring (input.year); -- &rft.date gets year only
return; -- done
வரி 395 ⟶ 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
வரி 407 ⟶ 396:
]]
 
local patternspatterns_t = {
-- year-initial numerical year-month-day
['ymd'] = {'^(%d%d%d%d)%-(%d%d)%-(%d%d)$', 'y', 'm', 'd'},
வரி 456 ⟶ 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
வரி 497 ⟶ 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);
வரி 515 ⟶ 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);
வரி 535 ⟶ 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
வரி 542 ⟶ 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
வரி 549 ⟶ 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
வரி 557 ⟶ 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
வரி 565 ⟶ 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
வரி 575 ⟶ 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
வரி 585 ⟶ 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
வரி 600 ⟶ 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
வரி 613 ⟶ 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
 
வரி 639 ⟶ 628:
end
 
elseif mw.ustring.match(date_string, patternspatterns_t['y'][1]) then -- year; here accept either YYY or YYYY
anchor_year, year = mw.ustring.match(date_string, patternspatterns_t['y'][1]);
if false == is_valid_year(year) then
return false;
வரி 754 ⟶ 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
 
வரி 827 ⟶ 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
வரி 843 ⟶ 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..
 
]]
வரி 908 ⟶ 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
வரி 925 ⟶ 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,035 ⟶ 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,071 ⟶ 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,163 ⟶ 1,177:
--[[--------------------------< 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 whenwith |archive-date=suggested
date from the |archive-url= timestamp in an appropriate format when the value in |archive-date= does not match
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
local function archive_date_check (archive_date, archive_url_timestamp)▼
|df= or cfg.global_df in that order. If <df> is nil, suggested date has format from |archive-date=. There is
local good, archive_date_ts = pcall (lang_object.formatDate, lang_object, 'Ymd', archive_date); -- |archive-date= value to YYYYMMDD format
a caveat: when |df=dmy or |df=mdy, the reformatter leaves |access-date= and |archive-date= formats as they are.
-- local archive_date_ts = lang_object:formatDate ('Ymd', archive_date); -- |archive-date= value to YYYYMMDD format
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.
 
]]
if good then
 
if not archive_url_timestamp:find (archive_date_ts, 1, true) then -- plain text find; begin search at position 1
▲local function archive_date_check (archive_date, archive_url_timestamp, df)
set_message ('err_archive_date_url_ts_mismatch'); -- emit an error message▼
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,190 ⟶ 1,227:
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" இலிருந்து மீள்விக்கப்பட்டது