Merge pull request #142 from blast-hardcheese/moving-logic-into-free

Moving logic into free

Author: blast-hardcheese

build.sbt

@@ -74,8 +74,8 @@ fullRunTask(
 )
 
 artifact in (Compile, assembly) := {
-  val art = (artifact in (Compile, assembly)).value
-  art.copy(`classifier` = Some("assembly"))
+  (artifact in (Compile, assembly)).value
+    .withClassifier(Option("assembly"))
 }
 
 addArtifact(artifact in (Compile, assembly), assembly)
@@ -88,7 +88,10 @@ addCommandAlias(
 
 val resetSample = TaskKey[Unit]("resetSample", "Reset sample module")
 
-resetSample := { "git clean -fdx modules/sample/src modules/sample/target" ! }
+resetSample := {
+  import scala.sys.process._
+  "git clean -fdx modules/sample/src modules/sample/target" !
+}
 
 addCommandAlias("example", "; resetSample ; runExample ; sample/test")
 addCommandAlias("testSuite", "; codegen/test ; resetSample; runExample ; sample/test")
@@ -141,8 +144,7 @@ val codegenSettings = Seq(
     "utf8"
   ),
   parallelExecution in Test := true,
-  fork := true,
-  offline := true
+  fork := true
 )
 
 lazy val root = (project in file("."))

modules/codegen/src/main/scala/com/twilio/guardrail/CLI.scala

@@ -9,7 +9,6 @@ import cats.~>
 import com.twilio.guardrail.core.CoreTermInterp
 import com.twilio.guardrail.terms.CoreTerm
 import com.twilio.swagger.core.{ LogLevel, LogLevels }
-import com.twilio.guardrail.generators.GeneratorSettings
 
 import scala.io.AnsiColor
 
