Merge pull request #148 from avaje/feature/module-info-generator

Add built in support for Throwable and StackTraceElement

Author: rbygrave

blackbox-test/src/test/java/org/example/customer/throwable/MyThrowable.java

@@ -0,0 +1,11 @@
+package org.example.customer.throwable;
+
+public class MyThrowable extends IllegalArgumentException {
+
+  public MyThrowable(String message) {
+    super(message);
+  }
+  public MyThrowable(String message, IllegalArgumentException cause) {
+    super(message, cause);
+  }
+}

blackbox-test/src/test/java/org/example/customer/throwable/ThrowableTest.java

@@ -0,0 +1,42 @@
+package org.example.customer.throwable;
+
+import io.avaje.jsonb.Json;
+import io.avaje.jsonb.JsonType;
+import io.avaje.jsonb.Jsonb;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@Json.Import(MyThrowable.class)
+class ThrowableTest {
+
+  Jsonb jsonb = Jsonb.builder().build();
+
+  @Test
+  void toJson() {
+    MyThrowable e = new MyThrowable("foo");
+    String asJson = jsonb.toJson(e);
+    assertThat(asJson).startsWith("{\"message\":\"foo\",\"stackTrace\":[\"org.example.customer.throwable.ThrowableTest.toJson(ThrowableTest.java:17)\",");
+  }
+
+
+  @Test
+  void toJsonViaThrowable() {
+    MyThrowable e = new MyThrowable("foo");
+
+    JsonType<Throwable> jsonThrowable = jsonb.type(Throwable.class);
+    String asJson = jsonThrowable.toJson(e);
+    assertThat(asJson).startsWith("{\"type\":\"class org.example.customer.throwable.MyThrowable\",\"message\":\"foo\",\"stackTrace\":[\"org.example.customer.throwable.ThrowableTest.toJsonViaThrowable");
+  }
+
+  @Test
+  void toJsonWithCauseViaThrowable() {
+    IllegalArgumentException cause = new IllegalArgumentException("bar");
+    MyThrowable e = new MyThrowable("foo", cause);
+
+    JsonType<Throwable> jsonThrowable = jsonb.type(Throwable.class);
+    String asJson = jsonThrowable.toJson(e);
+    assertThat(asJson).startsWith("{\"type\":\"class org.example.customer.throwable.MyThrowable\",\"message\":\"foo\",\"stackTrace\":[\"org.example.customer.throwable.ThrowableTest.toJsonWithCauseViaThrowable");
+    assertThat(asJson).contains("],\"cause\":{\"type\":\"class java.lang.IllegalArgumentException\",\"message\":\"bar\",\"stackTrace\":[");
+  }
+}

jsonb-generator/src/main/java/io/avaje/jsonb/generator/TypeReader.java

@@ -3,6 +3,7 @@
 import static io.avaje.jsonb.generator.ProcessingContext.*;
 
 import javax.lang.model.element.*;
