Close #340 - [refined4s-chimney] Add missing Transformer to unwra…

…p value for `ChimneyNewtype`
kevin-lee · Aug 15, 2024 · 3c1c183 · 3c1c183
1 parent d9f69e4
commit 3c1c183
Show file tree

Hide file tree

Showing 2 changed files with 85 additions and 20 deletions.
diff --git a/...s-chimney/shared/src/main/scala/refined4s/modules/chimney/derivation/ChimneyNewtype.scala b/...s-chimney/shared/src/main/scala/refined4s/modules/chimney/derivation/ChimneyNewtype.scala
@@ -11,9 +11,11 @@ trait ChimneyNewtype[A] {
 
   given wrapNewTypeForChimney: Transformer[A, self.Type] = wrap(_)
 
+  given unwrapNewTypeForChimney: Transformer[self.Type, A] = unwrap(_)
+
   given unwrapAndWrapNewTypeForChimney[C](
-    using anoterCoercible: Coercible[A, C]
+    using anotherCoercible: Coercible[A, C]
   ): Transformer[self.Type, C] =
-    b => anoterCoercible(unwrap(b))
+    b => anotherCoercible(unwrap(b))
 
 }
diff --git a/...imney/shared/src/test/scala/refined4s/modules/chimney/derivation/ChimneyNewtypeSpec.scala b/...imney/shared/src/test/scala/refined4s/modules/chimney/derivation/ChimneyNewtypeSpec.scala
@@ -14,12 +14,16 @@ import refined4s.types.all.PosInt
 object ChimneyNewtypeSpec extends Properties {
 
   override def tests: List[Test] = List(
-    property("test Newtype", testNewtype),
+    property("test Newtype to Newtype with Transformer", testNewtypeToNewtype),
+    property("test Newtype to non-Newtype with Transformer", testNewtypeToNonNewtype),
     property("test Newtype[Refined]", testRefinedNewtype),
     property("test case class", testCaseClass),
+    property("test case class with Newtype to non-Newtype", testCaseClassWithNewtypeToNonNewtype),
   )
 
-  def testNewtype: Property =
+  def testNewtypeToNewtype: Property = {
+    import TestType1.*
+
     for {
       nameString <- Gen
                       .string(Gen.alpha, Range.linear(1, 10))
@@ -34,8 +38,30 @@ object ChimneyNewtypeSpec extends Properties {
       val actual = name.into[Bar.Label].transform
       expected ==== actual
     }
+  }
+
+  def testNewtypeToNonNewtype: Property = {
+    import TestType1.*
+
+    for {
+      nameString <- Gen
+                      .string(Gen.alpha, Range.linear(1, 10))
+                      .list(Range.singleton(2))
+                      .map(_.mkString(" "))
+                      .log("nameString")
+      name = Foo.Name(nameString)
+    } yield {
+      import io.scalaland.chimney.dsl.*
+      val expected = nameString
+
+      val actual = name.into[String].transform
+      expected ==== actual
+    }
+  }
+
+  def testRefinedNewtype: Property = {
+    import TestType1.*
 
-  def testRefinedNewtype: Property =
     for {
       idNum <- NumGens.genPosIntMaxTo(PosInt(Int.MaxValue)).log("idNum")
       id = Foo.Id(idNum)
@@ -46,8 +72,11 @@ object ChimneyNewtypeSpec extends Properties {
       val actual = id.into[Bar.Code].transform
       expected ==== actual
     }
+  }
+
+  def testCaseClass: Property = {
+    import TestType1.*
 
-  def testCaseClass: Property =
     for {
       idNum      <- NumGens.genPosIntMaxTo(PosInt(Int.MaxValue)).log("idNum")
       nameString <- Gen
@@ -66,28 +95,62 @@ object ChimneyNewtypeSpec extends Properties {
       val actual = Foo(id, Foo.Baz(name)).into[Bar].transform
       expected ==== actual
     }
+  }
 
-  final case class Foo(id: Foo.Id, baz: Foo.Baz)
-  object Foo {
-    type Id = Id.Type
-    object Id extends Newtype[PosInt], ChimneyNewtype[PosInt]
+  def testCaseClassWithNewtypeToNonNewtype: Property = {
+    import TestTypes2.*
+    for {
+      nameString <- Gen
+                      .string(Gen.alpha, Range.linear(1, 10))
+                      .list(Range.singleton(2))
+                      .map(_.mkString(" "))
+                      .log("nameString")
 
-    type Name = Name.Type
-    object Name extends Newtype[String], ChimneyNewtype[String]
+      name = Person.Name(nameString)
+    } yield {
+      import io.scalaland.chimney.dsl.*
+
+      val expected = User(nameString)
 
-    final case class Baz(name: Name)
+      val actual = Person(name).into[User].transform
+      expected ==== actual
+    }
   }
 
-  final case class Bar(id: Bar.Code, baz: Bar.Baz)
+  object TestType1 {
+    final case class Foo(id: Foo.Id, baz: Foo.Baz)
 
-  object Bar {
-    type Code = Code.Type
-    object Code extends Newtype[PosInt], ChimneyNewtype[PosInt]
+    object Foo {
+      type Id = Id.Type
+      object Id extends Newtype[PosInt], ChimneyNewtype[PosInt]
 
-    type Label = Label.Type
-    object Label extends Newtype[String], ChimneyNewtype[String]
+      type Name = Name.Type
+      object Name extends Newtype[String], ChimneyNewtype[String]
 
-    final case class Baz(name: Label)
+      final case class Baz(name: Name)
+    }
+
+    final case class Bar(id: Bar.Code, baz: Bar.Baz)
+    object Bar {
+      type Code = Code.Type
+      object Code extends Newtype[PosInt], ChimneyNewtype[PosInt]
+
+      type Label = Label.Type
+      object Label extends Newtype[String], ChimneyNewtype[String]
+
+      final case class Baz(name: Label)
+    }
   }
 
+  object TestTypes2 {
+
+    final case class Person(name: Person.Name)
+    object Person {
+      type Name = Name.Type
+
+      object Name extends Newtype[String], ChimneyNewtype[String]
+    }
+
+    final case class User(name: String)
+  }
 }