Close #500: [refined4s-chimney] Add Transformer and PartialTransformer type-class instances for refined4s.types.time types

Author: kevin-lee

modules/refined4s-chimney/shared/src/main/scala/refined4s/modules/chimney/derivation/types/all.scala

@@ -3,5 +3,5 @@ package refined4s.modules.chimney.derivation.types
 /** @author Kevin Lee
   * @since 2024-08-09
   */
-trait all extends numeric, strings, network
+trait all extends numeric, strings, network, time
 object all extends all

modules/refined4s-chimney/shared/src/main/scala/refined4s/modules/chimney/derivation/types/time.scala

@@ -0,0 +1,69 @@
+package refined4s.modules.chimney.derivation.types
+
+import io.scalaland.chimney
+import io.scalaland.chimney.{PartialTransformer, Transformer}
+
+import refined4s.types.time.*
+
+/** @author Kevin Lee
+  * @since 2025-09-01
+  */
+trait time {
+  inline given derivedMonthToIntTransformer: Transformer[Month, Int]               = time.derivedMonthToIntTransformer
+  inline given derivedIntToMonthPartialTransformer: PartialTransformer[Int, Month] = time.derivedIntToMonthPartialTransformer
+
+  inline given derivedDayToIntTransformer: Transformer[Day, Int]               = time.derivedDayToIntTransformer
+  inline given derivedIntToDayPartialTransformer: PartialTransformer[Int, Day] = time.derivedIntToDayPartialTransformer
+
+  inline given derivedHourToIntTransformer: Transformer[Hour, Int]               = time.derivedHourToIntTransformer
+  inline given derivedIntToHourPartialTransformer: PartialTransformer[Int, Hour] = time.derivedIntToHourPartialTransformer
+
+  inline given derivedMinuteToIntTransformer: Transformer[Minute, Int]               = time.derivedMinuteToIntTransformer
+  inline given derivedIntToMinutePartialTransformer: PartialTransformer[Int, Minute] = time.derivedIntToMinutePartialTransformer
+
+  inline given derivedSecondToIntTransformer: Transformer[Second, Int]               = time.derivedSecondToIntTransformer
+  inline given derivedIntToSecondPartialTransformer: PartialTransformer[Int, Second] = time.derivedIntToSecondPartialTransformer
+
+  inline given derivedMillisToIntTransformer: Transformer[Millis, Int]               = time.derivedMillisToIntTransformer
+  inline given derivedIntToMillisPartialTransformer: PartialTransformer[Int, Millis] = time.derivedIntToMillisPartialTransformer
+
+}
+object time {
+
+  inline given derivedMonthToIntTransformer: Transformer[Month, Int] with {
+    override def transform(src: Month): Int = src.value
+  }
+  inline given derivedIntToMonthPartialTransformer: PartialTransformer[Int, Month] =
+    PartialTransformer(value => chimney.partial.Result.fromEitherString(Month.from(value)))
+
+  inline given derivedDayToIntTransformer: Transformer[Day, Int] with {
+    override def transform(src: Day): Int = src.value
+  }
+  inline given derivedIntToDayPartialTransformer: PartialTransformer[Int, Day] =
+    PartialTransformer(value => chimney.partial.Result.fromEitherString(Day.from(value)))
+
+  inline given derivedHourToIntTransformer: Transformer[Hour, Int] with {
+    override def transform(src: Hour): Int = src.value
+  }
+  inline given derivedIntToHourPartialTransformer: PartialTransformer[Int, Hour] =
+    PartialTransformer(value => chimney.partial.Result.fromEitherString(Hour.from(value)))
+
+  inline given derivedMinuteToIntTransformer: Transformer[Minute, Int] with {
+    override def transform(src: Minute): Int = src.value
+  }
+  inline given derivedIntToMinutePartialTransformer: PartialTransformer[Int, Minute] =
+    PartialTransformer(value => chimney.partial.Result.fromEitherString(Minute.from(value)))
+
+  inline given derivedSecondToIntTransformer: Transformer[Second, Int] with {
+    override def transform(src: Second): Int = src.value
+  }
+  inline given derivedIntToSecondPartialTransformer: PartialTransformer[Int, Second] =
+    PartialTransformer(value => chimney.partial.Result.fromEitherString(Second.from(value)))
+
+  inline given derivedMillisToIntTransformer: Transformer[Millis, Int] with {
+    override def transform(src: Millis): Int = src.value
+  }
+  inline given derivedIntToMillisPartialTransformer: PartialTransformer[Int, Millis] =
+    PartialTransformer(value => chimney.partial.Result.fromEitherString(Millis.from(value)))
+
+}

modules/refined4s-chimney/shared/src/test/scala/refined4s/modules/chimney/derivation/types/allSpec.scala

@@ -17,7 +17,11 @@ object allSpec extends Properties {
   object networkSpecWithAll extends networkSpec {
     override protected val networkTypeClasses: network = refined4s.modules.chimney.derivation.types.all
   }
+  object timeSpecWithAll extends timeSpec {
+    override protected val timeTypeClasses: time = refined4s.modules.chimney.derivation.types.all
+  }
 
-  override def tests: List[Test] = numericSpec.allTests ++ stringsSpec.allTests ++ networkSpec.allTests
+  override def tests: List[Test] =
+    numericSpec.allTests ++ stringsSpec.allTests ++ networkSpec.allTests ++ timeSpecWithAll.allTests
 
 }

