use simple ADT to encode attribute values

snabbdom/src/main/scala/snabbdom/AttrValue.scala

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 buntec
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (c) 2015 Simon Friis Vindum
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+package snabbdom
+
+sealed trait AttrValue
+
+object AttrValue {
+
+  def apply(s: String): AttrValue = StringAttrValue(s)
+  def apply(b: Boolean): AttrValue = BooleanAttrValue(b)
+
+  case class StringAttrValue(value: String) extends AttrValue
+  case class BooleanAttrValue(value: Boolean) extends AttrValue
+
+  implicit def stringToAttrValue(value: String): AttrValue =
+    StringAttrValue(value)
+
+  implicit def booleanToAttrValue(value: Boolean): AttrValue =
+    BooleanAttrValue(value)
+
+}

snabbdom/src/main/scala/snabbdom/modules/Attributes.scala

@@ -40,6 +40,8 @@ package snabbdom.modules
 
 import snabbdom._
 import org.scalajs.dom
+import snabbdom.AttrValue.BooleanAttrValue
+import snabbdom.AttrValue.StringAttrValue
 
 object Attributes {
 
@@ -68,20 +70,23 @@ object Attributes {
       attrs.foreach { case (key, cur) =>
         val old = oldAttrs.get(key)
         if (old.forall(_ != cur)) {
-          if (cur == true) {
-            elm.setAttribute(key, "")
-          } else if (cur == false) {
-            elm.removeAttribute(key)
-          } else {
-            if (key.charAt(0) != 'x') {
-              elm.setAttribute(key, cur.toString)
-            } else if (key.length > 3 && key.charAt(3) == ':') {
-              elm.setAttributeNS(xmlNS, key, cur.toString)
-            } else if (key.length > 5 && key.charAt(5) == ':') {
-              elm.setAttributeNS(xlinkNS, key, cur.toString)
-            } else {
-              elm.setAttribute(key, cur.toString)
-            }
+          cur match {
+            case BooleanAttrValue(value) =>
+              if (value) {
+                elm.setAttribute(key, "")
+              } else {
+                elm.removeAttribute(key)
+              }
+            case StringAttrValue(value) =>
+              if (key.charAt(0) != 'x') {
+                elm.setAttribute(key, value)
+              } else if (key.length > 3 && key.charAt(3) == ':') {
+                elm.setAttributeNS(xmlNS, key, value)
+              } else if (key.length > 5 && key.charAt(5) == ':') {
+                elm.setAttributeNS(xlinkNS, key, value)
+              } else {
+                elm.setAttribute(key, value)
+              }
           }
         }
       }

snabbdom/src/main/scala/snabbdom/package.scala

@@ -43,7 +43,6 @@ package object snabbdom {
   type VNodeQueue = mutable.ArrayBuffer[VNode]
 
   type PropValue = Any
-  type AttrValue = Any // JS snabbdom uses string | number | boolean
   type ClassValue = Boolean
   type StyleValue = String
   type KeyValue = String

snabbdom/src/main/scala/snabbdom/toVNode.scala

@@ -74,7 +74,11 @@ object toVNode {
         children.append(toVNode(childNode, domApi))
       }
 
-      if (attrs.nonEmpty) { data.attrs = Some(attrs.toMap) }
+      if (attrs.nonEmpty) {
+        data.attrs = Some(attrs.map { case (key, value) =>
+          key -> AttrValue(value)
+        }.toMap)
+      }
       if (datasets.nonEmpty) { data.dataset = Some(datasets.toMap) }
 
       if (

snabbdom/src/test/scala/snabbdom/AttributesSuite.scala

@@ -59,7 +59,7 @@ class AttributesSuite extends BaseSuite {
         VNodeData.builder
           .withAttrs(
             "href" -> "/foo",
-            "minlength" -> 1,
+            "minlength" -> "1",
             "selected" -> true,
             "disabled" -> false
           )
@@ -75,7 +75,11 @@ class AttributesSuite extends BaseSuite {
 
     vnode0.test("can be memoized") { vnode0 =>
       val cachedAttrs = VNodeData.builder
-        .withAttrs("href" -> "/foo", "minlength" -> 1, "selected" -> true)
+        .withAttrs(
+          "href" -> "/foo",
+          "minlength" -> "1",
+          "selected" -> true
+        )
         .build
       val vnode1 = h("div", cachedAttrs)
       val vnode2 = h("div", cachedAttrs)
@@ -96,8 +100,8 @@ class AttributesSuite extends BaseSuite {
           "div",
           VNodeData.builder
             .withAttrs(
-              "href" -> None,
-              "minlength" -> 0,
+              "href" -> "",
+              "minlength" -> "0",
               "value" -> "",
               "title" -> "undefined"
             )
@@ -112,7 +116,10 @@ class AttributesSuite extends BaseSuite {
 
     vnode0.test("are set correctly when namespaced") { vnode0 =>
       val vnode1 =
-        h("div", VNodeData.builder.withAttrs("xlink:href" -> "#foo").build)
+        h(
+          "div",
+          VNodeData.builder.withAttrs("xlink:href" -> "#foo").build
+        )
       val elm = patch(vnode0, vnode1).elm.get.asInstanceOf[dom.Element]
       assertEquals(
         elm.getAttributeNS("http://www.w3.org/1999/xlink", "href"),
@@ -148,7 +155,7 @@ class AttributesSuite extends BaseSuite {
           VNodeData.builder
             .withAttrs(
               "required" -> true,
-              "readonly" -> 1,
+              "readonly" -> "1",
               "noresize" -> "truthy"
             )
             .build
@@ -164,7 +171,10 @@ class AttributesSuite extends BaseSuite {
 
     vnode0.test("is omitted if the value is false") { vnode0 =>
       val vnode1 =
-        h("div", VNodeData.builder.withAttrs("required" -> false).build)
+        h(
+          "div",
+          VNodeData.builder.withAttrs("required" -> false).build
+        )
       val elm = patch(vnode0, vnode1).elm.get.asInstanceOf[dom.HTMLElement]
       assertEquals(elm.hasAttribute("required"), false)
       assertEquals(elm.getAttribute("required"), null)
@@ -174,7 +184,12 @@ class AttributesSuite extends BaseSuite {
       val vnode1 =
         h(
           "div",
-          VNodeData.builder.withAttrs("readonly" -> 0, "noresize" -> "").build
+          VNodeData.builder
+            .withAttrs(
+              "readonly" -> "0",
+              "noresize" -> ""
+            )
+            .build
         )
       val elm = patch(vnode0, vnode1).elm.get.asInstanceOf[dom.HTMLElement]
       assertEquals(elm.hasAttribute("readonly"), true)
@@ -190,12 +205,18 @@ class AttributesSuite extends BaseSuite {
       "is not considered as a boolean attribute and shouldn't be omitted"
     ) { vnode0 =>
       val vnode1 =
-        h("div", VNodeData.builder.withAttrs("constructor" -> true).build)
+        h(
+          "div",
+          VNodeData.builder.withAttrs("constructor" -> true).build
+        )
       val elm1 = patch(vnode0, vnode1).elm.get.asInstanceOf[dom.Element]
       assertEquals(elm1.hasAttribute("constructor"), true)
       assertEquals(elm1.getAttribute("constructor"), "")
       val vnode2 =
-        h("div", VNodeData.builder.withAttrs("constructor" -> false).build)
+        h(
+          "div",
+          VNodeData.builder.withAttrs("constructor" -> false).build
+        )
       val elm2 = patch(vnode1, vnode2).elm.get.asInstanceOf[dom.Element]
       assertEquals(elm2.hasAttribute("constructor"), false)
 

snabbdom/src/test/scala/snabbdom/SnabbdomSuite.scala

@@ -622,7 +622,7 @@ class SnabbdomSuite extends BaseSuite {
       onlyAttrs.setAttribute("foo", "bar")
       assertEquals(
         toVNode(onlyAttrs).data.flatMap(_.attrs).flatMap(_.get("foo")),
-        Some("bar")
+        Some(AttrValue("bar"))
       )
 
       val onlyDatasets = dom.document.createElement("div")
@@ -646,7 +646,7 @@ class SnabbdomSuite extends BaseSuite {
       bothAttrsAndDatasets.setAttribute("data-foo", "bar")
       bothAttrsAndDatasets.dataset("again") = "again"
       val data = toVNode(bothAttrsAndDatasets).data.get
-      assertEquals(data.attrs.flatMap(_.get("foo")), Some("bar"))
+      assertEquals(data.attrs.flatMap(_.get("foo")), Some(AttrValue("bar")))
       assertEquals(data.dataset.flatMap(_.get("foo")), Some("bar"))
       assertEquals(data.dataset.flatMap(_.get("again")), Some("again"))