feat: sbt plugin 'unmanaged' codegen

Not entirely happy with the approach: generating the code from the regular
protoc generators, but then 'filtering them out' of the managed sources
(that they get added to automatically) afterwards, and copying them over
'manually'.

It does save us from duplicating part of the sbt-protoc implementation
(in particular finding the correct `.proto` files and converting them
into `com.google.protobuf.Descriptors.FileDescriptor` instances).

Let's try it out, but if it leads to trouble we should definitely consider
avoiding the generators and doing that step 'ourselves'.

Author: raboof

codegen/scala-gen/src/main/scala/com/akkaserverless/codegen/scalasdk/AkkaserverlessUnmanagedGenerator.scala

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2021 Lightbend Inc.
+ *
+ * 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.
+ */
+
+package com.akkaserverless.codegen.scalasdk
+
+import com.google.protobuf.ExtensionRegistry
+import com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse
+import com.lightbend.akkasls.codegen.ModelBuilder
+import protocbridge.Artifact
+import protocgen.{ CodeGenApp, CodeGenRequest, CodeGenResponse }
+
+object AkkaserverlessUnmanagedGenerator extends CodeGenApp {
+  val enableDebug = "enableDebug"
+
+  override def registerExtensions(registry: ExtensionRegistry): Unit = {
+    registry.add(com.akkaserverless.Annotations.service)
+    registry.add(com.akkaserverless.Annotations.file)
+  }
+
+  override def process(request: CodeGenRequest): CodeGenResponse = {
+    val debugEnabled = request.parameter.contains(enableDebug)
+    val model = ModelBuilder.introspectProtobufClasses(request.filesToGenerate)(DebugPrintlnLog(debugEnabled))
+    try {
+      CodeGenResponse.succeed(
+        SourceGenerator
+          .generateUnmanaged(model)
+          .map(file =>
+            CodeGeneratorResponse.File
+              .newBuilder()
+              .setName(file.name)
+              .setContent(file.content)
+              .build()))
+    } catch {
+      case t: Throwable =>
+        t.printStackTrace()
+        CodeGenResponse.fail(t.getMessage)
+    }
+  }
+
+  override def suggestedDependencies: Seq[Artifact] = Nil
+}

codegen/scala-gen/src/main/scala/com/akkaserverless/codegen/scalasdk/SourceGenerator.scala

@@ -25,18 +25,18 @@ object SourceGenerator {
    * Generate the 'managed' code for this model: code that will be regenerated regularly in the 'compile' configuratio
    */
   def generateManaged(model: ModelBuilder.Model): Seq[File] =
-    Seq(File("foo/bar/Baz.scala", "package foo.bar\n\ntrait Baz"))
+    Seq(File("foo/bar/AbstractBaz.scala", "package foo.bar\n\nabstract class AbstractBaz"))
 
   /**
    * Generate the 'managed' code for this model: code that will be regenerated regularly in the 'compile' configuratio
    */
   def generateManagedTest(model: ModelBuilder.Model): Seq[File] =
-    Seq(File("foo/bar/BazSpec.scala", "package foo.bar\n\ntrait BazSpec"))
+    Seq(File("foo/bar/BazSpec.scala", "package foo.bar\n\nclass BazSpec { new Baz() }"))
 
   /**
    * Generate the 'unmanaged' code for this model: code that is generated once on demand and then maintained by the
    * user.
    */
   def generateUnmanaged(model: ModelBuilder.Model): Seq[File] =
-    Seq.empty
+    Seq(File("foo/bar/Baz.scala", "package foo.bar\n\nclass Baz extends AbstractBaz"))
 }

codegen/scala-gen/src/main/scala/com/akkaserverless/codegen/scalasdk/genUnmanaged.scala

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2021 Lightbend Inc.
+ *
+ * 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.
+ */
+
+package com.akkaserverless.codegen.scalasdk
+
+import protocbridge.SandboxedJvmGenerator
+
+object genUnmanaged {
+  def apply(options: Seq[String] = Seq.empty): (SandboxedJvmGenerator, Seq[String]) =
+    gen(options, "com.akkaserverless.codegen.scalasdk.AkkaserverlessUnmanagedGenerator$")
+}

sbt-plugin/src/main/scala/com/akkaserverless/sbt/AkkaserverlessPlugin.scala

@@ -16,7 +16,11 @@
 
 package com.akkaserverless.sbt
 
