Remove the complication of treating case class and string

Author: afsalthaj

docs/src/main/tut/examples.md

@@ -31,8 +31,7 @@ res2: String = The a, b and c are: ghi, xyz, C@3aaeb14
 
 // safeStr interpolation
 scala> safeStr"The a, b and c are: ${a}, ${b}, ${c}"
-<console>:24: error: The provided type is neither a string nor a case-class. Consider converting it to strings using <value>.asStr.
-       safeStr"The a, b and c are: ${a}, ${b}, ${c}"
+<console>:18: error: unable to find a safe instance for class C. Make sure it is a case class or a type that has safe instance.
                                                                                                     ^
 scala> safeStr"a and b: ${a}, ${b}"
 res2: com.thaj.safe.string.interpolator.SafeString = SafeString(a and b: ghi, xyz)

docs/src/main/tut/index.md

@@ -49,11 +49,11 @@ defined class X
 scala> val caseClassInstance = X("foo")
 caseClassInstance: X = X(foo)
 
-scala> val onlyString: String = "bar"
+scala> val string: String = "bar"
 onlyString: String = bar
 
-scala> safeStr"Works only if its either a string or a case class instance $caseClassInstance or $onlyString"
-res0: com.thaj.safe.string.interpolator.SafeString = SafeString(Works only if its either a string or a case class instance { name: foo } or bar)
+scala> safeStr"Works only if all of them has an instance of safe $caseClassInstance or $string"
+res0: com.thaj.safe.string.interpolator.SafeString = SafeString(Works only if it all of them has an instance of safe { name : foo } or bar)
 
 scala> class C
 defined class C
@@ -62,24 +62,27 @@ scala> val nonCaseClass = new C
 nonCaseClass: C = C@7e3131c8
 
 scala> safeStr"Doesn't work if there is a non-case class $nonCaseClass or $onlyString"
-<console>:17: error: The provided type is neither a string nor a case-class. Consider converting it to strings using <value>.asStr.
-       safeStr"Doesn't work if there is a non-case class $nonCaseClass or $onlyString"
+<console>:17: error: unable to find a safe instance for class C. Make sure it is a case class or a type that has safe instance.
                                                           ^
 // And don't cheat by `toString`
 scala> safeStr"Doesn't work if there is a non-case class ${nonCaseClass.toString} or $onlyString"
-<console>:17: error: Identified `toString` being called on the types. Either remove it or use <yourType>.asStr if it has an instance of Safe.
-       safeStr"Doesn't work if there is a non-case class ${nonCaseClass.toString} or $onlyString"
+<console>:17: error: Identified `toString` being called on the types. Make sure the type has a instance of Safe..
                                                                         ^
-
 ```
 
 # Concept and example usages.
 
-`safeStr""` is just like `s""` in scala, but it is type safe and _allows only_ 
+`safeStr""` is just like `s""` in scala, but it is type safe and _allows only_ types that has a safe instance.
+
+But don't worry. If you have a case class, the macros in `Safe.scala` will automatically derive it's safe instance
+as far as all ofthe individual fields has `Safe` instance which is also defined already in the companion object of `Safe`.
+It works for any deep/nested level of case classes.
+
+To sum up,
 
-* **strings**.
-* **case classes** which will be converted to json-like string by inspecting all fields, be it deeply nested or not, at compile time.
-* and provides consistent way to **hide secrets**.
+* Most of the types already has a Safe instance in companion object, hence `Int`, `Double` etc works straight away.
+* **case classes**  will be converted to json-like string by inspecting all fields, be it deeply nested or not, at compile time.
+* `Secret` types will be hidden too. We will see more on these in the below links.
 
 To understand more on the concepts and usages, please go through:
 

docs/src/main/tut/pretty_print.md

@@ -17,61 +17,17 @@ s: Xyz = Xyz(Abc(a,b,c),x)
 
 // scala string interpolation
 scala> s"The value of xyz is $s"
-res0: String = The value of xyz is Xyz(Abc(a,b,c),x)
+res5: String = The value of xyz is Xyz(Abc(a,b,c),x)
 
 // type safe string interpolation
 scala> safeStr"The value of xyz is $s"
-res1: com.thaj.safe.string.interpolator.SafeString = SafeString(The value of xyz is { name: x, abc: {x : a, y : b, z : c} })
+res6: com.thaj.safe.string.interpolator.SafeString = SafeString(The value of xyz is { abc : { a : a, b : b, c : c }, name : x })
 
 scala> res1.string
-res2: The value of xyz is { name: x, abc: {x : a, y : b, z : c} }
+res7: String = The value of xyz is { abc : { a : a, b : b, c : c }, name : x }
 ```
 
 
 This works for any level of **deep nested structure of case class**. This is done with the support of macro materializer in `Safe.scala`.
 The main idea here is, if any field in any part of the nested case class isn't safe to be converted to string, it will throw a compile time.
 Also, if any part of case classes has `Secret`s in it, the value will be hidden. More on this in `Secret / Password` section
