Cleaning up commits

Author: afsalthaj

build.sbt

@@ -1,8 +1,5 @@
-import com.sun.xml.internal.messaging.saaj.util.ByteInputStream
 import microsites.CdnDirectives
 
-import scala.tools.nsc.interpreter.InputStream
-
 lazy val root = (project in file("."))
   .dependsOn(macros)
   .settings(
@@ -110,4 +107,3 @@ lazy val rootBuildSettings = Seq(
   pomIncludeRepository := { _ => false },
   publishMavenStyle := true
 )
-

docs/src/main/tut/index.md

@@ -17,8 +17,8 @@ A few terrible logging examples :
    INFO: The student logged in: scala.Map(...)
    INFO: The student logged in: Details("name", "libraryPassword!!")
   ```
-  
-We need more type driven logging, consistent secret management, catching erroneous `toStrings` at compile time, rather than getting shocked and surprised at runtime.  
+Apart from logging, we have bumped into situations where we tried to concatenate / append "Any"thing using string interpolations, often resulting in logical errors as well.  
+You know this, we need more type driven logging and string interpolation operations, consistent secret management, catching erroneous `toStrings` at compile time, rather than getting shocked and surprised at runtime.  
 
 # Solution
 
@@ -27,13 +27,13 @@ Easy ! Use `safeStr"your log $a $b, $c"` instead of `s"your log $a $b, $c"` !
 Add this in your build.sbt
 
 ```scala
-libraryDependencies += "io.github.afsalthaj" %% "safe-string" % "1.2.8" 
+libraryDependencies += "io.github.afsalthaj" %% "safe-string" % "1.2.9" 
 ```
 
 Or, in ammonite;
 
 ```scala
-@ import $ivy.`io.github.afsalthaj::safe-string:1.2.8`
+@ import $ivy.`io.github.afsalthaj::safe-string:1.2.9`
 import $ivy.$
 ```
 
@@ -83,9 +83,11 @@ scala> safeStr"Doesn't work if there is a non-case class ${nonCaseClass.toString
 
 To understand more on the concepts and usages, please go through:
 
-1)  [A Simple Example](https://afsalthaj.github.io/safe-string-interpolation/examples.html)
-2) [Typesafe Pretty prints](https://afsalthaj.github.io/safe-string-interpolation/pretty_print.html) and 
-3) [Logging Secrets / Passwords](https://afsalthaj.github.io/safe-string-interpolation/secrets.html) 
+- [A Simple Example](https://afsalthaj.github.io/safe-string-interpolation/examples.html)
+
+- [Typesafe Pretty prints](https://afsalthaj.github.io/safe-string-interpolation/pretty_print.html) and 
+
+- [Logging Secrets / Passwords](https://afsalthaj.github.io/safe-string-interpolation/secrets.html) 
 
 to get started !
 

docs/src/main/tut/pretty_print.md

@@ -37,9 +37,11 @@ Also, if any part of case classes has `Secret`s in it, the value will be hidden.
 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. 
+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._

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

@@ -58,7 +58,7 @@ object SafeString {
                 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)"""
+                      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))"""

test/src/test/scala/test/com/thaj/safe/string/interpolator/SafeStringSpec.scala

@@ -3,7 +3,8 @@ package test.com.thaj.safe.string.interpolator
 import com.thaj.safe.string.interpolator.SafeString._
 import com.thaj.safe.string.interpolator.Secret
 import org.specs2.{ScalaCheck, Specification}
-import scalaz.NonEmptyList
+import scalaz.{@@, NonEmptyList, Tag}
+import test.com.thaj.safe.string.interpolator.SafeStringSpec.Xxx.{NewTaggedType, StringTT, StringTTT, TaggedType}
 
 object SafeStringSpec extends Specification with ScalaCheck {
   def is =
@@ -18,6 +19,7 @@ object SafeStringSpec extends Specification with ScalaCheck {
        SafeString works for GADTs $testGADT
        SafeString works for maps in case class $testMap
        SafeString works for case class with map and nonemptylist $testMapWithNonEmptyList
+       SafeString works for case class with tagged type in it $testMultipleTaggedType
       """
 
   final case class Dummy(name: String, age: Int)
@@ -92,4 +94,20 @@ object SafeStringSpec extends Specification with ScalaCheck {
     prop { a: String =>
       safeStr"works for gadt ${TestMapWithNonEmptyList(Map(a -> NonEmptyList(a, a)))}".string must_=== s"works for gadt { mapN: ${a} -> ${a},${a} }"
     }
+
+  final case class CaseTag(d: StringTTT, f: StringTT)
+
+  object Xxx {
+
+    sealed trait TaggedType
+    type StringTT = String @@ TaggedType
+
+    sealed trait NewTaggedType
+    type StringTTT = String @@ NewTaggedType
+  }
+
+  private def testMultipleTaggedType =
+    prop { a: String =>
+      safeStr"works for taggedtypes ${CaseTag(Tag[String, NewTaggedType](a), Tag[String, TaggedType](a))}".string must_=== s"works for taggedtypes { f: ${a}, d: ${a} }"
+    }
 }

version.sbt

@@ -1 +1 @@
-version in ThisBuild := "1.2.8"
+version in ThisBuild := "1.2.9"