-import com.akkaserverless.codegen.scalasdk.{ gen, genTests, AkkaserverlessGenerator }
+import java.nio.file.Path
+import java.nio.file.Paths
+import java.nio.file.Files
+
+import com.akkaserverless.codegen.scalasdk.{ gen, genTests, genUnmanaged, AkkaserverlessGenerator, SourceGenerator }
 import sbt.{ Compile, _ }
 import sbt.Keys._
 import sbtprotoc.ProtocPlugin
@@ -27,14 +31,52 @@ object AkkaserverlessPlugin extends AutoPlugin {
   override def trigger = allRequirements
   override def requires = ProtocPlugin
 
+  trait Keys { _: autoImport.type =>
+    val generateUnmanaged = taskKey[Unit](
+      "Generate \"unmanaged\" akkaserverless scaffolding code based on the available .proto definitions.\n" +
+      "These are the source files that are placed in the source tree, and after initial generation should typically be maintained by the user.\n" +
+      "Files that already exist they are not re-generated.")
+    val temporaryUnmanagedDirectory = settingKey[File]("Directory to generate 'unmanaged' sources into")
+  }
+  object autoImport extends Keys
+  import autoImport._
+
   override def projectSettings: Seq[sbt.Setting[_]] = Seq(
     libraryDependencies ++= Seq(
       "com.akkaserverless" % "akkaserverless-sdk-protocol" % "0.7.0-beta.18" % "protobuf",
       "com.google.protobuf" % "protobuf-java" % "3.17.3" % "protobuf"),
     Compile / PB.targets +=
       gen(Seq(AkkaserverlessGenerator.enableDebug)) -> (Compile / sourceManaged).value / "akkaserverless",
+    Compile / temporaryUnmanagedDirectory := (Compile / baseDirectory).value / "target" / "akkaserverless-unmanaged",
+    Compile / PB.targets +=
+      genUnmanaged(Seq(AkkaserverlessGenerator.enableDebug)) -> (Compile / temporaryUnmanagedDirectory).value,
     Test / PB.protoSources ++= (Compile / PB.protoSources).value,
     Test / PB.targets +=
-      genTests(Seq(AkkaserverlessGenerator.enableDebug)) -> (Test / sourceManaged).value / "akkaserverless")
+      genTests(Seq(AkkaserverlessGenerator.enableDebug)) -> (Test / sourceManaged).value / "akkaserverless",
+    Compile / generateUnmanaged := {
+      // Make sure generation has happened
+      (Compile / PB.generate).value
+      // Then copy over any new generated unmanaged sources
+      copyIfNotExist(
+        java.nio.file.Paths.get((Compile / temporaryUnmanagedDirectory).value.toURI),
+        Paths.get((Compile / sourceDirectory).value.toURI).resolve("scala"))
+    },
+    Compile / managedSources :=
+      (Compile / managedSources).value.filter(s => !isIn(s, (Compile / temporaryUnmanagedDirectory).value)))
+
+  def isIn(file: File, dir: File): Boolean =
+    Paths.get(file.toURI).startsWith(Paths.get(dir.toURI))
 
+  private def copyIfNotExist(from: Path, to: Path): Unit = {
+    java.nio.file.Files
+      .walk(from)
+      .filter(Files.isRegularFile(_))
+      .forEach(file => {
+        val target = to.resolve(from.relativize(file))
+        if (!Files.exists(target)) {
+          Files.createDirectories(target.getParent)
+          Files.copy(file, target)
+        }
+      })
+  }
 }

sbt-plugin/src/sbt-test/sbt-akkaserverless/basic/build.sbt

@@ -0,0 +1,9 @@
+import com.akkaserverless.sbt.AkkaserverlessPlugin.autoImport.generateUnmanaged
+
+Compile / compile := {
+  // Make sure 'generateUnmanaged' is executed on each compile, to generate scaffolding code for
+  // newly-introduced concepts.
+  // After initial generation they are to be maintained manually and will not be overwritten.
+  (Compile / generateUnmanaged).value
+  (Compile / compile).value
+}

sbt-plugin/src/sbt-test/sbt-akkaserverless/basic/test

@@ -1,5 +1,6 @@
 > compile
-$ exists target/scala-2.12/src_managed/main/akkaserverless/foo/bar/Baz.scala
+$ exists src/main/scala/foo/bar/Baz.scala
+$ exists target/scala-2.12/src_managed/main/akkaserverless/foo/bar/AbstractBaz.scala
 > Test/compile
 $ exists target/scala-2.12/src_managed/test/akkaserverless/foo/bar/BazSpec.scala
 $ absent target/scala-2.12/src_managed/test/akkaserverless/foo/bar/Baz.scala