-
-## Why case-classes ?
-
-While the purpose of `safe-string-interpolation` is to make sure you are passing only Strings to `safeStr`, it works for case-class instances as well.
-There is a reason for this.
-
-Delegating the job of stringifying a case class to the user has always been an infamous problem and it kills the user's time.
-The `safe-string-interpolation` takes up this tedious job, and macros under the hood converts it to a readable string, while hiding `Secret` types.
-
-PS: In the next release, we may ask the user to do `.asStr` explicitly on case classes as well. This will bring in more consistency.
-
-```scala
-
-@ import com.thaj.safe.string.interpolator.SafeString._
-import com.thaj.safe.string.interpolator.SafeString._
-
-@ case class Test(list: List[String])
-defined class Test
-
-@ val test = Test(List("foo", "bar"))
-test: Test = Test(List("foo", "bar"))
-
-@ safeStr"test will work $test"
-res4: com.thaj.safe.string.interpolator.SafeString = SafeString("test will work { list: foo,bar }")
-
-@ val test = List("foo", "bar")
-test: List[String] = List("foo", "bar")
-
-@ safeStr"test will not work $test"
-cmd6.sc:1: The provided type isn't a string nor it's a case class, or you might have tried a `toString` on non-strings !
-val res6 = safeStr"test will not work $test"
-                                       ^
-Compilation Failed
-
-@ safeStr"test will work by telling the compiler, yes, it is a string ${test.toString}"
-cmd6.sc:1: Identified `toString` being called on the types. Either remove it or use <yourType>.asStr if it has an instance of Safe.
-val res6 = safeStr"test will work by telling the compiler, yes, it is a string ${test.toString}"
-                                                                                      ^
-Compilation Failed
-
-@ safeStr"test will work by telling the compiler, yes, it is a string ${test.asStr}"
-res6: com.thaj.safe.string.interpolator.SafeString = SafeString("test will work by telling the compiler, yes, it is a string foo,bar")
-
-```

docs/src/main/tut/secrets.md

@@ -28,26 +28,27 @@ scala> s"The db connection is $dbConn"
 res2: String = The db connection is DbConn(driverstring,Secret(adifficultpassword))
 
 scala> safeStr"The db connection is $dbConn"
-res3: com.thaj.safe.string.interpolator.SafeString = SafeString(The db connection is { password: ******************, driver: driverstring })
-
+res1: com.thaj.safe.string.interpolator.SafeString = SafeString(The db connection is { driver : driverstring, password : ***** })
 
 ```
 
 **Secrets will be hidden wherever it exists in your nested case class**
 
 ## Your own secret ?
 
-If you don't want to use `interpolation.Secret` data type and need to use your own, then define `Safe` instance for it.
+If you don't want to use `com.thaj.safe.string.interpolator.Secret` data type and need to use your own, then define `Safe` instance for it.
 
 ```scala
 case class MySecret(value: String) extends AnyVal
 
 implicit val safeMySec: Safe[MySecret] = _ => "****"
 
-val conn = DbConnection("posgr", MySecret("this will be hidden"))
+case class DbConn(driver: String, password: MySecret)
+
+val conn = DbConn("posgr", MySecret("this will be hidden"))
 
 
 scala> safeStr"the db is $conn"
