Изменения

Модуль:Citation/CS1/Date validation (посмотреть исходный код)

Версия от 22:24, 2 сентября 2024

869 байт добавлено , 1 год назад

Обсуждение Википедии:Шаблоны цитирования CS1/2#Обновление от 31 августа 2024

Строка 327: Строка 327:

input.year2 = tonumber (input.year2) or lang_object:parseFormattedNumber (input.year2); -- COinS dates are pseudo-ISO 8601 so convert to Arabic numerals

−

~~-- start temporary Julian / Gregorian calendar uncertainty detection~~

+

if ((1582 == input.year) and (10 > tonumber(input.month))) or (1582 > input.year) then -- if a Julian calendar date

−

~~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 >~~----~~----------------------------------------------------------

+

--[[--------------------------< 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 ~~patterns~~ = {

+

local patterns_t = {

-- year-initial numerical year-month-day

−

['ymd'] = {'^(%d%d%d%d)%-(%d%d)%-(%d%d)$', 'y', 'm', 'd'},

+

['ymd'] = {'^(%d%d%d%d)%-(%d%d)%-(%d%d)$', 'y', 'm', 'd'},

+

['ym'] = {'^(%d%d%d%d)%-(%d%d)$', 'y', 'm'},

-- month-initial: month day, year

['Mdy'] = {'^(%D-) +([1-9]%d?), +((%d%d%d%d?)%a?)$', 'm', 'd', 'a', 'y'},

Строка 441: Строка 431:

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

['y-y'] = {'^(%d%d%d%d?)[%-–]((%d%d%d%d?)%a?)$'}, -- year range: YYY-YYY or YYY-YYYY or YYYY–YYYY; separated by unspaced endash; 100-9999

−

['y4-y2'] = {'^((%d%d)%d%d)[%-–]((%d%d)%a?)$'}, -- year range: YYYY–YY; separated by unspaced endash

+

-- ['y4-y2'] = {'^((%d%d)%d%d)[%-–]((%d%d)%a?)$'}, -- year range: YYYY–YY; separated by unspaced endash

['y'] = {'^((%d%d%d%d?)%a?)$'}, -- year; here accept either YYY or YYYY

}

Строка 456: Строка 446:

local function is_valid_embargo_date (v)

−

if v:match (~~patterns~~['ymd'][1]) or -- ymd

+

if v:match (patterns_t['ymd'][1]) or -- ymd

−

v:match (~~patterns~~['Mdy'][1]) or -- dmy

+

v:match (patterns_t['Mdy'][1]) or -- dmy

−

v:match (~~patterns~~['dMy'][1]) then -- mdy

+

v:match (patterns_t['dMy'][1]) then -- mdy

return true, v;

end

Строка 497: Строка 487:

local coins_date;

−

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

+

if date_string:match (patterns_t['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_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 date_string:match (patterns_t['ym'][1]) then -- year-initial numerical year month format

+

year, month = date_string:match (patterns_t['ym'][1]);

+

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

anchor_year = year;

−

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

+

elseif mw.ustring.match(date_string, patterns_t['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_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, ~~patterns~~['Md-dy'][1]) then -- month-initial day range: month day–day, year; days are separated by endash

+

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

+

month, day, day2, anchor_year, year = mw.ustring.match(date_string, patterns_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: Строка 510:

year2 = year;

−

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

+

elseif mw.ustring.match(date_string, patterns_t['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_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, ~~patterns~~['yMd'][1]) then -- year-initial: year month day; day: 1 or 2 two digits, leading zero allowed

+

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

+

anchor_year, year, month, day = mw.ustring.match(date_string, patterns_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, ~~patterns~~['d-dMy'][1]) then -- day-range-initial: day–day month year; days are separated by endash

+

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

+

day, day2, month, anchor_year, year = mw.ustring.match(date_string, patterns_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: Строка 530:

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

+

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

+

day, month, day2, month2, anchor_year, year = mw.ustring.match(date_string, patterns_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: Строка 537:

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

+

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

+

month, day, month2, day2, anchor_year, year = mw.ustring.match(date_string, patterns_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: Строка 544:

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

+

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

+

day, month, year, day2, month2, anchor_year, year2 = mw.ustring.match(date_string, patterns_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: Строка 552:

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

+

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

+

month, day, year, month2, day2, anchor_year, year2 = mw.ustring.match(date_string, patterns_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: Строка 560:

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

+

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

+

month, year, century, anchor_year, year2 = mw.ustring.match(date_string, patterns_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: Строка 570:

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

+

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

+

month, year, anchor_year, year2 = mw.ustring.match(date_string, patterns_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: Строка 580:

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~~['My-My'][1]) then -- month/season year - month/season year; separated by spaced endash

+

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

+

month, year, month2, anchor_year, year2 = mw.ustring.match(date_string, patterns_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: Строка 595:

end

−

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

+

elseif mw.ustring.match(date_string, patterns_t['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_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: Строка 608:

year2 = year;

−

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

+

elseif mw.ustring.match(date_string, patterns_t['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_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, ~~patterns~~['y-y'][1]) then -- Year range: YYY-YYY or YYY-YYYY or YYYY–YYYY; separated by unspaced endash; 100-9999

+

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

+

year, anchor_year, year2 = mw.ustring.match(date_string, patterns_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, ~~patterns~~['y4-y2'][1]) then -- Year range: YYYY–YY; separated by unspaced endash

+

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

−

local century;

+

-- 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_t['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 13 > tonumber(year2) then return false; end -- don't allow 2003-05 which might be May 2003

+

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

+

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

+

-- if in_array (param, {'date', 'publication-date', 'year'}) then -- here when 'valid' abbreviated year range; if one of these parameters

−

add_prop_cat ('year-range-abbreviated'); -- add properties cat

+

-- add_prop_cat ('year-range-abbreviated'); -- add properties cat

−

end

+

-- end

−

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

+

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~~['y'][1]);

+

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

if false == is_valid_year(year) then

return false;

Строка 754: Строка 749:

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', '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

Строка 779: Строка 799:

year = year_string:match ('(%d%d%d%d?)');

−

if date_string:match ('%d%d%d%d%-%d%d%-%d%d') and year_string:match ('%d%d%d%d%a') then --special case where both date and year are required YYYY-MM-DD and YYYYx

+

if ( date_string:match ('%d%d%d%d%-%d%d%-%d%d') or date_string:match ('%d%d%d%d%-%d%d') ) and year_string:match ('%d%d%d%d%a') then --special case where both date and year are required YYYY-MM-DD and YYYYx

date1 = date_string:match ('(%d%d%d%d)');

year = year_string:match ('(%d%d%d%d)');

Строка 794: Строка 814:

end

−

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

+

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

−

local century;

+

-- local century;

−

date1, century, date2 = mw.ustring.match(date_string, "((%d%d)%d%d)[%-–]+(%d%d)");

+

-- date1, century, date2 = mw.ustring.match(date_string, "((%d%d)%d%d)[%-–]+(%d%d)");

−

date2 = century..date2; -- convert YY to YYYY

+

-- date2 = century..date2; -- convert YY to YYYY

−

if year ~= date1 and year ~= date2 then

+

-- if year ~= date1 and year ~= date2 then

−

result = 0;

+

-- result = 0;

−

end

+

-- end

elseif date_string:match ("%d%d%d%d?") then -- any of the standard formats of date with one year

Строка 827: Строка 847:

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]

+

from mw.ustring.match() for the various date parts specified by patterns_t[pattern_idx][1]

−

Items in ~~patterns~~{} have the general form:

+

Items in patterns_t{} have the general form:

['ymd'] = {'^(%d%d%d%d)%-(%d%d)%-(%d%d)$', 'y', 'm', 'd'}, where:

['ymd'] is pattern_idx

−

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

+

patterns_t['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_t['ymd'][2] is an indicator letter identifying the content of the first capture

−

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

+

patterns_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: Строка 863:

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 ~~patterns~~[pattern_idx][format_param][n] where n is 2..

+

to the capture identifier letters specified by patterns_t[pattern_idx][format_param][n] where n is 2..

]]

Строка 908: Строка 928:

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

+

return; -- not in this set of date format patterns_t then not a reformattable date

end

Строка 925: Строка 945:

end

−

local c1, c2, c3, c4, c5, c6, c7; -- these hold the captures specified in ~~patterns~~[pattern_idx][1]

+

local c1, c2, c3, c4, c5, c6, c7; -- these hold the captures specified in patterns_t[pattern_idx][1]

−

c1, c2, c3, c4, c5, c6, c7 = mw.ustring.match (date, ~~patterns~~[pattern_idx][1]); -- get the captures

+

c1, c2, c3, c4, c5, c6, c7 = mw.ustring.match (date, patterns_t[pattern_idx][1]); -- get the captures

−

local t = { -- table that holds k/v pairs of date parts from the captures and ~~patterns~~[pattern_idx][2..]

+

local t = { -- table that holds k/v pairs of date parts from the captures and patterns_t[pattern_idx][2..]

−

[~~patterns~~[pattern_idx][2]] = c1; -- at minimum there is always one capture with a matching indicator letter

+

[patterns_t[pattern_idx][2]] = c1; -- at minimum there is always one capture with a matching indicator letter

−

[~~patterns~~[pattern_idx][3] or 'x'] = c2; -- ~~patterns~~ can have a variable number of captures; each capture requires an indicator letter;

+

[patterns_t[pattern_idx][3] or 'x'] = c2; -- patterns_t can have a variable number of captures; each capture requires an indicator letter;

−

[~~patterns~~[pattern_idx][4] or 'x'] = c3; -- where there is no capture, there is no indicator letter so n in ~~patterns~~[pattern_idx][n] will be nil;

+

[patterns_t[pattern_idx][4] or 'x'] = c3; -- where there is no capture, there is no indicator letter so n in patterns_t[pattern_idx][n] will be nil;

−

[~~patterns~~[pattern_idx][5] or 'x'] = c4; -- the 'x' here spoofs an indicator letter to prevent 'table index is nil' error

+

[patterns_t[pattern_idx][5] or 'x'] = c4; -- the 'x' here spoofs an indicator letter to prevent 'table index is nil' error

−

[~~patterns~~[pattern_idx][6] or 'x'] = c5;

+

[patterns_t[pattern_idx][6] or 'x'] = c5;

−

[~~patterns~~[pattern_idx][7] or 'x'] = c6;

+

[patterns_t[pattern_idx][7] or 'x'] = c6;

−

[~~patterns~~[pattern_idx][8] or 'x'] = c7;

+

[patterns_t[pattern_idx][8] or 'x'] = c7;

};

Строка 1035: Строка 1055:

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 (~~patterns~~) do

+

for pattern_idx, pattern in pairs (patterns_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

Строка 1071: Строка 1091:

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, ~~patterns~~.ymd[1]) then -- for those that are not ymd dates (ustring because here digits may not be Western)

+

not mw.ustring.match (param_val.val, patterns_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

+

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

Строка 1181: Строка 1201:

for _, v_t in ipairs ({{'dMy', 'dmy-all'}, {'Mdy', 'mdy-all'}}) do -- is |archive-date= format dmy or mdy?

−

if archive_date:match (~~patterns~~[v_t[1]][1]) then -- does the pattern match?

+

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;

Строка 1213: Строка 1233:

reformat_dates = reformat_dates,

set_selected_modules = set_selected_modules,

+

year_check = year_check,

year_date_check = year_date_check,

}

Анонимный участник

w>Wikisaurus