feat(forms): enhance form handling with selectForm and selectMappedForm

examples/client/src/main/scala/samples/EnumSample.scala

@@ -4,27 +4,49 @@ import com.raquo.laminar.api.L.*
 import dev.cheleb.scalamigen.*
 import io.github.iltotore.iron.*
 import io.github.iltotore.iron.constraint.all.*
+import java.util.UUID
 
 val enums = {
   enum Color(val code: String):
     case Black extends Color("000")
     case White extends Color("FFF")
     case Isabelle extends Color("???")
 
-  given colorForm: Form[Color] = enumForm(Color.values, Color.fromOrdinal)
+  given colorForm: Form[Color] =
+    selectForm(Color.values, labelMapper = c => s"$c ${c.code}")
+
+  case class Meal(id: UUID, name: String)
+
+  val allMeals = List(
+    Meal(UUID.fromString("00000000-0000-0000-0000-000000000001"), "Pizza"),
+    Meal(UUID.fromString("00000000-0000-0000-0000-000000000002"), "Pasta")
+  )
+
+  given mealForm: Form[UUID] =
+    selectMappedForm(allMeals, mapper = m => m.id, labelMapper = _.name)
 
   case class Basket(color: Color, cat: Cat)
 
   case class Cat(
       name: String,
       weight: Int :| Positive,
       kind: Boolean = true,
-      colol: Color
+      color: Color,
+      mealId: UUID
   )
 //  case class Dog(name: String, weight: Int)
 
   val enumVar = Var(
-    Basket(Color.Black, Cat("Scala", 10, true, Color.White))
+    Basket(
+      Color.Black,
+      Cat(
+        "Scala",
+        10,
+        true,
+        Color.White,
+        UUID.fromString("00000000-0000-0000-0000-000000000000")
+      )
+    )
   )
 
   Sample(
@@ -38,21 +60,33 @@ val enums = {
       }
     ),
     """|
-         |  enum Color(val code: String):
-         |    case Black extends Color("000")
-         |    case White extends Color("FFF")
-         |    case Isabelle extends Color("???")
-         |
-         |  given colorForm: Form[Color] = enumForm(Color.values, Color.fromOrdinal)
-         |
-         |  case class Basket(color: Color, cat: Cat)
-         |
-         |  case class Cat(
-         |      name: String,
-         |      age: Int,
-         |      color: Color
-         |  )
-         |
-         |""".stripMargin
+       |enum Color(val code: String):
+       |  case Black extends Color("000")
+       |  case White extends Color("FFF")
+       |  case Isabelle extends Color("???")
+       |
+       |given colorForm: Form[Color] =
+       |  selectForm(Color.values, labelMapper = c => s"$c ${c.code}")
+       |
+       |case class Meal(id: UUID, name: String)
+       |
+       |val allMeals = List(
+       |  Meal(UUID.fromString("00000000-0000-0000-0000-000000000001"), "Pizza"),
+       |  Meal(UUID.fromString("00000000-0000-0000-0000-000000000002"), "Pasta")
+       |)
+       |
+       |given mealForm: Form[UUID] =
+       |  selectMappedForm(allMeals, mapper = m => m.id, labelMapper = _.name)
+       |
+       |case class Basket(color: Color, cat: Cat)
+       |
+       |case class Cat(
+       |  name: String,
+       |  weight: Int :| Positive,
+       |  kind: Boolean = true,
+       |  color: Color,
+       |  mealId: UUID
+       |)
+       |""".stripMargin
   )
 }

examples/client/src/main/scala/samples/Sealed.scala

@@ -13,7 +13,7 @@ val sealedClasses = {
     case White extends Color("FFF")
     case Isabelle extends Color("???")
 
-  given colorForm: Form[Color] = enumForm(Color.values, Color.fromOrdinal)
+  given colorForm: Form[Color] = selectForm(Color.values)
 
   sealed trait Animal
 
@@ -86,7 +86,7 @@ val sealedClasses = {
        |    case White extends Color("FFF")
        |    case Isabelle extends Color("???")
        |
-       |  given colorForm: Form[Color] = enumForm(Color.values, Color.fromOrdinal)
+       |  given colorForm: Form[Color] = selectForm(Color.values)
        |
        |  sealed trait Animal
        |

modules/core/src/main/scala/dev/cheleb/scalamigen/ValidationEvent.scala

@@ -1,15 +1,42 @@
 package dev.cheleb.scalamigen
 
+/** A sealed trait representing the possible events that can be emitted by a
+  * validation.
+  *
+  * Events are emitted by the validation of a field. They are used to update the
+  * state.
+  */
 trait ValidationEvent
 
+/** The event emitted when the validation is successful.
+  *
+  * It will clear any error message for a field.
+  */
 case object ValidEvent extends ValidationEvent
 
+/** The event emitted when the validation is unsuccessful.
+  *
+  * @param errorMessage
+  *   The error message.
+  */
 final case class InvalideEvent(errorMessage: String) extends ValidationEvent
 
+/** The event emitted when the field is hidden (when Option is set to None).
+  *
+  * It will then ignore any validation status.
+  */
 case object HiddenEvent extends ValidationEvent
 
+/** The event emitted when the field is shown (when Option is set to Some).
+  *
+  * It will then redem any validation status.
+  */
 case object ShownEvent extends ValidationEvent
 
+/** Validation status.
+  *
+  * It is used to determine the status of a field.
+  */
 enum ValidationStatus:
   case Unknown
   case Valid

modules/core/src/main/scala/dev/cheleb/scalamigen/Validator.scala

@@ -2,6 +2,11 @@ package dev.cheleb.scalamigen
 
 import scala.util.Try
 
+/** A trait representing a validator for a type A.
+  *
+  * A validator is a function that takes a string and returns either an error
+  * message or a value of type A.
+  */
 trait Validator[A] {
   def validate(str: String): Either[String, A]
 }

modules/core/src/main/scala/dev/cheleb/scalamigen/package.scala

@@ -25,6 +25,19 @@ def stringForm[A](to: String => A) = new Form[A]:
         syncParent()
       }
     )
+
+/** A form for a secret type.
+  *
+  * The secret type is a string that should not be displayed in clear text.
+  *
+  * In general it is used for passwords, api keys, etc...
+  *
+  * Hence this sensitive data should be declared as an opaque type.
+  *
+  * @param to
+  *   The function to convert the string to the secret type.
+  * @return
+  */
 def secretForm[A <: String](to: String => A) = new Form[A]:
   override def render(
       path: List[Symbol],
@@ -68,40 +81,101 @@ def numericForm[A](f: String => Option[A], zero: A): Form[A] = new Form[A] {
       )
 }
 
-def enumForm[A](values: Array[A], f: Int => A) = new Form[A] {
+/** Render form as html select.
+  *
+  * @param elements
+  *   The elements to render.
+  * @param labelMapper
+  *   The function to map the element to a label. Default is toString.
+  * @return
+  */
+def selectForm[A](
+    elements: Array[A],
+    labelMapper: A => String = (a: A) => a.toString
+) =
+  new Form[A] {
 
-  override def render(
-      path: List[Symbol],
-      variable: Var[A],
-      syncParent: () => Unit
-  )(using
-      factory: WidgetFactory,
-      errorBus: EventBus[(String, ValidationEvent)]
-  ): HtmlElement =
-    val valuesLabels = values.map(_.toString)
-    div(
-      factory
-        .renderSelect { idx =>
-          variable.set(f(idx))
-          syncParent()
-        }
-        .amend(
-          valuesLabels.map { label =>
-            factory.renderOption(
-              label,
-              values
-                .map(_.toString)
-                .indexOf(label),
-              label == variable.now().toString
-            )
-          }.toSeq
-        )
-    )
+    override def render(
+        path: List[Symbol],
+        variable: Var[A],
+        syncParent: () => Unit
+    )(using
+        factory: WidgetFactory,
+        errorBus: EventBus[(String, ValidationEvent)]
+    ): HtmlElement =
+      val labels = elements.map(labelMapper)
+      div(
+        factory
+          .renderSelect { idx =>
+            variable.set(elements(idx))
+            syncParent()
+          }
+          .amend(
+            labels.map { label =>
+              factory.renderOption(
+                label,
+                elements
+                  .map(labelMapper)
+                  .indexOf(label),
+                label == labelMapper(variable.now())
+              )
+            }.toSeq
+          )
+      )
 
-}
+  }
 
-/** A form for a type A, no validation. Convenient to use for Opaque types. If
-  * you need validation, use a Form with a ValidationEvent.
+/** Render form as html select.
+  *
+  * @param elements
+  *   The elements to render.
+  * @param mapper
+  *   The function to map the element to a value.
+  * @param labelMapper
+  *   The function to map the element to a label. Default is toString.
+  * @return
+  */
+def selectMappedForm[A, B](
+    elements: Seq[A],
+    mapper: A => B,
+    labelMapper: A => String = (a: A) => a.toString
+) =
+  new Form[B] {
+
+    override def render(
+        path: List[Symbol],
+        variable: Var[B],
+        syncParent: () => Unit
+    )(using
+        factory: WidgetFactory,
+        errorBus: EventBus[(String, ValidationEvent)]
+    ): HtmlElement =
+      val labels = elements.map(labelMapper).zip(elements)
+      div(
+        factory
+          .renderSelect { idx =>
+            variable.set(mapper(elements(idx)))
+            syncParent()
+          }
+          .amend(
+            labels.map { (label, a) =>
+              factory.renderOption(
+                label,
+                elements
+                  .map(labelMapper)
+                  .indexOf(label),
+                a == variable.now()
+              )
+            }.toSeq
+          )
+      )
+
+  }
+
+/** A form for a type A, with validation.
+  *
+  * @param validator
+  *   The validator for the type A.
   */
 def stringFormWithValidation[A](using
     validator: Validator[A]