Grammalecte  Check-in [cab4036997]

Overview
Comment:[fr][core] prise en compte du calendrier julien (premier jet)
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | fr | core
Files: files | file ages | folders
SHA3-256: cab4036997d49e23e9d2a4e1282c7306ce066fb3858e6790602e10ec0a2ee5d5
User & Date: olr on 2018-10-22 20:44:15
Other Links: manifest | tags
Context
2018-10-24
09:49
[fr] faux positifs: énumération check-in: 9df50f20d9 user: olr tags: trunk, fr
2018-10-22
20:44
[fr][core] prise en compte du calendrier julien (premier jet) check-in: cab4036997 user: olr tags: trunk, fr, core
13:20
[fr] suppression diacritique incongru check-in: fc950b86fd user: olr tags: trunk, fr
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified gc_lang/fr/modules-js/gce_date_verif.js from [8555f52be9] to [895077be13].

︙
12
13
14
15
16
17
18
















19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

36
37
38
39






40
41
42

43
44
45
46
47


48
49
50
51
52
53
54
55
56
57
















58
59

60
61
62
63
64









65




66
67
68



69
70

71
72
73
74






75
76
77
78
79

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52




53
54
55
56
57
58



59
60
61
62


63
64










65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80


81





82
83
84
85
86
87
88
89
90
91
92
93
94
95



96
97
98


99




100
101
102
103
104
105




106








+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

















+
-
-
-
-
+
+
+
+
+
+
-
-
-
+



-
-
+
+
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+

+
+
+
+
-
-
-
+
+
+
-
-
+
-
-
-
-
+
+
+
+
+
+
-
-
-
-


    ["janvier", 1], ["février", 2], ["mars", 3], ["avril", 4], ["mai", 5], ["juin", 6], ["juillet", 7],
    ["août", 8], ["aout", 8], ["septembre", 9], ["octobre", 10], ["novembre", 11], ["décembre", 12]
]);
const _dDaysInMonth = new Map ([
    [1, 31], [2, 28], [3, 31], [4, 30], [5, 31], [6, 30], [7, 31],
    [8, 31], [8, 31], [9, 30], [10, 31], [11, 30], [12, 31]
]);

// Dans Python, datetime.weekday() envoie le résultat comme si nous étions dans un calendrier grégorien universal.
// https://fr.wikipedia.org/wiki/Passage_du_calendrier_julien_au_calendrier_gr%C3%A9gorien
// Selon Grégoire, le jeudi 4 octobre 1582 est immédiatement suivi par le vendredi 15 octobre.
// En France, la bascule eut lieu le 9 décembre 1582 qui fut suivi par le 20 décembre 1582.
// C’est la date retenue pour la bascule dans Grammalecte, mais le calendrier grégorien fut adopté dans le monde diversement.
// Il fallut des siècles pour qu’il soit adopté par l’Occident et une grande partie du reste du monde.
const _dGregorianToJulian = new Map ([
    ["lundi",    "jeudi"],
    ["mardi",    "vendredi"],
    ["mercredi", "samedi"],
    ["jeudi",    "dimanche"],
    ["vendredi", "lundi"],
    ["samedi",   "mardi"],
    ["dimanche", "mercredi"]
]);

function _checkDate (nDay, nMonth, nYear) {
    // returns true or false
    if (nMonth > 12 || nMonth < 1 || nDay > 31 || nDay < 1) {
        return false;
    }
    if (nDay <= _dDaysInMonth.get(nMonth)) {
        return true;
    }
    if (nDay === 29) {
        // leap years, http://jsperf.com/ily/15
        return !(nYear & 3 || !(nYear % 25) && nYear & 15);
    }
    return false;
}

function checkDate (sDay, sMonth, sYear) {
    // return True if the date is valid
    // to use if sMonth is a number
    return _checkDate(parseInt(sDay, 10), parseInt(sMonth, 10), parseInt(sYear, 10));
}

    if (!sMonth.gl_isDigit()) {
        sMonth = _dMonth.get(sMonth.toLowerCase());
    }
    if (_checkDate(parseInt(sDay, 10), parseInt(sMonth, 10), parseInt(sYear, 10))) {
        return new Date(parseInt(sYear, 10), parseInt(sMonth, 10)-1, parseInt(sDay, 10));
    }
