Moving over to the dynamically generated Args and Context pojos

blast-hardcheese · blast-hardcheese · commit b4f016eb6b11 · 2023-12-09T14:56:22.000-08:00
diff --git a/modules/cli/src/main/scala/dev/guardrail/cli/CLICommon.scala b/modules/cli/src/main/scala/dev/guardrail/cli/CLICommon.scala
@@ -9,6 +9,7 @@ import dev.guardrail._
 import dev.guardrail.core.{ LogLevel, LogLevels }
 import dev.guardrail.terms.protocol.PropertyRequirement
 import dev.guardrail.runner.GuardrailRunner
+import dev.guardrail.syntax.args._
 
 case class CommandLineResult(exitStatus: Int)
 
@@ -93,7 +94,7 @@ trait CLICommon extends GuardrailRunner {
     def expandTilde(path: String): String =
       path.replaceFirst("^~", System.getProperty("user.home"))
     val defaultArgs =
-      Args.empty.copy(context = Args.empty.context, defaults = true)
+      Args.empty.withDefaults(true)
 
     type From = (List[Args], List[String])
     type To   = List[Args]
@@ -105,7 +106,7 @@ trait CLICommon extends GuardrailRunner {
           .filter(_.defaults)
           .lastOption
           .getOrElse(defaultArgs)
-          .copy(defaults = false)
+          .withDefaults(false)
         def Continue(x: From): Target[Either[From, To]] = Target.pure(Either.left(x))
         def Return(x: To): Target[Either[From, To]]     = Target.pure(Either.right(x))
         def Bail(x: Error): Target[Either[From, To]]    = Target.raiseError(x)
@@ -116,29 +117,29 @@ trait CLICommon extends GuardrailRunner {
               debug("Finished") >> Return(already)
             case (Nil, xs @ (_ :: _)) => Continue((empty :: Nil, xs))
             case (sofar :: already, "--defaults" :: xs) =>
-              Continue((empty.copy(defaults = true) :: sofar :: already, xs))
+              Continue((empty.withDefaults(true) :: sofar :: already, xs))
             case (sofar :: already, "--client" :: xs) =>
               Continue((empty :: sofar :: already, xs))
             case (sofar :: already, "--server" :: xs) =>
-              Continue((empty.copy(kind = CodegenTarget.Server) :: sofar :: already, xs))
+              Continue((empty.withKind(CodegenTarget.Server) :: sofar :: already, xs))
             case (sofar :: already, "--models" :: xs) =>
-              Continue((empty.copy(kind = CodegenTarget.Models) :: sofar :: already, xs))
+              Continue((empty.withKind(CodegenTarget.Models) :: sofar :: already, xs))
             case (sofar :: already, "--framework" :: value :: xs) =>
               Continue((sofar.copyContext(framework = Some(value)) :: already, xs))
             case (sofar :: already, "--help" :: xs) =>
-              Continue((sofar.copy(printHelp = true) :: already, List.empty))
+              Continue((sofar.withPrintHelp(true) :: already, List.empty))
             case (sofar :: already, "--specPath" :: value :: xs) =>
-              Continue((sofar.copy(specPath = Option(expandTilde(value))) :: already, xs))
+              Continue((sofar.withSpecPath(Option(expandTilde(value))) :: already, xs))
             case (sofar :: already, "--tracing" :: xs) =>
               Continue((sofar.copyContext(tracing = true) :: already, xs))
             case (sofar :: already, "--outputPath" :: value :: xs) =>
-              Continue((sofar.copy(outputPath = Option(expandTilde(value))) :: already, xs))
+              Continue((sofar.withOutputPath(Option(expandTilde(value))) :: already, xs))
             case (sofar :: already, "--packageName" :: value :: xs) =>
-              Continue((sofar.copy(packageName = Option(value.trim.split('.').toList)) :: already, xs))
+              Continue((sofar.withPackageName(Option(value.trim.split('.').toList)) :: already, xs))
             case (sofar :: already, "--dtoPackage" :: value :: xs) =>
-              Continue((sofar.copy(dtoPackage = value.trim.split('.').toList) :: already, xs))
+              Continue((sofar.withDtoPackage(value.trim.split('.').toList) :: already, xs))
             case (sofar :: already, "--import" :: value :: xs) =>
-              Continue((sofar.copy(imports = sofar.imports :+ value) :: already, xs))
+              Continue((sofar.withImports(sofar.imports :+ value) :: already, xs))
             case (sofar :: already, "--module" :: value :: xs) =>
               Continue((sofar.copyContext(modules = sofar.context.modules :+ value) :: already, xs))
             case (sofar :: already, "--custom-extraction" :: xs) =>
diff --git a/modules/core/src/main/scala/dev/guardrail/Args.scala b/modules/core/src/main/scala/dev/guardrail/Args.scala
diff --git a/modules/core/src/main/scala/dev/guardrail/Context.scala b/modules/core/src/main/scala/dev/guardrail/Context.scala
diff --git a/modules/core/src/main/scala/dev/guardrail/core/CoreTermInterp.scala b/modules/core/src/main/scala/dev/guardrail/core/CoreTermInterp.scala
@@ -21,6 +21,7 @@ import dev.guardrail.generators.Framework
 import dev.guardrail.languages.LA
 import dev.guardrail.terms._
 import dev.guardrail.terms.protocol.PropertyRequirement
+import dev.guardrail.syntax.args._
 
 class CoreTermInterp[L <: LA](
     val defaultFramework: String,
diff --git a/modules/core/src/main/scala/dev/guardrail/syntax/args.scala b/modules/core/src/main/scala/dev/guardrail/syntax/args.scala
@@ -0,0 +1,56 @@
+package dev.guardrail.syntax
+
+import dev.guardrail.terms.protocol.PropertyRequirement
+import dev.guardrail.{ Args, AuthImplementation, CodegenTarget, Context, TagsBehaviour }
+import dev.guardrail.syntax.context._
+
+/* Syntax for `dev.guardrail.Args`
+ * Args is a dynamically generated pojo, defined in
+ * project/src/main/scala/modules/core.scala ,
+ * using functions from
+ * project/src/main/scala/interop .
+ */
+object args {
+  implicit class ArgsCompanionSyntax(args: Args.type) {
+    val empty: Args = new Args(CodegenTarget.Client, Option.empty, Option.empty, Option.empty, List.empty, false, Context.empty, false, List.empty)
+    def isEmpty: Args => Boolean = { args =>
+      args.specPath.isEmpty &&
+      args.outputPath.isEmpty &&
+      args.packageName.isEmpty &&
+      !args.printHelp
+    }
+  }
+
+  implicit class ArgsSyntax(args: Args) {
+    def copyContext(
+        framework: Option[String] = args.context.framework,
+        customExtraction: Boolean = args.context.customExtraction,
+        tracing: Boolean = args.context.tracing,
+        modules: List[String] = args.context.modules,
+        propertyRequirement: PropertyRequirement.Configured = args.context.propertyRequirement,
+        tagsBehaviour: TagsBehaviour = args.context.tagsBehaviour,
+        authImplementation: AuthImplementation = args.context.authImplementation
+    ): Args =
+      args.withContext(
+        args.context
+          .withFramework(framework)
+          .withCustomExtraction(customExtraction)
+          .withTracing(tracing)
+          .withModules(modules)
+          .withPropertyRequirement(propertyRequirement)
+          .withTagsBehaviour(tagsBehaviour)
+          .withAuthImplementation(authImplementation)
+      )
+
+    def copyPropertyRequirement(
+        encoder: PropertyRequirement.OptionalRequirement = args.context.propertyRequirement.encoder,
+        decoder: PropertyRequirement.OptionalRequirement = args.context.propertyRequirement.decoder
+    ): Args =
+      copyContext(
+        propertyRequirement = args.context.propertyRequirement.copy(
+          encoder = encoder,
+          decoder = decoder
+        )
+      )
+  }
+}
diff --git a/modules/core/src/main/scala/dev/guardrail/syntax/context.scala b/modules/core/src/main/scala/dev/guardrail/syntax/context.scala
@@ -0,0 +1,24 @@
+package dev.guardrail.syntax
+
+import dev.guardrail.{ AuthImplementation, Context, TagsBehaviour }
+import dev.guardrail.terms.protocol.PropertyRequirement
+
+/* Syntax for `dev.guardrail.Context`
+ * Context is a dynamically generated pojo, defined in
+ * project/src/main/scala/modules/core.scala ,
+ * using functions from
+ * project/src/main/scala/interop .
+ */
+object context {
+  implicit class ContextCompanionSyntax(args: Context.type) {
+    val empty: Context = Context(
+      None,
+      customExtraction = false,
+      tracing = false,
+      modules = List.empty,
+      propertyRequirement = PropertyRequirement.Configured(PropertyRequirement.OptionalLegacy, PropertyRequirement.OptionalLegacy),
+      tagsBehaviour = TagsBehaviour.TagsAreIgnored,
+      authImplementation = AuthImplementation.Disable
+    )
+  }
+}
diff --git a/modules/microsite/src/main/scala/DocsHelpers.scala b/modules/microsite/src/main/scala/DocsHelpers.scala
@@ -8,6 +8,7 @@ import scala.meta._
 
 import dev.guardrail._
 import dev.guardrail.core.Tracker
+import dev.guardrail.syntax.context._
 import dev.guardrail.generators.Framework
 import dev.guardrail.generators.scala.ScalaLanguage
 import dev.guardrail.terms.protocol.StaticDefns
diff --git a/project/src/main/scala/modules/core.scala b/project/src/main/scala/modules/core.scala
@@ -1,14 +1,55 @@
 package dev.guardrail.sbt.modules
 
 import dev.guardrail.sbt.Build._
+import dev.guardrail.sbt.interop.InteropKeys
+import dev.guardrail.sbt.interop.InteropTasks
 
 import sbt._
 import sbt.Keys._
 
 object core {
-  val catsVersion            = "2.10.0"
+  val catsVersion = "2.10.0"
 
-  val project = 
+  // Generate POJOs with convenience methods for the following classes:
+  def emitSources(sourceManagedPath: java.io.File): List[(scala.meta.Source, java.io.File)] = {
+    import _root_.scala.meta._
+    List(
+      (
+        InteropTasks.buildPOJO(
+          t"dev.guardrail.Args",
+          List(
+            param"kind: dev.guardrail.CodegenTarget",
+            param"specPath: Option[String]",
+            param"outputPath: Option[String]",
+            param"packageName: Option[List[String]]",
+            param"dtoPackage: List[String]",
+            param"printHelp: Boolean",
+            param"context: Context",
+            param"defaults: Boolean",
+            param"imports: List[String]",
+          )
+        ),
+        sourceManagedPath / "dev" / "guardrail" / "Args.scala"
+      ),
+      (
+        InteropTasks.buildPOJO(
+          t"dev.guardrail.Context",
+          List(
+            param"framework: Option[String]",
+            param"customExtraction: Boolean",
+            param"tracing: Boolean",
+            param"modules: List[String]",
+            param"propertyRequirement: dev.guardrail.terms.protocol.PropertyRequirement.Configured",
+            param"tagsBehaviour: dev.guardrail.TagsBehaviour",
+            param"authImplementation: dev.guardrail.AuthImplementation",
+          )
+        ),
+        sourceManagedPath / "dev" / "guardrail" / "Context.scala"
+      )
+    )
+  }
+
+  val project =
     commonModule("core")
       .settings(
         libraryDependencies ++= Seq(
@@ -20,5 +61,10 @@ object core {
           "org.typelevel"               %% "cats-kernel"                  % catsVersion,
           "org.scala-lang.modules"      %% "scala-java8-compat"           % "1.0.2",
         ).map(_.cross(CrossVersion.for3Use2_13)),
+        Compile / sourceGenerators += InteropKeys.generateTask,
+        InteropKeys.generateTask := {
+          val sourceManagedPath = (Compile / sourceManaged).value
+          InteropTasks.writeFiles(emitSources(sourceManagedPath)),
+        }
       )
 }
