Merge pull request #2 from evolution-gaming/coding-strategy-refactor

Improved name coding strategy

play-json-generic/src/main/scala/com/evolutiongaming/util/generic/EnumerationReads.scala

@@ -30,7 +30,7 @@ object EnumerationReads {
     ncs: NameCodingStrategy
   ): EnumerationReads[FieldType[K, V] :+: R] = create[FieldType[K, V] :+: R] { jsValue =>
     jsValue.validate[String] match {
-      case JsSuccess(s, _) if ncs.decode(s) == wit.value.name => JsSuccess(Inl(field[K](gv.from(HNil))))
+      case JsSuccess(s, _) if  ncs.matches(s, wit.value.name) => JsSuccess(Inl(field[K](gv.from(HNil))))
       case JsSuccess(_, _)                        => dr.reads(jsValue).map(Inr(_))
       case JsError(err)                           => JsError.apply(err)
     }

play-json-generic/src/main/scala/com/evolutiongaming/util/generic/NameCodingStrategy.scala

@@ -1,31 +1,39 @@
 package com.evolutiongaming.util.generic
 
 trait NameCodingStrategy {
-  def encode(s: String): String
-  def decode(s: String): String
+  def encode(input: String): String
+  def matches(encoded: String, compareAgainst: String): Boolean
 }
 
 trait LowPriority {
   implicit val default: NameCodingStrategy = new NameCodingStrategy {
-    override def encode(s: String): String = s
-    override def decode(s: String): String = s
+    override def encode(input: String): String = input
+    override def matches(encoded: String, compareAgainst: String): Boolean = encoded == compareAgainst
   }
 }
 
 object NameCodingStrategy extends LowPriority
 
 object NameCodingStrategies {
-  implicit val kebabCase: NameCodingStrategy = new NameCodingStrategy {
-    override def encode(s: String): String =
-      s.foldLeft(List.empty[String]) {
+  private def lowerCaseSepCoding(sep: String): NameCodingStrategy = new NameCodingStrategy {
+
+    override def encode(input: String): String =
+      input.foldLeft(List.empty[String]) {
         case (ll, n) if n.isUpper =>
           n.toLower.toString :: ll
         case (h :: t, n)          =>
           h + n :: t
         case (nil, n)             =>
           n.toString :: nil
-      }.reverse.mkString("-")
+      }.reverse.mkString(sep)
 
-    override def decode(s: String): String = s.split("-").map(_.capitalize).mkString("")
+    override def matches(encoded: String, compareAgainst: String): Boolean =
+      encoded == encode(compareAgainst)
   }
+
+  implicit val kebabCase: NameCodingStrategy = lowerCaseSepCoding("-")
+
+  implicit val snakeCase: NameCodingStrategy = lowerCaseSepCoding("_")
+
+  implicit val noSepCase: NameCodingStrategy = lowerCaseSepCoding("")
 }

play-json-generic/src/test/scala/com/evolutiongaming/util/generic/EnumerationDerivalSpec.scala

@@ -34,6 +34,17 @@ class EnumerationDerivalSpec extends FlatSpec with Matchers {
     js.as[AnEvent] shouldBe typ
   }
 
+  it should "be able to encode and decode in no sep case" in {
+    import EnumerationDerivalSpec.Formats.NoSepCase._
+
+    val typ: AnEvent = AnEvent.DoneSome
+    val json = Json.toJson(typ)
+
+    json.toString() shouldBe "\"donesome\""
+    json.as[AnEvent] shouldBe typ
+    succeed
+  }
+
 }
 
 object EnumerationDerivalSpec {
@@ -43,6 +54,13 @@ object EnumerationDerivalSpec {
       implicit val aReads: Reads[AnEvent] = EnumerationReads[AnEvent]
       implicit val aWrites: Writes[AnEvent] = EnumerationWrites[AnEvent]
     }
+
+    object NoSepCase {
+      import NameCodingStrategies.noSepCase
+      implicit val aReads: Reads[AnEvent] = EnumerationReads[AnEvent]
+      implicit val aWrites: Writes[AnEvent] = EnumerationWrites[AnEvent]
+    }
+
     object Default {
       implicit val aReads: Reads[AnEvent] = EnumerationReads[AnEvent]
       implicit val aWrites: Writes[AnEvent] = EnumerationWrites[AnEvent]

version.sbt

@@ -1 +1 @@
-version in ThisBuild := "0.2.1-SNAPSHOT"
+version in ThisBuild := "0.2.1"