+import javax.lang.model.type.TypeMirror;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -13,6 +14,8 @@
 final class TypeReader {
 
   private static final String JAVA_LANG_OBJECT = "java.lang.Object";
+  private static final String JAVA_LANG_THROWABLE = "java.lang.Throwable";
+  private static final Set<String> THROWABLE_INCLUDES = Set.of("getMessage", "getCause", "getStackTrace", "getSuppressed");
 
   private final List<MethodReader> publicConstructors = new ArrayList<>();
   private final List<FieldReader> allFields = new ArrayList<>();
@@ -42,6 +45,8 @@ final class TypeReader {
   private final List<MethodProperty> methodProperties = new ArrayList<>();
 
   private boolean optional;
+  /** Set when the type is known to extend Throwable */
+  private boolean extendsThrowable;
 
   TypeReader(TypeElement baseType, TypeElement mixInType, NamingConvention namingConvention, String typePropertyKey) {
     this.baseType = baseType;
@@ -156,7 +161,7 @@ private void readConstructor(Element element, TypeElement type) {
 
   private void readMethod(Element element, TypeElement type) {
     ExecutableElement methodElement = (ExecutableElement) element;
-    if (methodElement.getModifiers().contains(Modifier.PUBLIC)) {
+    if (checkMethod2(methodElement)) {
       List<? extends VariableElement> parameters = methodElement.getParameters();
       final String methodKey = methodElement.getSimpleName().toString();
       MethodReader methodReader = new MethodReader(methodElement, type).read();
@@ -166,14 +171,27 @@ private void readMethod(Element element, TypeElement type) {
         }
         allSetterMethods.put(methodKey.toLowerCase(), methodReader);
       } else if (parameters.size() == 0) {
-        if (!maybeGetterMethods.containsKey(methodKey)) {
-          maybeGetterMethods.put(methodKey, methodReader);
+        TypeMirror returnType = methodElement.getReturnType();
+        if (!"void".equals(returnType.toString())) {
+          if (!maybeGetterMethods.containsKey(methodKey)) {
+            maybeGetterMethods.put(methodKey, methodReader);
+          }
+          allGetterMethods.put(methodKey.toLowerCase(), methodReader);
         }
-        allGetterMethods.put(methodKey.toLowerCase(), methodReader);
       }
     }
   }
 
+  private boolean checkMethod2(ExecutableElement methodElement) {
+    if (!methodElement.getModifiers().contains(Modifier.PUBLIC)) {
+      return false;
+    }
+    if (extendsThrowable) {
+     return THROWABLE_INCLUDES.contains(methodElement.getSimpleName().toString());
+    }
+    return true;
+  }
+
   private void matchFieldsToSetterOrConstructor() {
     for (FieldReader field : allFields) {
       if (field.includeFromJson()) {
@@ -416,6 +434,9 @@ private void setFieldPositions() {
   private void addSuperType(TypeElement element) {
     String type = element.getQualifiedName().toString();
     if (!JAVA_LANG_OBJECT.equals(type) && !GenericType.isGeneric(type)) {
+      if (JAVA_LANG_THROWABLE.equals(type)) {
+        extendsThrowable = true;
+      }
       read(element);
       addSuperType(superOf(element));
     }

jsonb/src/main/java/io/avaje/jsonb/core/BasicTypeAdapters.java

@@ -51,7 +51,9 @@ final class BasicTypeAdapters {
         if (type == UUID.class) return new UuidAdapter().nullSafe();
         if (type == URL.class) return new UrlAdapter().nullSafe();
         if (type == URI.class) return new UriAdapter().nullSafe();
+        if (type == StackTraceElement.class) return new StackTraceElementAdapter().nullSafe();
         if (type == Object.class) return new ObjectJsonAdapter(jsonb).nullSafe();
+        if (type == Throwable.class) return new ThrowableAdapter(jsonb).nullSafe();
 
         final Class<?> rawType = Util.rawType(type);
         if (rawType.isEnum()) {
@@ -115,6 +117,80 @@ public String toString() {
     }
   }
 
+  private static final class StackTraceElementAdapter implements JsonAdapter<StackTraceElement> {
+    @Override
+    public StackTraceElement fromJson(JsonReader reader) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void toJson(JsonWriter writer, StackTraceElement value) {
+      writer.value(value.toString());
+    }
+
+    @Override
+    public String toString() {
+      return "JsonAdapter(StackTraceElement)";
+    }
+  }
+
+  private static final class ThrowableAdapter implements JsonAdapter<Throwable> {
+
+    private static final int MAX_STACK = 5;
+    private final JsonAdapter<StackTraceElement> stackTraceElementAdapter;
+
+    private ThrowableAdapter(Jsonb jsonb) {
+      this.stackTraceElementAdapter = jsonb.adapter(StackTraceElement.class);
+    }
+
+    @Override
+    public Throwable fromJson(JsonReader reader) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void toJson(JsonWriter writer, Throwable value) {
+      writer.beginObject();
+      writer.name("type");
+      writer.value(value.getClass().toString());
+      writer.name("message");
+      writer.value(value.getMessage());
+
+      StackTraceElement[] stackTrace = value.getStackTrace();
+      if (stackTrace != null && stackTrace.length > 0) {
+        int end = Math.min(MAX_STACK, stackTrace.length);
+        List<StackTraceElement> stackTraceElements = Arrays.asList(stackTrace).subList(0, end);
+        writer.name("stackTrace");
+        writer.beginArray();
+        for (StackTraceElement element : stackTraceElements) {
+          stackTraceElementAdapter.toJson(writer, element);
+        }
+        writer.endArray();
+      }
+
+      final Throwable cause = value.getCause();
+      if (cause != null) {
+        writer.name("cause");
+        toJson(writer, cause);
+      }
+      final Throwable[] suppressed = value.getSuppressed();
+      if (suppressed != null && suppressed.length > 0) {
+        writer.name("suppressed");
+        writer.beginArray();
+        for (Throwable sup : suppressed) {
+          toJson(writer, sup);
+        }
+        writer.endArray();
+      }
+      writer.endObject();
+    }
+
+    @Override
+    public String toString() {
+      return "JsonAdapter(URI)";
+    }
+  }
+
   static final class BooleanAdapter implements JsonAdapter<Boolean> {
     @Override
     public Boolean fromJson(JsonReader reader) {