Fix: forwardDate to effect month/year calculation

wanasit · Apr 9, 2023 · 665bda6 · 665bda6
1 parent 38d0c0a
commit 665bda6
Show file tree

Hide file tree

Showing 5 changed files with 129 additions and 26 deletions.
diff --git a/src/common/refiners/AbstractMergeDateRangeRefiner.ts b/src/common/refiners/AbstractMergeDateRangeRefiner.ts
@@ -16,31 +16,36 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
         if (!fromResult.start.isOnlyWeekdayComponent() && !toResult.start.isOnlyWeekdayComponent()) {
             toResult.start.getCertainComponents().forEach((key) => {
                 if (!fromResult.start.isCertain(key)) {
-                    fromResult.start.assign(key, toResult.start.get(key));
+                    fromResult.start.imply(key, toResult.start.get(key));
                 }
             });
 
             fromResult.start.getCertainComponents().forEach((key) => {
                 if (!toResult.start.isCertain(key)) {
-                    toResult.start.assign(key, fromResult.start.get(key));
+                    toResult.start.imply(key, fromResult.start.get(key));
                 }
             });
         }
 
         if (fromResult.start.date().getTime() > toResult.start.date().getTime()) {
             let fromMoment = fromResult.start.dayjs();
             let toMoment = toResult.start.dayjs();
-
-            if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, "days").isBefore(toMoment)) {
+            if (toResult.start.isOnlyWeekdayComponent() && toMoment.add(7, "days").isAfter(fromMoment)) {
+                toMoment = toMoment.add(7, "days");
+                toResult.start.imply("day", toMoment.date());
+                toResult.start.imply("month", toMoment.month() + 1);
+                toResult.start.imply("year", toMoment.year());
+            } else if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, "days").isBefore(toMoment)) {
                 fromMoment = fromMoment.add(-7, "days");
                 fromResult.start.imply("day", fromMoment.date());
                 fromResult.start.imply("month", fromMoment.month() + 1);
                 fromResult.start.imply("year", fromMoment.year());
-            } else if (toResult.start.isOnlyWeekdayComponent() && toMoment.add(7, "days").isAfter(fromMoment)) {
-                toMoment = toMoment.add(7, "days");
-                toResult.start.imply("day", toMoment.date());
-                toResult.start.imply("month", toMoment.month() + 1);
+            } else if (toResult.start.isDateWithUnknownYear() && toMoment.add(1, "years").isAfter(fromMoment)) {
+                toMoment = toMoment.add(1, "years");
                 toResult.start.imply("year", toMoment.year());
+            } else if (fromResult.start.isDateWithUnknownYear() && fromMoment.add(-1, "years").isBefore(toMoment)) {
+                fromMoment = fromMoment.add(-1, "years");
+                fromResult.start.imply("year", fromMoment.year());
             } else {
                 [toResult, fromResult] = [fromResult, toResult];
             }

diff --git a/src/common/refiners/ForwardDateRefiner.ts b/src/common/refiners/ForwardDateRefiner.ts
@@ -30,22 +30,6 @@ export default class ForwardDateRefiner implements Refiner {
                 }
             }
 
-            if (result.start.isOnlyDayMonthComponent() && refMoment.isAfter(result.start.dayjs())) {
-                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
-                    result.start.imply("year", result.start.get("year") + 1);
-                    context.debug(() => {
-                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
-                    });
-
-                    if (result.end && !result.end.isCertain("year")) {
-                        result.end.imply("year", result.end.get("year") + 1);
-                        context.debug(() => {
-                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
-                        });
-                    }
-                }
-            }
-
             if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
                 if (refMoment.day() >= result.start.get("weekday")) {
                     refMoment = refMoment.day(result.start.get("weekday") + 7);
@@ -76,6 +60,24 @@ export default class ForwardDateRefiner implements Refiner {
                     });
                 }
             }
+
+            // In case where we know the month, but not which year (e.g. "in December", "25th December"),
+            // try move to another year
+            if (result.start.isDateWithUnknownYear() && refMoment.isAfter(result.start.dayjs())) {
+                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
+                    result.start.imply("year", result.start.get("year") + 1);
+                    context.debug(() => {
+                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
+                    });
+
+                    if (result.end && !result.end.isCertain("year")) {
+                        result.end.imply("year", result.end.get("year") + 1);
+                        context.debug(() => {
+                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
+                        });
+                    }
+                }
+            }
         });
 
         return results;

diff --git a/src/results.ts b/src/results.ts
@@ -138,8 +138,8 @@ export class ParsingComponents implements ParsedComponents {
         return this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
     }
 
-    isOnlyDayMonthComponent(): boolean {
-        return this.isCertain("day") && this.isCertain("month") && !this.isCertain("year");
+    isDateWithUnknownYear(): boolean {
+        return this.isCertain("month") && !this.isCertain("year");
     }
 
     isValidDate(): boolean {

diff --git a/test/en/en_month.test.ts b/test/en/en_month.test.ts
@@ -117,6 +117,76 @@ test("Test - Month-Only expression", function () {
     });
 });
 
+test("Test - Month-Only Range expression", () => {
+    testSingleCase(chrono, "From May to December", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "From December to May", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From May to December, 2022", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.end.get("year")).toBe(2022);
+        expect(result.end.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "From December to May 2022", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2021);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2022);
+        expect(result.end.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From December to May 2020", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2019);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2020);
+        expect(result.end.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From December to May 2025", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2024);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2025);
+        expect(result.end.get("month")).toBe(5);
+    });
+});
+
+test("Test - Month with farward date option", () => {
+    testSingleCase(chrono, "in December", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "in May", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From May to December", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "From December to May", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2024);
+        expect(result.end.get("month")).toBe(5);
+    });
+});
+
 test("Test - Month expression in context", function () {
     testSingleCase(chrono, "The date is Sep 2012 is the date", (result) => {
         expect(result.index).toBe(12);

diff --git a/test/en/en_weekday.test.ts b/test/en/en_weekday.test.ts
@@ -273,6 +273,32 @@ test("Test - Weekday Overlap", function () {
     });
 });
 
+test("Test - Weekday range", () => {
+    testSingleCase(chrono.casual, "Friday to Monday", new Date(2023, 4 - 1, 9) /*Sunday*/, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(7);
+        expect(result.start.get("weekday")).toBe(5);
+
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(4);
+        expect(result.end.get("day")).toBe(10);
+        expect(result.end.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono.casual, "Monday to Friday", new Date(2023, 4 - 1, 9) /*Sunday*/, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("weekday")).toBe(1);
+
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(4);
+        expect(result.end.get("day")).toBe(14);
+        expect(result.end.get("weekday")).toBe(5);
+    });
+});
+
 test("Test - forward dates only option", () => {
     testSingleCase(
         chrono.casual,