function checkDateWithString (sDay, sMonth, sYear) {
    // to use if sMonth is a noun
    return _checkDate(parseInt(sDay, 10), _dMonth.get(sMonth.toLowerCase()), parseInt(sYear, 10));
    return false;
}

function checkDay (sWeekday, sDay, sMonth, sYear) {
    // to use if sMonth is a number
    if (checkDate(sDay, sMonth, sYear)) {
    // return True if sWeekday is valid according to the given date
    let xDate = checkDate(sDay, sMonth, sYear);
        let oDate = new Date(parseInt(sYear, 10), parseInt(sMonth, 10)-1, parseInt(sDay, 10));
        if (_lDay[oDate.getDay()] != sWeekday.toLowerCase()) {
            return false;
        }
        return true;
    }
    return false;
}

function checkDayWithString (sWeekday, sDay, sMonth, sYear) {
    if (xDate  &&  _getDay(xDate) != sWeekday.toLowerCase()) {
        return false;
    }
    // if the date isn’t valid, any day is valid.
    return true;
}

function getDay (sDay, sMonth, sYear) {
    // return the day of the date (in Gregorian calendar after 1582-12-20, in Julian calendar before 1582-12-09)
    let xDate = checkDate(sDay, sMonth, sYear);
    if (xDate) {
        return _getDay(xDate);
    }
    return ""
}

    // to use if sMonth is a noun
    if (checkDateWithString(sDay, sMonth, sYear)) {
function _getDay (xDate) {
        let oDate = new Date(parseInt(sYear, 10), _dMonth.get(sMonth.toLowerCase())-1, parseInt(sDay, 10));
        if (_lDay[oDate.getDay()] != sWeekday.toLowerCase()) {
            return false;
        }
        return true;
    // return the day of the date (in Gregorian calendar after 1582-12-20, in Julian calendar before 1582-12-09)
    if (xDate.getFullYear() > 1582) {
        // Calendrier grégorien
        return _lDay[xDate.getDay()];
    }
    if (xDate.getFullYear() < 1582) {
        // Calendrier julien
        let sGregorianDay = _lDay[xDate.getDay()];
        return _dGregorianToJulian.get(sGregorianDay, "Erreur: jour inconnu")
    }
    // 1582
    if ((xDate.getMonth()+1) < 12  || xDate.getDate() <= 9) {
        // Calendrier julien
        let sGregorianDay = _lDay[xDate.getDay()];
    return false;
}

        return _dGregorianToJulian.get(sGregorianDay, "Erreur: jour inconnu");
    }
    else if (xDate.getDate() >= 20) {
function getDay (sDay, sMonth, sYear) {
    // to use if sMonth is a number
        // Calendrier grégorien
    let oDate = new Date(parseInt(sYear, 10), parseInt(sMonth, 10)-1, parseInt(sDay, 10));
    return _lDay[oDate.getDay()];
}

        return _lDay[xDate.getDay()];
    }
    else {
        // 10 - 19 décembre 1582: jours inexistants en France.
        return "";
    }
function getDayWithString (sDay, sMonth, sYear) {
    // to use if sMonth is a noun
    let oDate = new Date(parseInt(sYear, 10), _dMonth.get(sMonth.toLowerCase())-1, parseInt(sDay, 10));
    return _lDay[oDate.getDay()];
}

Modified gc_lang/fr/modules/gce_date_verif.py from [c3f0a9eb2f] to [0f6e9ac587]. 

1
2
3
4



5
6
7
8
9















10

11

12


13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34



35

36
37
38
39

40
41
42
43
44





45
46
47
48
49
50
51
52
53
54





















1
2
3
4
5
6
7
8
9
10


11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

30
31
32
33
34
35
36
37
38
39










40



41
42
43
44
45
46
47
48

49





50
51
52
53
54





55
56



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76





+
+
+



-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+

+
-
+
+








-
-
-
-
-
-
-
-
-
-

-
-
-
+
+
+

+



-
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-


-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

#### GRAMMAR CHECKING ENGINE PLUGIN

#### Check date validity

import datetime


_lDay = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
_dMonth = { "janvier":1, "février":2, "mars":3, "avril":4, "mai":5, "juin":6, "juillet":7, "août":8, "aout":8, "septembre":9, "octobre":10, "novembre":11, "décembre":12 }

import datetime

# Dans Python, datetime.weekday() envoie le résultat comme si nous étions dans un calendrier grégorien universal.
# https://fr.wikipedia.org/wiki/Passage_du_calendrier_julien_au_calendrier_gr%C3%A9gorien
# Selon Grégoire, le jeudi 4 octobre 1582 est immédiatement suivi par le vendredi 15 octobre.
# En France, la bascule eut lieu le 9 décembre 1582 qui fut suivi par le 20 décembre 1582.
# C’est la date retenue pour la bascule dans Grammalecte, mais le calendrier grégorien fut adopté dans le monde diversement.
# Il fallut des siècles pour qu’il soit adopté par l’Occident et une grande partie du reste du monde.
_dGregorianToJulian = {
    "lundi":    "jeudi",
    "mardi":    "vendredi",
    "mercredi": "samedi",
    "jeudi":    "dimanche",
    "vendredi": "lundi",
    "samedi":   "mardi",
    "dimanche": "mercredi"
}


def checkDate (sDay, sMonth, sYear):
    "return True if the date is valid"
    "to use if <sMonth> is a number"
    if not sMonth.isdigit():
        sMonth = _dMonth.get(sMonth.lower(), "13")
    try:
        return datetime.date(int(sYear), int(sMonth), int(sDay))
    except ValueError:
        return False
    except:
        return True


def checkDateWithString (sDay, sMonth, sYear):
    "to use if <sMonth> is a noun"
    try:
        return datetime.date(int(sYear), _dMonth.get(sMonth.lower(), ""), int(sDay))
    except ValueError:
        return False
    except:
        return True


def checkDay (sWeekday, sDay, sMonth, sYear):
    "to use if <sMonth> is a number"
    oDate = checkDate(sDay, sMonth, sYear)
    if oDate and _lDay[oDate.weekday()] != sWeekday.lower():
    "return True if sWeekday is valid according to the given date"
    xDate = checkDate(sDay, sMonth, sYear)
    if xDate and _getDay(xDate) != sWeekday.lower():
        return False
    # if the date isn’t valid, any day is valid.
    return True


def checkDayWithString (sWeekday, sDay, sMonth, sYear):
def getDay (sDay, sMonth, sYear):
    "to use if <sMonth> is a noun"
    oDate = checkDate(sDay, _dMonth.get(sMonth, ""), sYear)
    if oDate and _lDay[oDate.weekday()] != sWeekday.lower():
        return False
    return True
    "return the day of the date (in Gregorian calendar after 1582-12-20, in Julian calendar before 1582-12-09)"
    xDate = checkDate(sDay, sMonth, sYear)
    if xDate:
        return _getDay(xDate)
    return ""


def getDay (sDay, sMonth, sYear):
    "to use if <sMonth> is a number"
    return _lDay[datetime.date(int(sYear), int(sMonth), int(sDay)).weekday()]


def getDayWithString (sDay, sMonth, sYear):
    "to use if <sMonth> is a noun"
    return _lDay[datetime.date(int(sYear), _dMonth.get(sMonth.lower(), ""), int(sDay)).weekday()]
def _getDay (xDate):
    "return the day of the date (in Gregorian calendar after 1582-12-20, in Julian calendar before 1582-12-09)"
    if xDate.year > 1582:
        # Calendrier grégorien
        return _lDay[xDate.weekday()]
    if xDate.year < 1582:
        # Calendrier julien
        sGregorianDay = _lDay[xDate.weekday()]
        return _dGregorianToJulian.get(sGregorianDay, "Erreur: jour inconnu")
    # 1582
    if xDate.month < 12  or xDate.day <= 9:
        # Calendrier julien
        sGregorianDay = _lDay[xDate.weekday()]
        return _dGregorianToJulian.get(sGregorianDay, "Erreur: jour inconnu")
    elif xDate.day >= 20:
        # Calendrier grégorien
        return _lDay[xDate.weekday()]
    else:
        # 10 - 19 décembre 1582: jours inexistants en France.
        return ""

Modified gc_lang/fr/rules.grx from [d0ae10ee5a] to [8a26d1e3e7].

︙
3006
3007
3008
3009
3010
3011
3012
3013

3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027



3028
3029
3030
3031
3032
3033
3034


3035
3036
3037
3038
3039
3040
3041

3006
3007
3008
3009
3010
3011
3012

3013
3014
3015
3016
3017
3018
3019
3020
3021



3022


3023
3024
3025
3026
3027
3028
3029
3030
3031

3032
3033
3034
3035
3036
3037
3038
3039
3040








-
+








-
-
-

-
-
+
+
+






-
+
+








    31 [avril|juin|septembre|novembre]
        <<- /date/ space_after(\1, 1, 1) ->> 30 \2                                                  # Cette date est invalide. Il n’y a que 30 jours en \2.

    [30|31] février
        <<- /date/ space_after(\1, 1, 1) ->> 28 février|29 février                                  # Cette date est invalide. Il n’y a que 28 ou 29 jours en février.

    ~^\d\d?$  [janvier|février|mars|avril|mai|juin|juillet|aout|août|septembre|octobre|novembre|décembre]  ~^\d{2,5}$
        <<- /date/ not checkDateWithString(\1, \2, \3) ->> _                                        # Cette date est invalide.
        <<- /date/ not checkDate(\1, \2, \3) ->> _                                                  # Cette date est invalide.

TEST: le {{31 avril}}
TEST: le {{30 février}}
TEST: {{29 février 2011}}


__date_journée_jour_mois_année__
    ([lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche])  ?,¿  ?le¿  (~^\d\d?$) - (~^\d\d?$) - (~^\d{2,5}$)
        <<- /date/ not after("^ +av(?:ant|) +J(?:C|ésus-Christ)") and not checkDay(\1, \2, \3, \4)
        -1>> =getDay(\2, \3, \4)                                                                            # Le jour de la date suivante est incorrect.

    ([lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche])  ?,¿  ?le¿  (~^\d\d?$)  ([janvier|février|mars|avril|mai|juin|juillet|aout|août|septembre|octobre|novembre|décembre])  (~^\d{2,5}$)
        <<- /date/ not after("^ +av(?:ant|) +J(?:C|ésus-Christ)") and not checkDayWithString(\1, \2, \3, \4)
        -1>> =getDayWithString(\2, \3, \4)                                                          # Le jour de la date suivante est incorrect.
        <<- /date/ not after("^ +av(?:ant|) +J(?:C|ésus-Christ)") and not checkDay(\1, \2, \3, \4)
        -1>> =getDay(\2, \3, \4)
        # Le jour de la date suivante est incorrect (selon le calendrier grégorien).|https://fr.wikipedia.org/wiki/Passage_du_calendrier_julien_au_calendrier_gr%C3%A9gorien

TEST: {{samedi}}, le 10-06-2014                                           ->> mardi
TEST: {{mercredi}}, le 10 juin 2014                                       ->> mardi
TEST: {{lundi}}, 18 août 1912                                             ->> dimanche
TEST: {{jeudi}} 17 aout 1912                                              ->> samedi
TEST: lundi, 18 août 1912 avant Jésus-Christ (date imaginaire)

TEST: {{jeudi}}, 18 août 1563 : mort de La Boétie (calendrier julien)     ->> mercredi
TEST: mercredi, 18 août 1563 : mort de La Boétie (calendrier julien)


!!
!!
!!!! Traits d’union                                                                               !!
!!
!!
︙

Fossil 2.20 [210e89a059] 2022-11-16 18:46:32
This page was generated in about 0.128s