-res1: com.thaj.safe.string.interpolator.SafeString = SafeString(the db is { password: ****, name: posgr })
+res3: com.thaj.safe.string.interpolator.SafeString = SafeString(the db is { driver : posgr, password : **** })
 
 ```

macros/src/main/scala/com/thaj/safe/string/interpolator/Safe.scala

@@ -1,6 +1,6 @@
 package com.thaj.safe.string.interpolator
 
-import scalaz.{@@, NonEmptyList}
+import scalaz.{@@, IList, NonEmptyList}
 
 import scala.language.experimental.macros
 import scala.reflect.macros.blackbox
@@ -29,10 +29,10 @@ object Safe {
   implicit val safeLong: Safe[Long] =
     _.toString
 
-  implicit val safeFloat: Safe[Float] =
+  implicit val safeDouble: Safe[Double] =
     _.toString
 
-  implicit val safeDouble: Safe[Double] =
+  implicit val safeFloat: Safe[Float] =
     _.toString
 
   implicit val safeChar: Safe[Char] =
@@ -50,6 +50,9 @@ object Safe {
   implicit def safeNonEmptyList[A: Safe]: Safe[NonEmptyList[A]] =
     _.map(t => Safe[A].value(t)).list.toList.mkString(",")
 
+  implicit def safeIList[A : Safe]: Safe[IList[A]] =
+    l => Safe[List[A]].value(l.toList)
+
   implicit def safeTagged[A: Safe, T]: Safe[A @@ T] =
     a => Safe[A].value(scalaz.Tag.unwrap(a))
 
@@ -65,24 +68,41 @@ object Safe {
   def materializeSafe[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Safe[T]] = {
     import c.universe._
     val tpe = weakTypeOf[T]
-    val fields = tpe.decls.collectFirst {
-      case m: MethodSymbol if m.isPrimaryConstructor ⇒ m
-    }.getOrElse(c.abort(NoPosition, s"Unable to find a safe instance for $tpe. Consider creating one manually."))
-      .paramLists.headOption.getOrElse(c.abort(NoPosition, s"Unable to find a safe instance for $tpe. Consider creating one manually."))
 
-    val str =
-      fields.foldLeft(Set[(TermName, c.universe.Tree)]()) { (str, field) ⇒
-        val tag = c.WeakTypeTag(field.typeSignature)
+    val tag = c.WeakTypeTag(tpe)
+    val symbol = tag.tpe.typeSymbol
 
-        val fieldName = field.name.toTermName
-        str ++ Set((fieldName, q""" com.thaj.safe.string.interpolator.Safe[$tag]"""))
+    if (symbol.isClass && symbol.asClass.isCaseClass) {
+      val fields = tpe.decls.collectFirst {
+        case m: MethodSymbol if m.isPrimaryConstructor ⇒ m
       }
-    
-    val res =
-      q"""new com.thaj.safe.string.interpolator.Safe[$tpe] {
-         override def value(a: $tpe): String = "{ " + ${str.map{case(x, y) => q""" ${x.toString} + " : " + $y.value(a.$x) """ }}.mkString(", ") + " }"
+        .getOrElse(
+          c.abort(NoPosition, s"Unable to find a safe instance for ${tpe.typeSymbol}. Consider creating one manually.")
+        )
+        .paramLists.headOption
+        .getOrElse(c.abort(NoPosition, s"Unable to find a safe instance for $tpe. Consider creating one manually."))
+
+      val str =
+        fields.foldLeft(Set[(TermName, c.universe.Tree)]()) { (str, field) ⇒
+          val tag = c.WeakTypeTag(field.typeSignature)
+
+          val fieldName = field.name.toTermName
+          str ++ Set((fieldName, q""" com.thaj.safe.string.interpolator.Safe[$tag]"""))
+        }
+
+      val res =
+        q"""new com.thaj.safe.string.interpolator.Safe[$tpe] {
+         override def value(a: $tpe): String = "{ " + ${
+          str
+            .map { case (x, y) => q""" ${x.toString} + " : " + $y.value(a.$x) """ }
+        }.mkString(", ") + " }"
       }"""
 
-    c.Expr[Safe[T]] { res }
+      c.Expr[Safe[T]] {
+        res
+      }
+    } else {
+      c.abort(NoPosition, s"unable to find a safe instance for ${tpe.typeSymbol}. Make sure it is a case class or a type that has safe instance.")
+    }
   }
 }

macros/src/main/scala/com/thaj/safe/string/interpolator/SafeString.scala

@@ -22,63 +22,29 @@ object SafeString {
   }
 
   object Macro {
-    // Not public, just for macros
-    def jsonLike(list: Set[String]) =
-      s"{ ${list.mkString(", ")} }"
-
     def impl(c: blackbox.Context)(args: c.Expr[Any]*): c.Expr[SafeString] = {
       import c.universe.{Name => _, _}
 
-      object CaseClassFieldAndName {
-        def unapply(sym: TermSymbol): Option[(TermName, Type)] = {
-          if (sym.isCaseAccessor && sym.isVal)
-            Some((TermName(sym.name.toString.trim), sym.typeSignature))
-          else
-            None
-        }
-      }
-
       c.prefix.tree match {
 
         case Apply(_, List(Apply(_, partz))) =>
           val parts: Seq[String] = partz map { case Literal(Constant(const: String)) => const }
 
           val res: c.universe.Tree =
-            args.toList.foldLeft(q"""StringContext.apply(..${parts})""")({ (acc, t) => {
-
+            args.toList.foldLeft(q"""StringContext.apply(..$parts)""")({ (acc, t) => {
               val nextElement = t.tree
-
               val tag = c.WeakTypeTag(nextElement.tpe)
-              val symbol = tag.tpe.typeSymbol
 
               if(nextElement.toString().contains(".toString"))
-                c.abort(t.tree.pos, s"Identified `toString` being called on the types. Either remove it or use <yourType>.asStr if it has an instance of Safe.")
+                c.abort(t.tree.pos, s"Identified `toString` being called on the types. Make sure the type has a instance of Safe.")
 
-              if (!(tag.tpe =:= typeOf[String]) && symbol.isClass && symbol.asClass.isCaseClass) {
-                val r: Set[c.universe.Tree] =
-                  nextElement.tpe.members.collect {
-                    case CaseClassFieldAndName(nme, typ) =>
-                      q"""com.thaj.safe.string.interpolator.Field(${nme.toString}, $nextElement.$nme.asStr)"""
-                  }.toSet
-
-                val field = q"""com.thaj.safe.string.interpolator.SafeString.Macro.jsonLike($r.map(_.toString))"""
-
-                acc match {
-                  case q"""StringContext.apply(..$raw).s(..$previousElements)""" => q"""StringContext.apply(..$raw).s(($previousElements :+ ..${field}) :_*)"""
-                  case _ => q"""${acc}.s(..$field)"""
-                }
-              }
+              val field = q"""com.thaj.safe.string.interpolator.Safe[${tag.tpe}].value($nextElement)"""
 
-              else if (tag.tpe =:= typeOf[String]) {
                 acc match {
-                  case q"""StringContext.apply(..$raw).s(..$previousElements)""" => q"""StringContext.apply(..$raw).s(($previousElements :+ $nextElement) :_*)"""
-                  case _ => q"""${acc}.s($nextElement)"""
+                  case q"""StringContext.apply(..$raw).s(..$previousElements)""" => q"""StringContext.apply(..$raw).s(($previousElements :+ ..$field) :_*)"""
+                  case _ => q"""$acc.s(..$field)"""
                 }
-              } else {
-                c.abort(t.tree.pos, "The provided type is neither a string nor a case-class. Consider converting it to strings using <value>.asStr.")
-              }
-            }
-            })
+            }})
 
           res match {
             case q"""StringContext.apply(..$raw).s(..$previousElements)""" => c.Expr(q"""com.thaj.safe.string.interpolator.SafeString($res)""")

project/DocSupport.scala

@@ -28,7 +28,7 @@ object DocSupport {
     micrositeHighlightTheme := "atom-one-light",
     micrositeGithubRepo := "safe-string-interpolation",
     micrositeHomepage := "https://afsalthaj.github.io/safe-string-interpolation",
-    micrositeBaseUrl := "/safe-string-interpolation",
+    micrositeBaseUrl := "iagcl/safe-string-interpolation",
     micrositeGithubOwner := "afsalthaj",
     micrositeGithubRepo := "safe-string-interpolation",
     micrositeGitterChannelUrl := "safe-string-interpolation/community",