Merge pull request #1015 from yadavan88/SCALA-438-date-range-list

Sample code for the generation of dates between a range

Author: dominiqueplante

scala-core-modules/scala-core-8/src/main/scala/com/baeldung/scala/dates/DateListGenerator.scala

@@ -0,0 +1,69 @@
+package com.baeldung.scala.dates
+
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+import scala.annotation.tailrec
+
+object DateListGenerator {
+
+  def recursiveDateList(
+    startDate: LocalDate,
+    endDate: LocalDate
+  ): List[LocalDate] = {
+    @tailrec
+    def findNextDate(
+      currentDate: LocalDate,
+      accDates: List[LocalDate]
+    ): List[LocalDate] = {
+      if (currentDate.isAfter(endDate)) {
+        accDates
+      } else {
+        findNextDate(currentDate.plusDays(1), accDates :+ currentDate)
+      }
+    }
+    findNextDate(startDate, Nil)
+  }
+
+  def foldLeftDateList(
+    startDate: LocalDate,
+    endDate: LocalDate
+  ): List[LocalDate] = {
+    val noOfDays = ChronoUnit.DAYS.between(startDate, endDate) + 1
+    (0 until noOfDays.toInt).foldLeft(List.empty[LocalDate]) { (acc, incr) =>
+      acc :+ startDate.plusDays(incr)
+    }
+  }
+
+  def iteratorDateList(
+    startDate: LocalDate,
+    endDate: LocalDate
+  ): List[LocalDate] = {
+    Iterator
+      .iterate(startDate)(_.plusDays(1))
+      .takeWhile(!_.isAfter(endDate))
+      .toList
+  }
+
+  def tabulateDateList(
+    startDate: LocalDate,
+    endDate: LocalDate
+  ): List[LocalDate] = {
+    val noOfDays = ChronoUnit.DAYS.between(startDate, endDate) + 1
+    List.tabulate(noOfDays.toInt)(startDate.plusDays(_))
+  }
+
+  def dateListEpochDays(
+    startDate: LocalDate,
+    endDate: LocalDate
+  ): List[LocalDate] = {
+    startDate.toEpochDay.to(endDate.toEpochDay).map(LocalDate.ofEpochDay).toList
+  }
+
+  def dateListDaysBetween(
+    startDate: LocalDate,
+    endDate: LocalDate
+  ): List[LocalDate] = {
+    val noOfDays = ChronoUnit.DAYS.between(startDate, endDate) + 1
+    (0 until noOfDays.toInt).map(startDate.plusDays(_)).toList
+  }
+}

scala-core-modules/scala-core-8/src/test/scala/com/baeldung/scala/dates/DateListGeneratorUnitTest.scala

@@ -0,0 +1,71 @@
+package com.baeldung.scala.dates
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.prop.TableDrivenPropertyChecks
+
+import java.time.LocalDate
+
+class DateListGeneratorUnitTest
+  extends AnyFlatSpec
+  with Matchers
+  with TableDrivenPropertyChecks {
+
+  private val start = LocalDate.parse("2023-10-28")
+  private val end = LocalDate.parse("2023-11-03")
+
+  private val expectedResult = List(
+    "2023-10-28",
+    "2023-10-29",
+    "2023-10-30",
+    "2023-10-31",
+    "2023-11-01",
+    "2023-11-02",
+    "2023-11-03"
+  ).map(LocalDate.parse)
+
+  private val inOutTable = Table(
+    ("startDate", "endDate", "expectedOutput", "message"),
+    (start, end, expectedResult, "1 week"),
+    (start, start, List(start), "start and end as start"),
+    (end, end, List(end), "start and end as end"),
+    (start, start.minusDays(1), List.empty, "end before start")
+  )
+
+  forAll(inOutTable) { (startDate, endDate, expectedDates, prefix) =>
+
+    it should s"[${prefix}] generate a list of dates between a range using recursion" in {
+      val recDateList = DateListGenerator.recursiveDateList(startDate, endDate)
+      assert(recDateList == expectedDates)
+    }
+
+    it should s"[${prefix}] generate a list of dates between a range using foldLeft" in {
+      val foldedDateList =
+        DateListGenerator.foldLeftDateList(startDate, endDate)
+      assert(foldedDateList == expectedDates)
+    }
+
+    it should s"[${prefix}] generate a list of dates between a range using iterator" in {
+      val iteratorDates = DateListGenerator.iteratorDateList(startDate, endDate)
+      assert(iteratorDates == expectedDates)
+    }
+
+    it should s"[${prefix}] generate a list of dates between a range using tabulator" in {
+      val tabulateDateList =
+        DateListGenerator.tabulateDateList(startDate, endDate)
+      assert(tabulateDateList == expectedDates)
+    }
+
+    it should s"[${prefix}] generate a list of dates between a range using epoch days" in {
+      val datesEpoch = DateListGenerator.dateListEpochDays(startDate, endDate)
+      assert(datesEpoch == expectedDates)
+    }
+
+    it should s"[${prefix}] generate a list of dates between a range using daysBetween" in {
+      val dates = DateListGenerator.dateListDaysBetween(startDate, endDate)
+      assert(dates == expectedDates)
+    }
+
+  }
+
+}