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

    m (Changed protection level for "Module:Citation/CS1/Date validation": to match the other modules in the suite ([Edit=Require administrator access] (indefinite) [Move=Require administrator access] (indefinite)))
    (sync from sandbox;)
    Line 1: Line 1:
    local p = {}


    --[[--------------------------< F O R W A R D  D E C L A R A T I O N S >--------------------------------------
    --[[--------------------------< F O R W A R D  D E C L A R A T I O N S >--------------------------------------
    Line 7: Line 4:


    local is_set, in_array; -- imported functions from selected Module:Citation/CS1/Utilities
    local is_set, in_array; -- imported functions from selected Module:Citation/CS1/Utilities
    local cfg; -- table of tables imported from slected Module:Citation/CS1/Configuration
    local cfg; -- table of tables imported from selected Module:Citation/CS1/Configuration
     


    --[=[-------------------------< I S _ V A L I D _ A C C E S S D A T E >----------------------------------------
    --[=[-------------------------< I S _ V A L I D _ A C C E S S D A T E >----------------------------------------
    Line 96: Line 94:
    37-39 = Quadrimester 1, Quadrimester 2, Quadrimester 3 (4 months each)
    37-39 = Quadrimester 1, Quadrimester 2, Quadrimester 3 (4 months each)
    40-41 = Semestral 1, Semestral-2 (6 months each)
    40-41 = Semestral 1, Semestral-2 (6 months each)


    ]]
    ]]
    Line 105: Line 102:
    0; -- not a recognized season name
    0; -- not a recognized season name
    end
    end


    --[[--------------------------< I S _ P R O P E R _ N A M E >--------------------------------------------------
    --[[--------------------------< I S _ P R O P E R _ N A M E >--------------------------------------------------
    Line 117: Line 115:
    0; -- not a recognized named date
    0; -- not a recognized named date
    end
    end


    --[[--------------------------< I S _ V A L I D _ M O N T H _ O R _ S E A S O N >------------------------------
    --[[--------------------------< I S _ V A L I D _ M O N T H _ O R _ S E A S O N >------------------------------
    Line 125: Line 124:


    local function is_valid_month_or_season (month_season)
    local function is_valid_month_or_season (month_season)
    if 0 == get_month_number (month_season) then -- if month text isn't one of the twelve months, might be a season
    if 0 == get_month_number (month_season) then -- if month text isn't one of the twelve months, might be a season
    if 0 == get_season_number (month_season) then -- not a month, is it a season?
    if 0 == get_season_number (month_season) then -- not a month, is it a season?
    return false; -- return false not a month or one of the five seasons
    return false; -- return false not a month or one of the five seasons
    end
    end
    end
    end
    return true;
    return true;
    end
    end


    --[[--------------------------< I S _ V A L I D _ Y E A R >----------------------------------------------------
    --[[--------------------------< I S _ V A L I D _ Y E A R >----------------------------------------------------
    Line 141: Line 141:
    local function is_valid_year(year)
    local function is_valid_year(year)
    if not is_set(year_limit) then
    if not is_set(year_limit) then
    year_limit = tonumber(os.date("%Y"))+1; -- global variable so we only have to fetch it once
    year_limit = tonumber(os.date("%Y"))+1; -- global variable so we only have to fetch it once
    end
    end
    return tonumber(year) <= year_limit; -- false if year is in the future more than one year
    return tonumber(year) <= year_limit; -- false if year is in the future more than one year
    end
    end


    --[[--------------------------< I S _ V A L I D _ D A T E >----------------------------------------------------
    --[[--------------------------< I S _ V A L I D _ D A T E >----------------------------------------------------
    Line 168: Line 169:
    month_length = 28; -- then 28 days unless
    month_length = 28; -- then 28 days unless
    if 1582 > tonumber(year) then -- Julian calendar
    if 1582 > tonumber(year) then -- Julian calendar
    if 0==(year%4) then
    if 0==(year%4) then -- is a leap year?
    month_length = 29;
    month_length = 29; -- if leap year then 29 days in February
    end
    end
    else -- Gregorian calendar
    else -- Gregorian calendar
    Line 185: Line 186:
    return true;
    return true;
    end
    end


    --[[--------------------------< I S _ V A L I D _ M O N T H _ R A N G E _ S T Y L E >--------------------------
    --[[--------------------------< I S _ V A L I D _ M O N T H _ R A N G E _ S T Y L E >--------------------------
    Line 338: Line 340:
    return;
    return;
    end
    end
    --[[--------------------------< P A T T E R N S >--------------------------------------------------------------
    this is the list of patterns for date formats that this module recognizes.  Approximately the first half of these
    patterns represent formats that might be reformatted into another format.  Those that might be reformatted have
    'indicator' letters that identify the content of the matching capture: 'd' (day), 'm' (month), 'a' (anchor year),
    'y' (year); second day, month, year have a '2' suffix.
    These patterns are used for both date validation and for reformatting.  This table should not be moved to ~/Configuration
    because changes to this table require changes to check_date() and to reformatter() and reformat_date()
    ]]
    local patterns = {
    -- year-initial numerical year-month-day
    ['ymd'] = {'^(%d%d%d%d)%-(%d%d)%-(%d%d)$', 'y', 'm', 'd'},
    -- month-initial: month day, year
    ['Mdy'] = {'^(%D-) +([1-9]%d?), +((%d%d%d%d?)%a?)$', 'm', 'd', 'a', 'y'},
    -- month-initial day range: month day–day, year; days are separated by endash
    ['Md-dy'] = {'^(%D-) +([1-9]%d?)[%-–]([1-9]%d?), +((%d%d%d%d)%a?)$', 'm', 'd', 'd2', 'a', 'y'},
    -- day-initial: day month year
    ['dMy'] = {'^([1-9]%d?) *(%D-) +((%d%d%d%d?)%a?)$', 'd', 'm', 'a', 'y'},
    -- year-initial: year month day; day: 1 or 2 two digits, leading zero allowed; not supported at en.wiki
    -- ['yMd'] = {'^((%d%d%d%d?)%a?) +(%D-) +(%d%d?)$', 'a', 'y', 'm', 'd'},
    -- day-range-initial: day–day month year; days are separated by endash
    ['d-dMy'] = {'^([1-9]%d?)[%-–]([1-9]%d?) +(%D-) +((%d%d%d%d)%a?)$', 'd', 'd2', 'm', 'a', 'y'},
    -- day initial month-day-range: day month - day month year; uses spaced endash
    ['dM-dMy'] = {'^([1-9]%d?) +(%D-) +[%-–] +([1-9]%d?) +(%D-) +((%d%d%d%d)%a?)$', 'd', 'm', 'd2', 'm2', 'a', 'y'},
    -- month initial month-day-range: month day – month day, year;  uses spaced endash
    ['Md-Mdy'] = {'^(%D-) +([1-9]%d?) +[%-–] +(%D-) +([1-9]%d?), +((%d%d%d%d)%a?)$','m', 'd', 'm2', 'd2', 'a', 'y'},
    -- day initial month-day-year-range: day month year - day month year; uses spaced endash
    ['dMy-dMy'] = {'^([1-9]%d?) +(%D-) +(%d%d%d%d) +[%-–] +([1-9]%d?) +(%D-) +((%d%d%d%d)%a?)$', 'd', 'm', 'y', 'd2', 'm2', 'a', 'y2'},
    -- month initial month-day-year-range: month day, year – month day, year;  uses spaced endash
    ['Mdy-Mdy'] = {'^(%D-) +([1-9]%d?), +(%d%d%d%d) +[%-–] +(%D-) +([1-9]%d?), +((%d%d%d%d)%a?)$', 'm', 'd', 'y', 'm2', 'd2', 'a', 'y2'},
    -- these date formats cannot be converted, per se, but month name can be rendered short or long
    -- month/season year - month/season year; separated by spaced endash
    ['My-My'] = {'^(%D-) +(%d%d%d%d) +[%-–] +(%D-) +((%d%d%d%d)%a?)$', 'm', 'y', 'm2', 'a', 'y2'},
    -- 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
    ['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
    ['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
    ['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
    ['y'] = {'^((%d%d%d%d?)%a?)$'}, -- year; here accept either YYY or YYYY
    }




    Line 372: Line 424:
    local coins_date;
    local coins_date;


    if date_string:match("^%d%d%d%d%-%d%d%-%d%d$") then -- year-initial numerical year month day format
    if date_string:match (patterns['ymd'][1]) then -- year-initial numerical year month day format
    year, month, day=string.match(date_string, "(%d%d%d%d)%-(%d%d)%-(%d%d)");
    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
    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;
    anchor_year = year;
    elseif mw.ustring.match(date_string, "^%D- +[1-9]%d?, +[1-9]%d%d%d%a?$") then -- month-initial: month day, year
    month, day, anchor_year, year=mw.ustring.match(date_string, "(%D-) +(%d%d?),%s*((%d%d%d%d?)%a?)");
    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 = get_month_number (month);
    month = get_month_number (month);
    if 0 == month then return false; end -- return false if month text isn't one of the twelve months
    if 0 == month then return false; end -- return false if month text isn't one of the twelve months
    elseif mw.ustring.match(date_string, "^%D- +[1-9]%d?[%-–][1-9]%d?, +[1-9]%d%d%d%a?$") then -- month-initial day range: month day–day, year; days are separated by endash
    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, "(%D-) +(%d%d?)[%-–](%d%d?), +((%d%d%d%d)%a?)");
    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;
    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);
    month = get_month_number (month);
    if 0 == month then return false; end -- return false if month text isn't one of the twelve months
    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, "^[1-9]%d? +%D- +[1-9]%d%d%d%a?$") then -- day-initial: day month 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, "(%d%d*)%s*(%D-) +((%d%d%d%d?)%a?)");
    day, month, anchor_year, year=mw.ustring.match(date_string, patterns['dMy'][1]);
    month = get_month_number (month);
    month = get_month_number (month);
    if 0 == month then return false; end -- return false if month text isn't one of the twelve months
    if 0 == month then return false; end -- return false if month text isn't one of the twelve months


    --[[ NOT supported at en.wiki
    --[[ NOT supported at en.wiki
    elseif mw.ustring.match(date_string, "^[1-9]%d%d%d%a? +%D- +%d%d?$") then -- year-initial: year month day; day: 1 or 2 two digits, leading zero allowed
    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, "((%d%d%d%d?)%a?) +(%D-) +(%d%d?)");
    anchor_year, year, month, day=mw.ustring.match(date_string, patterns['yMd'][1]);
    month = get_month_number (month);
    month = get_month_number (month);
    if 0 == month then return false; end -- return false if month text isn't one of the twelve months
    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 ]]
    -- end NOT supported at en.wiki ]]


    elseif mw.ustring.match(date_string, "^[1-9]%d?[%-–][1-9]%d? +%D- +[1-9]%d%d%d%a?$") then -- day-range-initial: day–day month year; days are separated by endash
    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, "(%d%d?)[%-–](%d%d?) +(%D-) +((%d%d%d%d)%a?)");
    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;
    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);
    month = get_month_number (month);
    if 0 == month then return false; end -- return false if month text isn't one of the twelve months
    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, "^[1-9]%d? +%D- +[%-–] +[1-9]%d? +%D- +[1-9]%d%d%d%a?$") then -- day initial month-day-range: day month - day month year; uses spaced endash
    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, "(%d%d?) +(%D-) +[%-–] +(%d%d?) +(%D-) +((%d%d%d%d)%a?)");
    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;
    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
    month = get_month_number (month); -- for metadata
    month2 = get_month_number (month2);
    month2 = get_month_number (month2);
    year2=year;
    year2=year;


    elseif mw.ustring.match(date_string, "^%D- +[1-9]%d? +[%-–] +%D- +[1-9]%d?, +[1-9]%d%d%d%a?$") then -- month initial month-day-range: month day – month day, year;  uses spaced endash
    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, "(%D-) +(%d%d?) +[%-–] +(%D-) +(%d%d?), +((%d%d%d%d)%a?)");
    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)) or not is_valid_year(year) then return false; end
    if (not is_valid_month_season_range(month, month2)) or not is_valid_year(year) then return false; end
    month = get_month_number (month); -- for metadata
    month = get_month_number (month); -- for metadata
    month2 = get_month_number (month2);
    month2 = get_month_number (month2);
    year2=year;
    year2=year;


    elseif mw.ustring.match(date_string, "^[1-9]%d? +%D- +[1-9]%d%d%d +[%-–] +[1-9]%d? +%D- +[1-9]%d%d%d%a?$") then -- day initial month-day-year-range: day month year - day month year; uses spaced endash
    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, "(%d%d?) +(%D-) +(%d%d%d%d) +[%-–] +(%d%d?) +(%D-) +((%d%d%d%d)%a?)");
    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 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
    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
    month = get_month_number (month); -- for metadata
    month2 = get_month_number (month2);
    month2 = get_month_number (month2);


    elseif mw.ustring.match(date_string, "^%D- +[1-9]%d?, +[1-9]%d%d%d +[%-–] +%D- +[1-9]%d?, +[1-9]%d%d%d%a?$") then -- month initial month-day-year-range: month day, year – month day, year;  uses spaced endash
    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, "(%D-) +(%d%d?), +(%d%d%d%d) +[%-–] +(%D-) +(%d%d?), +((%d%d%d%d)%a?)");
    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 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
    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
    month = get_month_number (month); -- for metadata
    month2 = get_month_number (month2);
    month2 = get_month_number (month2);


    elseif mw.ustring.match(date_string, "^%D- +[1-9]%d%d%d[%-–]%d%d%a?$") then -- special case Winter/Summer year-year (YYYY-YY); year separated with unspaced endash
    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;
    local century;
    month, year, century, anchor_year, year2=mw.ustring.match(date_string, "(%D-) +((%d%d)%d%d)[%-–]((%d%d)%a?)");
    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
    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
    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 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
    if not is_valid_year(year2) then return false; end -- no year farther in the future than next year
    month = get_season_number (month);
    month = get_season_number (month);


    elseif mw.ustring.match(date_string, "^%D- +[1-9]%d%d%d[%-–][1-9]%d%d%d%a?$") then -- special case Winter/Summer year-year; year separated with unspaced endash
    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, "(%D-) +(%d%d%d%d)[%-–]((%d%d%d%d)%a?)");
    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
    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 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
    if not is_valid_year(year2) then return false; end -- no year farther in the future than next year
    month = get_season_number (month); -- for metadata
    month = get_season_number (month); -- for metadata


    elseif mw.ustring.match(date_string, "^%D- +[1-9]%d%d%d +[%-–] +%D- +[1-9]%d%d%d%a?$") then -- month/season year - month/season year; separated by spaced endash
    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, "(%D-) +(%d%d%d%d) +[%-–] +(%D-) +((%d%d%d%d)%a?)");
    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 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 0 ~= get_month_number(month) and 0 ~= get_month_number(month2) and is_valid_month_range_style(month, month2) then -- both must be month year, same month style
    if 0 ~= get_month_number(month) and 0 ~= get_month_number(month2) and is_valid_month_range_style(month, month2) then -- both must be month year, same month style
    month = get_month_number(month);
    month = get_month_number(month);
    month2 = get_month_number(month2);
    month2 = get_month_number(month2);
    elseif 0 ~= get_season_number(month) and 0 ~= get_season_number(month2) then -- both must be or season year, not mixed
    elseif 0 ~= get_season_number(month) and 0 ~= get_season_number(month2) then -- both must be or season year, not mixed
    month = get_season_number(month);
    month = get_season_number(month);
    month2 = get_season_number(month2);
    month2 = get_season_number(month2);
    Line 470: Line 523:
    end
    end


    elseif mw.ustring.match(date_string, "^%D-[%-–]%D- +[1-9]%d%d%d%a?$") then -- month/season range year; months separated by endash  
    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, "(%D-)[%-–](%D-)%s*((%d%d%d%d)%a?)");
    month, month2, anchor_year, year=mw.ustring.match(date_string, patterns['M-My'][1]);
    if (not is_valid_month_season_range(month, month2)) or (not is_valid_year(year)) then return false; end
    if (not is_valid_month_season_range(month, month2)) 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
    if 0 ~= get_month_number(month) then -- determined to be a valid range so just check this one to know if month or season
    Line 482: Line 535:
    year2=year;
    year2=year;
    elseif mw.ustring.match(date_string, "^%D- +%d%d%d%d%a?$") then -- month/season year or proper-name year
    elseif mw.ustring.match(date_string, patterns['My'][1]) then -- month/season year or proper-name year
    month, anchor_year, year=mw.ustring.match(date_string, "(%D-)%s*((%d%d%d%d)%a?)");
    month, anchor_year, year=mw.ustring.match(date_string, patterns['My'][1]);
    if not is_valid_year(year) then return false; end
    if not is_valid_year(year) then return false; end
    if not is_valid_month_or_season (month) and 0 == is_proper_name (month) then return false; end
    if not is_valid_month_or_season (month) and 0 == is_proper_name (month) then return false; end
    Line 494: Line 547:
    end
    end


    elseif mw.ustring.match(date_string, "^[1-9]%d%d%d?[%-–][1-9]%d%d%d?%a?$") then -- Year range: YYY-YYY or YYY-YYYY or YYYY–YYYY; separated by unspaced endash; 100-9999
    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, "(%d%d%d%d?)[%-–]((%d%d%d%d?)%a?)");
    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 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


    elseif mw.ustring.match(date_string, "^[1-9]%d%d%d[%-–]%d%d%a?$") then -- Year range: YYYY–YY; separated by unspaced endash
    elseif mw.ustring.match(date_string, patterns['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, "((%d%d)%d%d)[%-–]((%d%d)%a?)");
    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 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
    Line 509: Line 562:
    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


    elseif date_string:match("^[1-9]%d%d%d?%a?$") then -- year; here accept either YYY or YYYY
    elseif date_string:match (patterns['y'][1]) then -- year; here accept either YYY or YYYY
    anchor_year, year=date_string:match("((%d%d%d%d?)%a?)");
    anchor_year, year=date_string:match (patterns['y'][1]);
    if false == is_valid_year(year) then
    if false == is_valid_year(year) then
    return false;
    return false;
    Line 576: Line 629:
    for k, v in pairs(date_parameters_list) do -- for each date-holding parameter in the list
    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
    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=
    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
    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
    anchor_year, COinS_date = v.val:match("((c%. [1-9]%d%d%d?)%a?)"); -- anchor year and COinS_date only from |date= parameter
    Line 587: Line 640:
    end
    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 -- 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?)"); --"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 -- 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?)"); --"nd"; no error when date parameter is set to no date
    else
    else
    Line 595: Line 648:
    end
    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?)");
    good_date, anchor_year, COinS_date = true, v.val:match("((%d+)%a?)");
    end
    end
    elseif 'access-date'==k then -- if the parameter is |date=
    elseif 'access-date'==k then -- if the parameter is |date=
    good_date = check_date (v.val, nil, true); -- go test the date; nil is a placeholder; true is the test_accessdate flag
    good_date = check_date (v.val, nil, true); -- go test the date; nil is a placeholder; true is the test_accessdate flag
    elseif 'embargo'==k then -- if the parameter is |embargo=
    elseif 'embargo'==k then -- if the parameter is |embargo=
    good_date = check_date (v.val); -- go test the date
    good_date = check_date (v.val); -- go test the date
    if true == good_date then -- if the date is a valid 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 |embargo= date a single dmy, mdy, or ymd formatted date? yes:returns embargo; no: returns 9999
    end
    end
    else -- any other date-holding parameter
    else -- any other date-holding parameter
    good_date = check_date (v.val); -- go test the date
    good_date = check_date (v.val); -- go test the date
    end
    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
    Line 616: Line 669:
    end
    end
    end
    end
    return anchor_year, embargo_date, error_message; -- and done
    return anchor_year, embargo_date, error_message; -- and done
    end
    end


    Line 652: Line 705:
    end
    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)");
    Line 672: Line 725:




    --[[-------------------------< R E F O R M A T   T A B L E S >------------------------------------------------
    --[[--------------------------< R E F O R M A T T E R >--------------------------------------------------------
     
    These table are used exclusively for reformatting dates
     
    ]]
     
    local source_patterns = { -- this table holds patterns that match allowed date formats used to extract date components
    ['dmy'] = '^(%d%d?)%s+(%a+)%s+(%d%d%d%d)$',
    ['mdy'] = '^(%a+)%s+(%d%d?),%s+(%d%d%d%d)$',
    ['ymd'] = '^(%d%d%d%d)%-(%d%d)-(%d%d)$',
    }


    local short_formats = { -- this table holds format strings used by os.date() for short month names
    reformat 'date' into new format specified by format_param if pattern_idx (the current format of 'date') can be
    ['dmy'] = '%e %b %Y',
    reformatted.  Does the grunt work for reformat_dates().
    ['mdy'] = '%b %e, %Y',
    ['ymd'] = '%F',
    }


    local long_formats = { -- this table holds format strings used by os.date() for long month names
    The table re_formats maps patern_idx (current format) and format_param (desired format) to a table that holds:
    ['dmy'] = '%e %B %Y',
    format string used by string.format()
    ['mdy'] = '%B %e, %Y',
    identifier letters ('d', 'm', 'y', 'd2', 'm2', 'y2') that serve as indexes into a table t{} that holds captures
    ['ymd'] = '%F',
    from mw.ustring.match() for the various date parts specified by  patterns[pattern_idx][1]
    }


    Items in patterns{} 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['ymd'][2] is an indicator letter identifying the content of the first capture
    patterns['ymd'][3] ... the second capture etc


    --[[-------------------------< G E T _ D M Y _ D A T E _ P A R T S >------------------------------------------
    when a pattern matches a date, the captures are loaded into table t{} in capture order using the idemtifier
    characters as indexes into t{}  For the above, a ymd date is in t{} as:
    t.y = first capture (year), t.m = second capture (month), t.d = third capture (day)


    extracts year, month and day from DMY formatted date, places them in the source_date table, and returns.
    To reformat, this function is called with the pattern_idx that matches the current format of the date and with
    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..


    ]]
    ]]


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




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


    extracts year, month and day from MDY formatted date, places them in the source_date table, and returns.
    if in_array (pattern_idx, {'My', 'M-My', 'My-My'}) then -- these are not dmy/mdy so can't be 'reformatted' into either
    format_param = 'any'; -- so format-agnostic
    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
    if 'yMd' == format_param then -- not supported at en.wiki
    return; -- not a reformattable date
    end
    local c1, c2, c3, c4, c5, c6, c7; -- these hold the captures specified in patterns[pattern_idx][1]
    c1, c2, c3, c4, c5, c6, c7 = mw.ustring.match (date, patterns[pattern_idx][1]); -- get the captures


    local function get_mdy_date_parts (date, source_date)
    local t = { -- table that holds k/v pairs of date parts from the captures and patterns[pattern_idx][2..]
    source_date.month, source_date.day, source_date.year = date:match (source_patterns['mdy']); -- get date components as strings
    [patterns[pattern_idx][2]] = c1; -- at minimum there is always one capture with a matching indicator letter
    source_date.month = get_month_number (source_date.month); -- get month number
    [patterns[pattern_idx][3] or 'x'] = c2; -- patterns can have a variable number of captures; each capture requires an indicator letter;
    end
    [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[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[pattern_idx][7] or 'x'] = c6;
    [patterns[pattern_idx][8] or 'x'] = c7;
    };


    if tonumber(t.m) then -- if raw month is a number (converting from ymd)
    if 's' == mon_len then -- if we are to use abbreviated month names
    t.m = cfg.date_names['inv_local_s'][tonumber(t.m)]; -- convert it to a month name
    else
    t.m = cfg.date_names['inv_local_l'][tonumber(t.m)]; -- convert it to a month name
    end
    elseif 'ymd' == format_param then -- when converting to ymd
    if 1582 > tonumber(t.y) then -- ymd format dates not allowed before 1582
    return;
    end
    t.m = string.format ('%02d', get_month_number (t.m)); -- make sure that month and day are two digits
    t.d = string.format ('%02d', t.d);
    elseif mon_len then -- if mon_len is set to either 'short' or 'long'
    for _, mon in ipairs ({'m', 'm2'}) do -- because there can be two month names, check both
    if t[mon] then
    t[mon] = get_month_number (t[mon]); -- get the month number for this month (is length agnostic)
    if 0 == t[mon] then return; end -- seasons and named dates can't be converted
    t[mon] = (('s' == mon_len) and cfg.date_names['inv_local_s'][t[mon]]) or cfg.date_names['inv_local_l'][t[mon]]; -- fetch month name according to length
    end
    end
    end


    --[[-------------------------< G E T _ Y M D _ D A T E _ P A R T S >------------------------------------------
    local new_date = string.format (re_formats[pattern_idx][format_param][1], -- format string
     
    t[re_formats[pattern_idx][format_param][2]], -- named captures from t{}
    extracts year, month and day from YMD formatted date, places them in the source_date table, and returns.
    t[re_formats[pattern_idx][format_param][3]],
     
    t[re_formats[pattern_idx][format_param][4]],
    ]]
    t[re_formats[pattern_idx][format_param][5]],
    t[re_formats[pattern_idx][format_param][6]],
    t[re_formats[pattern_idx][format_param][7]],
    t[re_formats[pattern_idx][format_param][8]]
    );


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


    Line 734: Line 881:
    --[[-------------------------< R E F O R M A T _ D A T E S >--------------------------------------------------
    --[[-------------------------< R E F O R M A T _ D A T E S >--------------------------------------------------


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


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


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


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


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


    ]]
    ]]


    local function reformat_dates (date_parameters_list, format, short)
    local function reformat_dates (date_parameters_list, format)
    local all = false; -- set to false to skip access- and archive-dates
    local all = false; -- set to false to skip access- and archive-dates
    local len_p = 'l'; -- default publication date length shall be long
    local len_a = 'l'; -- default access-/archive-date length shall be long
    local result = false;
    local result = false;
    local format_str;
    local new_date;
    local source_date = {};
    if format:match('%a+%-all') then
    if format:match('%a+%-all') then -- manual df keyword; auto df keyword when length not specified in {{use xxx dates}};
    format = format:match('(%a+)%-all'); -- extract the format
    format = format:match('(%a+)%-all'); -- extract the format
    all = true; -- set to true to format access- and archive-dates
    all = true; -- all dates are long format dates because this keyword doesn't specify length
    end
    elseif format:match('%a+%-[lsy][sy]?') then -- auto df keywords; internal only
    all = true; -- auto df applies to all dates; use length specified by capture len_p for all dates
    format, len_p, len_a = format:match('(%a+)%-([lsy])([sy]?)'); -- extract the format and length keywords
    if 'y' == len_p then -- because allowed by MOS:DATEUNIFY (sort of) range dates and My dates not reformatted
    format = 'ymd'; -- override {{use xxx dates}}
    elseif (not is_set(len_a)) or (len_p == len_a) then -- no access-/archive-date length specified or same length as publication dates then
    len_a = len_p; -- in case len_a not set
    end
    end -- else only publication dates and they are long
     
    for param_name, param_val in pairs (date_parameters_list) do -- for each date-holding parameter in the list
    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 the parameter has a value
    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
    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 source, pattern in pairs (source_patterns) do
    for pattern_idx, pattern in pairs (patterns) do
    if param_val.val:match (pattern) then
    if mw.ustring.match (param_val.val, pattern[1]) then
    if 'ymd' == source then
    if all and in_array (param_name, {'access-date', 'archive-date'}) then -- if this date is an access- or archive-date
    get_ymd_date_parts (param_val.val, source_date); -- get the date parts into the source_date table
    new_date = reformatter (param_val.val, pattern_idx, (('y' == len_a) and 'ymd') or format, len_a); -- choose ymd or dmy/mdy according to len_a setting
    elseif 'dmy' == source then
    else -- all other dates
    get_dmy_date_parts (param_val.val, source_date); -- get the date parts into the source_date table
    new_date = reformatter (param_val.val, pattern_idx, format, len_p);
    elseif 'mdy' == source then
    get_mdy_date_parts (param_val.val, source_date); -- get the date parts into the source_date table
    end
    if 'ymd' == format and 1582 > tonumber(source_date.year) then -- ymd format dates not allowed before 1582
    return false; -- abandon reformatting
    end
    end
    if short then
    if new_date then -- set when date was reformatted
    format_str = short_formats[format];
    date_parameters_list[param_name].val = new_date; -- update date in date list
    else
    result = true; -- and announce that changes have been made
    format_str = long_formats[format];
    end
    end
    -- convert date and save;
    date_parameters_list[param_name].val = mw.text.trim (os.date (format_str, os.time(source_date))); -- strip leading space when single digit day and %e is first format
    result = true;
    end -- if
    end -- if
    end -- for
    end -- for
    Line 790: Line 947:
    end -- if
    end -- if
    end -- for
    end -- for
    return result; -- declare result and done
    return result; -- declare boolean result and done
    end
    end


    Line 808: Line 965:
    for param_name, param_val in pairs(date_parameters_list) do -- for each date-holding parameter in the list
    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 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
    param_val.val, n = param_val.val:gsub ('%-', '–'); -- replace any hyphen with ndash
    if 0 ~= n then
    if 0 ~= n then
    date_parameters_list[param_name].val = param_val.val; -- update the list
    date_parameters_list[param_name].val = param_val.val; -- update the list
    result = true;
    result = true;
    end
    end
    Line 849: Line 1,006:
    end
    end
    if mode then -- might be a season
    if mode then -- might be a season
    xlate = mw.getContentLanguage():formatDate(mode, '1' .. month); -- translate the month name to this local language
    xlate = mw.getContentLanguage():formatDate(mode, '1' .. month); -- translate the month name to this local language
    date = mw.ustring.gsub (date, month, xlate); -- replace the English with the translation
    date = mw.ustring.gsub (date, month, xlate); -- replace the English with the translation
    date_parameters_list[param_name].val = date; -- save the translated date
    date_parameters_list[param_name].val = date; -- save the translated date
    modified = true;
    modified = true;
    end
    end
    Line 882: Line 1,039:




    --[[--------------------------< E X P O R T E D  F U N C T I O N S >------------------------------------------
    ]]


    return { -- return exported functions
    return { -- return exported functions
    Retrieved from "https://nonbinary.wiki/wiki/Module:Citation/CS1/Date_validation"