add macros module

Author: xuwei-k

Diff for: README.md

@@ -7,6 +7,8 @@ The structure of this project is hugely inspired by [scalapb-json4s](https://git
 
 Include in your `build.sbt` file
 
+### core
+
 ```scala
 libraryDependencies += "io.github.scalapb-json" %% "scalapb-circe" % "0.4.0"
 ```
@@ -17,6 +19,12 @@ for scala-js
 libraryDependencies += "io.github.scalapb-json" %%% "scalapb-circe" % "0.4.0"
 ```
 
+### macros
+
+```scala
+libraryDependencies += "io.github.scalapb-json" %% "scalapb-circe-macros" % "0.4.1"
+```
+
 ### for ScalaPB 0.7.x
 
 see https://github.com/scalapb-json/scalapb-circe/tree/0.2.x

Diff for: build.sbt

@@ -17,6 +17,30 @@ val tagOrHash = Def.setting {
 
 val unusedWarnings = Seq("-Ywarn-unused")
 
+lazy val macros = project
+  .in(file("macros"))
+  .settings(
+    commonSettings,
+    name := UpdateReadme.scalapbCirceMacrosName,
+    libraryDependencies ++= Seq(
+      "io.github.scalapb-json" %%% "scalapb-json-macros" % scalapbJsonCommonVersion.value,
+    )
+  )
+  .dependsOn(
+    scalapbCirceJVM
+  )
+
+lazy val tests = crossProject(JVMPlatform, JSPlatform)
+  .in(file("tests"))
+  .settings(
+    commonSettings,
+    noPublish,
+  )
+  .configure(_ dependsOn macros)
+  .dependsOn(
+    scalapbCirce % "test->test"
+  )
+
 val scalapbCirce = crossProject(JVMPlatform, JSPlatform)
   .in(file("core"))
   .enablePlugins(BuildInfoPlugin)

Diff for: macros/src/main/scala/scalapb_circe/ProtoMacrosCirce.scala

@@ -0,0 +1,73 @@
+package scalapb_circe
+
+import scalapb.{GeneratedMessage, GeneratedMessageCompanion, Message}
+
+import scala.reflect.macros.blackbox
+import language.experimental.macros
+import scala.util.Try
+
+object ProtoMacrosCirce {
+
+  implicit class ProtoContextCirce(private val c: StringContext) extends AnyVal {
+    def struct(): com.google.protobuf.struct.Struct =
+      macro ProtoMacrosCirce.protoStructInterpolation
+    def value(): com.google.protobuf.struct.Value =
+      macro ProtoMacrosCirce.protoValueInterpolation
+  }
+
+  implicit class FromJsonCirce[A <: GeneratedMessage with Message[A]](
+    private val companion: GeneratedMessageCompanion[A]
+  ) extends AnyVal {
+    def fromJsonConstant(json: String): A =
+      macro ProtoMacrosCirce.fromJsonConstantImpl0[A]
+
+    def fromJson(json: String): A =
+      macro ProtoMacrosCirce.fromJsonImpl[A]
+
+    def fromJsonDebug(json: String): A =
+      macro ProtoMacrosCirce.fromJsonDebugImpl
+
+    def fromJsonOpt(json: String): Option[A] =
+      macro ProtoMacrosCirce.fromJsonOptImpl[A]
+
+    def fromJsonEither(json: String): Either[Throwable, A] =
+      macro ProtoMacrosCirce.fromJsonEitherImpl[A]
+
+    def fromJsonTry(json: String): Try[A] =
+      macro ProtoMacrosCirce.fromJsonTryImpl[A]
+  }
+}
+
+class ProtoMacrosCirce(override val c: blackbox.Context) extends scalapb_json.ProtoMacrosCommon(c) {
+
+  import c.universe._
+
+  override def fromJsonImpl[A: c.WeakTypeTag](json: c.Tree): c.Tree = {
+    val A = weakTypeTag[A]
+    q"_root_.scalapb_circe.JsonFormat.fromJsonString[$A]($json)"
+  }
+
+  override def fromJsonConstantImpl[A <: GeneratedMessage with Message[A]: c.WeakTypeTag: GeneratedMessageCompanion](
+    string: String
+  ): c.Tree = {
+    val A = weakTypeTag[A]
+    scalapb_circe.JsonFormat.fromJsonString[A](string)
+    q"_root_.scalapb_circe.JsonFormat.fromJsonString[$A]($string)"
+  }
+
+  private[this] def parseJson(json: String): io.circe.Json = {
+    io.circe.parser.parse(json).fold(throw _, identity)
+  }
+
+  override protected[this] def protoString2Struct(string: String): c.Tree = {
+    val json = parseJson(string)
+    val struct = StructFormat.structParser(json)
+    q"$struct"
+  }
+
+  override protected[this] def protoString2Value(string: String): c.Tree = {
+    val json = parseJson(string)
+    val value = StructFormat.structValueParser(json)
+    q"$value"
+  }
+}

Diff for: project/UpdateReadme.scala

@@ -5,12 +5,13 @@ import sbtrelease.Git
 object UpdateReadme {
 
   val scalapbCirceName = "scalapb-circe"
+  val scalapbCirceMacrosName = "scalapb-circe-macros"
 
   val updateReadmeTask = { state: State =>
     val extracted = Project.extract(state)
     val v = extracted get version
     val org = extracted get organization
-    val modules = scalapbCirceName :: Nil
+    val modules = scalapbCirceName :: scalapbCirceMacrosName :: Nil
     val readme = "README.md"
     val readmeFile = file(readme)
     val newReadme = Predef

Diff for: tests/shared/src/test/scala/scalapb_circe/ProtoMacroTest.scala

@@ -0,0 +1,72 @@
+package scalapb_circe
+
+import org.scalatest.FunSpec
+import org.scalatest.Matchers
+import scalapb_circe.ProtoMacrosCirce._
+import com.google.protobuf.struct._
+import jsontest.test.MyTest
+
+import scala.util.Success
+
+class ProtoMacrosCirceTest extends FunSpec with Matchers {
+  describe("ProtoMacrosCirce") {
+    it("struct") {
+      assert(struct"{}" == Struct.defaultInstance)
+
+      assert(
+        struct"""{ "a" : [1, false, null, "x"] }""" == Struct(
+          Map(
+            "a" -> Value(
+              Value.Kind.ListValue(
+                ListValue(
+                  List(
+                    Value(Value.Kind.NumberValue(1.0)),
+                    Value(Value.Kind.BoolValue(false)),
+                    Value(Value.Kind.NullValue(NullValue.NULL_VALUE)),
+                    Value(Value.Kind.StringValue("x"))
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+
+      """ struct" { invalid json " """ shouldNot compile
+    }
+
+    it("value") {
+      assert(value" 42 " == Value(Value.Kind.NumberValue(42)))
+      assert(value" false " == Value(Value.Kind.BoolValue(false)))
+      assert(value""" "x" """ == Value(Value.Kind.StringValue("x")))
+      assert(value""" [] """ == Value(Value.Kind.ListValue(ListValue())))
+
+      """ value" { invalid json " """ shouldNot compile
+    }
+
+    it("fromJson") {
+      assert(MyTest.fromJsonConstant("{}") === MyTest())
+      assert(
+        MyTest.fromJsonConstant(
+          """{
+            "hello" : "foo",
+            "foobar" : 42
+          }"""
+        ) === MyTest().update(
+          _.hello := "foo",
+          _.foobar := 42
+        )
+      )
+      """ jsontest.test.MyTest.fromJsonConstant("{") """ shouldNot compile
+
+      assert(MyTest.fromJsonTry("{").isFailure)
+      assert(MyTest.fromJsonTry("""{"hello":"foo"}""") === Success(MyTest(hello = Some("foo"))))
+
+      assert(MyTest.fromJsonOpt("{").isEmpty)
+      assert(MyTest.fromJsonOpt("""{"hello":"foo"}""") === Some(MyTest(hello = Some("foo"))))
+
+      assert(MyTest.fromJsonEither("{").isLeft)
+      assert(MyTest.fromJsonEither("""{"hello":"foo"}""") === Right(MyTest(hello = Some("foo"))))
+    }
+  }
+}