Java language support redux

.gitignore

@@ -4,8 +4,11 @@ target/
 modules/sample*/target/
 modules/sample*/src/main/scala/*
 modules/sample*/src/main/scala/generated/*
+modules/sample*/src/main/java/*
+modules/sample*/src/main/java/generated/*
 !modules/sample*/src/main/scala/App.scala
 !modules/sample*/src/main/scala/support
+!modules/sample*/src/main/java/support
 !modules/sample*/src/test/resources/
 
 .idea

build.sbt

@@ -17,7 +17,11 @@ val catsEffectVersion = "1.0.0"
 val circeVersion      = "0.10.1"
 val http4sVersion     = "0.19.0"
 val scalatestVersion  = "3.0.7"
+val javaparserVersion = "3.7.1"
 val endpointsVersion  = "0.8.0"
+val ahcVersion        = "2.8.1"
+val dropwizardVersion = "1.3.9"
+val jerseyVersion     = "2.25.1"
 
 mainClass in assembly := Some("com.twilio.guardrail.CLI")
 
@@ -43,8 +47,28 @@ val exampleCases: List[(java.io.File, String, Boolean, List[String])] = List(
   (sampleResource("pathological-parameters.yaml"), "pathological", false, List.empty)
 )
 
-val exampleArgs: List[List[String]] = exampleCases
-  .foldLeft(List.empty[List[String]])({
+val exampleJavaArgs: List[List[String]] = exampleCases
+  .foldLeft(List[List[String]](List("java")))({
+    case (acc, (path, prefix, tracing, extra)) =>
+      acc ++ (for {
+        kind <- List("client", "server")
+        frameworkPair <- List(
+          ("dropwizard", "dropwizard"),
+        )
+        (frameworkName, frameworkPackage) = frameworkPair
+        tracingFlag                       = if (tracing) Option("--tracing") else Option.empty[String]
+      } yield
+        (
+          List(s"--${kind}") ++
+            List("--specPath", path.toString()) ++
+            List("--outputPath", s"modules/sample-${frameworkPackage}/src/main/java/generated") ++
+            List("--packageName", s"${prefix}.${kind}.${frameworkPackage}") ++
+            List("--framework", frameworkName)
+        ) ++ tracingFlag ++ extra)
+  })
+
+val exampleScalaArgs: List[List[String]] = exampleCases
+  .foldLeft(List[List[String]](List("scala")))({
     case (acc, (path, prefix, tracing, extra)) =>
       acc ++ (for {
         frameworkSuite <- List(
@@ -65,12 +89,20 @@ val exampleArgs: List[List[String]] = exampleCases
         ) ++ tracingFlag ++ extra)
   })
 
+lazy val runJavaExample: TaskKey[Unit] = taskKey[Unit]("Run scala generator with example args")
+fullRunTask(
+  runJavaExample,
+  Test,
+  "com.twilio.guardrail.CLI",
+  exampleJavaArgs.flatten.filter(_.nonEmpty): _*
+)
+
 lazy val runScalaExample: TaskKey[Unit] = taskKey[Unit]("Run scala generator with example args")
 fullRunTask(
   runScalaExample,
   Test,
   "com.twilio.guardrail.CLI",
-  exampleArgs.flatten.filter(_.nonEmpty): _*
+  exampleScalaArgs.flatten.filter(_.nonEmpty): _*
 )
 
 artifact in (Compile, assembly) := {
@@ -81,23 +113,27 @@ artifact in (Compile, assembly) := {
 addArtifact(artifact in (Compile, assembly), assembly)
 
 val resetSample = TaskKey[Unit]("resetSample", "Reset sample module")
-val frameworks = List("akkaHttp", "endpoints", "http4s")
+val scalaFrameworks = List("akkaHttp", "endpoints", "http4s")
+val javaFrameworks = List("dropwizard")
 
 resetSample := {
   import scala.sys.process._
-  (List("sample") ++ frameworks.map(x => s"sample-${x}"))
+  (List("sample") ++ (scalaFrameworks ++ javaFrameworks).map(x => s"sample-${x}"))
     .foreach(sampleName => s"git clean -fdx modules/${sampleName}/src modules/${sampleName}/target" !)
 }
 
 // Deprecated command
 addCommandAlias("example", "runtimeSuite")
 
 addCommandAlias("cli", "runMain com.twilio.guardrail.CLI")
-addCommandAlias("runtimeSuite", "; resetSample ; runScalaExample ; " + frameworks.map(x => s"${x}Sample/test").mkString("; "))
-addCommandAlias("scalaTestSuite", "; codegen/test ; runtimeSuite")
-addCommandAlias("format", "; codegen/scalafmt ; codegen/test:scalafmt ; " + frameworks.map(x => s"${x}Sample/scalafmt ; ${x}Sample/test:scalafmt").mkString("; "))
-addCommandAlias("checkFormatting", "; codegen/scalafmtCheck ; " + frameworks.map(x => s"${x}Sample/scalafmtCheck ; ${x}Sample/test:scalafmtCheck").mkString("; "))
-addCommandAlias("testSuite", "; scalaTestSuite")
+addCommandAlias("runtimeScalaSuite", "; resetSample ; runScalaExample ; " + scalaFrameworks.map(x => s"${x}Sample/test").mkString("; "))
+addCommandAlias("runtimeJavaSuite", "; resetSample ; runJavaExample ; " + javaFrameworks.map(x => s"${x}Sample/test").mkString("; "))
+addCommandAlias("runtimeSuite", "runtimeScalaSuite ; runtimeJavaSuite")
+addCommandAlias("scalaTestSuite", "; codegen/test ; runtimeScalaSuite")
+addCommandAlias("javaTestSuite", "; codegen/test ; runtimeJavaSuite")
+addCommandAlias("format", "; codegen/scalafmt ; codegen/test:scalafmt ; " + scalaFrameworks.map(x => s"${x}Sample/scalafmt ; ${x}Sample/test:scalafmt").mkString("; "))
+addCommandAlias("checkFormatting", "; codegen/scalafmtCheck ; " + scalaFrameworks.map(x => s"${x}Sample/scalafmtCheck ; ${x}Sample/test:scalafmtCheck").mkString("; "))
+addCommandAlias("testSuite", "; scalaTestSuite ; javaTestSuite")
 
 addCommandAlias(
   "publishBintray",
@@ -150,13 +186,14 @@ lazy val codegen = (project in file("modules/codegen"))
     (name := "guardrail") +:
       codegenSettings,
     libraryDependencies ++= testDependencies ++ Seq(
-      "org.scalameta"           %% "scalameta"     % "4.1.0",
-      "io.swagger.parser.v3"    % "swagger-parser" % "2.0.8",
-      "org.tpolecat"            %% "atto-core"     % "0.6.3",
-      "org.typelevel"           %% "cats-core"     % catsVersion,
-      "org.typelevel"           %% "cats-kernel"   % catsVersion,
-      "org.typelevel"           %% "cats-macros"   % catsVersion,
-      "org.typelevel"           %% "cats-free"     % catsVersion
+      "org.scalameta"           %% "scalameta"                    % "4.1.0",
+      "com.github.javaparser"   % "javaparser-symbol-solver-core" % javaparserVersion,
+      "io.swagger.parser.v3"    % "swagger-parser"                % "2.0.8",
+      "org.tpolecat"            %% "atto-core"                    % "0.6.3",
+      "org.typelevel"           %% "cats-core"                    % catsVersion,
+      "org.typelevel"           %% "cats-kernel"                  % catsVersion,
+      "org.typelevel"           %% "cats-macros"                  % catsVersion,
+      "org.typelevel"           %% "cats-free"                    % catsVersion
     ),
     scalacOptions += "-language:higherKinds",
     bintrayRepository := {
@@ -245,6 +282,31 @@ lazy val endpointsSample = (project in file("modules/sample-endpoints"))
     scalafmtOnCompile := false
   )
 
+lazy val dropwizardSample = (project in file("modules/sample-dropwizard"))
+  .settings(
+    codegenSettings,
+    javacOptions ++= Seq(
+      "-Xlint:all"
+    ),
+    testOptions in Test += Tests.Argument(TestFrameworks.JUnit, "-a", "-v"),
+    libraryDependencies ++= Seq(
+      "io.dropwizard"              %  "dropwizard-core"        % dropwizardVersion,
+      "org.glassfish.jersey.media" %  "jersey-media-multipart" % jerseyVersion,
+      "org.asynchttpclient"        %  "async-http-client"      % ahcVersion,
+      "org.scala-lang.modules"     %% "scala-java8-compat"     % "0.9.0"            % Test,
+      "org.scalatest"              %% "scalatest"              % scalatestVersion   % Test,
+      "junit"                      %  "junit"                  % "4.12"             % Test,
+      "com.novocode"               %  "junit-interface"        % "0.11"             % Test,
+      "org.mockito"                %% "mockito-scala"          % "1.2.0"            % Test,
+      "io.dropwizard"              %  "dropwizard-testing"     % dropwizardVersion  % Test,
+			"org.glassfish.jersey.test-framework.providers" % "jersey-test-framework-provider-grizzly2" % jerseyVersion % Test
+    ),
+		crossPaths := false,  // strangely needed to get the JUnit tests to run at all
+    skip in publish := true,
+    scalafmtOnCompile := false
+  )
+
 watchSources ++= (baseDirectory.value / "modules/sample/src/test" ** "*.scala").get
+watchSources ++= (baseDirectory.value / "modules/sample/src/test" ** "*.java").get
 
 logBuffered in Test := false

modules/codegen/src/main/resources/java/Shower.java

@@ -0,0 +1,80 @@
+public class Shower {
+    @SuppressWarnings("serial")
+    public static class UnshowableInstanceException extends RuntimeException {
+        public UnshowableInstanceException(final Object instance) {
+            super("Instance of type " + instance.getClass().getName() + " is not showable");
+        }
+    }
+
+    public static interface Showable<T> {
+        String show(T value);
+    }
+
+    private static final Shower instance = new Shower();
+
+    public static Shower getInstance() {
+        return instance;
+    }
+
+    private final java.util.Map<Class<?>, Showable<?>> showables = new java.util.concurrent.ConcurrentHashMap<>();
+
+    private Shower() {
+        registerDefaultInstances();
+    }
+
+    public <T> void register(final Class<T> cls, final Showable<T> showable) {
+        this.showables.put(cls, showable);
+    }
+
+    @SuppressWarnings("unchecked")
+    public String show(final Object value) {
+        return show(value, (Class<Object>)value.getClass());
+    }
+
+    @SuppressWarnings("unchecked")
+    public boolean canShow(final Class<?> cls) {
+        if (this.showables.containsKey(cls)) {
+            return true;
+        } else {
+            final Class<?> superclass = cls.getSuperclass();
+            if (superclass != null) {
+                return canShow(superclass);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private String show(final Object value, final Class<Object> cls) {
+        if (this.showables.containsKey(cls)) {
+            final Showable<Object> showable = (Showable<Object>)this.showables.get(cls);
+            return showable.show(value);
+        } else {
+            final Class<Object> superclass = cls.getSuperclass();
+            if (superclass != null) {
+                return show(value, superclass);
+            } else {
+                throw new UnshowableInstanceException(value);
+            }
+        }
+    }
+
+    private void registerDefaultInstances() {
+        register(Boolean.class, String::valueOf);
+        register(Byte.class, String::valueOf);
+        register(Character.class, String::valueOf);
+        register(Short.class, String::valueOf);
+        register(Integer.class, String::valueOf);
+        register(Long.class, String::valueOf);
+        register(java.math.BigInteger.class, java.math.BigInteger::toString);
+        register(Float.class, String::valueOf);
+        register(Double.class, String::valueOf);
+        register(java.math.BigDecimal.class, java.math.BigDecimal::toString);
+        register(String.class, value -> value);
+        register(java.time.LocalDate.class, value -> value.format(java.time.format.DateTimeFormatter.ISO_DATE));
+        register(java.time.OffsetDateTime.class, value -> value.format(java.time.format.DateTimeFormatter.ISO_OFFSET_DATE_TIME));
+        register(java.net.URL.class, java.net.URL::toString);
+        register(java.net.URI.class, java.net.URI::toString);
+    }
+}

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

@@ -7,9 +7,9 @@ import cats.~>
 import com.twilio.guardrail.core.CoreTermInterp
 import com.twilio.guardrail.terms.CoreTerm
 import com.twilio.swagger.core.{ LogLevel, LogLevels, StructuredLogger }
-import com.twilio.guardrail.languages.{ LA, ScalaLanguage }
-
+import com.twilio.guardrail.languages.{ JavaLanguage, LA, ScalaLanguage }
 import scala.io.AnsiColor
+import scala.util.{ Failure, Success }
 
 object CLICommon {
   def run[L <: LA](args: Array[String])(interpreter: CoreTerm[L, ?] ~> CoreTarget): Unit = {
@@ -134,8 +134,10 @@ object CLICommon {
 
 trait CLICommon {
   val scalaInterpreter: CoreTerm[ScalaLanguage, ?] ~> CoreTarget
+  val javaInterpreter: CoreTerm[JavaLanguage, ?] ~> CoreTarget
 
   val handleLanguage: PartialFunction[String, Array[String] => Unit] = {
+    case "java"  => CLICommon.run(_)(javaInterpreter)
     case "scala" => CLICommon.run(_)(scalaInterpreter)
   }
 
@@ -147,6 +149,7 @@ trait CLICommon {
 
 object CLI extends CLICommon {
   import com.twilio.guardrail.generators.{ AkkaHttp, Endpoints, Http4s }
+  import com.twilio.guardrail.generators.Java
   import scala.meta._
   val scalaInterpreter = CoreTermInterp[ScalaLanguage](
     "akka-http", {
@@ -157,4 +160,17 @@ object CLI extends CLICommon {
       _.parse[Importer].toEither.bimap(err => UnparseableArgument("import", err.toString), importer => Import(List(importer)))
     }
   )
+
+  val javaInterpreter = CoreTermInterp[JavaLanguage](
+    "dropwizard", {
+      case "dropwizard" => Java.Dropwizard
+    }, { str =>
+      import com.github.javaparser.JavaParser
+      import scala.util.Try
+      Try(JavaParser.parseImport(s"import ${str};")) match {
+        case Success(value) => Right(value)
+        case Failure(t)     => Left(UnparseableArgument("import", t.getMessage))
+      }
+    }
+  )
 }

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

@@ -10,7 +10,7 @@ import com.twilio.guardrail.terms.framework.FrameworkTerms
 import com.twilio.guardrail.terms.{ RouteMeta, ScalaTerms, SwaggerTerms }
 import java.net.URI
 
-case class Clients[L <: LA](clients: List[Client[L]])
+case class Clients[L <: LA](clients: List[Client[L]], supportDefinitions: List[SupportDefinition[L]])
 case class Client[L <: LA](pkg: List[String],
                            clientName: String,
                            imports: List[L#Import],
@@ -35,6 +35,7 @@ object ClientGenerator {
     for {
       clientImports      <- getImports(context.tracing)
       clientExtraImports <- getExtraImports(context.tracing)
+      supportDefinitions <- generateSupportDefinitions(context.tracing)
       clients <- groupedRoutes.traverse({
         case (className, unsortedRoutes) =>
           val routes     = unsortedRoutes.sortBy(r => (r.path, r.method))
@@ -73,6 +74,6 @@ object ClientGenerator {
             Client[L](className, clientName, (clientImports ++ frameworkImports ++ clientExtraImports), staticDefns, client, responseDefinitions.flatten)
           }
       })
-    } yield Clients[L](clients)
+    } yield Clients[L](clients, supportDefinitions)
   }
 }