modules/refined4s-chimney/shared/src/test/scala/refined4s/modules/chimney/derivation/types/timeSpec.scala

@@ -0,0 +1,196 @@
+package refined4s.modules.chimney.derivation.types
+
+import hedgehog.*
+import hedgehog.runner.*
+import io.scalaland.chimney
+import io.scalaland.chimney.dsl.*
+import refined4s.types.TimeGens
+import refined4s.types.time.*
+
+/** @author Kevin Lee
+  * @since 2025-09-01
+  */
+trait timeSpec {
+
+  protected val timeTypeClasses: refined4s.modules.chimney.derivation.types.time
+  import timeTypeClasses.given
+
+  def allTests: List[Test] = List(
+    // Month
+    property("test from Month to Int", testFromMonthToInt),
+    property("test from Int to Month", testToIntToMonth),
+    // Day
+    property("test from Day to Int", testFromDayToInt),
+    property("test from Int to Day", testToIntToDay),
+    // Hour
+    property("test from Hour to Int", testFromHourToInt),
+    property("test from Int to Hour", testToIntToHour),
+    // Minute
+    property("test from Minute to Int", testFromMinuteToInt),
+    property("test from Int to Minute", testToIntToMinute),
+    // Second
+    property("test from Second to Int", testFromSecondToInt),
+    property("test from Int to Second", testToIntToSecond),
+    // Millis
+    property("test from Millis to Int", testFromMillisToInt),
+    property("test from Int to Millis", testToIntToMillis),
+  )
+
+  def testFromMonthToInt: Property =
+    for {
+      month <- TimeGens.genMonth.log("month")
+    } yield {
+      val input = month
+
+      val expected = month.value
+      val actual   = input.into[Int].transform
+
+      actual ==== expected
+    }
+
+  def testToIntToMonth: Property =
+    for {
+      month <- TimeGens.genMonth.log("month")
+    } yield {
+      val input = month.value
+
+      val expected = chimney.partial.Result.fromValue(month)
+
+      val actual = input.intoPartial[Month].transform
+
+      actual ==== expected
+    }
+
+  def testFromDayToInt: Property =
+    for {
+      day <- TimeGens.genDay.log("day")
+    } yield {
+      val input = day
+
+      val expected = day.value
+      val actual   = input.into[Int].transform
+
+      actual ==== expected
+    }
+
+  def testToIntToDay: Property =
+    for {
+      day <- TimeGens.genDay.log("day")
+    } yield {
+      val input = day.value
+
+      val expected = chimney.partial.Result.fromValue(day)
+
+      val actual = input.intoPartial[Day].transform
+
+      actual ==== expected
+    }
+
+  def testFromHourToInt: Property =
+    for {
+      hour <- TimeGens.genHour.log("hour")
+    } yield {
+      val input = hour
+
+      val expected = hour.value
+      val actual   = input.into[Int].transform
+
+      actual ==== expected
+    }
+
+  def testToIntToHour: Property =
+    for {
+      hour <- TimeGens.genHour.log("hour")
+    } yield {
+      val input = hour.value
+
+      val expected = chimney.partial.Result.fromValue(hour)
+
+      val actual = input.intoPartial[Hour].transform
+
+      actual ==== expected
+    }
+
+  def testFromMinuteToInt: Property =
+    for {
+      minute <- TimeGens.genMinute.log("minute")
+    } yield {
+      val input = minute
+
+      val expected = minute.value
+      val actual   = input.into[Int].transform
+
+      actual ==== expected
+    }
+
+  def testToIntToMinute: Property =
+    for {
+      minute <- TimeGens.genMinute.log("minute")
+    } yield {
+      val input = minute.value
+
+      val expected = chimney.partial.Result.fromValue(minute)
+
+      val actual = input.intoPartial[Minute].transform
+
+      actual ==== expected
+    }
+
+  def testFromSecondToInt: Property =
+    for {
+      second <- TimeGens.genSecond.log("second")
+    } yield {
+      val input = second
+
+      val expected = second.value
+      val actual   = input.into[Int].transform
+
+      actual ==== expected
+    }
+
+  def testToIntToSecond: Property =
+    for {
+      second <- TimeGens.genSecond.log("second")
+    } yield {
+      val input = second.value
+
+      val expected = chimney.partial.Result.fromValue(second)
+
+      val actual = input.intoPartial[Second].transform
+
+      actual ==== expected
+    }
+
+  def testFromMillisToInt: Property =
+    for {
+      millis <- TimeGens.genMillis.log("millis")
+    } yield {
+      val input = millis
+
+      val expected = millis.value
+      val actual   = input.into[Int].transform
+
+      actual ==== expected
+    }
+
+  def testToIntToMillis: Property =
+    for {
+      millis <- TimeGens.genMillis.log("millis")
+    } yield {
+      val input = millis.value
+
+      val expected = chimney.partial.Result.fromValue(millis)
+
+      val actual = input.intoPartial[Millis].transform
+
+      actual ==== expected
+    }
+
+}
+object timeSpec extends Properties, timeSpec {
+
+  override protected object timeTypeClasses extends refined4s.modules.chimney.derivation.types.time
+
+  override def tests: List[Test] = allTests
+
+}