@@ -22,11 +21,11 @@ object CLICommon {
       args.span(arg => LogLevels(arg.stripPrefix("--")).isDefined)
     val level: Option[String] = levels.lastOption.map(_.stripPrefix("--"))
 
-    val fallback = List.empty[(GeneratorSettings, ReadSwagger[Target[List[WriteTree]]])]
+    val fallback = List.empty[ReadSwagger[Target[List[WriteTree]]]]
     val result = Common
       .runM[CoreTerm](newArgs)
       .foldMap(interpreter)
-      .fold[List[(GeneratorSettings, ReadSwagger[Target[List[WriteTree]]])]](
+      .fold[List[ReadSwagger[Target[List[WriteTree]]]]](
         {
           case MissingArg(args, Error.ArgName(arg)) =>
             println(s"${AnsiColor.RED}Missing argument:${AnsiColor.RESET} ${AnsiColor.BOLD}${arg}${AnsiColor.RESET} (In block ${args})")
@@ -66,22 +65,20 @@ object CLICommon {
     print(coreLogger.show)
 
     val (logger, paths) = deferred
-      .traverse({
-        case (generatorSettings, rs) =>
-          ReadSwagger
-            .readSwagger(rs)
-            .fold(
-              { err =>
-                println(s"${AnsiColor.RED}${err}${AnsiColor.RESET}")
-                Applicative[Settings].pure(List.empty[Path])
-              },
-              _.fold({ err =>
-                println(s"${AnsiColor.RED}Error: ${err}${AnsiColor.RESET}")
-                unsafePrintHelp()
-                List.empty[Path]
-              }, _.map(WriteTree.unsafeWriteTree))
-            )
-            .run(generatorSettings)
+      .traverse({ rs =>
+        ReadSwagger
+          .readSwagger(rs)
+          .fold(
+            { err =>
+              println(s"${AnsiColor.RED}${err}${AnsiColor.RESET}")
+              Applicative[Logger].pure(List.empty[Path])
+            },
+            _.fold({ err =>
+              println(s"${AnsiColor.RED}Error: ${err}${AnsiColor.RESET}")
+              unsafePrintHelp()
+              List.empty[Path]
+            }, _.map(WriteTree.unsafeWriteTree))
+          )
       })
       .map(_.flatten)
       .run

modules/codegen/src/main/scala/com/twilio/guardrail/ClientGenerator.scala

@@ -5,11 +5,12 @@ import cats.free.Free
 import cats.instances.all._
 import cats.syntax.all._
 import com.twilio.guardrail.protocol.terms.client.ClientTerms
-import com.twilio.guardrail.languages.ScalaLanguage
 import com.twilio.guardrail.languages.LA
+import com.twilio.guardrail.generators.Http4sHelper
+import com.twilio.guardrail.terms.framework.FrameworkTerms
+import com.twilio.guardrail.terms.{ RouteMeta, ScalaTerms, SwaggerTerms }
 
 import scala.collection.JavaConverters._
-import com.twilio.guardrail.terms.RouteMeta
 
 case class Clients[L <: LA](clients: List[Client[L]])
 case class Client[L <: LA](pkg: List[String],
@@ -29,21 +30,34 @@ object ClientGenerator {
       host: Option[String],
       basePath: Option[String],
       groupedRoutes: List[(List[String], List[RouteMeta])]
-  )(protocolElems: List[StrictProtocolElems[L]])(implicit C: ClientTerms[L, F]): Free[F, Clients[L]] = {
+  )(protocolElems: List[StrictProtocolElems[L]])(implicit C: ClientTerms[L, F], Fw: FrameworkTerms[L, F], Sc: ScalaTerms[L, F], Sw: SwaggerTerms[L, F]): Free[F, Clients[L]] = {
     import C._
+    import Sw._
     for {
       clientImports      <- getImports(context.tracing)
       clientExtraImports <- getExtraImports(context.tracing)
       clients <- groupedRoutes.traverse({
-        case (pkg, routes) =>
+        case (className, unsortedRoutes) =>
+          val routes     = unsortedRoutes.sortBy(r => (r.path, r.method))
+          val clientName = s"${className.lastOption.getOrElse("").capitalize}Client"
+          def splitOperationParts(operationId: String): (List[String], String) = {
+            val parts = operationId.split('.')
+            (parts.drop(1).toList, parts.last)
+          }
+
           for {
-            responseDefinitions <- routes.flatTraverse {
-              case RouteMeta(path, method, operation) =>
-                generateResponseDefinitions(operation, protocolElems)
+            responseClientPair <- routes.traverse {
+              case route @ RouteMeta(path, method, operation) =>
+                for {
+                  operationId         <- getOperationId(operation)
+                  responses           <- Http4sHelper.getResponses[L, F](operationId, operation, protocolElems)
+                  responseDefinitions <- generateResponseDefinitions(operationId, responses, protocolElems)
+                  parameters          <- route.getParameters[L, F](protocolElems)
+                  clientOp            <- generateClientOperation(className, context.tracing, parameters)(route, operationId, responses)
+                } yield (responseDefinitions, clientOp)
             }
-            clientOperations <- routes.traverse(generateClientOperation(pkg, context.tracing, protocolElems) _)
-            clientName  = s"${pkg.lastOption.getOrElse("").capitalize}Client"
-            tracingName = Option(pkg.mkString("-")).filterNot(_.isEmpty)
+            (responseDefinitions, clientOperations) = responseClientPair.unzip
+            tracingName                             = Option(className.mkString("-")).filterNot(_.isEmpty)
             ctorArgs  <- clientClsArgs(tracingName, schemes, host, context.tracing)
             companion <- buildCompanion(clientName, tracingName, schemes, host, ctorArgs, context.tracing)
             client <- buildClient(
@@ -58,7 +72,7 @@ object ClientGenerator {
               context.tracing
             )
           } yield {
-            Client[L](pkg, clientName, (clientImports ++ frameworkImports ++ clientExtraImports), companion, client, responseDefinitions)
+            Client[L](className, clientName, (clientImports ++ frameworkImports ++ clientExtraImports), companion, client, responseDefinitions.flatten)
           }
       })
     } yield Clients[L](clients)